"Vanilla" multi-dimensional Metadynamics. More...

#include <Meta.h>

Inheritance diagram for SSAGES::Meta:

Public Member Functions
	Meta (const MPI_Comm &world, const MPI_Comm &comm, double height, const std::vector< double > &widths, const std::vector< double > &lowerb, const std::vector< double > &upperb, const std::vector< double > &lowerk, const std::vector< double > &upperk, Grid< Vector > *grid, unsigned int hillfreq, 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	LoadHills (const std::string &filename)
	Load hills from file. More...

	~Meta ()
	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 Meta *	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
void	AddHill (const CVList &cvs, int iteration)
	Adds a new hill. More...

void	CalcBiasForce (const CVList &cvs)
	Computes the bias force. More...

void	PrintHill (const Hill &hill, int interation)
	Prints the new hill to file. More...

Private Attributes
std::vector< Hill >	hills_
	Hills.

double	height_
	Hill height.

std::vector< double >	widths_
	Hill widths.

std::vector< double >	derivatives_
	Derivatives and temporary storage vectors.

std::vector< double >	tder_

std::vector< double >	dx_

unsigned int	hillfreq_
	Frequency of new hills.

Grid< Vector > *	grid_
	CV Grid.

std::vector< double >	upperb_
	Bounds.

std::vector< double >	lowerb_

std::vector< double >	upperk_
	Bound restraints.

std::vector< double >	lowerk_

std::ofstream	hillsout_
	Output stream for hill data.

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

"Vanilla" multi-dimensional Metadynamics.

Implementation of a "vanilla" multi-dimensional Metadynamics method with no bells and whistles.

Definition at line 68 of file Meta.h.

Constructor & Destructor Documentation

SSAGES::Meta::Meta	(	const MPI_Comm &	world,
		const MPI_Comm &	comm,
		double	height,
		const std::vector< double > &	widths,
		const std::vector< double > &	lowerb,
		const std::vector< double > &	upperb,
		const std::vector< double > &	lowerk,
		const std::vector< double > &	upperk,
		Grid< Vector > *	grid,
		unsigned int	hillfreq,
		unsigned int	frequency
	)

inline

Constructor.

Parameters

world	MPI global communicator.
comm	MPI local communicator.
height	Height of the hills to be deposited.
widths	Width of the hills to be deposited.
hillfreq	Frequency of depositing hills.
frequency	Frequency of invoking this method.

Constructs an instance of Metadynamics method.

Note: The size of "widths" should be commensurate with the number of CV's expected.

Definition at line 132 of file Meta.h.

                                      : 
         Method(frequency, world, comm), hills_(), height_(height), widths_(widths), 
         derivatives_(0), tder_(0), dx_(0), hillfreq_(hillfreq), grid_(grid),
         upperb_(upperb), lowerb_(lowerb), upperk_(upperk), lowerk_(lowerk)
         {
         }

Member Function Documentation

void SSAGES::Meta::AddHill	(	const CVList &	cvs,
		int	iteration
	)

private

Adds a new hill.

Parameters

cvs	List of CVs.
iteration	Current iteration.

Definition at line 168 of file Meta.cpp.

References SSAGES::gaussian(), and SSAGES::gaussianDerv().

     {
         int n = cvs.size();
 
         // Assume we have the same number of procs per walker.
         int nwalkers = world_.size()/comm_.size();
 
         // We need to exchange CV values across the walkers 
         // and to each proc on a walker.    
         std::vector<double> cvals(n*nwalkers, 0);
 
         if(comm_.rank() == 0)
         {
             for(auto i = 0, j = world_.rank()/comm_.size()*n; i < n; ++i,++j)
                 cvals[j] = cvs[i]->GetValue();
         }
 
         // Reduce across all processors and add hills.
         MPI_Allreduce(MPI_IN_PLACE, cvals.data(), n*nwalkers, MPI_DOUBLE, MPI_SUM, world_);
         
         for(int i = 0; i < n*nwalkers; i += n)
         {
             std::vector<double> cval(cvals.begin() + i, cvals.begin() + i + n);
             hills_.emplace_back(cval, widths_, height_);
             
             // Write hill to file.
             if(world_.rank() == 0)
                 PrintHill(hills_.back(), iteration);
         }
 
         // If grid is defined, add bias onto grid. 
         if(grid_ != nullptr)
         {
             std::vector<double> dx(n, 0.0), df(n, 1.0);
             auto& hill = hills_.back();
             for(auto it = grid_->begin(); it != grid_->end(); ++it)
             {
                 auto& val = *it;
                 auto coord = it.coordinates();
 
                 // Compute difference between grid point and current val. 
                 for(size_t i = 0; i < n; ++i)
                 {
                     dx[i] = -cvs[i]->GetDifference(coord[i]);
                     df[i] = 1.;
                 }
 
                 // Compute derivative.
                 for(size_t i = 0; i < n; ++i)
                 {
                     for(size_t j = 0; j < n; ++j)
                     {
                         if(j != i) 
                             df[i] *= gaussian(dx[j], hill.width[j]);
                         else
                             df[i] *= gaussianDerv(dx[j], hill.width[j]);
                     }
                 }
 
                 // Add to grid. 
                 for(size_t i = 0; i < n; ++i)
                     val[i] += height_*df[i];
             }
         }
     }

Here is the call graph for this function:

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

static

Definition at line 332 of file Meta.cpp.

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

     {
         ObjectRequirement validator;
         Value schema;
         Reader reader;
         
         reader.parse(JsonSchema::MetadynamicsMethod, schema);
         validator.Parse(schema, path);
 
         // Validate inputs.
         validator.Validate(json, path);
         if(validator.HasErrors())
             throw BuildException(validator.GetErrors());
 
         std::vector<double> widths;
         for(auto& s : json["widths"])
             widths.push_back(s.asDouble());
 
         std::vector<double> lowerb, upperb, lowerk, upperk;
         Grid<Vector>* grid = nullptr;
         if(json.isMember("grid"))
             grid = Grid<Vector>::BuildGrid(json.get("grid", Json::Value()));
         else if(!json.isMember("lower_bounds") || !json.isMember("upper_bounds"))
             throw BuildException({
                 "#/Method/Metadynamics: Both upper_bounds and lower_bounds "
                 "must be defined if grid is not being used."});
 
         // Assume all vectors are the same size. 
         for(int i = 0; i < json["lower_bound_restraints"].size(); ++i)
         {
             lowerk.push_back(json["lower_bound_restraints"][i].asDouble());
             upperk.push_back(json["upper_bound_restraints"][i].asDouble());
             lowerb.push_back(json["lower_bounds"][i].asDouble());
             upperb.push_back(json["upper_bounds"][i].asDouble());
         }
     
         auto height = json.get("height", 1.0).asDouble();
         auto hillfreq = json.get("hill_frequency", 1).asInt();
         auto freq = json.get("frequency", 1).asInt();
 
         auto* m = new Meta(
             world, comm, height, widths, 
             lowerb, upperb, lowerk, upperk,
             grid, hillfreq, freq
         );
 
         if(json.isMember("load_hills"))
             m->LoadHills(json["load_hills"].asString());
 
         return m;       
     }

Here is the call graph for this function:

void SSAGES::Meta::CalcBiasForce ( const CVList & cvs )

private

Computes the bias force.

Parameters

cvs	List of CVs.

Definition at line 253 of file Meta.cpp.

References SSAGES::gaussian(), and SSAGES::gaussianDerv().

     {   
         // Reset bias and derivatives.
         double bias = 0.;
         auto n = cvs.size();
 
         // Reset vectors.
         std::fill(derivatives_.begin(), derivatives_.end(), 0);
         
         // Look up and apply grid bias. 
         if(grid_ != nullptr)
         {
             bool inbounds = true;
             std::vector<double> val(n, 0.);
             for(size_t i = 0; i < n; ++i)
             {
                 val[i] = cvs[i]->GetValue();
                 if(val[i] < grid_->GetLower(i) || val[i]  > grid_->GetUpper(i))
                     inbounds = false;
             }
 
             if(inbounds)
             {
                 auto frc = (*grid_)[val];
                 for(size_t i = 0; i < n; ++i)
                     derivatives_[i] = frc[i];
             }
             else
             {
                 if(comm_.rank() == 0)
                 {
                     std::cerr << "Metadynamics: out of bounds ( ";
                     for(auto& v : val)
                         std::cerr << v << " "; 
                     std::cerr << ")" << std::endl;
                 }
             }
         }
         else
         {
             // Loop through hills and calculate the bias force.
             for(auto& hill : hills_)
             {       
                 auto tbias = 1.;
                 std::fill(tder_.begin(), tder_.end(), 1.0);
                 std::fill(dx_.begin(), dx_.end(), 1.0);
                 
                 for(size_t i = 0; i < n; ++i)
                 {
                     dx_[i] = cvs[i]->GetDifference(hill.center[i]);
                     tbias *= gaussian(dx_[i], hill.width[i]);
                 }
 
                 for(size_t i = 0; i < n; ++i)
                     for(size_t j = 0; j < n; ++j)
                     {
                         if(j != i) 
                             tder_[i] *= gaussian(dx_[j], hill.width[j]);
                         else
                             tder_[i] *= gaussianDerv(dx_[j], hill.width[j]);
                     }
 
                 bias += height_ * tbias;
                 for(size_t i = 0; i < n; ++i)
                     derivatives_[i] += height_*tder_[i];
             }
         }
 
         // Restraints.
         for(size_t i = 0; i < n; ++i)
         {
             auto cval = cvs[i]->GetValue();
             if(cval < lowerb_[i])
                 derivatives_[i] += lowerk_[i]*(cval - lowerb_[i]);
             else if(cval > upperb_[i])
                 derivatives_[i] += upperk_[i]*(cval - upperb_[i]);
         }
     }

Here is the call graph for this function:

void SSAGES::Meta::LoadHills ( const std::string & filename )

Load hills from file.

Parameters

filename File name containing hills.

Note: File format must match the output written by this method and the dimensionality of the hills must match the initialized Meta class.

Definition at line 136 of file Meta.cpp.

     {
         std::ifstream file(filename);
         std::string line; 
 
         auto dim = widths_.size();
         double iteration = 0, height = 0;
         std::vector<double> width(dim, 0.), center(dim, 0);
 
         // First line is a comment. 
         std::getline(file, line);
         while(std::getline(file, line))
         {
             std::istringstream iss(line);
             iss >> iteration; // Not really using this. 
             
             // Load centers.
             for(size_t i = 0; i < dim; ++i)
                 iss >> center[i];
             
             // Load widths.
             for(size_t i = 0; i < dim; ++i)
                 iss >> width[i];
             
             // Load height. 
             iss >> height;
 
             hills_.emplace_back(center, width, height);
         }
     }

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

overridevirtual

Post-integration hook.

Parameters

snapshot	Current simulation snapshot.
cvmanager	Collective variable manager.

Implements SSAGES::Method.

Definition at line 100 of file Meta.cpp.

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

     {
         auto cvs = cvmanager.GetCVs(cvmask_);
         // Add hills when needed.
         if(snapshot->GetIteration() % hillfreq_ == 0)
             AddHill(cvs, snapshot->GetIteration());
 
         // Always calculate the current bias.
         CalcBiasForce(cvs);
 
         // Take each CV and add its biased forces to the atoms
         // using the chain rule.
         auto& forces = snapshot->GetForces();
         auto& virial = snapshot->GetVirial();
 
         for(size_t i = 0; i < cvs.size(); ++i)
         {
             auto& grad = cvs[i]->GetGradient();
             auto& boxgrad = cvs[i]->GetBoxGradient();
             
             // Update the forces in snapshot by adding in the force bias from each
             // CV to each atom based on the gradient of the CV.
             for (size_t j = 0; j < forces.size(); ++j)
                 for(size_t k = 0; k < 3; ++k)
                     forces[j][k] -= derivatives_[i]*grad[j][k];
             
             virial += derivatives_[i]*boxgrad;
         }
     }

Here is the call graph for this function:

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

overridevirtual

Post-simulation hook.

Parameters

snapshot	Current simulation snapshot.
cvmanager	Collective variable manager.

Implements SSAGES::Method.

Definition at line 131 of file Meta.cpp.

132 {

133 }

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

overridevirtual

Pre-simulation hook.

Parameters

snapshot	Current simulation snapshot.
cvmanager	Collective variable manager.

Implements SSAGES::Method.

Definition at line 62 of file Meta.cpp.

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

     {
         auto cvs = cvmanager.GetCVs(cvmask_);
         // Write ouput file header.
         if(world_.rank() == 0)
         {
             hillsout_.open("hills.out");
             hillsout_ << "#Iteration "; 
 
             for(size_t i = 0; i < cvs.size(); ++i)
                 hillsout_ << "center." << i << " ";
     
             for(size_t i = 0; i < cvs.size(); ++i)
                 hillsout_ << "sigma." << i << " ";
             
             hillsout_ << "height" << std::endl;
                 
             hillsout_.close();
         }
 
         // Initialize grid to zero. 
         if(grid_ != nullptr)
         {
             Vector vec = Vector::Zero(cvs.size());
             std::fill(grid_->begin(), grid_->end(), vec);
         } 
 
         auto n = snapshot->GetTargetIterations();
         n = n ? n : 1e5; // Pre-allocate at least something.
     
         hills_.reserve(n+1);
         widths_.reserve(n+1);
         derivatives_.resize(cvs.size());
         tder_.resize(cvs.size());
         dx_.resize(cvs.size());
     }

Here is the call graph for this function:

void SSAGES::Meta::PrintHill	(	const Hill &	hill,
		int	interation
	)

private

Prints the new hill to file.

Parameters

hill	Hill to be printed.
iteration	Current iteration.

Definition at line 236 of file Meta.cpp.

References SSAGES::Hill::center, and SSAGES::Hill::width.

     {
         hillsout_.open("hills.out", std::fstream::app);
         
         hillsout_ << iteration << " ";
         hillsout_.precision(8);
         
         for(auto& cv : hill.center)
             hillsout_ << cv << " ";
         
         for(auto& w : hill.width)
             hillsout_ << w << " ";
 
         hillsout_ << height_ << std::endl;
         hillsout_.close();
     }

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

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

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation