Integrator.h

#ifndef DDMD_INTEGRATOR_H
#define DDMD_INTEGRATOR_H

#include <util/param/ParamComposite.h>          // base class
#include <ddMd/simulation/SimulationAccess.h>   // base class
#include <ddMd/misc/DdTimer.h>                  // member

#include <iostream>

/*
* 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.
*/

namespace DdMd
{

   using namespace Util;

   class Simulation;

   class Integrator : public ParamComposite, public SimulationAccess
   {

   public:

      Integrator(Simulation& simulation);

      ~Integrator();

      void readParameters(std::istream& in);

      void loadParameters(Serializable::IArchive& ar);

      void save(Serializable::OArchive& ar);

      virtual void run(int nStep) = 0;

      virtual void clear();

      /*
      * Reduce timing statistics data from all domain processors.
      *
      * This method must be called simultaneously on all processors. It should
      * always be called immediately before calling outputStatistics on the
      * master processor. 
      *
      * On return, the value of each of the time intervals stored by the
      * internal DdMd::Timer is replaced by its average over all processors.
      * It does not reset the timer to zero, and may thus be called more 
      * than once while contining to accumulate statistics.
      */
      void computeStatistics();

      virtual void outputStatistics(std::ostream& out);

      double time() const;

      int iStep() const;

   protected:

      enum TimeId {ANALYZER, INTEGRATE1, CHECK, ALLREDUCE, TRANSFORM_F, 
                   EXCHANGE, CELLLIST, TRANSFORM_R, PAIRLIST, UPDATE, 
                   ZERO_FORCE, PAIR_FORCE, BOND_FORCE, ANGLE_FORCE, 
                   DIHEDRAL_FORCE, EXTERNAL_FORCE, INTEGRATE2, 
                   MODIFIER, DEBUG, SIGNAL, MISC, NTime};

      virtual void initDynamicalState();

      virtual void setup() = 0;

      void setIsSetup();

      bool isSetup() const;

      void setupAtoms();

      void computeForces();

      void computeForcesAndVirial();

      bool isExchangeNeeded(double skin);

      const std::string& saveFileName() const;

      int saveInterval() const;

      /*
      * Return the timer by reference.
      */
      DdTimer& timer();

      int   iStep_;

   private:

      // Performance timer
      DdTimer timer_;

      // Has setup been called at least once?
      bool isSetup_;

      std::string saveFileName_;

      int saveInterval_;

   };

   /*
   * Get current step index.
   */
   inline int Integrator::iStep() const
   {  return iStep_ ; }

   /*
   * Has setup been called at least once?
   */
   inline bool Integrator::isSetup() const
   {  return isSetup_ ; }

   /*
   * Mark as having been setup at least once.
   */
   inline void Integrator::setIsSetup()
   {  isSetup_ = true; }

   /*
   * Set any internal dynamical state variables to default initial values.
   *  
   * Empty default implementation. This virtual method is called by clear().
   */
   inline void Integrator::initDynamicalState(){}

   /*
   * Return the timer by reference.
   */
   inline DdTimer& Integrator::timer()
   {  return timer_; }

   /*
   * Get restart file base name. 
   */
   inline const std::string& Integrator::saveFileName() const
   { return saveFileName_; }

   /*
   * Get interval for writing a restart file.
   */
   inline int Integrator::saveInterval() const
   { return saveInterval_; }

}
#endif