ABF.h

#pragma once

#include "Method.h"
#include <fstream>
#include <vector>
#include <string>
#include "Grids/Grid.h"


namespace SSAGES
{


    class ABF : public Method
    {
    private:    

        std::vector<Grid<double>*> F_;
    

        std::vector<Grid<double>*> Fworld_;


        Grid<int> *N_;


        Grid<int> *Nworld_;
        

        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_;

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