#include <Umbrella.h>

Inheritance diagram for SSAGES::Umbrella:

Public Member Functions
	Umbrella (const MPI_Comm &world, const MPI_Comm &comm, const std::vector< double > &kspring, const std::vector< double > &centers, std::string name, unsigned int frequency)
	Constructor. More...

	Umbrella (const MPI_Comm &world, const MPI_Comm &comm, const std::vector< double > &kspring, const std::vector< double > &centers0, const std::vector< double > &centers1, int timesteps, std::string name, unsigned int frequency)
	Constructor. More...

void	PreSimulation (Snapshot *snapshot, const class CVManager &cvmanager) override
	Pre-simulation hook. More...

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

void	PostSimulation (Snapshot *snapshot, const class CVManager &cvmanager) override
	Post-simulation hook. More...

void	SetOutputFrequency (int outfreq)
	Set output frequency. More...

void	SetAppend (bool append)
	Set append mode. More...

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 Umbrella *	Build (const Json::Value &json, const MPI_Comm &world, const MPI_Comm &comm, const std::string &path)

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

Private Member Functions
double	GetCurrentCenter (int iteration, unsigned i)

void	PrintUmbrella (const CVList &cvs, uint iteration)
	Print umbrella values. More...

Private Attributes
std::vector< double >	kspring_
	Vector of spring constants.

std::vector< double >	centers0_
	Vector of equilibrium distances.

std::vector< double >	centers1_

int	time_
	Amount of time over which to scale centers.

std::string	filename_
	Output filename.

int	outfreq_
	Frequency of outputting data.

std::ofstream	umbrella_
	Output stream for umbrella data.

bool	append_
	Append to output files?

Additional Inherited Members
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

Umbrella sampling method.

Umbrella sampling method to constrain an arbitrary number of CVs at specified equilibrium distances.

Definition at line 35 of file Umbrella.h.

Constructor & Destructor Documentation

SSAGES::Umbrella::Umbrella	(	const MPI_Comm &	world,
		const MPI_Comm &	comm,
		const std::vector< double > &	kspring,
		const std::vector< double > &	centers,
		std::string	name,
		unsigned int	frequency
	)

inline

Constructor.

Parameters

world	MPI global communicator.
comm	MPI local communicator.
kspring	List of spring constants.
centers	List of spring equilibrium positions.
name	Filename.
frequency	Frequency with which this method is applied.

Create instance of umbrella with spring constants "kspring", and centers "centers". Note the sizes of the vectors should be commensurate with the number of CVs.

Definition at line 89 of file Umbrella.h.

                                          : 
         Method(frequency, world, comm), kspring_(kspring), centers0_(centers),
         centers1_(centers), time_(0), filename_(name), outfreq_(1), append_(false)
         {
         }

SSAGES::Umbrella::Umbrella	(	const MPI_Comm &	world,
		const MPI_Comm &	comm,
		const std::vector< double > &	kspring,
		const std::vector< double > &	centers0,
		const std::vector< double > &	centers1,
		int	timesteps,
		std::string	name,
		unsigned int	frequency
	)

inline

Constructor.

Parameters

world	MPI global communicator.
comm	MPI local communicator.
kspring	List of spring constants.
centers0	List of starting spring equilibrium positions.
centers1	List of ending spring equilibrium positions.
timesteps	Number of timesteps over which to scale centers.
name	Filename.
frequency	Frequency with which this method is applied.

Create instance of umbrella with spring constants "kspring", and centers "centers". Note the sizes of the vectors should be commensurate with the number of CVs.

Definition at line 115 of file Umbrella.h.

                                          : 
         Method(frequency, world, comm), kspring_(kspring), centers0_(centers0),
         centers1_(centers1), time_(timesteps), filename_(name), outfreq_(1)
         {
         }

Member Function Documentation

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

static

Definition at line 113 of file Umbrella.cpp.

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

     {
         ObjectRequirement validator;
         Value schema;
         Reader reader;
 
         reader.parse(JsonSchema::UmbrellaMethod, schema);
         validator.Parse(schema, path);
 
         // Validate inputs.
         validator.Validate(json, path);
         if(validator.HasErrors())
             throw BuildException(validator.GetErrors());
         
         //TODO walker id should be obtainable in method as
         //     opposed to calculated like this. 
         uint wid = mxx::comm(world).rank()/mxx::comm(comm).size(); 
         bool ismulti = mxx::comm(world).size() > mxx::comm(comm).size();
         uint wcount = mxx::comm(world).size() / mxx::comm(comm).size();
 
         std::vector<std::vector<double>> ksprings;
         for(auto& s : json["ksprings"])
         {
             std::vector<double> kspring;
             if(s.isArray())
                 for(auto& k : s)
                     kspring.push_back(k.asDouble());
             else
                 kspring.push_back(s.asDouble());
             
             ksprings.push_back(kspring);
         }
 
         std::vector<std::vector<double>> centers0, centers1;
         if(json.isMember("centers"))
         {
             for(auto& s : json["centers"])
             {
                 std::vector<double> center;
                 if(s.isArray())
                     for(auto& k : s)
                         center.push_back(k.asDouble());
                 else
                     center.push_back(s.asDouble());
                 
                 centers0.push_back(center);
             }
         }
         else if(json.isMember("centers0") && json.isMember("centers1") && json.isMember("timesteps"))
         {
             for(auto& s : json["centers0"])
             {           
                 std::vector<double> center;
                 if(s.isArray())
                     for(auto& k : s)
                         center.push_back(k.asDouble());
                 else
                     center.push_back(s.asDouble());
                 
                 centers0.push_back(center);
             }
 
             for(auto& s : json["centers1"])
             {           
                 std::vector<double> center;
                 if(s.isArray())
                     for(auto& k : s)
                         center.push_back(k.asDouble());
                 else
                     center.push_back(s.asDouble());
                 
                 centers1.push_back(center);
             }
         }
         else
             throw BuildException({"Either \"centers\" or \"timesteps\", \"centers0\" and \"centers1\" must be defined for umbrella."});
 
         if(ksprings[0].size() != centers0[0].size())
             throw BuildException({"Need to define a spring for every center or a center for every spring!"});
         
         // If only one set of center/ksprings are specified. Fill it up for multi.
         if(ismulti)
         {
             if(ksprings.size() == 1)
                 for(size_t i = 1; i < wcount; ++i)
                     ksprings.push_back(ksprings[0]);
             else if(ksprings.size() != wcount)
                 throw std::invalid_argument(path + ": Multi-walker simulations requires that the number of \"ksprings\" match the number of walkers.");
             if(centers0.size() == 1)
                 for(size_t i = 1; i < wcount; ++i)
                     centers0.push_back(centers0[0]);
             else if(centers0.size() != wcount)
                 throw std::invalid_argument(path + ": Multi-walker simulations requires that the number of \"centers\"/\"centers0\" match the number of walkers.");
             if(centers1.size() == 1)
                 for(size_t i = 1; i < wcount; ++i)
                     centers1.push_back(centers1[0]);
             else if(centers1.size()) // centers1 is optional.
                 throw std::invalid_argument(path + ": Multi-walker simulations requires that the number of \"centers1\" match the number of walkers.");
         }
 
         auto freq = json.get("frequency", 1).asInt();
 
         uint timesteps = 0; 
         if(json.isMember("timesteps"))
         {
             if(json["timesteps"].isArray())
                 timesteps = json["timesteps"][wid].asUInt();
             else
                 timesteps = json["timesteps"].asUInt();
         }
 
         std::string name = "umbrella.dat"; 
         if(json["output_file"].isArray())
             name = json["output_file"][wid].asString(); 
         else if(ismulti)
             throw std::invalid_argument(path + ": Multi-walker simulations require a separate output file for each.");
         else
             name = json["output_file"].asString();
 
         Umbrella* m = nullptr;
         if(timesteps == 0)
             m = new Umbrella(world, comm, ksprings[wid], centers0[wid], name, freq);
         else
             m = new Umbrella(world, comm, ksprings[wid], centers0[wid], centers1[wid], timesteps, name, freq);
 
         m->SetOutputFrequency(json.get("output_frequency",0).asInt());
         m->SetAppend(json.get("append", false).asBool());
         
         return m;
     }

Here is the call graph for this function:

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

overridevirtual

Post-integration hook.

Parameters

snapshot	Simulation snapshot.
cvmanager	Collective variable manager.

Implements SSAGES::Method.

Definition at line 57 of file Umbrella.cpp.

References SSAGES::CVManager::GetCVs(), SSAGES::Snapshot::GetForces(), SSAGES::Snapshot::GetHMatrix(), SSAGES::Snapshot::GetIteration(), and SSAGES::Snapshot::GetVirial().

     {
         // Get necessary info. 
         auto cvs = cvmanager.GetCVs(cvmask_);
         auto& forces = snapshot->GetForces();
         auto& virial = snapshot->GetVirial();
         auto& H = snapshot->GetHMatrix();
 
         for(size_t i = 0; i < cvs.size(); ++i)
         {
             // Get current CV and gradient.
             auto& cv = cvs[i];
             auto& grad = cv->GetGradient();
             auto& boxgrad = cv->GetBoxGradient();
             // Compute dV/dCV.
             auto center = GetCurrentCenter(snapshot->GetIteration(), i);
             auto D = kspring_[i]*cv->GetDifference(center);
 
             // Update forces.
             for(size_t j = 0; j < forces.size(); ++j)
                 forces[j] -= D*grad[j];
             
             // Update virial. 
             virial += D*boxgrad;
         }
 
         if(snapshot->GetIteration() % outfreq_ == 0)
             PrintUmbrella(cvs, snapshot->GetIteration());
     }

Here is the call graph for this function:

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

overridevirtual

Post-simulation hook.

Parameters

snapshot	Simulation snapshot.
cvmanager	Collective variable manager.

Implements SSAGES::Method.

Definition at line 87 of file Umbrella.cpp.

     {
         if(comm_.rank() ==0)
             umbrella_.close();
     }

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

overridevirtual

Pre-simulation hook.

Parameters

snapshot	Simulation snapshot.
cvmanager	Collective variable manager.

Implements SSAGES::Method.

Definition at line 33 of file Umbrella.cpp.

References SSAGES::CVManager::GetCVs().

     {
         if(comm_.rank() == 0)
         {
             if(append_)
                 umbrella_.open(filename_.c_str(), std::ofstream::out | std::ofstream::app);
             else
             {
                 // Write out header.
                 umbrella_.open(filename_.c_str(), std::ofstream::out);
                 umbrella_ << "#"; 
                 umbrella_ << "Iteration "; 
 
                 auto cvs = cvmanager.GetCVs(cvmask_); 
                 for(size_t i = 0; i < cvs.size(); ++i)
                     umbrella_ << "cv_" + std::to_string(i) << " ";
 
                 for(size_t i = 0; i < cvs.size() - 1; ++i)
                     umbrella_ << "center_" + std::to_string(i) << " ";  
                 umbrella_ << "center_" + std::to_string(cvs.size() - 1) << std::endl;
             }
         }
     }

Here is the call graph for this function:

void SSAGES::Umbrella::PrintUmbrella	(	const CVList &	cvs,
		uint	iteration
	)

private

Print umbrella values.

Parameters

cvs	List of CVs.
iteration	Current iteration.

Definition at line 93 of file Umbrella.cpp.

     {
         if(comm_.rank() ==0)
         {
             umbrella_.precision(8);
             umbrella_ << iteration << " ";
 
             // Print out CV values first.
             for(auto& cv : cvs)
                 umbrella_ << cv->GetValue() << " ";
             
             // Print out target (center) of each CV. 
             for(size_t i = 0; i < cvs.size() - 1; ++i)
                 umbrella_ << GetCurrentCenter(iteration, i) << " "; 
             umbrella_ << GetCurrentCenter(iteration, cvs.size() - 1);
 
             umbrella_ << std::endl;
         }
     }

void SSAGES::Umbrella::SetAppend ( bool append )

inline

Set append mode.

Parameters

append Whether to enable or disable append mode.

Definition at line 162 of file Umbrella.h.

References append_.

Referenced by Build().

         {
             append_ = append;
         }

Here is the caller graph for this function:

void SSAGES::Umbrella::SetOutputFrequency ( int outfreq )

inline

Set output frequency.

Parameters

iter	New value for output frequency.

Definition at line 153 of file Umbrella.h.

References outfreq_.

Referenced by Build().

         {
             outfreq_ = outfreq;
         }

Here is the caller graph for this function:

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

/home/cody/SSAGES/src/Methods/Umbrella.h
/home/cody/SSAGES/src/Methods/Umbrella.cpp

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation