StringMethod.h

#pragma once

#include <numeric>

#include "Method.h"
#include <fstream>

namespace SSAGES
{

    class StringMethod : public Method
    {
    protected:  
        
        std::vector<double> centers_;

        std::vector<double> newcenters_;


        std::vector<std::vector<double> > worldstring_;

        int mpiid_;

        std::vector<double> tol_;

        int numnodes_;

        unsigned int maxiterator_;

        std::vector<double> cvspring_;

        unsigned int iterator_;

        uint iteration_;

        std::ofstream stringout_;

        int sendneigh_;

        int recneigh_;

        std::vector<std::vector<double>> prev_positions_;

        std::vector<std::vector<double>> prev_velocities_;

        std::vector<std::vector<int>> prev_IDs_;

        virtual void StringUpdate() = 0;


        double distance(const std::vector<double>& x, const std::vector<double>& y) const
        {
            double distance = 0;
            for (size_t i = 0; i < x.size(); i++)
                distance += pow((x[i] - y[i]),2);

            return sqrt(distance);
        }

        void PrintString(const CVList& CV);


        void GatherNeighbors(std::vector<double> *lcv0, std::vector<double> *ucv0);


        void StringReparam(double alpha_star);


        void UpdateWorldString(const CVList& cvs);

        bool TolCheck() const
        {
            if(tol_.size() == 0)
                return false;

            for(size_t i = 0; i < centers_.size(); i++)
            {
                if(fabs(centers_[i] - worldstring_[mpiid_][i]) > tol_[i])
                {
                    return false;
                }
            }

            return true;
        }


        bool CheckEnd(const CVList& CV);

    public:

        StringMethod(const MPI_Comm& world,
                     const MPI_Comm& comm,
                     const std::vector<double>& centers,
                     unsigned int maxiterations,
                     const std::vector<double> cvspring,
                     unsigned int frequency) : 
        Method(frequency, world, comm), centers_(centers), 
        maxiterator_(maxiterations), 
        cvspring_(cvspring), iterator_(1), iteration_(0)
        {
            newcenters_.resize(centers_.size(), 0);
        }

        void PreSimulation(Snapshot* snapshot, const class CVManager& cvmanager) override;

        virtual void PostIntegration(Snapshot* snapshot, const class CVManager& cvmanager) override = 0;

        // Post-simulation hook.
        void PostSimulation(Snapshot*, const class CVManager&) override
        {
            stringout_.close();
        }


        void SetTolerance(std::vector<double> tol)
        {
            for(auto& t : tol)
                tol_.push_back(t);
        }

        void SetSendRecvNeighbors();

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

        virtual ~StringMethod() {}
    };
}