ABF.h

 
#pragma once
 
#include "Method.h"
#include <fstream>
#include <vector>
#include <string>
#include "Grids/Grid.h"
 
 
namespace SSAGES
{
 
    class ABF : public Method
    {
    private:
 
        Grid<int> *N_;
 
 
        Grid<int> *Nworld_;
 
        std::vector<Grid<double>*> F_;
 
 
        std::vector<Grid<double>*> Fworld_;
        
 
        std::vector<std::vector<double>> restraint_;
 
        std::vector<bool> isperiodic_;
 
 
        std::vector<std::vector<double>> periodicboundaries_;       
 
        int min_;
 
        Eigen::VectorXd wdotp1_;
 
        Eigen::VectorXd wdotp2_;
 
        Eigen::VectorXd Fold_;
 
        bool massweigh_;
 
        std::vector<Vector3> biases_;
 
        unsigned int dim_;
 
        std::ofstream worldout_;
 
        std::string filename_;
 
        std::string Nworld_filename_;
 
        std::string Fworld_filename_;
 
 
        std::vector<std::vector<double>> histdetails_;
 
 
        int FBackupInterv_;
 
 
        double unitconv_;
 
 
        void CalcBiasForce(const Snapshot* snapshot, const CVList& cvs, const std::vector<double> &cvVals);
        
        void WriteData();
 
        double timestep_;
 
        unsigned int iteration_;
 
        Eigen::VectorXd mass_;
 
 
        bool boundsCheck(const std::vector<double> &CVs);
        
 
    public: 
 
        ABF(const MPI_Comm& world,
            const MPI_Comm& comm,
            Grid<int> *N,
            Grid<int> *Nworld,
            std::vector<Grid<double>*> F,
            std::vector<Grid<double>*> Fworld,
            std::vector<std::vector<double>> restraint,
            std::vector<bool> isperiodic,
            std::vector<std::vector<double>> periodicboundaries,
            double min,
            bool massweigh,
            std::string filename,
            std::string Nworld_filename,
            std::string Fworld_filename,
            const std::vector<std::vector<double>>& histdetails,
            int FBackupInterv,
            double unitconv,
            double timestep,
            unsigned int frequency) :
        Method(frequency, world, comm), N_(N), Nworld_(Nworld), F_(F), Fworld_(Fworld),  restraint_(restraint), isperiodic_(isperiodic), periodicboundaries_(periodicboundaries),
        min_(min), wdotp1_(), wdotp2_(), Fold_(), massweigh_(massweigh),
        biases_(), dim_(0), filename_(filename), Nworld_filename_(Nworld_filename), Fworld_filename_(Fworld_filename),
        histdetails_(histdetails), 
        FBackupInterv_(FBackupInterv), unitconv_(unitconv), timestep_(timestep),
        iteration_(0)
        {
        }
 
        void PreSimulation(Snapshot* snapshot, const class CVManager& cvmanager) override;
 
        void PostIntegration(Snapshot* snapshot, const class CVManager& cvmanager) override;
 
        void PostSimulation(Snapshot* snapshot, const class CVManager& cvmanager) override;
 
 
        void SetIteration(const int iter)
        {
            iteration_ = iter;
        }
 
        static ABF* Build(const Json::Value& json, 
                              const MPI_Comm& world,
                              const MPI_Comm& comm,
                              const std::string& path);
 
        ~ABF() {}
    };
}