mcMd/potentials/pair/PairFactory.cpp

/*
* Simpatico - Simulation Package for Polymeric and Molecular Liquids
*
* Copyright 2010 - 2014, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/

#include <mcMd/potentials/pair/PairFactory.h>

#include <mcMd/simulation/System.h>
#include <mcMd/mdSimulation/MdSystem.h>

// PairPotential interfaces and implementation classes
#include <mcMd/potentials/pair/MdPairPotential.h>
#include <mcMd/potentials/pair/MdPairPotentialImpl.h>
#include <mcMd/potentials/pair/McPairPotential.h>
#include <mcMd/potentials/pair/McPairPotentialImpl.h>
#ifdef SIMP_COULOMB
#include <mcMd/potentials/pair/MdEwaldPairPotentialImpl.h>
#endif

// Pair Potential interaction classes
#include <simp/interaction/pair/LJPair.h>
#include <simp/interaction/pair/WcaPair.h>
#include <simp/interaction/pair/DpdPair.h>

#ifdef SIMP_BOND
#include <simp/interaction/pair/CompensatedPair.h>
#include <simp/interaction/bond/FeneBond.h>
#endif


namespace McMd
{

   using namespace Util;
   using namespace Simp;

   PairFactory::PairFactory()
   {}

   /*
   * Add a subfactory to the list of children, and set communicator (if any).
   */
   void PairFactory::addSubfactory(PairFactory& subfactory)
   {  subfactories_.push_back(&subfactory); }

   /*
   * Return a pointer to a new McPairInteration, if possible.
   */
   McPairPotential* 
   PairFactory::mcFactory(const std::string& name, System& system) const
   {
      McPairPotential* ptr = 0;

      // Try subfactories first
      ptr = tryMcSubfactories(name, system);
      if (ptr) return ptr;

      if (name == "LJPair") {
         ptr = new McPairPotentialImpl<LJPair>(system);
      } else
      if (name == "WcaPair") {
         ptr = new McPairPotentialImpl<WcaPair>(system);
      } else
      if (name == "DpdPair") {
         ptr = new McPairPotentialImpl<DpdPair>(system);
      }
      #ifdef SIMP_BOND 
      else
      if (name == "CompensatedPair<DpdPair,FeneBond>") {
         ptr = new McPairPotentialImpl< CompensatedPair<DpdPair, FeneBond> >(system);
      }
      #endif
      return ptr;
   }

   /*
   * Return a pointer to a new MdPairPotential, if possible.
   */
   MdPairPotential* 
   PairFactory::mdFactory(const std::string& name, System& system) const
   {
      MdPairPotential* ptr = 0;
      MdSystem& mdsystem = dynamic_cast<MdSystem&>(system);

      // Try subfactories first
      ptr = tryMdSubfactories(name, system);
      if (ptr) return ptr;

      #ifdef SIMP_COULOMB
      if (!mdsystem.simulation().hasCoulomb()) {
      #endif

         // std::cout << "Attempting to instantiate MdPairPotentialImpl instance - neutral system" 
         //          << std::endl;
         if (name == "LJPair") {
            ptr = new MdPairPotentialImpl<LJPair>(mdsystem);
         } else
         if (name == "WcaPair") {
            ptr = new MdPairPotentialImpl<WcaPair>(mdsystem);
         } else
         if (name == "DpdPair") {
            ptr = new MdPairPotentialImpl<DpdPair>(mdsystem);
         } 
         #ifdef SIMP_BOND 
         else
         if (name == "CompensatedPair<DpdPair,FeneBond>") {
            ptr = new 
            MdPairPotentialImpl<CompensatedPair<DpdPair,FeneBond> >(mdsystem);
         }
         #endif

      #ifdef SIMP_COULOMB
      } else {
         // std::cout << "Attempting to construct MdEwaldPairPotentialImpl instance - charged system" 
         //           << std::endl;
         if (name == "LJPair") {
            ptr = new MdEwaldPairPotentialImpl<LJPair>(mdsystem);
         } else
         if (name == "WcaPair") {
            ptr = new MdEwaldPairPotentialImpl<WcaPair>(mdsystem);
         } else
         if (name == "DpdPair") {
            ptr = new MdEwaldPairPotentialImpl<DpdPair>(mdsystem);
         } 
         #ifdef SIMP_BOND 
         else
         if (name == "CompensatedPair<DpdPair,FeneBond>") {
            ptr = new 
            MdEwaldPairPotentialImpl<CompensatedPair<DpdPair,FeneBond> >(mdsystem);
         }
         #endif
      }
      #endif

      return ptr;
   }

   /*
   * Convert an McPairPotential to a MdPairPotential, if possible.
   */
   MdPairPotential* 
   PairFactory::mdFactory(McPairPotential& potential) const
   {
      std::string name = potential.interactionClassName();
      MdPairPotential* ptr = 0;

      // Try subfactories first
      ptr = tryMdSubfactories(potential);
      if (ptr) return ptr;

      if (name == "LJPair") {
         McPairPotentialImpl<LJPair>* mcPtr 
             = dynamic_cast< McPairPotentialImpl<LJPair>* >(&potential);
         ptr = new MdPairPotentialImpl<LJPair>(*mcPtr);
      } else
      if (name == "WcaPair") {
         McPairPotentialImpl<WcaPair>* mcPtr 
             = dynamic_cast< McPairPotentialImpl<WcaPair>* >(&potential);
         ptr = new MdPairPotentialImpl<WcaPair>(*mcPtr);
      } else
      if (name == "DpdPair") {
         McPairPotentialImpl<DpdPair>* mcPtr 
             = dynamic_cast< McPairPotentialImpl<DpdPair>* >(&potential);
         ptr = new MdPairPotentialImpl<DpdPair>(*mcPtr);
      } 
      #ifdef SIMP_BOND 
      else 
      if (name == "CompensatedPair<DpdPair,FeneBond>") {
         McPairPotentialImpl< CompensatedPair<DpdPair, FeneBond> >* mcPtr 
             = dynamic_cast< McPairPotentialImpl< CompensatedPair<DpdPair, FeneBond> >* >(&potential);
         ptr = new MdPairPotentialImpl< CompensatedPair<DpdPair, FeneBond> >(*mcPtr);
      }
      #endif
      return ptr;
   }

   /*
   * Try all subfactories in sequence searching for a match.
   */
   McPairPotential* 
   PairFactory::tryMcSubfactories(const std::string& className, System& system) const
   {
      McPairPotential* typePtr = 0;
      int n = subfactories_.size();
      for (int i = 0; i < n && typePtr == 0; ++i) {
         typePtr = subfactories_[i]->mcFactory(className, system);
      }
      return typePtr;
   }

   /*
   * Try all subfactories in sequence searching for a match.
   */
   MdPairPotential* 
   PairFactory::tryMdSubfactories(const std::string& className, System& system) const
   {
      MdPairPotential* typePtr = 0;
      int n = subfactories_.size();
      for (int i = 0; i < n && typePtr == 0; ++i) {
         typePtr = subfactories_[i]->mdFactory(className, system);
      }
      return typePtr;
   }

   /*
   * Try all subfactories in sequence searching for a match.
   */
   MdPairPotential* PairFactory::tryMdSubfactories(McPairPotential& potential) const
   {
      MdPairPotential* typePtr = 0;
      int n = subfactories_.size();
      for (int i = 0; i < n && typePtr == 0; ++i) {
         typePtr = subfactories_[i]->mdFactory(potential);
      }
      return typePtr;
   }

}