Swarm of Trajectories String Method. More...

#include <Swarm.h>

Inheritance diagram for SSAGES::Swarm:

[legend]

Public Member Functions
	Swarm (const MPI_Comm &world, const MPI_Comm &comm, const std::vector< double > &centers, unsigned int maxiterations, const std::vector< double > cvspring, unsigned int frequency, unsigned int InitialSteps, unsigned int HarvestLength, unsigned int NumberTrajectories, unsigned int SwarmLength)
	Constructor. More...

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

	~Swarm ()
	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
void	StringUpdate () override
	Updates the positions of the string.

bool	CVInitialized (const CVList &cvs)
	Helper function check if CVs are initialized correctly. More...

Private Attributes
std::vector< double >	cv_drift_
	Drift of CVs for one iteration.

unsigned int	initialize_steps_
	Total number of MD steps for initialization for one iteration.

unsigned int	harvest_length_
	Length to run before harvesting a trajectory for unrestrained sampling.

unsigned int	restrained_steps_
	Total number of restrained MD steps for one iteration.

unsigned int	number_trajectories_
	Number of trajectories per swarm.

unsigned int	swarm_length_
	Length of unrestrained trajectories.

unsigned int	unrestrained_steps_
	Total number of unrestrained MD steps for one iteration.

unsigned int	index_
	For indexing trajectory vectors.

std::vector< Label >	traj_atomids_
	Store atom IDs for starting trajecotires.

bool	sampling_started
	Flag for determing whether to perform initialization or not.

bool	snapshot_stored
	Flag for whether a snapshot was stored in the umbrella sampling.

int	initialized
	Flag for whether a system is initialized at a given iteration.

bool	original_initialized
	Flag for whether a system was initialized before it checked whether other systems were.

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

Swarm of Trajectories String Method.

Implementation of the swarm of trajectories string method.

Definition at line 32 of file Swarm.h.

Constructor & Destructor Documentation

◆ Swarm()

SSAGES::Swarm::Swarm	(	const MPI_Comm &	world,
		const MPI_Comm &	comm,
		const std::vector< double > &	centers,
		unsigned int	maxiterations,
		const std::vector< double >	cvspring,
		unsigned int	frequency,
		unsigned int	InitialSteps,
		unsigned int	HarvestLength,
		unsigned int	NumberTrajectories,
		unsigned int	SwarmLength
	)

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	Aplly method with this frequency.
InitialSteps	Number of initial steps.
HarvestLength	Length of trajectory before weighing.
NumberTrajectories	Number of trajectories.
SwarmLength	Lengt of the swarms.

Constructs an instance of the swarm of trajectories method.

Definition at line 103 of file Swarm.h.

                                             : 
             StringMethod(world, comm, centers, maxiterations, cvspring, frequency),                 
             cv_drift_(), 
             initialize_steps_(InitialSteps), 
             harvest_length_(HarvestLength), 
             number_trajectories_(NumberTrajectories), 
             swarm_length_(SwarmLength)
             {
                 cv_drift_.resize(centers_.size(), 0);
                 prev_positions_.resize(number_trajectories_);
                 prev_velocities_.resize(number_trajectories_);
                 prev_IDs_.resize(number_trajectories_);
                 //Additional initializing
  
                 index_ = 0;  
                 restrained_steps_ = harvest_length_*number_trajectories_; 
                 unrestrained_steps_ = swarm_length_*number_trajectories_;
                 sampling_started = false;
                 snapshot_stored = false;
  
                 iterator_ = 0; //Override default StringMethod.h initializing
             }

References SSAGES::StringMethod::centers_, cv_drift_, harvest_length_, index_, SSAGES::StringMethod::iterator_, number_trajectories_, SSAGES::StringMethod::prev_IDs_, SSAGES::StringMethod::prev_positions_, SSAGES::StringMethod::prev_velocities_, restrained_steps_, sampling_started, snapshot_stored, swarm_length_, and unrestrained_steps_.

Member Function Documentation

◆ CVInitialized()

bool SSAGES::Swarm::CVInitialized ( const CVList & cvs )

private

Helper function check if CVs are initialized correctly.

Parameters

cvs	List of CVs to check

Returns: Boolean if CVs are initialized correctly

Definition at line 35 of file Swarm.cpp.

     {
         double threshold = 0.2;
         const double eps = 0.0000000001;
         double diff;
  
         //On the first iteration, check that the CVs are within (threshold*100)% of the center value they're associated to
         for(size_t i = 0; i < cvs.size(); i++)
         {
             if(std::abs(centers_[i]) <= eps)
             {//e.g. if centers_[i] = 0.0
                 if(std::abs(cvs[i]->GetValue()) <= threshold)
                 {
                     diff = 0; //If current value is approximately zero then go ahead
                 }
                 else
                 {
                     diff = 2*threshold; //Will always be greater than threshold
                 }
                 //diff = std::abs((cvs[i]->GetValue() - (centers_[i]+eps))) / ((cvs[i]->GetValue() + (eps + centers_[i]))/2.0);
                 //std::cout << "MPIID = " << mpiid_ << " and center[" << i << "] = 0.0 and diff = " << diff << std::endl; 
             }
             else
             {
                 diff = std::abs((cvs[i]->GetValue() - (centers_[i]))) / ((cvs[i]->GetValue() + (centers_[i]))/2.0);
                 //std::cout << "MPIID = " << mpiid_ << " and center[" << i << "] != 0.0 and diff = " << diff << std::endl; 
             }
             if(std::abs(diff) >= threshold)
             {
                 return false; //proceed to initialize again
             }
         } 
         return true; //OK to move on to regular sampling
     }

References SSAGES::StringMethod::centers_.

Referenced by PostIntegration().

Here is the caller graph for this function:

◆ PostIntegration()

void SSAGES::Swarm::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 70 of file Swarm.cpp.

     {
         auto cvs = cvmanager.GetCVs(cvmask_);
         auto& forces = snapshot->GetForces();
         auto& positions = snapshot->GetPositions();
         auto& velocities = snapshot->GetVelocities();
  
         //First check if a previous snapshot was stored; the system is definitely initialized if so
         if(snapshot_stored)
         {
             initialized = true;
         }
         else
         {
             initialized = CVInitialized(cvs); //If no snapshot stored, evalute whether the system finish initializing
         }
         
         original_initialized = initialized; //Will remember whether this system was initialized before the MPI call overrides it
  
         //If system finished initializing and hadn't entered the sampling blocks, check if a snapshot was stored.  If not, store one and don't store any future snapshots.
         if(initialized && !sampling_started)
         {
             if(!snapshot_stored)
             {
                 prev_positions_[index_] = snapshot->SerializePositions();
                 prev_velocities_[index_] = snapshot->SerializeVelocities();
                 prev_IDs_[index_] = snapshot->SerializeIDs();
                 snapshot_stored = true;
             }
         } 
         MPI_Allreduce(MPI_IN_PLACE, &initialized, 1, MPI_INT, MPI_LAND, world_); //Check if all systems are initialized; initialize is only true if everything node finished initializing
         //If any system wasn't initialized and the sampling block were not entered, begin restraining each node
         if(!initialized && !sampling_started)
         {
             //Do restrained sampling; NO trajectory harvesting 
             if(!original_initialized)
             {
                 //If the system was not initialized originally, restrain it
                 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++)
                     {
                         for(int k = 0; k < forces[j].size(); k++)
                         {
                             forces[j][k] -= (double)D*grad[j][k];
                         }
                     }
                 }
             }
             else
             {
                 //If the system was already initialized, simply reset the positions and velocities; this keeps them in their initialized states
                 index_ = 0;
                 for(auto& force: forces)
                     force.setZero();
  
                 for(size_t i = 0; i < prev_IDs_[index_].size(); i++)
                 {
                     auto localindex = snapshot->GetLocalIndex(prev_IDs_[index_][i]);
                     if(localindex!= -1)
                     {
                         positions[localindex][0] = prev_positions_[index_][i*3];
                         positions[localindex][1] = prev_positions_[index_][i*3 + 1];
                         positions[localindex][2] = prev_positions_[index_][i*3 + 2];
  
                         velocities[localindex][0] = prev_velocities_[index_][i*3];
                         velocities[localindex][1] = prev_velocities_[index_][i*3 + 1];
                         velocities[localindex][2] = prev_velocities_[index_][i*3 + 2];
  
                     }
                 }
             }
         }
         else
         {
             //Enter this block is every node was done initializing, or the sampling had already begun
             if(!sampling_started)
             {
                 sampling_started = true; //If the node got here right after initializing, set the flag that sampling has begun (preventing unneeded initializing in the future)
             }
             if(iterator_ <= initialize_steps_ + restrained_steps_)
             {
                 //Do restrained sampling, and do harvest trajectories
                 for(size_t i = 0; i < cvs.size(); i++)
                 {
                     if(iterator_ == 0)
                     {
                         index_ = 0; //Reset index when starting
                     }
                     //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++)
                     {
                         for(int k = 0; k < forces[j].size(); k++)
                         {
                             forces[j][k] -= (double)D*grad[j][k]; 
                         }
                     }
                 }
                 if(iterator_ > initialize_steps_)
                 {
                     //Harvest a trajectory every harvest_length_ steps
                     if(iterator_ % harvest_length_ == 0)
                     {
                         prev_positions_[index_] = snapshot->SerializePositions();
                         prev_velocities_[index_] = snapshot->SerializeVelocities();
                         prev_IDs_[index_] = snapshot->SerializeIDs();
                         index_++;
                     }
                 }
                 if(iterator_ == initialize_steps_ + restrained_steps_)
                 {
                     //Reset positions and forces before first call to unrestrained sampling
                     index_ = 0;
                     for(auto& force: forces)
                         force.setZero();
  
                     for(size_t i = 0; i < prev_IDs_[index_].size(); i++)
                     {
                         auto localindex = snapshot->GetLocalIndex(prev_IDs_[index_][i]);
                         if(localindex!= -1)
                         {
                             positions[localindex][0] = prev_positions_[index_][i*3];
                             positions[localindex][1] = prev_positions_[index_][i*3 + 1];
                             positions[localindex][2] = prev_positions_[index_][i*3 + 2];
  
                             velocities[localindex][0] = prev_velocities_[index_][i*3];
                             velocities[localindex][1] = prev_velocities_[index_][i*3 + 1];
                             velocities[localindex][2] = prev_velocities_[index_][i*3 + 2];
  
                         }
                     }
                 }
                 iterator_++;
             }
             else if(iterator_ <= initialize_steps_ + restrained_steps_ + unrestrained_steps_)
             {
                 //Launch unrestrained trajectories
                 if((iterator_ - initialize_steps_ - restrained_steps_) % swarm_length_ == 0)
                 {
                     //End of trajectory, harvest drift
                     for(size_t i = 0; i < cv_drift_.size(); i++)
                     { 
                         cv_drift_[i] = (cv_drift_[i]*index_ + cvs[i]->GetMinimumImage(centers_[i])  - centers_[i]) / (index_+1); //Calculate running average of drifts 
                     }
                     //Set up for next trajectory
                     index_++;
  
                     if(index_ < number_trajectories_)
                     {
                         for(auto& force: forces)
                             force.setZero();
  
                         for(size_t i = 0; i < prev_IDs_[index_].size(); i++)
                         {
                             auto localindex = snapshot->GetLocalIndex(prev_IDs_[index_][i]);
                             if(localindex!= -1)
                             {
                                 positions[localindex][0] = prev_positions_[index_][i*3];
                                 positions[localindex][1] = prev_positions_[index_][i*3 + 1];
                                 positions[localindex][2] = prev_positions_[index_][i*3 + 2];
  
                                 velocities[localindex][0] = prev_velocities_[index_][i*3];
                                 velocities[localindex][1] = prev_velocities_[index_][i*3 + 1];
                                 velocities[localindex][2] = prev_velocities_[index_][i*3 + 2];
  
                             }
                         }
                     }
                 }
                 iterator_++;
             }
             else
             {
                 //Evolve CVs, reparametrize, and reset vectors
                 iteration_++;
                 
                 MPI_Barrier(world_);
                 StringUpdate();
                 CheckEnd(cvs);
                 MPI_Barrier(world_);
                 UpdateWorldString(cvs); 
                 PrintString(cvs);
  
                 iterator_ = 0;
                 index_ = 0;
                 snapshot_stored = false;
  
                 for(size_t i = 0; i < cv_drift_.size(); i++)
                 {
                     cv_drift_[i] = 0; 
                 }
             }
         } 
     }

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/Swarm.h
/home/michael/development/SSAGES/src/Methods/Swarm.cpp

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Swarm()

Member Function Documentation

◆ CVInitialized()

◆ PostIntegration()