Swarm.h

#include "StringMethod.h"
#include <fstream>
#include <iostream>

namespace SSAGES
{

    class Swarm : public StringMethod //Calls Method constructor first, then Swarm constructor
    {
        private:

            std::vector<double> cv_drift_; 
                        
            unsigned int initialize_steps_; 

            unsigned int harvest_length_;

            unsigned int restrained_steps_; 

            unsigned int number_trajectories_;

            unsigned int swarm_length_;

            unsigned int unrestrained_steps_;

            unsigned int index_;

            std::vector<Label> traj_atomids_; 

            void StringUpdate();

            bool CVInitialized(const CVList& cvs);

            bool sampling_started;
            
            bool snapshot_stored;        
            
            int initialized;

            bool original_initialized; 

        public:


            Swarm(const MPI_Comm& world, 
                  const MPI_Comm& comm, 
                  const std::vector<double>& centers,
                  unsigned int maxiterations,
                  const std::vector<double> cvspring,
                  unsigned int frequency,
                  unsigned int InitialSteps, 
                  unsigned int HarvestLength, 
                  unsigned int NumberTrajectories, 
                  unsigned int SwarmLength) : 
            StringMethod(world, comm, centers, maxiterations, cvspring, frequency),                 
            cv_drift_(), 
            initialize_steps_(InitialSteps), 
            harvest_length_(HarvestLength), 
            number_trajectories_(NumberTrajectories), 
            swarm_length_(SwarmLength)
            {
                cv_drift_.resize(centers_.size(), 0);
                prev_positions_.resize(number_trajectories_);
                prev_velocities_.resize(number_trajectories_);
                prev_IDs_.resize(number_trajectories_);
                //Additional initializing

                index_ = 0;  
                restrained_steps_ = harvest_length_*number_trajectories_; 
                unrestrained_steps_ = swarm_length_*number_trajectories_;
                sampling_started = false;
                snapshot_stored = false;

                iterator_ = 0; //Override default StringMethod.h initializing
            }

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

            ~Swarm()
            {
            }
    };
}