System.h

#ifndef MCMD_SYSTEM_H
#define MCMD_SYSTEM_H

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

#include <util/global.h>

#include <util/param/ParamComposite.h>        // base class

#include <simp/boundary/Boundary.h>           // member (typedef)
#include <mcMd/chemistry/Molecule.h>          // member template parameter

#include <util/containers/DArray.h>           // member template
#include <util/containers/ArraySet.h>         // member template
#include <util/containers/PArrayIterator.h>   // inline function begin()

#include <iostream>
#include <string>
#include <set>

class SystemTest;

namespace Util { 
   template <typename T> class Factory;
   class FileMaster;
}

namespace Simp {
   class EnergyEnsemble;
   class BoundaryEnsemble;
}
 
namespace McMd
{

   using namespace Util;
   using namespace Simp;

   class MoleculeSetObserver 
   {
   public:

      virtual ~MoleculeSetObserver(){};
   
      virtual void notifyMoleculeSetChanged() = 0;
   };

   class Simulation;
   class ConfigIo;
   class TrajectoryReader;
   class PairFactory;
   #ifdef SIMP_BOND
   class BondPotential;
   #endif
   #ifdef SIMP_ANGLE
   class AnglePotential;
   #endif
   #ifdef SIMP_DIHEDRAL
   class DihedralPotential;
   #endif
   #ifdef SIMP_COULOMB
   class CoulombFactory;
   #endif
   #ifdef SIMP_EXTERNAL
   class ExternalPotential;
   #endif
   #ifdef SIMP_SPECIAL
   class SpecialFactory;
   #endif
   #ifdef MCMD_LINK
   class LinkPotential;
   class LinkMaster;
   #endif 
   #ifdef SIMP_TETHER
   class TetherFactory;
   class TetherMaster;
   #endif 
   #ifdef MCMD_PERTURB
   class Perturbation;
   #ifdef UTIL_MPI
   class ReplicaMove;
   #endif
   #endif
   
   class System : public ParamComposite
   {
   
   public:

      // Typedefs

      typedef ArraySet<Molecule>             MoleculeSet;

      typedef PArrayIterator<Molecule>       MoleculeIterator;

      typedef ConstPArrayIterator<Molecule>  ConstMoleculeIterator;

      // Methods

      System();

      System(const System& other);
 
      virtual ~System();
 

    
      void setId(int Id);
  
      void setSimulation(Simulation& simulation);

      void setFileMaster(FileMaster& filemaster);

      virtual void readParameters(std::istream& in);
 
      virtual void loadParameters(Serializable::IArchive &ar);

      void saveParameters(Serializable::OArchive &ar);



      Factory<ConfigIo>& configIoFactory();

      void setConfigIo(std::string& classname);

      virtual void readConfig(std::istream& in);

      void readConfig(std::string filename);

      void writeConfig(std::ostream& out);

      void writeConfig(std::string filename);

      virtual void loadConfig(Serializable::IArchive& ar);

      void saveConfig(Serializable::OArchive& ar);



      Factory<TrajectoryReader>& trajectoryReaderFactory();


      
      void addMolecule(Molecule& molecule);

      void removeMolecule(Molecule& molecule); 

      void removeAllMolecules();

      void subscribeMoleculeSetChange(MoleculeSetObserver& observer);

      void unsubscribeMoleculeSetChange(MoleculeSetObserver& observer);


      
      int nMolecule(int speciesId) const;

      int nAtom() const;

      bool isEmpty() const;

      int moleculeId(const Molecule& molecule) const;

      Molecule& molecule(int speciesId, int moleculeId);

      Molecule& randomMolecule(int speciesId);

      void begin(int speciesId, MoleculeIterator& iterator);

      void begin(int speciesId, ConstMoleculeIterator& iterator) const;


    
      #ifndef SIMP_NOPAIR 

      PairFactory& pairFactory();

      std::string pairStyle() const;
      #endif

      #ifdef SIMP_BOND

      Factory<BondPotential>& bondFactory();

      std::string bondStyle() const;
      #endif

      #ifdef SIMP_ANGLE

      Factory<AnglePotential>& angleFactory();

      std::string angleStyle() const;
      #endif

      #ifdef SIMP_DIHEDRAL

      Factory<DihedralPotential>& dihedralFactory();

      std::string dihedralStyle() const;
      #endif

      #ifdef SIMP_COULOMB

      CoulombFactory& coulombFactory();

      std::string coulombStyle() const;
      #endif

      #ifdef SIMP_EXTERNAL

      Factory<ExternalPotential>& externalFactory();

      std::string externalStyle() const;
      #endif

      #ifdef SIMP_SPECIAL

      SpecialFactory& specialFactory();

      std::string specialStyle() const;
      #endif

      #ifdef MCMD_LINK

      Factory<BondPotential>& linkFactory();

      std::string linkStyle() const;

      LinkMaster& linkMaster() const;
      #endif

      #ifdef SIMP_TETHER

      TetherFactory& tetherFactory();

      std::string tetherStyle() const;

      TetherMaster& tetherMaster() const;
      #endif

      #ifdef MCMD_PERTURB


      Factory<Perturbation>& perturbationFactory();

      void setExpectPerturbation();

      bool expectPerturbation() const;

      bool hasPerturbation() const;

      Perturbation& perturbation() const;
     
      #ifdef UTIL_MPI 

      bool hasReplicaMove() const;
      
      ReplicaMove& replicaMove() const;
      #endif // UTIL_MPI

      #endif // MCMD_PERTURB

    
      int id() const;
  
      Simulation& simulation() const;

      Boundary& boundary() const;

      EnergyEnsemble& energyEnsemble() const;

      BoundaryEnsemble& boundaryEnsemble() const;

      FileMaster& fileMaster() const;

      bool isCopy() const;

      virtual bool isValid() const;


   protected:

      Boundary& maxBoundary() const;

      virtual ConfigIo* newDefaultConfigIo();

      virtual Factory<ConfigIo>* newDefaultConfigIoFactory();

      virtual Factory<TrajectoryReader>* newDefaultTrajectoryReaderFactory();

      #ifdef MCMD_PERTURB

      virtual Factory<Perturbation>* newDefaultPerturbationFactory()
      {  return 0; }

      void readPerturbation(std::istream& in);

      void loadPerturbation(Serializable::IArchive& ar);

      void savePerturbation(Serializable::OArchive& ar);

      #ifdef UTIL_MPI

      void readReplicaMove(std::istream& in);

      void loadReplicaMove(Serializable::IArchive& ar);

      void saveReplicaMove(Serializable::OArchive& ar);
      #endif // UTIL_MPI
      #endif // MCMD_PERTURB

      void allocateMoleculeSets();

      void readFileMaster(std::istream& in);

      void loadFileMaster(Serializable::IArchive& ar);

      void saveFileMaster(Serializable::OArchive& ar);

      void readPotentialStyles(std::istream& in);

      void loadPotentialStyles(Serializable::IArchive& ar);

      void savePotentialStyles(Serializable::OArchive& ar);

      void readEnsembles(std::istream& in);

      void loadEnsembles(Serializable::IArchive& ar);

      void saveEnsembles(Serializable::OArchive& ar);

      #ifdef MCMD_LINK

      void readLinkMaster(std::istream& in);

      void loadLinkMaster(Serializable::IArchive& ar);

      void saveLinkMaster(Serializable::OArchive& ar);
      #endif 

      #ifdef SIMP_TETHER

      void readTetherMaster(std::istream& in);

      void loadTetherMaster(Serializable::IArchive& ar);

      void saveTetherMaster(Serializable::OArchive& ar);
      #endif // SIMP_TETHER

   private:

      DArray<MoleculeSet>* moleculeSetsPtr_;
 
      Boundary* boundaryPtr_;
 
      #ifdef MCMD_LINK
      LinkMaster* linkMasterPtr_;
      #endif

      #ifdef SIMP_TETHER
      TetherMaster* tetherMasterPtr_;
      #endif

      Simulation* simulationPtr_;

      EnergyEnsemble* energyEnsemblePtr_;
   
      BoundaryEnsemble* boundaryEnsemblePtr_;
  
      #ifndef SIMP_NOPAIR 
      PairFactory* pairFactoryPtr_;
      #endif
   
      #ifdef SIMP_BOND
      Factory<BondPotential>* bondFactoryPtr_;
      #endif
  
      #ifdef SIMP_ANGLE 
      Factory<AnglePotential>* angleFactoryPtr_;
      #endif
   
      #ifdef SIMP_DIHEDRAL
      Factory<DihedralPotential>* dihedralFactoryPtr_;
      #endif
  
      #ifdef SIMP_COULOMB
      CoulombFactory*  coulombFactoryPtr_;
      #endif
  
      #ifdef SIMP_EXTERNAL
      Factory<ExternalPotential>* externalFactoryPtr_;
      #endif
  
      #ifdef SIMP_SPECIAL
      SpecialFactory* specialFactoryPtr_;
      #endif
  
      #ifdef MCMD_LINK
      Factory<BondPotential>* linkFactoryPtr_;
      #endif
   
      #ifdef SIMP_TETHER
      TetherFactory* tetherFactoryPtr_;
      #endif
   
      ConfigIo* configIoPtr_;
   
      Factory<ConfigIo>* configIoFactoryPtr_;
   
      Factory<TrajectoryReader>* trajectoryReaderFactoryPtr_;

      FileMaster* fileMasterPtr_;
   
      #ifdef MCMD_PERTURB
      Perturbation* perturbationPtr_;

      Factory<Perturbation>* perturbationFactoryPtr_;
      
      #ifdef UTIL_MPI
      ReplicaMove* replicaMovePtr_;
      
      bool hasReplicaMove_;

      #endif  // UTIL_MPI
      #endif  // MCMD_PERTURB
      #ifndef SIMP_NOPAIR
      std::string pairStyle_;
      #endif

      #ifdef SIMP_BOND
      std::string bondStyle_;
      #endif

      #ifdef SIMP_ANGLE
      std::string angleStyle_;
      #endif

      #ifdef SIMP_DIHEDRAL
      std::string dihedralStyle_;
      #endif

      #ifdef SIMP_COULOMB
      std::string coulombStyle_;
      #endif

      #ifdef SIMP_EXTERNAL
      std::string externalStyle_;
      #endif

      #ifdef SIMP_SPECIAL
      std::string specialStyle_;
      #endif

      #ifdef MCMD_LINK
      std::string linkStyle_;
      #endif

      #ifdef SIMP_TETHER
      std::string tetherStyle_;
      #endif

      int id_;

      bool isCopy_;

      bool createdFileMaster_;

      #ifdef MCMD_PERTURB
      bool expectPerturbationParam_;

      bool createdPerturbation_;

      bool createdPerturbationFactory_;
      
      #ifdef UTIL_MPI
      bool createdReplicaMove_;
      #endif // ifdef UTIL_MPI
      #endif // ifdef MCMD_PERTURB

      std::set<MoleculeSetObserver*> observers_;

      void notifyMoleculeSetObservers() const;

   //friends:

      friend class SystemInterface;
      friend class ::SystemTest;

   }; 


   // Inline functions 

   /* 
   * Get integer Id for this System.
   */
   inline int System::id() const
   { return id_; }

   /* 
   * Get the parent Simulation by reference.
   */
   inline Simulation& System::simulation() const
   { 
      assert(simulationPtr_);
      return *simulationPtr_; 
   }
 
   /* 
   * Get the Boundary by reference.
   */
   inline Boundary& System::boundary() const
   { 
      assert(boundaryPtr_);
      return *boundaryPtr_;
   }

   #ifdef MCMD_LINK
   /* 
   * Get the LinkMaster by reference.
   */
   inline LinkMaster& System::linkMaster() const
   { 
      assert(linkMasterPtr_);
      return *linkMasterPtr_; 
   }
   #endif

   #ifdef SIMP_TETHER
   /* 
   * Get the TetherMaster by reference.
   */
   inline TetherMaster& System::tetherMaster() const
   { 
      assert(tetherMasterPtr_);
      return *tetherMasterPtr_; 
   }
   #endif

   /* 
   * Get the EnergyEnsemble by reference.
   */
   inline EnergyEnsemble& System::energyEnsemble() const
   { 
      assert(energyEnsemblePtr_);
      return *energyEnsemblePtr_; 
   }

   /* 
   * Get the BoundaryEnsemble by reference.
   */
   inline BoundaryEnsemble& System::boundaryEnsemble() const
   { 
      assert(boundaryEnsemblePtr_);
      return *boundaryEnsemblePtr_; 
   }

   /* 
   * Get the FileMaster by reference.
   */
   inline FileMaster& System::fileMaster() const
   { 
      assert(fileMasterPtr_);
      return *fileMasterPtr_; 
   }

   /* 
   * Was this System instantiated with the copy constructor?
   */
   inline bool System::isCopy() const
   { return isCopy_; }

   /* 
   * Get the number of molecules of a specific Species in this System.
   */
   inline int System::nMolecule(int speciesId) const
   {  
      assert(moleculeSetsPtr_);  
      return (*moleculeSetsPtr_)[speciesId].size(); 
   }

   /* 
   * Get a specific molecule of a specific Species.
   */
   inline Molecule& System::molecule(int speciesId, int moleculeId)
   {  
      assert(moleculeSetsPtr_);  
      return (*moleculeSetsPtr_)[speciesId][moleculeId]; 
   }

   /* 
   * Initialize a MoleculeIterator for molecules of one Species.
   */
   inline 
   void System::begin(int speciesId, MoleculeIterator& iterator)
   {
      assert(moleculeSetsPtr_);  
      (*moleculeSetsPtr_)[speciesId].begin(iterator); 
   }

   /* 
   * Initialize a MoleculeIterator for molecules of one Species.
   */
   inline 
   void System::begin(int speciesId, ConstMoleculeIterator& iterator) const
   {
      assert(moleculeSetsPtr_);  
      (*moleculeSetsPtr_)[speciesId].begin(iterator); 
   }

   #ifdef MCMD_PERTURB

   inline bool System::expectPerturbation() const
   { return expectPerturbationParam_; }

   inline Factory<Perturbation>& System::perturbationFactory()
   { return *perturbationFactoryPtr_; }

   /* 
   * Does this system have an associated Perturbation?
   */
   inline bool System::hasPerturbation() const
   {  return perturbationPtr_; }

   /*
   * Get the Perturbation by reference.
   */
   inline Perturbation& System::perturbation() const
   { 
      assert(perturbationPtr_);
      return *perturbationPtr_; 
   }

   #ifdef UTIL_MPI
   /* 
   * Does this system have an associated ReplicaMove?
   */
   inline bool System::hasReplicaMove() const
   {  return replicaMovePtr_; }
   
   /*
   * Get the ReplicaMove by reference.
   */
   inline ReplicaMove& System::replicaMove() const
   {
      assert(replicaMovePtr_);
      return *replicaMovePtr_;
   }
   #endif // UTIL_MPI
   #endif // MCMD_PERTURB

   /*
   * Subscribe to moleculeSet change signal.
   */
   inline void System::subscribeMoleculeSetChange(MoleculeSetObserver& observer)
   {  observers_.insert(&observer); }

   /*
   * Unsubscribe from moleculeSet change signal.
   */
   inline void System::unsubscribeMoleculeSetChange(MoleculeSetObserver& observer)
   {  observers_.erase(&observer); }

   /*
   * Notifiy all observers
   */
   inline void System::notifyMoleculeSetObservers() const
   {
      std::set<MoleculeSetObserver*>::iterator itr;

      for ( itr = observers_.begin();
            itr != observers_.end(); itr++ )
         (*itr)->notifyMoleculeSetChanged();
   }

}
#endif