SSAGES::CFF Class Reference

Combined Force Frequency (CFF) Algorithm. More...

#include <CFF.h>

Inheritance diagram for SSAGES::CFF:

Public Member Functions
	CFF (const MPI_Comm &world, const MPI_Comm &comm, const Eigen::VectorXi &topol, Grid< Eigen::VectorXd > *fgrid, Grid< unsigned int > *hgrid, Grid< double > *ugrid, std::vector< Grid< double > * > F, std::vector< Grid< double > * > Fworld, const std::vector< double > &lowerb, const std::vector< double > &upperb, const std::vector< double > &lowerk, const std::vector< double > &upperk, double temperature, double unitconv, double timestep, double weight, unsigned int nsweep, int min)
	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	SetPrevWeight (double h)
	Set previous history weight.
void	SetOutput (const std::string &outfile)
	Set name of output file.
void	SetOutputOverwrite (bool overwrite)
	Set overwrite flag on output file.
void	SetConvergeIters (unsigned int citers)
	Set number of iterations after which we turn on full weight.
void	SetMaxIters (unsigned int iters)
	Set maximum number of training iterations per sweep.
void	SetMinLoss (double loss)
	Set minimum loss function value (should be zero for production).
void	SetRatio (double trainratio)
	Set training ratio for gradient vs value.
	~CFF ()
	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 CFF *	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	TrainNetwork ()
	Trains the neural network. More...
void	WriteBias ()
	Writes out the bias and CFF output files.

Private Attributes
Eigen::VectorXi	topol_
	Neural network topology.
unsigned int	sweep_
	Number of iterations per sweep.
unsigned int	nsweep_
unsigned int	citers_
	Number of iterations after which we turn on full weight.
nnet::neural_net	net_
	Neural network trained using visit frequency.
nnet::neural_net	net2_
	Neural network trained on both visit frequency and force.
double	timestep_
	Timestep.
double	pweight_
	Previous and current histogram weight.
double	weight_
double	temp_
	System temperature and energy units.
double	kbt_
std::vector< Grid< double > * >	F_
	Generalized force grid that stores total of the local walker.
std::vector< Grid< double > * >	Fworld_
	Generalized force grid that stors the global total.
Eigen::VectorXd	Fold_
	To hold the last iterations F_ value for removing bias.
Eigen::VectorXd	wdotp1_
	To hold last iteration wdotp value for numerical derivative.
Eigen::VectorXd	wdotp2_
	To hold second to last iteration wdotp value for numerical derivative.
Grid< Eigen::VectorXd > *	fgrid_
	Force grid.
Grid< unsigned int > *	hgrid_
	Histogram grid.
Eigen::ArrayXi	Nworld_
	Histogram grid for that sotres the number of global hits.
Grid< double > *	ugrid_
	Unbiased histogram grid.
double	ratio_
	Hold parameters to adjust ratio of 1st and 2nd neural networks (freq vs force-based).
Eigen::MatrixXd	hist_
	Eigen matrices of grids.
Eigen::MatrixXd	bias_
std::vector< double >	lowerb_
	Bounds.
std::vector< double >	upperb_
std::vector< double >	lowerk_
	Bound restraints.
std::vector< double >	upperk_
std::string	outfile_
	Output filename.
bool	overwrite_
	Overwrite outputs.
int	dim_
	Number of CVs in system.
double	unitconv_
	Unit conversion from mass*velocity/time to force.
int	min_
Eigen::MatrixXd	force_to_val_ratio_
	To hold booleans for training neural network only in specific region for net2_.

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

Combined Force Frequency (CFF) Algorithm.

Implementation of the CFF algorithm based on Sevgen et al. J. Chem. Theory Comput. 2020, 16, 3, 1448-1455.

Definition at line 36 of file CFF.h.

Constructor & Destructor Documentation

CFF()

SSAGES::CFF::CFF ( const MPI_Comm &  world, const MPI_Comm &  comm, const Eigen::VectorXi &  topol, Grid< Eigen::VectorXd > *  fgrid, Grid< unsigned int > *  hgrid, Grid< double > *  ugrid, std::vector< Grid< double > * >  F, std::vector< Grid< double > * >  Fworld, const std::vector< double > &  lowerb, const std::vector< double > &  upperb, const std::vector< double > &  lowerk, const std::vector< double > &  upperk, double  temperature, double  unitconv, double  timestep, double  weight, unsigned int  nsweep, int  min  )

inline

Constructor.

Parameters

world	MPI global communicator.
comm	MPI local communicator.
topol	Topology of network.
fgrid	Grid containing biasing forces.
hgrid	Grid containing histogram.
ugrid	Grid containing unbiased histogram.
F	Vector of grids holding local raw generalized force totals per bin per CV.
Fworld	Vector of grids holding global raw generalized force totals per bin per CV.
lowerb	Lower bounds for CVs.
upperb	Upper bounds for CVs.
lowerk	Lower bound restraints for CVs.
upperk	Upper bound restraints for CVs.
temperature	Temperature of the simulation.
unitconv	Unit conversion from d(momentum)/d(time) to force.
timestep	Simulation time step.
weight	Relative weight of the statistics in sweep.
nsweep	Number of iterations in the sweep.
min	Number of counts for scaling back force biasing

Constructs an instance of Combined Force Frequency method.

Definition at line 151 of file CFF.h.

          :
            Method(1, world, comm), topol_(topol), sweep_(0), nsweep_(nsweep), citers_(0),
            net_(topol), net2_(topol), timestep_(timestep), pweight_(1.), weight_(weight),
            temp_(temperature), kbt_(), F_(F), Fworld_(Fworld), fgrid_(fgrid),
            hgrid_(hgrid), ugrid_(ugrid), hist_(), bias_(), lowerb_(lowerb),
            upperb_(upperb), lowerk_(lowerk), upperk_(upperk), outfile_("CFF.out"),
            overwrite_(true), unitconv_(unitconv), min_(min)
        {
            // Create histogram grid matrix.
            hist_.resize(hgrid_->size(), hgrid_->GetDimension());
 
            // Fill it up.
            int i = 0;
            for(auto it = hgrid_->begin(); it != hgrid_->end(); ++it)
            {
                auto coord = it.coordinates();
                auto n = coord.size();
                for(decltype(n) j = 0; j < n; ++j)
                    hist_(i, j) = coord[j];
                ++i;
            }
 
            // Initialize free energy surface vector.
            bias_.resize(hgrid_->size(), 1);
            net_.forward_pass(hist_);
            net2_.forward_pass(hist_);
            bias_.array() = net_.get_activation().col(0).array();
        }

References SSAGES::Grid< T >::begin(), SSAGES::Grid< T >::end(), SSAGES::GridBase< T >::GetDimension(), hgrid_, hist_, net2_, net_, and SSAGES::GridBase< T >::size().

Here is the call graph for this function:

Member Function Documentation

Build()

CFF * SSAGES::CFF::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 407 of file CFF.cpp.

    {
        ObjectRequirement validator;
        Value schema;
        CharReaderBuilder rbuilder;
        CharReader* reader = rbuilder.newCharReader();
        reader->parse(
            JsonSchema::CFFMethod.c_str(),
            JsonSchema::CFFMethod.c_str() + JsonSchema::CFFMethod.size(),
            &schema,
            nullptr
        );
        validator.Parse(schema, path);
 
        // Validate inputs.
        validator.Validate(json, path);
        if(validator.HasErrors())
            throw BuildException(validator.GetErrors());
 
        // Grid.
        auto jsongrid = json.get("grid", Json::Value());
        auto* fgrid = Grid<Eigen::VectorXd>::BuildGrid(jsongrid);
        auto* hgrid = Grid<unsigned int>::BuildGrid(jsongrid);
        auto* ugrid = Grid<double>::BuildGrid(jsongrid);
        std::vector<Grid<double>*> F(json["grid"]["upper"].size());
        for(auto& grid : F)
            grid =  Grid<double>::BuildGrid(jsongrid);
        std::vector<Grid<double>*> Fworld(json["grid"]["upper"].size());
        for(auto& grid : Fworld)
            grid =  Grid<double>::BuildGrid(jsongrid);
 
        // Topology.
        auto nlayers = json["topology"].size() + 2;
        Eigen::VectorXi topol(nlayers);
        topol[0] = fgrid->GetDimension();
        topol[nlayers-1] = 1;
        for(decltype(nlayers) i = 0; i < json["topology"].size(); ++i)
            topol[i+1] = json["topology"][i].asInt();
 
        // CFF parameters
        auto weight = json.get("weight", 1.).asDouble();
        auto temp = json["temperature"].asDouble();
        auto nsweep = json["nsweep"].asUInt();
        auto unitconv = json.get("unit_conversion", 1).asDouble();
        auto timestep = json.get("timestep", 0.002).asDouble();
        auto min = json.get("minimum_count", 200).asInt();
 
        // Assume all vectors are the same size.
        std::vector<double> lowerb, upperb, lowerk, upperk;
        auto lbr_size = json["lower_bound_restraints"].size();
        for(decltype(lbr_size) i = 0; i < lbr_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* m = new CFF(world, comm, topol, fgrid, hgrid, ugrid, F, Fworld, lowerb, upperb, lowerk, upperk, temp, unitconv, timestep, weight, nsweep, min);
 
        // Set optional params.
        m->SetPrevWeight(json.get("prev_weight", 1).asDouble());
        m->SetOutput(json.get("output_file", "CFF.out").asString());
        m->SetOutputOverwrite( json.get("overwrite_output", true).asBool());
        m->SetConvergeIters(json.get("converge_iters", 0).asUInt());
        m->SetMaxIters(json.get("max_iters", 1000).asUInt());
        m->SetMinLoss(json.get("min_loss", 0).asDouble());
        m->SetRatio(json.get("ratio", 0.0).asDouble());
 
        return m;
    }

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

Here is the call graph for this function:

PostIntegration()

void SSAGES::CFF::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.

First, information from current snapshot is retrieved and stored in v-integration hook. Then, coordinates in CV space are determined. Then, for each CV, biasing force is calculated. Then, neural networks are trained if called. Then, information is printed out if called. Finally, bias is applied using either genralized force (for the first sweep) or neural networks.

Implements SSAGES::Method.

Definition at line 79 of file CFF.cpp.

    {
 
        // Gather information.
        // // Bias energy is kb*T*ln(P) where P = unbiased distribution
        auto cvs = cvmanager.GetCVs(cvmask_);
        auto& vels = snapshot->GetVelocities();
        auto& mass = snapshot->GetMasses();
        auto& forces = snapshot->GetForces();
        auto& virial = snapshot->GetVirial();
        auto n = snapshot->GetNumAtoms();
 
        using NAtoms = decltype(n);
 
        if(snapshot->GetIteration() && snapshot->GetIteration() % nsweep_ == 0 && snapshot->GetIteration() >= nsweep_*1 )
        {
            // Switch to full blast.
            if(citers_ && snapshot->GetIteration() > citers_)
                pweight_ = 1.0;
 
            TrainNetwork();
            if(IsMasterRank(world_))
                WriteBias();
        }
 
        // Determine if we are in bounds.
        Eigen::RowVectorXd vec(dim_);
        std::vector<double> val(dim_);
        bool inbounds = true;
        for(int i = 0; i < dim_; ++i)
        {
            val[i] = cvs[i]->GetValue();
            vec[i] = cvs[i]->GetValue();
            if(val[i] < hgrid_->GetLower(i) || val[i] > hgrid_->GetUpper(i))
                inbounds = false;
        }
 
        // Initialize matrix to hold the CV gradient.
        Eigen::MatrixXd J(dim_, 3*n);
 
        // Fill J and CV. Each column represents grad(CV) with flattened Cartesian elements.
        for(int i = 0; i < dim_; ++i)
        {
            auto& grad = cvs[i]->GetGradient();
            for(NAtoms j = 0; j < n; ++j)
                J.block<1, 3>(i,3*j) = grad[j];
        }
 
        //* Calculate W using Darve's approach (http://mc.stanford.edu/cgi-bin/images/0/06/Darve_2008.pdf).
        // However, we will not use mass weighing.
        Eigen::MatrixXd Jmass = J.transpose();
 
        Eigen::MatrixXd Minv = J*Jmass;
        MPI_Allreduce(MPI_IN_PLACE, Minv.data(), Minv.size(), MPI_DOUBLE, MPI_SUM, comm_);
        Eigen::MatrixXd Wt = Minv.inverse()*Jmass.transpose();
 
        // Fill momenta.
        Eigen::VectorXd momenta(3*n);
        for(NAtoms i = 0; i < n; ++i)
            momenta.segment<3>(3*i) = mass[i]*vels[i];
 
        // Compute dot(w,p)
        Eigen::VectorXd wdotp = Wt*momenta;
 
        // Reduce dot product across processors.
        MPI_Allreduce(MPI_IN_PLACE, wdotp.data(), wdotp.size(), MPI_DOUBLE, MPI_SUM, comm_);
 
        // Compute d(wdotp)/dt second order backwards finite difference.
        // Adding old force removes bias.
        Eigen::VectorXd dwdotpdt = unitconv_*(1.5*wdotp - 2.0*wdotp1_ + 0.5*wdotp2_)/timestep_ + Fold_;
        Eigen::VectorXd derivatives = Eigen::VectorXd::Zero(dim_);
 
        // If we are in bounds, sum force and frequency into running total.
        if (inbounds)
        {
            if(IsMasterRank(comm_))
            {
                for(int i=0; i<dim_; ++i)
                    F_[i]->at(val) += dwdotpdt[i];
 
                hgrid_->at(val) += 1;
            }
 
            // Initial sweep is the same as doing adaptive basing force
            // i.e., Calculate biasing forces from averaged F at current CV coodinates
 
            if(snapshot->GetIteration() < nsweep_)
            {
                for(int i = 0; i < dim_; ++i)
                    derivatives[i] = (F_[i]->at(val)/std::max((double(hgrid_->at(val))),double(min_)));
            }
            else
            {
                net_.forward_pass(vec);
                net2_.forward_pass(vec);
                derivatives = net_.get_gradient(0)*ratio_ + net2_.get_gradient(0)*(1.0-ratio_);
            }
 
        }
        // If out of bounds, apply harmonic restraint
        else
        {
            // Output to screen CV value that is out of bounds
            if(IsMasterRank(comm_))
            {
                std::cerr << "CFF (" << snapshot->GetIteration() << "): out of bounds ( ";
                for(auto& v : val)
                    std::cerr << v << " ";
                std::cerr << ")" << std::endl;
            }
 
            // Apply harmonic restraints
            for(int i = 0; i < dim_; ++i)
            {
                auto cval = cvs[i]->GetValue();
                if(cval < lowerb_[i])
                    derivatives[i] += lowerk_[i]*cvs[i]->GetDifference(cval - lowerb_[i]);
                else if(cval > upperb_[i])
                    derivatives[i] += upperk_[i]*cvs[i]->GetDifference(cval - upperb_[i]);
            }
        }
 
 
        for(int i = 0; i < dim_; ++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 (NAtoms j = 0; j < n; ++j)
                forces[j] -= derivatives[i]*grad[j];
 
            // Update virial.
            virial += derivatives[i]*boxgrad;
        }
        // Collect all walkers.
        MPI_Barrier(world_);
 
        // Store the old summed forces.
        Fold_ = derivatives;
 
        // Update finite difference time derivatives.
        wdotp2_ = wdotp1_;
        wdotp1_ = wdotp;
    }

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

Here is the call graph for this function:

PostSimulation()

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

overridevirtual

Method call post simulation.

Post-simulation hook.

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 227 of file CFF.cpp.

    {
    }

PreSimulation()

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

overridevirtual

Method call prior to simulation initiation.

Pre-simulation hook.

Parameters

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

This function will be called before the simulation is started.

Initialize biasing forces and histogram.

Implements SSAGES::Method.

Definition at line 41 of file CFF.cpp.

    {
        auto cvs = cvmanager.GetCVs(cvmask_);
        dim_ = cvs.size();
 
        // Size and initialize Fold_.
        Fold_.setZero(dim_);
 
        // Initialize w \dot p's for finite difference.
        wdotp1_.setZero(dim_);
        wdotp2_.setZero(dim_);
 
        int ndim = hgrid_->GetDimension();
        kbt_ = snapshot->GetKb()*temp_;
 
        // Zero out forces and histogram.
        Eigen::VectorXd vec = Eigen::VectorXd::Zero(ndim);
        std::fill(hgrid_->begin(), hgrid_->end(), 0);
        std::fill(ugrid_->begin(), ugrid_->end(), 1.0);
        std::fill(fgrid_->begin(), fgrid_->end(), vec);
 
        // Initialize Nworld.
        Eigen::Map<Eigen::Array<unsigned int, Eigen::Dynamic, 1>> hist(hgrid_->data(), hgrid_->size());
        Nworld_ = hist.cast<int>();
 
        // Scale initial bias by 1/2*kT and make them positive.
        bias_.array() = abs(bias_.array())*kbt_*0.5;
     }

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

Here is the call graph for this function:

TrainNetwork()

void SSAGES::CFF::TrainNetwork ( )

private

Trains the neural network.

Train neural networks.

Definition at line 232 of file CFF.cpp.

    {
        // Start the clock to measure the neural network training time.
        std::clock_t start = std::clock();
 
        // Increment cycle counter.
        ++sweep_;
 
        // Reduce histogram across procs and sync in case system is periodic.
        mxx::allreduce(hgrid_->data(), hgrid_->size(), std::plus<unsigned int>(), world_);
        hgrid_->syncGrid();
 
        // Update visit frequencies.
        Eigen::Map<Eigen::Array<unsigned int, Eigen::Dynamic, 1>> hist(hgrid_->data(), hgrid_->size());
        Nworld_ += hist.cast<int>();
 
        // Synchronize unbiased histogram.
        ugrid_->syncGrid();
        Eigen::Map<Eigen::Matrix<double, Eigen::Dynamic, 1>> uhist(ugrid_->data(), ugrid_->size());
 
        // Update average biased forces across all processors
        std::vector<Eigen::MatrixXd> Ftrain;
        for(int i=0; i<dim_; ++i)
        {
            MPI_Allreduce(F_[i]->data(), Fworld_[i]->data(), (F_[i]->size()), MPI_DOUBLE, MPI_SUM, world_);
            Fworld_[i]->syncGrid();
 
            // Damp forces used to train net2_ via minimum number of hits
            Eigen::ArrayXd Nmin = Eigen::ArrayXd::Ones(Fworld_[0]->size())*min_;
            Ftrain.push_back(Eigen::Map<Eigen::Array<double, Eigen::Dynamic, 1>> (Fworld_[i]->data(),Fworld_[i]->size()) /
                ( (Nworld_.cast<double>()).max(Nmin) ) );
        }
 
        // Calculate unbiased histrogram from previous unbiased histogram plus estimates from bias energy.
        uhist.array() = pweight_*uhist.array() + hist.cast<double>()*(bias_/kbt_).array().exp()*weight_;
 
        // Synchronize unbiased histogram and clear global histogram holder.
        ugrid_->syncGrid();
        hist.setZero();
 
        // Initialize boolean vector to enable training data.
        // 1 = include specified CV bin for training; 0 = remove from training.
        // Useful for training data partially in the future.
        force_to_val_ratio_ = Eigen::MatrixXd::Zero(hist_.rows(),1);
 
        // Bias energy is kb*T*ln(P) where P = unbiased distribution.
        bias_.array() = kbt_*uhist.array().log();
        bias_.array() -= bias_.minCoeff();
 
        if (ratio_ > 0.6)
        {
            net2_.init_weights();
        }
 
        // Train network.
        net_.autoscale(hist_, bias_);
        net2_.autoscale_w_grad(hist_, bias_, Ftrain);
        if(IsMasterRank(world_))
        {
            SetRatio(1.0);
            double gamma1;
            gamma1 = net_.train(hist_, bias_, true);
            SetRatio(0.0);
            double gamma2 = net2_.train_w_grad(hist_, bias_,Ftrain, force_to_val_ratio_, true);
            std::cout << "gamma1 " << gamma1 << " " << gamma2 << std::endl;
            ratio_ = gamma1/(gamma1+gamma2);
 
            std::cout << std::endl << "Ratio: " << ratio_ << std::endl;
 
            // Output file that accumulates information on the value of ratio_ for every sweeps
            std::ofstream gammaout;
            gammaout.open(outfile_ + "_gamma", std::ios_base::app);
            gammaout.precision(16);
            gammaout << sweep_ << " " << gamma1 << " " << gamma2 << " " << ratio_ << std::endl;
            gammaout.close();
        }
 
        // Send optimal neural net params to all procs.
        nnet::vector_t wb = net_.get_wb();
        mxx::bcast(wb.data(), wb.size(), 0, world_);
        net_.set_wb(wb);
 
        nnet::vector_t wb2 = net2_.get_wb();
        mxx::bcast(wb2.data(), wb2.size(), 0, world_);
        net2_.set_wb(wb2);
 
        mxx::bcast(&ratio_, 1, 0, world_);
 
        // Evaluate and subtract off min value for applied bias.
        net_.forward_pass(hist_);
        net2_.forward_pass(hist_);
        bias_.array() = net_.get_activation().col(0).array() * ratio_ + net2_.get_activation().col(0).array() * (1.0-ratio_);
        bias_.array() -= bias_.minCoeff();
 
        // Average the generalized force for each bin and output the file.
        if(IsMasterRank(world_))
        {
            int gridPoints = 1;
            for(int i = 0 ; i < dim_; ++i)
                gridPoints = gridPoints * hgrid_->GetNumPoints(i);
 
            std::string filename;
            filename = overwrite_ ? "F_out" : "F_out_"+std::to_string(sweep_);
            std::ofstream file(filename);
            file << std::endl;
            file << "Sweep: " << sweep_ << std::endl;
            file << "Printing out the current Biasing Vector Field from CFF." << std::endl;
            file << "First (Nr of CVs) columns are the coordinates, the next (Nr of CVs) columns are components of the Generalized Force vector at that point." << std::endl;
            file << "The columns are " << gridPoints << " long, mapping out a surface of ";
            for (int i = 0 ; i < dim_-1; ++i)
                file << (hgrid_->GetNumPoints())[i] << " by " ;
            file << (hgrid_->GetNumPoints(dim_-1)) << " points in " << dim_ << " dimensions." << std::endl;
            file << std::endl;
 
            for(int j=0; j < (Ftrain[0].array()).size();++j)
            {
                file << std::setw(14) << std::setprecision(8) << std::fixed << hist_.row(j);
                for(int i = 0 ; i < dim_; ++i){
                    nnet::matrix_t x = Ftrain[i].array();
                    file << std::setw(14) << std::setprecision(8) << std::fixed << x(j) << " ";
                }
                file << std::endl;
            }
            file << std::endl;
            file << std::endl;
            file.close();
        }
 
        // Output training time information
        double duration = ( std::clock() - start ) / (double) CLOCKS_PER_SEC;
        std::ofstream file1("traintime.out",std::ofstream::app);
        file1 << duration << std::endl;
        file1.close();
 
    }

Member Data Documentation

min_

int SSAGES::CFF::min_

private

The minimum number of hits required before full biasing, bias is F_[i]/max(N_[i],min_).

Definition at line 122 of file CFF.h.

---

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

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