McSimulation.h

#ifndef MCMD_MC_SIMULATION_H
#define MCMD_MC_SIMULATION_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 <mcMd/simulation/Simulation.h>           // base class
#include <mcMd/mcSimulation/McSystem.h>           // member
#include <mcMd/mcSimulation/McAnalyzerManager.h>  // member
#include <mcMd/mcSimulation/McCommandManager.h>   // member
#include <mcMd/mcMoves/McMoveManager.h>           // member
#include <util/global.h>

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

namespace McMd
{

   using namespace Util;

   class McMove;

   class McSimulation : public Simulation
   {

   public:

      using ParamComposite::load;

      #ifdef UTIL_MPI

      McSimulation(MPI::Intracomm& communicator);
      #endif

      McSimulation();

      virtual ~McSimulation();



      void setOptions(int argc, char **argv);

      void readParam();

      virtual void readParam(std::istream &in);
   
      virtual void readParameters(std::istream &in);



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

      void load(const std::string& filename);

      virtual void save(Serializable::OArchive &ar);

      void save(const std::string& filename);

      template <class Archive>
      void serialize(Archive& ar, unsigned int version);



      void readCommands(std::istream& in);

      void readCommands();

      bool readCommand(std::string command, std::istream& in);



      void simulate(int endStep, bool isContinuation = false);

      void analyzeConfigs(int min, int max, std::string basename);

      void analyzeTrajectory(int min, int max, 
                             std::string classname, std::string filename);



      McSystem& system();

      const McSystem& system() const;

      Factory<McMove>& mcMoveFactory();

      virtual bool isValid() const;


   protected:

      McMoveManager& mcMoveManager();

   private:
   
      McSystem system_;
   
      McMoveManager mcMoveManager_;

      McAnalyzerManager mcAnalyzerManager_;

      McCommandManager mcCommandManager_;

      std::istream* paramFilePtr_;

      std::string saveFileName_;

      int saveInterval_;

      bool isInitialized_;

      bool isRestarting_;

   }; 

   // Inline member functions

   /* 
   * Get the McSystem by reference.
   */
   inline McSystem& McSimulation::system()
   {  return system_; }

   /* 
   * Get the McSystem by const reference.
   */
   inline const McSystem& McSimulation::system() const
   {  return system_; }

   /* 
   * Get the McMoveManager (protected).
   */
   inline 
   McMoveManager& McSimulation::mcMoveManager()
   {  return mcMoveManager_; }

}    
#endif