BasisFunc.h

#pragma once

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

namespace SSAGES
{


    struct Map
    {
        double value;

        std::vector<int> map;


        Map(const std::vector<int>& map,
            double value) :
            value(value), map(map)
        {}
    };


    struct BasisLUT
    {
        std::vector<double> values;

        std::vector<double> derivs;


        BasisLUT(const std::vector<double>& values,
            const std::vector<double>& derivs) :
            values(values), derivs(derivs)
        {}
    };
        

    class Basis : public Method
    {
    private:    
        

        Histogram<int> *hist_;


        std::vector<Map> coeff_;


        std::vector<double> unbias_;

        std::vector<double> coeff_arr_;

        std::vector<BasisLUT> LUT_;


        std::vector<double> derivatives_;

        std::vector<unsigned int> polyords_;


        std::vector<double> restraint_;

        std::vector<double> boundUp_;

        std::vector<double> boundLow_;
        
        unsigned int cyclefreq_;
        
        unsigned int mpiid_;


        double weight_;


        double temperature_;

        double tol_;

        bool bounds_;

        bool converge_exit_;


        void UpdateBias(const CVList& cvs, const double);


        void CalcBiasForce(const CVList& cvs);


        void PrintBias(const CVList& cvs, const double beta);


        void BasisInit(const CVList& cvs);

        std::ofstream basisout_;

        std::ofstream coeffout_;

        std::string bnme_;

        std::string cnme_;

        uint iteration_;

    public:

        Basis(const MPI_Comm& world,
              const MPI_Comm& comm,
              Histogram<int> *hist,
              const std::vector<unsigned int>& polyord,
              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 std::string cnme,
              const double temperature,
              const double tol,
              const double weight,
              bool converge) :
        Method(frequency, world, comm), hist_(hist),
        coeff_(), unbias_(), coeff_arr_(), LUT_(), derivatives_(), polyords_(polyord),
        restraint_(restraint), boundUp_(boundUp), boundLow_(boundLow),
        cyclefreq_(cyclefreq), mpiid_(0), weight_(weight),
        temperature_(temperature), tol_(tol),
        converge_exit_(converge), bnme_(bnme), cnme_(cnme), 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)
        {
            coeff_arr_ = coeff;
            unbias_ = unbias;
        }

        static Basis* Build(const Json::Value& json, 
                                const MPI_Comm& world,
                                const MPI_Comm& comm,
                                const std::string& path);

        ~Basis()
        {
            delete hist_;
        }
    };
}