Modifier.h

#ifndef DDMD_MODIFIER_H
#define DDMD_MODIFIER_H

#include <util/param/ParamComposite.h>  // base class
#include <util/misc/Bit.h>              // constants in namespace

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

namespace DdMd
{

   class Simulation;
   using namespace Util;

   class Modifier : public ParamComposite
   {

   public:

      Modifier();

      Modifier(Simulation& simulation);

      virtual ~Modifier();


 
      virtual void setup(){};

      virtual void preIntegrate1(long iStep) {};

      virtual void postIntegrate1(long iStep) {};

      virtual void preTransform(long iStep) {};

      virtual void preExchange(long iStep) {};

      virtual void postExchange(long iStep) {};

      virtual void postNeighbor(long iStep) {};

      virtual void preUpdate(long iStep) {};

      virtual void postUpdate(long iStep) {};

      virtual void preForce(long iStep) {};

      virtual void postForce(long iStep) {};

      virtual void endOfStep(long iStep) {};



      virtual void packExchange() {};

      virtual void unpackExchange() {};

      virtual void packUpdate() {};

      virtual void unpackUpdate() {};

      virtual void packReverseUpdate() {};

      virtual void unpackReverseUpdate() {};



      class Flags 
      { 
      public:

         static const Bit Setup;

         static const Bit PreIntegrate1;

         static const Bit PostIntegrate1;

         static const Bit PreTransform;

         static const Bit PreExchange;

         static const Bit PostExchange;

         static const Bit PostNeighbor;

         static const Bit PreUpdate;

         static const Bit PostUpdate;

         static const Bit PreForce;

         static const Bit PostForce;

         static const Bit EndOfStep;

         static const Bit Exchange;

         static const Bit Update;

         static const Bit ReverseUpdate;
      };

      bool isSet(Bit flag) const;

      unsigned int flags() const;



      int interval() const;

      bool isAtInterval(long iStep) const;


      static void initStatic();

   protected:

      Simulation& simulation();

      void set(Bit flag);

      void readInterval(std::istream &in);

      void loadInterval(Serializable::IArchive &ar);

      void saveInterval(Serializable::OArchive &ar);

   private:

      unsigned int flags_;

      long  interval_;

      Simulation* simulationPtr_;

   };

   // Inline member functions

   /*
   * Return interval value.
   */
   inline int Modifier::interval() const
   {  return interval_; }

   /*
   * Return true iff the iStep is a multiple of the interval.
   */
   inline bool Modifier::isAtInterval(long iStep) const
   {  return (iStep%interval_ == 0); }

   /*
   * Get the parent Simulation by reference.
   */
   inline Simulation& Modifier::simulation()
   {  return *simulationPtr_; }

}
#endif