Finite Temperature Spring Method. More...

#include <FiniteTempString.h>

Inheritance diagram for SSAGES::FiniteTempString:

[legend]

Public Member Functions
	FiniteTempString (const MPI_Comm &world, const MPI_Comm &comm, const std::vector< double > &centers, unsigned int maxiterations, unsigned int blockiterations, double tau, const std::vector< double > cvspring, double kappa, unsigned int springiter, unsigned int frequency)
	Constructor. More...

void	PostIntegration (Snapshot *snapshot, const class CVManager &cvmanager) override
	Method call post integration. More...

	~FiniteTempString ()
	Destructor.

Public Member Functions inherited from SSAGES::StringMethod
	StringMethod (const MPI_Comm &world, const MPI_Comm &comm, const std::vector< double > &centers, unsigned int maxiterations, const std::vector< double > cvspring, unsigned int frequency)
	Constructor. More...

void	PreSimulation (Snapshot *snapshot, const class CVManager &cvmanager) override
	Method call prior to simulation initiation. More...

void	PostSimulation (Snapshot *snapshot, const class CVManager &cvmanager) override
	Method call post simulation. More...

void	SetTolerance (std::vector< double > tol)
	Set the tolerance for quitting method. More...

void	SetSendRecvNeighbors ()
	Communicate neighbor lists over MPI.

virtual	~StringMethod ()
	Destructor.

Public Member Functions inherited from SSAGES::Method
	Method (unsigned int frequency, const MPI_Comm &world, const MPI_Comm &comm)
	Constructor. More...

void	SetCVMask (const std::vector< unsigned int > &mask)
	Sets the collective variable mask. More...

virtual	~Method ()
	Destructor.

Public Member Functions inherited from SSAGES::EventListener
	EventListener (unsigned int frequency)
	Constructor. More...

unsigned int	GetFrequency () const
	Get frequency of event listener. More...

virtual	~EventListener ()
	Destructor.

Private Member Functions
bool	InCell (const CVList &cvs) const
	Checks if CV is in Voronoi cell. More...

void	StringUpdate () override
	Updates the string according to the FTS method.

Private Attributes
double	kappa_
	String modification parameter.

unsigned int	blockiterations_
	Number of steps to block average the CV's postions over.

double	tau_
	Time step of string change.

unsigned int	min_num_umbrella_steps_
	Minimum number of steps to apply umbrella sampling.

int	run_umbrella_
	Flag to run umbrella or not during post-integration.

unsigned int	umbrella_iter_
	Iterator that keeps track of umbrella iterations.

std::vector< double >	prev_CVs_
	Stores the last positions of the CVs.

bool	reset_for_umbrella
	Flag for whether a system was to run umbrella sampling before checking against other systems.

Additional Inherited Members
Static Public Member Functions inherited from SSAGES::StringMethod
static StringMethod *	Build (const Json::Value &json, const MPI_Comm &world, const MPI_Comm &comm, const std::string &path)
	Build a derived method from JSON node. More...

Static Public Member Functions inherited from SSAGES::Method
static Method *	BuildMethod (const Json::Value &json, const MPI_Comm &world, const MPI_Comm &comm, const std::string &path)
	Build a derived method from JSON node. More...

Static Public Member Functions inherited from SSAGES::EventListener
static unsigned int	GetWalkerID (const MPI_Comm &world, const MPI_Comm &comm)
	Get walker ID number of specified communicator. More...

static unsigned int	GetNumWalkers (const MPI_Comm &world, const MPI_Comm &comm)
	Get total number of walkers in the simulation. More...

static bool	IsMasterRank (const MPI_Comm &comm)
	Check if current processor is master. More...

Protected Member Functions inherited from SSAGES::StringMethod
double	distance (const std::vector< double > &x, const std::vector< double > &y) const
	Helper function for calculating distances. More...

void	PrintString (const CVList &CV)
	Prints the CV positions to file. More...

void	GatherNeighbors (std::vector< double > lcv0, std::vector< double > ucv0)
	Gather neighbors over MPI. More...

void	StringReparam (double alpha_star)
	Reparameterize the string. More...

void	UpdateWorldString (const CVList &cvs)
	Update the world string over MPI. More...

bool	TolCheck () const
	Check whether tolerance criteria have been met. More...

bool	CheckEnd (const CVList &CV)
	Check if method reached one of the exit criteria. More...

Protected Attributes inherited from SSAGES::StringMethod
std::vector< double >	centers_
	CV starting location values.

std::vector< double >	newcenters_
	CV starting location values.

std::vector< std::vector< double > >	worldstring_
	The world's strings centers for each CV. More...

int	mpiid_
	The node this belongs to.

std::vector< double >	tol_
	Tolerance criteria for determining when to stop string (default 0 if no tolerance criteria)

int	numnodes_
	Number of nodes on a string.

unsigned int	maxiterator_
	Maximum cap on number of string method iterations performed.

std::vector< double >	cvspring_
	Vector of spring constants.

unsigned int	iterator_
	The local method iterator.

unsigned int	iteration_
	The global method iteration.

std::ofstream	stringout_
	Output stream for string data.

int	sendneigh_
	Neighbor to send info to.

int	recneigh_
	Neighbor to gain info from.

std::vector< std::vector< double > >	prev_positions_
	Store positions for starting trajectories.

std::vector< std::vector< double > >	prev_velocities_
	Store velocities for starting trajectories.

std::vector< std::vector< int > >	prev_IDs_
	Store atom IDs for starting trajectories.

Protected Attributes inherited from SSAGES::Method
mxx::comm	world_
	Global MPI communicator.

mxx::comm	comm_
	Local MPI communicator.

std::vector< unsigned int >	cvmask_
	Mask which identifies which CVs to act on.

Detailed Description

Finite Temperature Spring Method.

Implementation of a multi-walker finite string method with hard wall voronoi cells and running block averages.

Definition at line 35 of file FiniteTempString.h.

Constructor & Destructor Documentation

◆ FiniteTempString()

SSAGES::FiniteTempString::FiniteTempString	(	const MPI_Comm &	world,
		const MPI_Comm &	comm,
		const std::vector< double > &	centers,
		unsigned int	maxiterations,
		unsigned int	blockiterations,
		double	tau,
		const std::vector< double >	cvspring,
		double	kappa,
		unsigned int	springiter,
		unsigned int	frequency
	)

inline

Constructor.

Parameters

world	MPI global communicator.
comm	MPI local communicator.
centers	List of centers.
maxiterations	Maximum number of iterations.
blockiterations	Number of iterations per block averaging.
tau	Value of tau (default: 0.1).
cvspring	Spring constants for cvs.
kappa	Value of kappa (default: 0.1).
springiter	Minimum number of umbrella steps.
frequency	Frequency with which this method is invoked.

Constructs an instance of Finite String method.

Store positions for starting trajectories

Store velocities for starting trajectories

Definition at line 90 of file FiniteTempString.h.

                                                  : 
         StringMethod(world, comm, centers, maxiterations, cvspring, frequency),
         kappa_(kappa), blockiterations_(blockiterations), tau_(tau), 
         min_num_umbrella_steps_(springiter), run_umbrella_(true),
         umbrella_iter_(1), reset_for_umbrella(false)
         {
             prev_positions_.resize(1);
  
             prev_velocities_.resize(1);
  
             prev_IDs_.resize(1);
  
         }

References SSAGES::StringMethod::prev_IDs_, SSAGES::StringMethod::prev_positions_, and SSAGES::StringMethod::prev_velocities_.

Member Function Documentation

◆ InCell()

bool SSAGES::FiniteTempString::InCell ( const CVList & cvs ) const

private

Checks if CV is in Voronoi cell.

Parameters

cvs	List of CVs to check

Returns: Boolean if all CVs are in the Voronoi cell

Definition at line 32 of file FiniteTempString.cpp.

     {
         std::vector<double> dists (numnodes_, 0);
  
         // Record the difference between all cvs and all nodes
         for (int i = 0; i < numnodes_; i++)
             for(size_t j = 0; j < cvs.size(); j++)
                 dists[i]+= pow(cvs[j]->GetDifference(worldstring_[i][j]),2);
         
         if(std::min_element(dists.begin(), dists.end()) - dists.begin() == mpiid_)
             return true;
  
         return false;
     }

References SSAGES::StringMethod::mpiid_, SSAGES::StringMethod::numnodes_, and SSAGES::StringMethod::worldstring_.

Referenced by PostIntegration().

Here is the caller graph for this function:

◆ PostIntegration()

void SSAGES::FiniteTempString::PostIntegration	(	Snapshot *	snapshot,
		const class CVManager &	cvmanager
	)

overridevirtual

Method call post integration.

Post-integration hook.

Parameters

snapshot	Pointer to the simulation snapshot.
cvmanager	Collective variable manager.

This function will be called after each integration step.

Implements SSAGES::StringMethod.

Definition at line 48 of file FiniteTempString.cpp.

     {
         auto cvs = cvmanager.GetCVs(cvmask_);
         auto& forces = snapshot->GetForces();
         bool insidecell;
  
         if(reset_for_umbrella)
         {
             //If the system was not going to run the umbrella anymore, reset its position
             for(auto& force : forces)
             {
                 force.setZero();
             }
             
             auto& Pos = snapshot->GetPositions();
  
             for(size_t i = 0; i < prev_IDs_[0].size(); i++)
             {
                 auto localindex = snapshot->GetLocalIndex(prev_IDs_[0][i]);
                 if(localindex!= -1)
                 {
                     Pos[localindex][0] = prev_positions_[0][i*3];
                     Pos[localindex][1] = prev_positions_[0][i*3 + 1];
                     Pos[localindex][2] = prev_positions_[0][i*3 + 2];
                 }
             }                       
         }
         for(auto& cv : cvs)
         {
             //Trigger a rebuild of the CVs since we reset the positions
             cv->Evaluate(*snapshot);
         }
         insidecell = InCell(cvs); 
  
         MPI_Allreduce(MPI_IN_PLACE, &run_umbrella_, 1, MPI_INT, MPI_LOR, world_); //Compares all run_umbrellas on all processors - if any is true, all are set to true
  
         if(run_umbrella_)
         { 
             if(umbrella_iter_ == min_num_umbrella_steps_)
             {
                 //After reaching the minimum umbrella sampling checkpoint, evaluate whether to keep going (per individual image)
                 if(insidecell)
                 {
                     //Stop umbrella sampling if inside cell
                     run_umbrella_ = false;
                     reset_for_umbrella = true;
  
                     //This node is done initializing; so store this snapshot
                     prev_positions_[0] = snapshot->SerializePositions();
                     prev_IDs_[0] = snapshot->SerializeIDs();
                 }
                 umbrella_iter_ = 1; 
             }
             else
             {
                 if(!reset_for_umbrella)
                 {
                     //If not at the minimum step checkpoint AND not a system which was already done, add restraining force
                     for(size_t i = 0; i < cvs.size(); i++)
                     {
                         // Get current cv and gradient
                         auto& cv = cvs[i];
                         auto& grad = cv->GetGradient();
  
                         // Compute dV/dCV
                         auto D = cvspring_[i]*(cv->GetDifference(centers_[i]));
  
                         // Update forces
                         for(size_t j = 0; j < forces.size(); j++)
                                 forces[j] -= D*grad[j];
                     }
                     umbrella_iter_++; //Progress toward checkpoint 
                 }
                 else
                 {
                     //End umbrella sampling of this node if it was already initialized
                     run_umbrella_ = false;
                 }
             }
             return; //Don't do any sampling after restraining
         }
         else
         {
             //If run umbrella was false (only possible if every node was done) then set reset to false for next string method iteration (only proceed past umbrella sampling if no images require further umbrella sampling)
             reset_for_umbrella = false;
         }
  
         if(!insidecell)
         {
             //If last step took the system outside the Voronoi cell, reset the position and zero the force to reset the trajectory 
             for(auto& force : forces)
                 force.setZero();
  
             auto& Pos = snapshot->GetPositions();
  
             for(size_t i = 0; i < prev_IDs_[0].size(); i++)
             {
                 auto localindex = snapshot->GetLocalIndex(prev_IDs_[0][i]);
                 if(localindex!= -1)
                 {
                     Pos[localindex][0] = prev_positions_[0][i*3];
                     Pos[localindex][1] = prev_positions_[0][i*3 + 1];
                     Pos[localindex][2] = prev_positions_[0][i*3 + 2];
                 }
             } 
             
             // Calculate running averages for each CV at each node based on previous CV
             for(size_t i = 0; i < newcenters_.size(); i++)
             {
                 newcenters_[i] = newcenters_[i] * (iteration_ * blockiterations_ + iterator_ - 1) + prev_CVs_[i];
                 newcenters_[i] /= (iteration_ * blockiterations_ + iterator_);
             }
         }
         else
         {
             // Calculate running averages for each CV at each node 
             for(size_t i = 0; i < newcenters_.size(); i++)
             {
                 newcenters_[i] = newcenters_[i] * (iteration_ * blockiterations_ + iterator_ - 1) + cvs[i]->GetMinimumImage(centers_[i]);
                 newcenters_[i] /= (iteration_ * blockiterations_ + iterator_);
             }
             
             //Store info about this step in prev_vectors
             prev_CVs_.clear();
             for(size_t i = 0; i < centers_.size(); i++)
             {
                 prev_CVs_.push_back(cvs[i]->GetMinimumImage(centers_[i]));
             }
             prev_positions_[0] = snapshot->SerializePositions();
             prev_IDs_[0] = snapshot->SerializeIDs();
         }
  
         // Update the string, every blockiterations_ string method iterations
         if(iterator_ % blockiterations_ == 0)
         {
             MPI_Barrier(world_);
             StringUpdate();
             CheckEnd(cvs);
             MPI_Barrier(world_);
             UpdateWorldString(cvs); 
             PrintString(cvs);
  
             iterator_ = 0; //Number of steps within current method iteration
             iteration_++; //Increment string method iteration
  
             if(!InCell(cvs))
             {
                 run_umbrella_ = true;
                 reset_for_umbrella = false; 
             }
             MPI_Allreduce(MPI_IN_PLACE, &run_umbrella_, 1, MPI_INT, MPI_LOR, world_); //Compares all run_umbrellas on all processors - if any is true, all are set to true  
         }
  
         iterator_++; //Iterate number of steps within current method iteration  
     }

References blockiterations_, SSAGES::StringMethod::centers_, SSAGES::StringMethod::CheckEnd(), SSAGES::Method::cvmask_, SSAGES::StringMethod::cvspring_, SSAGES::CVManager::GetCVs(), SSAGES::Snapshot::GetForces(), SSAGES::Snapshot::GetLocalIndex(), SSAGES::Snapshot::GetPositions(), InCell(), SSAGES::StringMethod::iteration_, SSAGES::StringMethod::iterator_, min_num_umbrella_steps_, SSAGES::StringMethod::newcenters_, prev_CVs_, SSAGES::StringMethod::prev_IDs_, SSAGES::StringMethod::prev_positions_, SSAGES::StringMethod::PrintString(), reset_for_umbrella, run_umbrella_, SSAGES::Snapshot::SerializeIDs(), SSAGES::Snapshot::SerializePositions(), StringUpdate(), umbrella_iter_, SSAGES::StringMethod::UpdateWorldString(), and SSAGES::Method::world_.

Here is the call graph for this function:

The documentation for this class was generated from the following files:

/home/michael/development/SSAGES/src/Methods/FiniteTempString.h
/home/michael/development/SSAGES/src/Methods/FiniteTempString.cpp

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FiniteTempString()

Member Function Documentation

◆ InCell()

◆ PostIntegration()