String base class for FTS, Swarm, and elastic band. More...

#include <StringMethod.h>

Inheritance diagram for SSAGES::StringMethod:

Public Member Functions
	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
	Pre-simulation hook.

virtual void	PostIntegration (Snapshot *snapshot, const class CVManager &cvmanager) override=0
	Post-integration hook.

void	PostSimulation (Snapshot *, const class 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 (uint frequency, const MPI_Comm &world, const MPI_Comm &comm)
	Constructor. More...

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

virtual	~Method ()
	Destructor.

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

uint	GetFrequency () const
	Get frequency of event listener. More...

virtual	~EventListener ()
	Destructor.

Static Public Member Functions
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...

Protected Member Functions
virtual void	StringUpdate ()=0
	Updates the position of the string.

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.

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 has been met.

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

Protected Attributes
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.

uint	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< uint >	cvmask_
	Mask which identifies which CVs to act on.

Detailed Description

String base class for FTS, Swarm, and elastic band.

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

Definition at line 38 of file StringMethod.h.

Constructor & Destructor Documentation

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
	)

inline

Constructor.

Parameters

world	MPI global communicator.
comm	MPI local communicator.
centers	List of centers.
maxiterations	Maximum number of iterations.
cvspring	Spring constants for cvs.
frequency	Frequency with which this method is invoked.

Definition at line 170 of file StringMethod.h.

References centers_, and newcenters_.

                                              : 
         Method(frequency, world, comm), centers_(centers), 
         maxiterator_(maxiterations), 
         cvspring_(cvspring), iterator_(1), iteration_(0)
         {
             newcenters_.resize(centers_.size(), 0);
         }

Member Function Documentation

StringMethod * SSAGES::StringMethod::Build	(	const Json::Value &	json,
		const MPI_Comm &	world,
		const MPI_Comm &	comm,
		const std::string &	path
	)

static

Build a derived method from JSON node.

Parameters

json	JSON Value containing all input information.
world	MPI global communicator.
comm	MPI local communicator.
path	Path for JSON path specification.

Returns: Pointer to the Method built. nullptr if an unknown error occurred.

This function builds a registered method from a JSON node. The difference between this function and "Build" is that this automatically determines the appropriate derived type based on the JSON node information.

Note: Object lifetime is the caller's responsibility.

Definition at line 215 of file StringMethod.cpp.

References Json::Requirement::GetErrors(), Json::Requirement::HasErrors(), Json::ObjectRequirement::Parse(), SetTolerance(), and Json::ObjectRequirement::Validate().

     {
         ObjectRequirement validator;
         Value schema;
         Reader reader;
 
         StringMethod* m = nullptr;
 
         reader.parse(JsonSchema::StringMethod, schema);
         validator.Parse(schema, path);
 
         // Validate inputs.
         validator.Validate(json, path);
         if(validator.HasErrors())
             throw BuildException(validator.GetErrors());
 
         unsigned int wid = mxx::comm(world).rank()/mxx::comm(comm).size();
         std::vector<double> centers;
         for(auto& s : json["centers"][wid])
             centers.push_back(s.asDouble());
 
         auto maxiterator = json.get("max_iterations", 0).asInt();
 
         std::vector<double> ksprings;
         for(auto& s : json["ksprings"])
             ksprings.push_back(s.asDouble());
 
         auto freq = json.get("frequency", 1).asInt();
 
         // Get stringmethod flavor. 
         std::string flavor = json.get("flavor", "none").asString();
         if(flavor == "ElasticBand")
         {
             reader.parse(JsonSchema::ElasticBandMethod, schema);
             validator.Parse(schema, path);
 
             // Validate inputs.
             validator.Validate(json, path);
             if(validator.HasErrors())
                 throw BuildException(validator.GetErrors());
 
             auto eqsteps = json.get("equilibration_steps", 20).asInt();
             auto evsteps = json.get("evolution_steps", 5).asInt();
             auto stringspring = json.get("kstring", 10.0).asDouble();
             auto isteps = json.get("block_iterations", 100).asInt();
             auto tau = json.get("time_step", 0.1).asDouble();
 
             m = new ElasticBand(world, comm, centers, 
                                 maxiterator, isteps,
                                 tau, ksprings, eqsteps,
                                 evsteps, stringspring, freq);
 
             if(json.isMember("tolerance"))
             {
                 std::vector<double> tol;
                 for(auto& s : json["tolerance"])
                     tol.push_back(s.asDouble());
 
                 m->SetTolerance(tol);
             }
         }
         else if(flavor == "FTS")
         {
             reader.parse(JsonSchema::FTSMethod, schema);
             validator.Parse(schema, path);
 
             // Validate inputs.
             validator.Validate(json, path);
             if(validator.HasErrors())
                 throw BuildException(validator.GetErrors());
             
             auto isteps = json.get("block_iterations", 2000).asInt();
             auto tau = json.get("time_step", 0.1).asDouble();
             auto kappa = json.get("kappa", 0.1).asDouble();
             auto springiter = json.get("umbrella_iterations",2000).asDouble();
             m = new FiniteTempString(world, comm, centers, 
                                      maxiterator, isteps,
                                      tau, ksprings, kappa,
                                      springiter, freq);
 
             if(json.isMember("tolerance"))
             {
                 std::vector<double> tol;
                 for(auto& s : json["tolerance"])
                     tol.push_back(s.asDouble());
 
                 m->SetTolerance(tol);
             }
         }
         else if(flavor == "SWARM")
         {
             reader.parse(JsonSchema::SwarmMethod, schema);
             validator.Parse(schema, path);
             
             //Validate input
             validator.Validate(json, path);
             if(validator.HasErrors())
                 throw BuildException(validator.GetErrors());
 
             auto InitialSteps = json.get("initial_steps", 2500).asInt();
             auto HarvestLength = json.get("harvest_length", 10).asInt();
             auto NumberTrajectories = json.get("number_of_trajectories", 250).asInt();
             auto SwarmLength = json.get("swarm_length", 20).asInt();
             
             m = new Swarm(world, comm, centers, maxiterator, ksprings, freq, InitialSteps, HarvestLength, NumberTrajectories, SwarmLength);
             
             if(json.isMember("tolerance"))
             {
                 std::vector<double> tol;
                 for(auto& s : json["tolerance"])
                     tol.push_back(s.asDouble());
 
                 m->SetTolerance(tol);
             }
         }
         
         return m;
     }

Here is the call graph for this function:

bool SSAGES::StringMethod::CheckEnd ( const CVList & CV )

protected

Check if method reached one of the exit criteria.

Parameters

CV	list of CVs.

Returns: True if one of the exit criteria is met.

The string method exits if either the maximum number of iteration has been reached or if all CVs are within the given tolerance thresholds.

Definition at line 128 of file StringMethod.cpp.

Referenced by SSAGES::ElasticBand::PostIntegration(), SSAGES::FiniteTempString::PostIntegration(), and SSAGES::Swarm::PostIntegration().

     {
         if(maxiterator_ && iteration_ > maxiterator_)
         {
             std::cout << "System has reached max string method iterations (" << maxiterator_ << ") as specified in the input file(s)." << std::endl; 
             std::cout << "Exiting now" << std::endl; 
             PrintString(CV); //Ensure that the system prints out if it's about to exit
             MPI_Abort(world_, EXIT_FAILURE);
         }
 
         int local_tolvalue = TolCheck();
 
         MPI_Allreduce(MPI_IN_PLACE, &local_tolvalue, 1, MPI_INT, MPI_LAND, world_);
 
         if(local_tolvalue)
         {
             std::cout << "System has converged within tolerance criteria. Exiting now" << std::endl;
             PrintString(CV); //Ensure that the system prints out if it's about to exit
             MPI_Abort(world_, EXIT_FAILURE);
         }
 
         return true;
     }

Here is the caller graph for this function:

double SSAGES::StringMethod::distance	(	const std::vector< double > &	x,
		const std::vector< double > &	y
	)		const

inlineprotected

Helper function for calculating distances.

Parameters

x	List of coordinates.
y	List of coordinates.

Returns: Sum of distances between the x-values and y-values.

Definition at line 102 of file StringMethod.h.

Referenced by SSAGES::FiniteTempString::StringUpdate(), and SSAGES::Swarm::StringUpdate().

         {
             double distance = 0;
             for (size_t i = 0; i < x.size(); i++)
                 distance += pow((x[i] - y[i]),2);
 
             return sqrt(distance);
         }

Here is the caller graph for this function:

void SSAGES::StringMethod::GatherNeighbors	(	std::vector< double > *	lcv0,
		std::vector< double > *	ucv0
	)

protected

Gather neighbors over MPI.

Parameters

lcv0	Pointer to store array of lower CV values.
ucv0	Pointer to store array of upper CV values.

Definition at line 53 of file StringMethod.cpp.

Referenced by SSAGES::ElasticBand::StringUpdate(), SSAGES::Swarm::StringUpdate(), and SSAGES::FiniteTempString::StringUpdate().

     {
         MPI_Status status;
 
         if(comm_.rank() == 0)
         {
             MPI_Sendrecv(&centers_[0], centers_.size(), MPI_DOUBLE, sendneigh_, 1234,
                 &(*lcv0)[0], centers_.size(), MPI_DOUBLE, recneigh_, 1234, 
                 world_, &status);
 
             MPI_Sendrecv(&centers_[0], centers_.size(), MPI_DOUBLE, recneigh_, 4321,
                 &(*ucv0)[0], centers_.size(), MPI_DOUBLE, sendneigh_, 4321, 
                 world_, &status);
         }
 
         MPI_Bcast(&(*lcv0)[0],centers_.size(),MPI_DOUBLE,0,comm_);
         MPI_Bcast(&(*ucv0)[0],centers_.size(),MPI_DOUBLE,0,comm_);
     }

Here is the caller graph for this function:

void SSAGES::StringMethod::PostSimulation	(	Snapshot *	snapshot,
		const class CVManager &	cvmanager
	)

inlineoverridevirtual

Method call post simulation.

Parameters

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

This function will be called after the end of the simulation run.

Implements SSAGES::Method.

Definition at line 190 of file StringMethod.h.

References stringout_.

         {
             stringout_.close();
         }

void SSAGES::StringMethod::SetTolerance ( std::vector< double > tol )

inline

Set the tolerance for quitting method.

Parameters

tol	List of tolerances for each CV.

Set the tolerance levels until which the method should run. The method quit, when the tolerance level is reached for all CVs.

Definition at line 202 of file StringMethod.h.

References tol_.

Referenced by Build().

         {
             for(auto& t : tol)
                 tol_.push_back(t);
         }

Here is the caller graph for this function:

void SSAGES::StringMethod::StringReparam ( double alpha_star )

protected

Reparameterize the string.

Parameters

alpha_star Factor for reparametrization.

Definition at line 72 of file StringMethod.cpp.

Referenced by SSAGES::FiniteTempString::StringUpdate(), and SSAGES::Swarm::StringUpdate().

     {
         std::vector<double> alpha_star_vector(numnodes_,0.0);
 
         //Reparameterization
         //Alpha star is the uneven mesh, approximated as linear distance between points
         if(comm_.rank()==0)
             alpha_star_vector[mpiid_] = mpiid_ == 0 ? 0 : alpha_star;
 
         //Gather each alpha_star into a vector 
         MPI_Allreduce(MPI_IN_PLACE, &alpha_star_vector[0], numnodes_, MPI_DOUBLE, MPI_SUM, world_);
 
         for(size_t i = 1; i < alpha_star_vector.size(); i++)
             alpha_star_vector[i] += alpha_star_vector[i-1];
         
         for(size_t i = 1; i < alpha_star_vector.size(); i++)
             alpha_star_vector[i] /= alpha_star_vector[numnodes_ - 1];
 
         tk::spline spl; //Cubic spline interpolation
 
         for(size_t i = 0; i < centers_.size(); i++)
         {
             std::vector<double> cvs_new(numnodes_, 0.0);
 
             if(comm_.rank() == 0)
                 cvs_new[mpiid_] = centers_[i];
 
             MPI_Allreduce(MPI_IN_PLACE, &cvs_new[0], numnodes_, MPI_DOUBLE, MPI_SUM, world_);
 
             spl.set_points(alpha_star_vector, cvs_new);
             centers_[i] = spl(mpiid_/(numnodes_ - 1.0)); 
         }
     }

Here is the caller graph for this function:

void SSAGES::StringMethod::UpdateWorldString ( const CVList & cvs )

protected

Update the world string over MPI.

Parameters

cvs	List of CVs.

Definition at line 106 of file StringMethod.cpp.

Referenced by SSAGES::ElasticBand::PostIntegration(), SSAGES::FiniteTempString::PostIntegration(), and SSAGES::Swarm::PostIntegration().

     {
         for(size_t i = 0; i < centers_.size(); i++)
         {
             std::vector<double> cvs_new(numnodes_, 0.0);
 
             if(comm_.rank() == 0)
             {
                 cvs_new[mpiid_] = centers_[i];
             }
 
             MPI_Allreduce(MPI_IN_PLACE, &cvs_new[0], numnodes_, MPI_DOUBLE, MPI_SUM, world_);
 
             for(int j = 0; j < numnodes_; j++)
             {
                 worldstring_[j][i] = cvs_new[j];
                 //Represent worldstring in periodic space
                 worldstring_[j][i] = cvs[i]->GetPeriodicValue(worldstring_[j][i]); 
             }
         }
     }