ReplicaMove.h

#ifdef UTIL_MPI
#ifndef MCMD_REPLICA_MOVE_H 
#define MCMD_REPLICA_MOVE_H 


/*
* Simpatico - Simulation Package for Polymeric and Molecular Liquids 
* 
* Copyright 2010 - 2017, The Regents of the University of Minnesota.
* Gibbs sampler algorithm implemented by Jens Glaser, March 2012.
*
* Distributed under the terms of the GNU General Public License.  
*/ 

#include <util/param/ParamComposite.h> // base class 
#include <util/space/Vector.h>          // Util namespace
#include <util/misc/Notifier.h>          // Util namespace
#include <util/containers/DArray.h>
#include <util/containers/Pair.h>
#include <util/global.h>

#include <fstream>

namespace McMd
{

   using namespace Util;

   class System;

   typedef Pair<int> sendRecvPair;


   class ReplicaMove : public ParamComposite,
                       public Notifier<sendRecvPair>
   {
   
   public:
   
      ReplicaMove(System& system);
   
      virtual ~ReplicaMove();

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

      virtual void loadParameters(Serializable::IArchive& ar);

      virtual void save(Serializable::OArchive& ar);

      virtual bool move();

      long interval() const;
   
      bool isAtInterval(long counter) const;

      void notifyObservers(sendRecvPair partners);
 
      long nAttempt();
       
      long nAccept(); 

   protected:

      System& system();

   private:

      System* systemPtr_;

      MPI::Intracomm* communicatorPtr_;

      int   myId_;

      int   nProcs_;

      std::ofstream outputFile_;

      int   nParameters_;
      
      long interval_;

      int nSampling_;

      Vector   *ptPositionPtr_;

      Vector   *myPositionPtr_;

      long  swapAttempt_;

      long  swapAccept_;

   };
   // Inline methods

   /*
   * Return interval value.
   */
   inline long ReplicaMove::interval() const
   { return interval_; }
   
   /*
   * Return true iff counter is a multiple of the interval.
   */
   inline bool ReplicaMove::isAtInterval(long counter) const
   { return (counter%interval_ == 0); }
   
   /*
   * Number of attempts in given direction.
   */
   inline long ReplicaMove::nAttempt() 
   {  return swapAttempt_; }
   
   /*
   * Number of accepted moves in given direction.
   */
   inline long ReplicaMove::nAccept()
   {  return swapAccept_; }

   /*
   * Return reference to parent System.
   */
   inline System& ReplicaMove::system()
   { 
      assert(systemPtr_);
      return *systemPtr_; 
   }

}
#endif
#endif // ifdef UTIL_MPI