fts/brownian/BdSimulator.h

#ifndef RP_BD_SIMULATOR_H
#define RP_BD_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 BdSimulator : public T::Simulator 
   {
 
   public:
 
      // Protected constructor and destructor (see below).
 
      // Not copyable or assignable.
      BdSimulator(BdSimulator<D,T> const &) = delete;
      BdSimulator<D,T>& operator = (BdSimulator<D,T> const &) = delete;


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


      void simulate(int nStep);

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


      bool hasBdStep() const;

      typename T::BdStep& bdStep();

      typename T::AnalyzerManager& analyzerManager();

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

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

 
   protected:

      using SystemT = typename T::System;

      using SimulatorT = typename T::Simulator;

      using BdSimulatorT = typename T::BdSimulator;

      BdSimulator(SystemT& system, BdSimulatorT& bdSimulator);

      ~BdSimulator();
 
      // Inherited protected function (selected)
      using SimulatorT::state;
 
      // Inherited protected data members (selected)
      using SimulatorT::iStep_;
      using SimulatorT::iTotalStep_;
 
   private:

      using AnalyzerT = typename T::Analyzer;

      typename T::AnalyzerManager* analyzerManagerPtr_;

      typename T::BdStep* bdStepPtr_;

      Factory< typename T::BdStep >* bdStepFactoryPtr_;

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

      void setup(int nStep);
 
   };
 
   // Inline member functions
 
   // Does this BdSimulator have a BdStep?
   template <int D, class T> inline
   bool BdSimulator<D,T>::hasBdStep() const
   {  return (bool)bdStepPtr_; }
 
   // Get the BdStep.
   template <int D, class T> inline
   typename T::BdStep& BdSimulator<D,T>::bdStep()
   {
      UTIL_CHECK(bdStepPtr_);
      return *bdStepPtr_;
   }
 
   // Get the AnalyzerManager (const).
   template <int D, class T> inline
   typename T::AnalyzerManager const& 
   BdSimulator<D,T>::analyzerManager() const
   {  return *analyzerManagerPtr_; }
 
   // Get the AnalyzerManager (non-const).
   template <int D, class T> inline
   typename T::AnalyzerManager& BdSimulator<D,T>::analyzerManager()
   {  return *analyzerManagerPtr_; }
 
}
}
#endif