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

#include <StringMethod.h>

Inheritance diagram for SSAGES::StringMethod:

[legend]

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
	Method call prior to simulation initiation. More...

virtual void	PostIntegration (Snapshot *snapshot, const class CVManager &cvmanager) override=0
	Method call post integration. 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.

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

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

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

◆ StringMethod()

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 176 of file StringMethod.h.

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

References centers_, and newcenters_.

Member Function Documentation

◆ Build()

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 220 of file StringMethod.cpp.

     {
         ObjectRequirement validator;
         Value schema;
         CharReaderBuilder rbuilder;
         CharReader* reader = rbuilder.newCharReader();
         
         StringMethod* m = nullptr;
  
         reader->parse(JsonSchema::StringMethod.c_str(),
                       JsonSchema::StringMethod.c_str() + JsonSchema::StringMethod.size(),
                       &schema, nullptr);
         validator.Parse(schema, path);
  
         // Validate inputs.
         validator.Validate(json, path);
         if(validator.HasErrors())
             throw BuildException(validator.GetErrors());
  
         unsigned int wid = GetWalkerID(world, comm);
         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.c_str(),
                           JsonSchema::ElasticBandMethod.c_str() + JsonSchema::ElasticBandMethod.size(),
                           &schema, nullptr);
             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.c_str(),
                           JsonSchema::FTSMethod.c_str() + JsonSchema::FTSMethod.size(),
                           &schema, nullptr);
             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.c_str(),
                           JsonSchema::SwarmMethod.c_str() + JsonSchema::SwarmMethod.size(),
                           &schema, nullptr);
             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;
     }

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

Here is the call graph for this function:

◆ CheckEnd()

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.

     {
         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;
     }

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

Here is the caller graph for this function:

◆ distance()

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.

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

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

Here is the caller graph for this function:

◆ GatherNeighbors()

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.

     {
         MPI_Status status;
  
         if(IsMasterRank(comm_))
         {
             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_);
     }

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

Here is the caller graph for this function:

◆ PostIntegration()

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

overridepure virtual

Method call post integration.

Parameters

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

This function will be called after each integration step.

Implements SSAGES::Method.

Implemented in SSAGES::Swarm, SSAGES::FiniteTempString, and SSAGES::ElasticBand.

◆ PostSimulation()

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

overridevirtual

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 169 of file StringMethod.cpp.

     {
         stringout_.close();
     }

◆ PreSimulation()

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

overridevirtual

Method call prior to simulation initiation.

Parameters

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

This function will be called before the simulation is started.

Implements SSAGES::Method.

Definition at line 152 of file StringMethod.cpp.

     {
         char file[1024];
         mpiid_ = snapshot->GetWalkerID();
         sprintf(file, "node-%04d.log",mpiid_);
         stringout_.open(file);
  
         auto cvs = cvmanager.GetCVs(cvmask_);        
         SetSendRecvNeighbors();
         worldstring_.resize(numnodes_);
         for(auto& w : worldstring_)
             w.resize(centers_.size());
         
         UpdateWorldString(cvs);
         PrintString(cvs);
     }

References SSAGES::CVManager::GetCVs(), and SSAGES::Snapshot::GetWalkerID().

Here is the call graph for this function:

◆ PrintString()

void SSAGES::StringMethod::PrintString ( const CVList & CV )

protected

Prints the CV positions to file.

Parameters

CV	Collective Variables to be printed

Definition at line 38 of file StringMethod.cpp.

     {
         if(IsMasterRank(comm_))
         {
             //Write node, iteration, centers of the string and current CV value to output file
             stringout_.precision(8);
             stringout_ << mpiid_ << " " << iteration_ << " ";
  
             for(size_t i = 0; i < centers_.size(); i++)
                 stringout_ << worldstring_[mpiid_][i] << " " << CV[i]->GetValue() << " ";
  
             stringout_ << std::endl;
         }
     }

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

Here is the caller graph for this function:

◆ SetTolerance()

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 205 of file StringMethod.h.

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

References tol_.

Referenced by Build().

Here is the caller graph for this function:

◆ StringReparam()

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.

     {
         std::vector<double> alpha_star_vector(numnodes_,0.0);
  
         //Reparameterization
         //Alpha star is the uneven mesh, approximated as linear distance between points
         if(IsMasterRank(comm_))
             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(IsMasterRank(comm_))
                 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)); 
         }
     }

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

Here is the caller graph for this function:

◆ TolCheck()

bool SSAGES::StringMethod::TolCheck ( ) const

inlineprotected

Check whether tolerance criteria have been met.

Returns: Boolean for whether tolerance criteria have been met.

Definition at line 140 of file StringMethod.h.

         {
             if(tol_.size() == 0)
                 return false;
  
             for(size_t i = 0; i < centers_.size(); i++)
             {
                 if(fabs(centers_[i] - worldstring_[mpiid_][i]) > tol_[i])
                 {
                     return false;
                 }
             }
  
             return true;
         }

References centers_, mpiid_, tol_, and worldstring_.

◆ UpdateWorldString()

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.

     {
         for(size_t i = 0; i < centers_.size(); i++)
         {
             std::vector<double> cvs_new(numnodes_, 0.0);
  
             if(IsMasterRank(comm_))
             {
                 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]); 
             }
         }
     }

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

Here is the caller graph for this function:

Member Data Documentation

◆ worldstring_

std::vector<std::vector<double> > SSAGES::StringMethod::worldstring_

protected

The world's strings centers for each CV.

worldstring_[node#][cv#]

Definition at line 52 of file StringMethod.h.

Referenced by SSAGES::FiniteTempString::InCell(), and TolCheck().

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

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ StringMethod()

Member Function Documentation

◆ Build()

◆ CheckEnd()

◆ distance()

◆ GatherNeighbors()

◆ PostIntegration()

◆ PostSimulation()

◆ PreSimulation()

◆ PrintString()

◆ SetTolerance()

◆ StringReparam()

◆ TolCheck()

◆ UpdateWorldString()

Member Data Documentation

◆ worldstring_