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_;
 
        unsigned int 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;
 
        void PostSimulation(Snapshot* snapshot, const class CVManager& cvmanager) override;
 
 
        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() {}
    };
}