SSAGES::Meta Class Reference

"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
	Method call prior to simulation initiation. More...
void	PostIntegration (Snapshot *snapshot, const class CVManager &cvmanager) override
	Method call post integration. More...
void	PostSimulation (Snapshot *snapshot, const class CVManager &cvmanager) override
	Method call post simulation. More...
void	LoadHills (const std::string &filename)
	Load hills from file. More...
	~Meta ()
	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 Meta *	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...

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 iteration)
	Prints the new hill to file. More...

Private Attributes
std::vector< Hill >	hills_
	Hills.
double	height_
	Hill height.
std::vector< double >	widths_
	Hill widths.
unsigned int	hillfreq_
	Frequency of new hills.
Grid< Vector > *	grid_
	CV Grid.
std::ofstream	hillsout_
	Output stream for hill data.
std::vector< double >	derivatives_
std::vector< double >	tder_
std::vector< double >	dx_
std::vector< double >	upperb_
std::vector< double >	lowerb_
std::vector< double >	upperk_
std::vector< double >	lowerk_

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

"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

Meta()

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.
lowerb	Lower bounds for CVs.
upperb	Upper bounds for CVs.
lowerk	Lower bound restraints for CVs.
upperk	Upper bound restraints for CVs.
grid	Grid containing bias.
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 143 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

AddHill()

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.

    {
        size_t 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(IsMasterRank(comm_))
        {
            for(size_t i = 0, j = GetWalkerID(world_,comm_)*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(size_t 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(IsMasterRank(world_))
                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];
            }
        }
    }

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

Here is the call graph for this function:

Build()

Meta * SSAGES::Meta::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 332 of file Meta.cpp.

    {
        ObjectRequirement validator;
        Value schema;
        CharReaderBuilder rbuilder;
        CharReader* reader = rbuilder.newCharReader();
 
        reader->parse(JsonSchema::MetadynamicsMethod.c_str(),
                      JsonSchema::MetadynamicsMethod.c_str() + JsonSchema::MetadynamicsMethod.size(),
                      &schema, nullptr);
        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 < static_cast<int>(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;       
    }

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

Here is the call graph for this function:

CalcBiasForce()

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.

    {   
        // 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(IsMasterRank(comm_))
                {
                    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]);
        }
    }

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

Here is the call graph for this function:

LoadHills()

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

PostIntegration()

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

overridevirtual

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.

Definition at line 100 of file Meta.cpp.

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

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

Here is the call graph for this function:

PostSimulation()

void SSAGES::Meta::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 131 of file Meta.cpp.

    {
    }

PreSimulation()

void SSAGES::Meta::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 62 of file Meta.cpp.

    {
        auto cvs = cvmanager.GetCVs(cvmask_);
        // Write ouput file header.
        if(IsMasterRank(world_))
        {
            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());
    }

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

Here is the call graph for this function:

PrintHill()

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

private

Prints the new hill to file.

Parameters

hill	Hill to be printed.
iteration	Current iteration.

Definition at line 236 of file Meta.cpp.

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

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

Member Data Documentation

derivatives_

std::vector<double> SSAGES::Meta::derivatives_

private

Derivatives and temporary storage vectors.

Definition at line 82 of file Meta.h.

upperb_

std::vector<double> SSAGES::Meta::upperb_

private

Bounds

Definition at line 93 of file Meta.h.

upperk_

std::vector<double> SSAGES::Meta::upperk_

private

Bound restraints.

Definition at line 98 of file Meta.h.

---

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

• /home/michael/development/SSAGES/src/Methods/Meta.h
• /home/michael/development/SSAGES/src/Methods/Meta.cpp