fts/montecarlo/McSimulator.h

#ifndef RP_MC_SIMULATOR_H
#define RP_MC_SIMULATOR_H
 
/*
* PSCF - Polymer Self-Consistent Field
*
* Copyright 2015 - 2025, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include <util/global.h>
#include <iostream>
#include <string>
 
// Forward declaration
namespace Util { template <class T> class Factory; }
 
namespace Pscf {
namespace Rp {
 
   using namespace Util;

   template <int D, class T>
   class McSimulator : public T::Simulator
   {
 
   public:


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


      void simulate(int nStep);

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

      virtual void outputTimers(std::ostream& out) const;

      virtual void clearTimers();


      typename T::McMoveManager const& mcMoveManager() const;

      typename T::McMoveManager& mcMoveManager();

      typename T::AnalyzerManager const & analyzerManager() const;

      typename T::AnalyzerManager& analyzerManager();

      Factory<typename T::TrajectoryReader>& trajectoryReaderFactory();

      bool hasMcMoves() const;

      bool needsCc();

      bool needsDc();

 
   protected:

      using SystemT = typename T::System;

      using SimulatorT = typename T::Simulator;

      using McSimulatorT = typename T::McSimulator;

      McSimulator(SystemT& system, McSimulatorT& mcSimulator);

      ~McSimulator();
 
      // Prohibit copying and assignment. 
      McSimulator(McSimulator<D,T> const &) = delete;
      McSimulator<D,T>& operator = (McSimulator<D,T> const &) = delete;
 
      // Inherited protected member function (selected).
      using SimulatorT::state;
 
      // Inherited protected data members (selected).
      using SimulatorT::iStep_;
      using SimulatorT::iTotalStep_;
 
   private:

      using AnalyzerT = typename T::Analyzer;

      typename T::McMoveManager* mcMoveManagerPtr_;

      typename T::AnalyzerManager* analyzerManagerPtr_;

      Factory<typename T::TrajectoryReader>* trajectoryReaderFactoryPtr_;
 
      // Private member function

      void setup(int nStep);
 
   };
 
   // Inline member function definitions
 
   // Get the Monte-Carlo move manager (const)
   template <int D, class T> inline
   typename T::McMoveManager const& McSimulator<D,T>::mcMoveManager() const
   {  
      UTIL_ASSERT(mcMoveManagerPtr_);
      return *mcMoveManagerPtr_; 
   }
 
   // Get the Monte-Carlo move manager (non-const).
   template <int D, class T> inline
   typename T::McMoveManager& McSimulator<D,T>::mcMoveManager()
   {  
      UTIL_ASSERT(mcMoveManagerPtr_);
      return *mcMoveManagerPtr_; 
   }
 
   // Get the Analyzer manager (const).
   template <int D, class T> inline
   typename T::AnalyzerManager const& McSimulator<D,T>::analyzerManager() 
   const
   {  
      UTIL_ASSERT(analyzerManagerPtr_);
      return *analyzerManagerPtr_; 
   }
 
   // Get the Analyzer manager.
   template <int D, class T> inline
   typename T::AnalyzerManager& McSimulator<D,T>::analyzerManager()
   {  
      UTIL_ASSERT(analyzerManagerPtr_);
      return *analyzerManagerPtr_; 
   }
 
   // Get the TrajectoryReader factory.
   template <int D, class T> inline
   Factory<typename T::TrajectoryReader>& 
   McSimulator<D,T>::trajectoryReaderFactory()
   {
      UTIL_ASSERT(trajectoryReaderFactoryPtr_);
      return *trajectoryReaderFactoryPtr_;
   }
 
   // Have any MC moves been defined?
   template <int D, class T> inline
   bool McSimulator<D,T>::hasMcMoves() const
   {  return (bool)(mcMoveManager().size() > 0); }
 
   // Does the stored state need to include Cc fields?
   template <int D, class T> inline
   bool McSimulator<D,T>::needsCc()
   {  return state().needsCc; }
 
   // Does the stored state need to include Dc fields?
   template <int D, class T> inline
   bool McSimulator<D,T>::needsDc()
   {  return state().needsDc; }
 
}
}
#endif