#include <ForwardFlux.h>

Inheritance diagram for SSAGES::ForwardFlux:

[legend]

Classes
class	FFSConfigID
	Nested class to store different FFS Config IDs. More...

Public Member Functions
	ForwardFlux (const MPI_Comm &world, const MPI_Comm &comm, double ninterfaces, std::vector< double > interfaces, unsigned int N0Target, std::vector< unsigned int > M, bool initialFluxFlag, bool saveTrajectories, unsigned int currentInterface, std::string output_directory, unsigned int frequency)
	Constructor. More...

void	PreSimulation (Snapshot *snapshot, const class CVManager &cvmanager) override
	Method call prior to simulation initiation. More...

virtual void	PostIntegration (Snapshot *snapshot, const class CVManager &cvmanager) override=0
	Method call post integration. More...

void	PostSimulation (Snapshot *snapshot, const class CVManager &cvmanager) override
	Method call post simulation. More...

Public Member Functions inherited from SSAGES::Method
	Method (unsigned int frequency, const MPI_Comm &world, const MPI_Comm &comm)
	Constructor. More...

void	SetCVMask (const std::vector< unsigned int > &mask)
	Sets the collective variable mask. More...

virtual	~Method ()
	Destructor.

Public Member Functions inherited from SSAGES::EventListener
	EventListener (unsigned int frequency)
	Constructor. More...

unsigned int	GetFrequency () const
	Get frequency of event listener. More...

virtual	~EventListener ()
	Destructor.

Static Public Member Functions
static ForwardFlux *	Build (const Json::Value &json, const MPI_Comm &world, const MPI_Comm &comm, const std::string &path)
	Build a derived method from JSON node. More...

Static Public Member Functions inherited from SSAGES::Method
static Method *	BuildMethod (const Json::Value &json, const MPI_Comm &world, const MPI_Comm &comm, const std::string &path)
	Build a derived method from JSON node. More...

Static Public Member Functions inherited from SSAGES::EventListener
static unsigned int	GetWalkerID (const MPI_Comm &world, const MPI_Comm &comm)
	Get walker ID number of specified communicator. More...

static unsigned int	GetNumWalkers (const MPI_Comm &world, const MPI_Comm &comm)
	Get total number of walkers in the simulation. More...

static bool	IsMasterRank (const MPI_Comm &comm)
	Check if current processor is master. More...

Protected Member Functions
void	CheckInitialStructure (const CVList &)
	Function that checks the initial structure that user provides.

void	WriteInitialFlux ()
	Function to compute and write the initial flux.

void	AddNewIDsToQueue ()

bool	HasReturnedToA (double current)
	Function checks if configuration has returned to A. More...

int	HasCrossedInterface (double current, double prev, unsigned int i)
	Function checks if configuration has crossed interface specified since the last check. More...

void	WriteFFSConfiguration (Snapshot *snapshot, FFSConfigID &ffsconfig, bool wassuccess)
	Write a file corresponding to FFSConfigID from current snapshot. More...

void	ReadFFSConfiguration (Snapshot *snapshot, FFSConfigID &ffsconfig, bool wassuccess)
	Read a file corresponding to a FFSConfigID into current snapshot. More...

void	ComputeInitialFlux (Snapshot *, const CVList &)
	Compute Initial Flux.

virtual void	CheckForInterfaceCrossings (Snapshot *, const class CVManager &)=0
	Function that checks if interfaces have been crossed (different for each FFS flavor)

virtual void	InitializeQueue (Snapshot *, const CVList &)=0
	Initialize the Queue.

void	ComputeTransitionProbabilities ()
	Compute the probability of going from each lambda_i to lambda_{i+1}. More...

void	PrintQueue ()
	Print the queue, useful for debugging.

void	PopQueueMPI (Snapshot *, const CVList &, unsigned)
	Pop the queue, do MPI so that all procs maintain the same queue.

void	FluxBruteForce (Snapshot *, const CVList &)
	Compute the flux via brute force. More...

void	ReconstructTrajectories (Snapshot *)
	When simulation is finished, parse through the trajectories that reached B, and reconstruct the complete trajectory from where it started at A (lambda0)

void	ComputeCommittorProbability (Snapshot *)
	When simulation is finished, recursively parse through the trajectories that reached B or failed back to A and calculate the Commitor Probability of that state going to B (_pB)

void	AppendTrajectoryFile (Snapshot *, std::ofstream &)

void	OpenTrajectoryFile (std::ofstream &)
	Take the current config in snapshot and append it to the provided ofstream.

Protected Attributes
double	_ninterfaces

std::vector< double >	_interfaces
	FFS Interfaces.

bool	_interfaces_increase
	Interfaces must monotonically increase (or decrease), this determines whether going to the 'next' interface will be higher values of CV, or lower ones.

double	_cvvalue_previous
	Previous cv position, used to determine if you've crossed an interface since last time.

double	_cvvalue
	current cv position

double	_rate
	rate constant

std::vector< FFSConfigID >	Lambda0ConfigLibrary
	Data structure that holds a Library N0 configurations at lambda0.

double	_N0TotalSimTime
	Total Simulation Time spent in accumulating \ _N0.

unsigned int	_N0Target
	Number of configurations to store at lambda0, target.

double	_fluxA0
	Flux of trajectories out of state A. Denoted PhiA0 over h_A in Allen2009.

std::vector< unsigned int >	_M

std::vector< unsigned int >	_A
	Number of attempts from interface i.

std::vector< double >	_P
	Flag to determine wheter fluxA0 should be calculated, seems not using this. More...

std::vector< unsigned int >	_S

std::vector< unsigned int >	_N

bool	_pop_tried_but_empty_queue

bool	_initialFluxFlag
	if 1, compute initial flux

bool	initializeQueueFlag
	if 1, initialize the Queue

FFSConfigID	myFFSConfigID
	The current FFSConfigID of this MPI process.

bool	_saveTrajectories
	should the FFS trajectories be saved

unsigned int	_nfailure_total

std::vector< std::vector< double > >	_pB

unsigned int	_current_interface
	Current Interface.

std::deque< FFSConfigID >	FFSConfigIDQueue

std::string	_output_directory
	Directory of FFS output.

std::ofstream	_trajectory_file
	file to which the current trajectory is written to

std::default_random_engine	_generator
	random number generator

unsigned int	iteration_
	Method iteration counter/.

Protected Attributes inherited from SSAGES::Method
mxx::comm	world_
	Global MPI communicator.

mxx::comm	comm_
	Local MPI communicator.

std::vector< unsigned int >	cvmask_
	Mask which identifies which CVs to act on.

Detailed Description

ForwardFlux sampling method.

The notation used here is drawn largely from Allen, Valeriani and Rein ten Wolde. J. Phys.: Condens. Matter (2009) 21:463102. We recommend referring to this review if the reader is unfamiliar with the method, or our variable naming conventions.

Definition at line 38 of file ForwardFlux.h.

Constructor & Destructor Documentation

◆ ForwardFlux()

SSAGES::ForwardFlux::ForwardFlux	(	const MPI_Comm &	world,
		const MPI_Comm &	comm,
		double	ninterfaces,
		std::vector< double >	interfaces,
		unsigned int	N0Target,
		std::vector< unsigned int >	M,
		bool	initialFluxFlag,
		bool	saveTrajectories,
		unsigned int	currentInterface,
		std::string	output_directory,
		unsigned int	frequency
	)

inline

Constructor.

Parameters

world	MPI global communicator.
comm	MPI local communicator.
ninterfaces	Number of interfaces.
interfaces	Vector of interfaces.
N0Target	Required number of initial configurations.
M	Vector of trials.
initialFluxFlag	Flag for first step of this method.
saveTrajectories	Flag to save flux trajectories.
currentInterface	The number of the current interface.
output_directory	Directory to which trajectories are saved.
frequency	Frequency with which this method is invoked.

Create instance of Forward Flux

Definition at line 284 of file ForwardFlux.h.

                                                                                                        : 
          Method(frequency, world, comm), _ninterfaces(ninterfaces), _interfaces(interfaces), _N0Target(N0Target), 
          _M(M), _initialFluxFlag(initialFluxFlag), _saveTrajectories(saveTrajectories), _current_interface(currentInterface),
          _output_directory(output_directory), _generator(1), iteration_(0) 
         {
             //_output_directory = "FFSoutput";
             mkdir(_output_directory.c_str(),S_IRWXU); //how to make directory?
  
             //_current_interface = 0;
             _N0TotalSimTime = 0;
  
             if (!_initialFluxFlag)
                 initializeQueueFlag = true;
  
             _A.resize(_ninterfaces);
             _P.resize(_ninterfaces);
             _S.resize(_ninterfaces);
             _N.resize(_ninterfaces);
  
             //_N[_current_interface] = _N0Target;
             /*_M.resize(_ninterfaces);
  
             //code for setting up simple simulation and debugging
             _ninterfaces = 5;
             int i;
             _interfaces.resize(_ninterfaces);
             _interfaces[0]=-1.0;
             _interfaces[1]=-0.95;
             _interfaces[2]=-0.8;
             _interfaces[3]= 0;
             _interfaces[4]= 1.0;
  
             _saveTrajectories = true;
  
             _initialFluxFlag = true;
  
             for(i=0;i<_ninterfaces;i++) _M[i] = 50;
  
             _N0Target = 100;*/
             //_N0Target = 100;
             _nfailure_total = 0;
  
  
             //check if interfaces monotonically increase or decrease
             bool errflag = false;
             if (_interfaces[0]< _interfaces[1]) _interfaces_increase = true;
             else if (_interfaces[0] > _interfaces[1]) _interfaces_increase = false;
             else errflag = true;
             for (unsigned int i=0;i<_ninterfaces-1;i++)
             {
                 if((_interfaces_increase) && (_interfaces[i] >= _interfaces[i+1]))
                     errflag = true;
                 else if ((!_interfaces_increase) && (_interfaces[i] <= _interfaces[i+1]))
                     errflag = true;
             }
             if (errflag)
             {
                 std::cerr << "Error! The interfaces are poorly defined. They must be monotonically increasing or decreasing and cannot equal one another! Please fix this.\n";
                 for (auto interface : _interfaces)
                     std::cerr << interface << " ";
                 std::cerr << "\n";
                 MPI_Abort(world_, EXIT_FAILURE);
             }
  
             // This is to generate an artificial Lambda0ConfigLibrary, Hadi's code does this for real
             // THIS SHOULD BE SOMEWHERE ELSE!!! 
             Lambda0ConfigLibrary.resize(_N0Target);
             std::normal_distribution<double> distribution(0,1);
             for (unsigned int i = 0; i < _N0Target ; i++)
             {
                 Lambda0ConfigLibrary[i].l = 0;
                 Lambda0ConfigLibrary[i].n = i;
                 Lambda0ConfigLibrary[i].a = 0;
                 Lambda0ConfigLibrary[i].lprev = 0;
                 Lambda0ConfigLibrary[i].nprev = i;
                 Lambda0ConfigLibrary[i].aprev = 0;
                 //FFSConfigID ffsconfig = Lambda0ConfigLibrary[i];
             }
             /*// Write the dump file out
             std::ofstream file;
             std::string filename = _output_directory + "/l" + std::to_string(ffsconfig.l) + "-n" + std::to_string(ffsconfig.n) + ".dat";
             file.open(filename.c_str());
  
             //first line gives ID of where it came from
             file << ffsconfig.lprev << " " << ffsconfig.nprev << " " << ffsconfig.aprev << "\n";
             //write position and velocity
             file << "1 -1 0 0 " << distribution(_generator) << " "  << distribution(_generator) << " 0\n";
  
             }
             */
             _pop_tried_but_empty_queue = false;
         }

References _A, _initialFluxFlag, _interfaces, _interfaces_increase, _N, _N0Target, _N0TotalSimTime, _nfailure_total, _ninterfaces, _output_directory, _P, _pop_tried_but_empty_queue, _S, initializeQueueFlag, Lambda0ConfigLibrary, and SSAGES::Method::world_.

Member Function Documentation

◆ AddNewIDsToQueue()

void SSAGES::ForwardFlux::AddNewIDsToQueue ( )

protected

Function that adds new FFS configurations to the Queue Different FFS flavors can have differences in this method

◆ AppendTrajectoryFile()

void SSAGES::ForwardFlux::AppendTrajectoryFile	(	Snapshot *	snapshot,
		std::ofstream &	file
	)

protected

Take the current config in snapshot and append it to the provided ofstream Current format is xyz style (including vx,vy,vz)

Definition at line 279 of file ForwardFlux.cpp.

     {
         const auto& positions = snapshot->GetPositions();
         const auto& velocities = snapshot->GetVelocities();
         const auto& atomID = snapshot->GetAtomIDs();
  
         //first line gives number of atoms
         file << atomID.size() << "\n\n";
  
         // Then write positions and velocities
         for(size_t i = 0; i< atomID.size(); i++)
         {
             file<<atomID[i]<<" ";
             file<<positions[i][0]<<" "<<positions[i][1]<<" "<<positions[i][2]<<" ";
             file<<velocities[i][0]<<" "<<velocities[i][1]<<" "<<velocities[i][2]<<std::endl;
         }
     }

References SSAGES::Snapshot::GetAtomIDs(), SSAGES::Snapshot::GetPositions(), and SSAGES::Snapshot::GetVelocities().

Referenced by SSAGES::DirectForwardFlux::CheckForInterfaceCrossings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Build()

ForwardFlux * SSAGES::ForwardFlux::Build	(	const Json::Value &	json,
		const MPI_Comm &	world,
		const MPI_Comm &	comm,
		const std::string &	path
	)

static

Build a derived method from JSON node.

Parameters

json	JSON Value containing all input information.
world	MPI global communicator.
comm	MPI local communicator.
path	Path for JSON path specification.

Returns: Pointer to the Method built. nullptr if an unknown error occurred.

This function builds a registered method from a JSON node. The difference between this function and "Build" is that this automatically determines the appropriate derived type based on the JSON node information.

Note: Object lifetime is the caller's responsibility.

Definition at line 628 of file ForwardFlux.cpp.

     {
         ObjectRequirement validator;
         Value schema;
         CharReaderBuilder rbuilder;
         CharReader* reader = rbuilder.newCharReader();
  
         reader->parse(JsonSchema::ForwardFluxMethod.c_str(),
                       JsonSchema::ForwardFluxMethod.c_str() + JsonSchema::ForwardFluxMethod.size(),
                       &schema, nullptr);
         validator.Parse(schema, path);
  
         // Validate inputs.
         validator.Validate(json, path);
         if(validator.HasErrors())
             throw BuildException(validator.GetErrors());
         
         double ninterfaces = json.get("nInterfaces", 2).asDouble();
         std::vector<double> interfaces;
         for(auto& s : json["interfaces"])
             interfaces.push_back(s.asDouble());
  
         std::vector<unsigned int> M;
         for(auto& s : json["trials"])
             M.push_back(s.asInt());
         
         if ((ninterfaces != interfaces.size()) || (ninterfaces != M.size()))
             throw BuildException({"The size of \"interfaces\" and \"trials\" must be equal to \"nInterfaces\". See documentation for more information"});
  
         auto N0Target = json.get("N0Target", 1).asInt();
         auto initialFluxFlag = json.get("computeInitialFlux", true).asBool();
         auto saveTrajectories = json.get("saveTrajectories", true).asBool();
         auto currentInterface = json.get("currentInterface", 0).asInt();
         auto freq = json.get("frequency", 1).asInt();
         auto flavor = json.get("flavor", "none").asString();
         auto output_directory = json.get("outputDirectoryName", "FFSoutput").asString();
  
         // TODO: Implement multiple processes per walker
         if(mxx::comm(comm).size() > 1)
         {
             throw BuildException({"Forward Flux currently only works with 1 process per walker."});
         }
  
         if(flavor == "DirectForwardFlux")
         {
             return new DirectForwardFlux(world, comm, ninterfaces, interfaces, N0Target, M, initialFluxFlag, saveTrajectories, currentInterface, output_directory, freq);               
         }
         else 
         {
             throw BuildException({"Unknown flavor of forward flux. The options are \"DirectForwardFlux\""});
         }
     }

References Json::Requirement::GetErrors(), Json::Requirement::HasErrors(), Json::ObjectRequirement::Parse(), and Json::ObjectRequirement::Validate().

Here is the call graph for this function:

◆ ComputeTransitionProbabilities()

void SSAGES::ForwardFlux::ComputeTransitionProbabilities ( )

protected

Compute the probability of going from each lambda_i to lambda_{i+1}.

Using number of successes and number of trials This will need to be different for each FFS flavor

Definition at line 214 of file ForwardFlux.cpp.

     {
         double Ptotal = 1;
         for (unsigned int i = 0; i < _ninterfaces -1; i++)
             Ptotal *= _P[i];
  
         _rate = Ptotal*_fluxA0;
         
         //write file
         std::ofstream file;
         std::string filename = _output_directory + "/rate.dat";
         file.open(filename.c_str());
         if (!file) {std::cerr << "Error! Unable to write " << filename << "\n"; exit(1);}
         file << _rate << "\n";
         file.close();
     }

◆ FluxBruteForce()

void SSAGES::ForwardFlux::FluxBruteForce	(	Snapshot *	,
		const CVList &
	)

protected

Compute the flux via brute force.

Eventually this should be a new class that inherits from ForwardFlux, but for the time being I'll just hard code it This function takes the configurations at lambda0 and run them until they reach B (lambdaN) or return to A

◆ HasCrossedInterface()

int SSAGES::ForwardFlux::HasCrossedInterface	(	double	current,
		double	prev,
		unsigned int	i
	)

protected

Function checks if configuration has crossed interface specified since the last check.

Simple function, given current and previous CV position, checks if interface i has been crossed. If crossed in positive direction, return +1, if crossed in negative direction return -1, if nothing crossed return 0.

Parameters

current	Current value of CV.
prev	Previous value of CV.
i	Index of interface to check for crossing.

Returns: Ternary value for direction of crossing (positive, negative, or none).

Definition at line 79 of file ForwardFlux.cpp.

     {
         double interface_location = _interfaces[i];
         if (_interfaces_increase)
         {
           if ((prev <= interface_location) && (current >= interface_location))
               return 1;
           else if ((prev >= interface_location) && (current <= interface_location))
               return -1;
           else
               return 0;
         }
         else
         {
           if ((prev >= interface_location) && (current <= interface_location))
               return 1;
           else if ((prev <= interface_location) && (current >= interface_location))
               return -1;
           else
               return 0;
         }
     }

Referenced by SSAGES::DirectForwardFlux::CheckForInterfaceCrossings().

Here is the caller graph for this function:

◆ HasReturnedToA()

bool SSAGES::ForwardFlux::HasReturnedToA ( double current )

protected

Function checks if configuration has returned to A.

Parameters

current Current value of CV.

Returns: Boolean if the trajectory returned to state A

Definition at line 102 of file ForwardFlux.cpp.

     {
         double interface_location = _interfaces[0];
         if (_interfaces_increase)
         {
             if (current < interface_location) return true;
             else return false;
         }
         else
         {
             if (current > interface_location) return true;
             else return false;
         }
     }

Referenced by SSAGES::DirectForwardFlux::CheckForInterfaceCrossings().

Here is the caller graph for this function:

◆ PostIntegration()

virtual void SSAGES::ForwardFlux::PostIntegration	(	Snapshot *	snapshot,
		const class CVManager &	cvmanager
	)

overridepure virtual

Method call post integration.

Parameters

snapshot	Pointer to the simulation snapshot.
cvmanager	Collective variable manager.

This function will be called after each integration step.

Implements SSAGES::Method.

Implemented in SSAGES::DirectForwardFlux.

◆ PostSimulation()

void SSAGES::ForwardFlux::PostSimulation	(	Snapshot *	snapshot,
		const class CVManager &	cvmanager
	)

overridevirtual

Method call post simulation.

Parameters

snapshot	Pointer to the simulation snapshot.
cvmanager	Collective variable manager.

This function will be called after the end of the simulation run.

Implements SSAGES::Method.

Definition at line 48 of file ForwardFlux.cpp.

     {
         std::cout << "Post simulation\n";
  
         ComputeCommittorProbability(snapshot);
         ComputeTransitionProbabilities();
  
         if (_saveTrajectories)
             ReconstructTrajectories(snapshot);  
         
         MPI_Abort(world_, EXIT_FAILURE); //more elegant solution?
     }

Referenced by SSAGES::DirectForwardFlux::CheckForInterfaceCrossings().

Here is the caller graph for this function:

◆ PreSimulation()

void SSAGES::ForwardFlux::PreSimulation	(	Snapshot *	snapshot,
		const class CVManager &	cvmanager
	)

overridevirtual

Method call prior to simulation initiation.

Parameters

snapshot	Pointer to the simulation snapshot.
cvmanager	Collective variable manager.

This function will be called before the simulation is started.

Implements SSAGES::Method.

Definition at line 39 of file ForwardFlux.cpp.

     {
         auto cvs = cvmanager.GetCVs(cvmask_);
         if(cvs.size() > 1)
             throw BuildException({"Forwardflux currently only works with one cv."});
  
         std::cout << "\nWARNING! MAKE SURE LAMMPS GIVES A DIFFERENT RANDOM SEED TO EACH PROCESSOR, OTHERWISE EACH FFS TRAJ WILL BE IDENTICAL!\n";        
     }

References SSAGES::CVManager::GetCVs().

Here is the call graph for this function:

◆ ReadFFSConfiguration()

void SSAGES::ForwardFlux::ReadFFSConfiguration	(	Snapshot *	snapshot,
		FFSConfigID &	ffsconfig,
		bool	wassuccess
	)

protected

Read a file corresponding to a FFSConfigID into current snapshot.

Parameters

snapshot	Current snaphshot of the system
ffsconfig	ID of the current FFS configuration
wassuccess	If the last attempt was a success

Definition at line 297 of file ForwardFlux.cpp.

     {
         auto& positions = snapshot->GetPositions();
         auto& velocities = snapshot->GetVelocities();
         auto& atomID = snapshot->GetAtomIDs();
         auto& forces = snapshot->GetForces();
         //auto& ID = snapshot->GetSnapshotID();
  
         std::ifstream file; 
         std::string filename;
         if (wassuccess)
           filename =  _output_directory + "/l"+ std::to_string(ffsconfig.l) +"-n"+ std::to_string(ffsconfig.n) + ".dat";
         else
           filename =  _output_directory + "/fail-l"+ std::to_string(ffsconfig.l) +"-n"+ std::to_string(ffsconfig.n) + ".dat";
  
         std::string line;
         file.open(filename);
         if(!file) 
         {
             std::cerr << "Error! Unable to read " << filename << "\n"; 
             MPI_Abort(world_, EXIT_FAILURE);
         }
  
         unsigned int line_count = 0; 
         while(!std::getline(file,line).eof())
         {
             int atomindex = -1;
             
             //parse line into tokens
             std::string buf; // Have a buffer string
             std::stringstream ss(line); // Insert the string into a stream
             std::vector<std::string> tokens; // Create vector to hold our words
             while (ss >> buf)
                 tokens.push_back(buf);
  
             // first line contains the previous ffsconfig information
             if ((line_count == 0) && (tokens.size() == 3))
             {
                 ffsconfig.lprev = std::stoi(tokens[0]);
                 ffsconfig.nprev = std::stoi(tokens[1]);
                 ffsconfig.aprev = std::stoi(tokens[2]);
             }
             // all other lines contain config information
             else if ((line_count != 0) && (tokens.size() == 7))
             {
                 //FIXME: try using snapshot->GetLocalIndex()
  
                 //copied from Ben's previous implementation
                 for(size_t i=0; i < atomID.size(); i++)
                 {
                     if(atomID[i] == std::stoi(tokens[0]))
                         atomindex = i;
                 }
  
                 if(atomindex < 0)
                 {
                     std::cout<<"error, could not locate atomID "<<tokens[0]<<" from dumpfile"<<std::endl;
                     MPI_Abort(world_, EXIT_FAILURE);
                 }
  
                 positions[atomindex][0] = std::stod(tokens[1]);
                 positions[atomindex][1] = std::stod(tokens[2]);
                 positions[atomindex][2] = std::stod(tokens[3]);
                 velocities[atomindex][0] = std::stod(tokens[4]);
                 velocities[atomindex][1] = std::stod(tokens[5]);
                 velocities[atomindex][2] = std::stod(tokens[6]);
  
                 for(auto& force : forces)
                     force.setZero();
             }
             // else throw error
             else
             {
                 std::cout<<"ERROR: incorrect line format in "<< filename <<" on line" << line_count << ":\n";
                 std::cout<<line<<std::endl;
                 MPI_Abort(world_, EXIT_FAILURE);
             }
             line_count++;
         }
         file.close();
     }

References SSAGES::ForwardFlux::FFSConfigID::aprev, SSAGES::Snapshot::GetAtomIDs(), SSAGES::Snapshot::GetForces(), SSAGES::Snapshot::GetPositions(), SSAGES::Snapshot::GetVelocities(), SSAGES::ForwardFlux::FFSConfigID::l, SSAGES::ForwardFlux::FFSConfigID::lprev, SSAGES::ForwardFlux::FFSConfigID::n, and SSAGES::ForwardFlux::FFSConfigID::nprev.

Here is the call graph for this function:

◆ WriteFFSConfiguration()

void SSAGES::ForwardFlux::WriteFFSConfiguration	(	Snapshot *	snapshot,
		FFSConfigID &	ffsconfig,
		bool	wassuccess
	)

protected

Write a file corresponding to FFSConfigID from current snapshot.

Parameters

snapshot	Current snaphshot of the system
ffsconfig	ID of the current FFS configuration
wassuccess	If the last attempt was a success

Definition at line 231 of file ForwardFlux.cpp.

     {
         const auto& positions = snapshot->GetPositions();
         const auto& velocities = snapshot->GetVelocities();
         const auto& atomID = snapshot->GetAtomIDs();
         //unsigned natoms = snapshot->GetNumAtoms();
         //const auto& dumpfilename = snapshot->GetSnapshotID();
  
         // Write the dump file out
         std::ofstream file;
         std::string filename;
         if (wassuccess)
           filename = _output_directory + "/l" + std::to_string(ffsconfig.l) + "-n" + std::to_string(ffsconfig.n) + ".dat";
         else
           filename = _output_directory + "/fail-l" + std::to_string(ffsconfig.l) + "-n" + std::to_string(ffsconfig.n) + ".dat";
  
         file.open(filename.c_str());
         if(!file)
         {
             std::cerr << "Error! Unable to write " << filename << "\n"; 
             MPI_Abort(world_, EXIT_FAILURE);
         }
  
         //first line gives ID of where it came from
         file << ffsconfig.lprev << " " << ffsconfig.nprev << " " << ffsconfig.aprev << "\n";
  
         // Then write positions and velocities
         for(size_t i = 0; i< atomID.size(); i++)
         //for(size_t i = 0; i< natoms; i++)
         {
             file<<atomID[i]<<" ";
             file<<positions[i][0]<<" "<<positions[i][1]<<" "<<positions[i][2]<<" ";
             file<<velocities[i][0]<<" "<<velocities[i][1]<<" "<<velocities[i][2]<<std::endl;
         }
     }

References SSAGES::ForwardFlux::FFSConfigID::aprev, SSAGES::Snapshot::GetAtomIDs(), SSAGES::Snapshot::GetPositions(), SSAGES::Snapshot::GetVelocities(), SSAGES::ForwardFlux::FFSConfigID::l, SSAGES::ForwardFlux::FFSConfigID::lprev, SSAGES::ForwardFlux::FFSConfigID::n, and SSAGES::ForwardFlux::FFSConfigID::nprev.

Referenced by SSAGES::DirectForwardFlux::CheckForInterfaceCrossings().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ _M

std::vector<unsigned int> SSAGES::ForwardFlux::_M

protected

Number of trials to attemt from each interface Note _M[0] sets the number of 'branches' for RBFFS and BGFFS?

Definition at line 109 of file ForwardFlux.h.

Referenced by SSAGES::DirectForwardFlux::CheckForInterfaceCrossings(), and SSAGES::DirectForwardFlux::InitializeQueue().

◆ _N

std::vector<unsigned int> SSAGES::ForwardFlux::_N

protected

Current number of configurations currently stored at interface i This is somewhat redundant since _N[i] == _S[i-1], but for clarity N[0] - current number of configurations collected at lambda0 (first interface)

Definition at line 127 of file ForwardFlux.h.

Referenced by SSAGES::DirectForwardFlux::CheckForInterfaceCrossings(), ForwardFlux(), and SSAGES::DirectForwardFlux::InitializeQueue().

◆ _nfailure_total

unsigned int SSAGES::ForwardFlux::_nfailure_total

protected

Counts the total number of failures eventually if I prune, will want this to be a vector, where it stores the number of failures at each interface however in the absence of pruning, a traj can only fail at lambda0, so this is just a scalar

Definition at line 149 of file ForwardFlux.h.

Referenced by SSAGES::DirectForwardFlux::CheckForInterfaceCrossings(), and ForwardFlux().

◆ _ninterfaces

double SSAGES::ForwardFlux::_ninterfaces

protected

Number of FFS interfaces note that _ninterfaces = n+1 where n is lambda_n the interface defining B

Definition at line 78 of file ForwardFlux.h.

Referenced by SSAGES::DirectForwardFlux::CheckForInterfaceCrossings(), and ForwardFlux().

◆ _P

std::vector<double> SSAGES::ForwardFlux::_P

protected

Flag to determine wheter fluxA0 should be calculated, seems not using this.

Probability of going from lambda_{i} to lambda_{i+1}

Definition at line 118 of file ForwardFlux.h.

Referenced by SSAGES::DirectForwardFlux::CheckForInterfaceCrossings(), and ForwardFlux().

◆ _pB

std::vector<std::vector<double> > SSAGES::ForwardFlux::_pB

protected

commitor probability. The probability of a given configuration reaching B

Definition at line 153 of file ForwardFlux.h.

◆ _pop_tried_but_empty_queue

bool SSAGES::ForwardFlux::_pop_tried_but_empty_queue

protected

Keep track of jobs that have suceeded or failed but couldn't get reassigned a new task and must wait for the queue to get more jobs This could happen in DFFS once a job has finished but M[i] hasn't been reached (waiting on other jobs) If this is the case I call it a 'zombie job', since the job is running, but isnt doing anything useful. Its just burning cpu cycles waiting for the queue to repopulate

Definition at line 132 of file ForwardFlux.h.

Referenced by SSAGES::DirectForwardFlux::CheckForInterfaceCrossings(), and ForwardFlux().

◆ _S

std::vector<unsigned int> SSAGES::ForwardFlux::_S

protected

Number of successes from lambda_{i} to lambda_{i+1} (might need to be 2d vector if multiple branches are used (with RBFFS)

Definition at line 122 of file ForwardFlux.h.

Referenced by SSAGES::DirectForwardFlux::CheckForInterfaceCrossings(), and ForwardFlux().

◆ FFSConfigIDQueue

std::deque<FFSConfigID> SSAGES::ForwardFlux::FFSConfigIDQueue

protected

Queue When a given processor reaches an interface, it pulls a config from this Queue to figure out what it should do next This object should be syncronized between all FFS walkers (is walker the correct terminology here?) technically this is a double-ended queue, this was mostly for debugging to allow element access of the queue (which std::queue doesn't allow). I use it like a queue though.

Definition at line 163 of file ForwardFlux.h.

Referenced by SSAGES::DirectForwardFlux::CheckForInterfaceCrossings(), and SSAGES::DirectForwardFlux::InitializeQueue().

The documentation for this class was generated from the following files:

/home/michael/development/SSAGES/src/Methods/ForwardFlux.h
/home/michael/development/SSAGES/src/Methods/ForwardFlux.cpp

Classes

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ForwardFlux()

Member Function Documentation

◆ AddNewIDsToQueue()

◆ AppendTrajectoryFile()

◆ Build()

◆ ComputeTransitionProbabilities()

◆ FluxBruteForce()

◆ HasCrossedInterface()

◆ HasReturnedToA()

◆ PostIntegration()

◆ PostSimulation()

◆ PreSimulation()

◆ ReadFFSConfiguration()

◆ WriteFFSConfiguration()

Member Data Documentation

◆ _M

◆ _N

◆ _nfailure_total

◆ _ninterfaces

◆ _P

◆ _pB

◆ _pop_tried_but_empty_queue

◆ _S

◆ FFSConfigIDQueue