BasisFunc.h

 
#pragma once
 
#include "Method.h"
#include "Utility/Basis.h"
#include "Grids/Grid.h"
#include <fstream>
#include <vector>
 
namespace SSAGES
{       
 
    class BFS : public Method
    {
    private:    
        
 
        Grid<unsigned int> *h_;
 
 
        Grid<double> *b_;
 
 
        Grid<std::vector<double>> *f_;
 
 
        std::vector<double> unbias_;
 
        std::vector<double> coeffArr_;
 
 
        BasisEvaluator evaluator_;
 
 
        std::vector<double> restraint_;
 
        std::vector<double> boundUp_;
 
        std::vector<double> boundLow_;
        
        unsigned int cyclefreq_;
 
        unsigned int cyclefreqTmp_;
 
        unsigned int step_;
        
        unsigned int mpiid_;
 
 
        double weight_;
 
 
        double temperature_;
 
        double tol_;
 
        bool bounds_;
 
        bool convergeExit_;
 
 
        void ProjectBias(const CVList& cvs, const double beta);
 
 
        void InBounds(const CVList& cvs);
 
 
        void PrintBias(const CVList& cvs, const double beta);
 
        std::string bnme_;
 
        unsigned int iteration_;
 
    public:
 
        BFS(const MPI_Comm& world,
            const MPI_Comm& comm,
            Grid<unsigned int> *h,
            Grid<std::vector<double>> *f,
            Grid<double> *b,
            const std::vector<BasisFunction*>& functions,
            const std::vector<double>& restraint,
            const std::vector<double>& boundUp,
            const std::vector<double>& boundLow,
            unsigned int cyclefreq,
            unsigned int frequency,
            const std::string bnme,
            const double temperature,
            const double tol,
            const double weight,
            bool converge) :
        Method(frequency, world, comm), 
        h_(h),  b_(b), f_(f), unbias_(), coeffArr_(), evaluator_(functions),
        restraint_(restraint), boundUp_(boundUp), boundLow_(boundLow),
        cyclefreq_(cyclefreq), mpiid_(0), weight_(weight),
        temperature_(temperature), tol_(tol),
        convergeExit_(converge), bnme_(bnme), 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;
        }
 
 
        void SetBasis(const std::vector<double>&coeff, std::vector<double>&unbias)
        {
            evaluator_.SetCoeff(coeff);
            unbias_ = unbias;
        }
 
        static BFS* Build(const Json::Value& json, 
                          const MPI_Comm& world,
                          const MPI_Comm& comm,
                          const std::string& path);
 
        ~BFS()
        {
            //delete h_;
            //delete f_;
            //delete b_;
        }
    };
}