Potential.h

#ifndef DDMD_POTENTIAL_H
#define DDMD_POTENTIAL_H

#include <util/param/ParamComposite.h>  // base class
#include <util/misc/Setable.h>          // template for members
#include <util/space/Tensor.h>          // parameter for member

/*
* 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 Potential : public ParamComposite
   {

   public:

      Potential();

      virtual ~Potential();

      void setReverseUpdateFlag(bool reverseUpdateFlag);

      bool reverseUpdateFlag() const;



      virtual void computeForces() = 0;

      #ifdef UTIL_MPI
      virtual void computeEnergy(MPI::Intracomm& communicator) = 0;
      #else
      virtual void computeEnergy() = 0;
      #endif

      double energy() const;

      void unsetEnergy();

      bool isEnergySet() const;

      #ifdef UTIL_MPI
      virtual void computeStress(MPI::Intracomm& communicator)
      #else
      virtual void computeStress()
      #endif
      {}

      #ifdef UTIL_MPI
      virtual void computeForcesAndStress(MPI::Intracomm& communicator);
      #else
      virtual void computeForcesAndStress();
      #endif

      Tensor stress() const;

      double pressure() const;

      void unsetStress();

      bool isStressSet() const;

      #ifdef UTIL_MPI

      virtual bool isValid(MPI::Intracomm& communicator) const;
      #endif


   protected:

      void setEnergy(double energy);

      void setStress(const Tensor& stress);

      void incrementPairStress(const Vector& f, const Vector& dr, 
                               Tensor& stress) const;

      #ifdef UTIL_MPI
      void reduceEnergy(double localEnergy, MPI::Intracomm& communicator);
      #else
      void reduceEnergy();
      #endif

      #ifdef UTIL_MPI
      void reduceStress(Tensor& localStress, MPI::Intracomm& communicator);
      #else
      void reduceStress();
      #endif

   private:

      Setable<Tensor> stress_;

      Setable<double> energy_;

      bool reverseUpdateFlag_;

   };

   inline bool Potential::reverseUpdateFlag() const
   {  return reverseUpdateFlag_; }

   /*
   * Add a pair contribution to the virial tensor (protected).
   */
   inline void 
   Potential::incrementPairStress(const Vector& f, const Vector& dr, 
                                  Tensor& stress) const
   {
      int i, j;
      for (i = 0; i < Dimension; ++i) {
         for (j = 0; j < Dimension; ++j) {
            stress(i, j) += f[i]*dr[j];
         }
      }
   }

}
#endif