#include <DirectForwardFlux.h>

Inheritance diagram for SSAGES::DirectForwardFlux:

Public Member Functions
	DirectForwardFlux (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	PostIntegration (Snapshot *snapshot, const class CVManager &cvmanager) override
	Post-integration hook. More...

Public Member Functions inherited from 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)
	Constructor. More...

void	PreSimulation (Snapshot *snapshot, const class CVManager &cvmanager) override
	Pre-simulation hook. More...

void	PostSimulation (Snapshot *snapshot, const class CVManager &cvmanager) override
	Post-simulation hook. More...

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

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

virtual	~Method ()
	Destructor.

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

uint	GetFrequency () const
	Get frequency of event listener. More...

virtual	~EventListener ()
	Destructor.

Static Public Member Functions
static DirectForwardFlux *	Build (const Json::Value &json, const MPI_Comm &world, const MPI_Comm &comm, const std::string &path)

Static Public Member Functions inherited from SSAGES::ForwardFlux
static ForwardFlux *	Build (const Json::Value &json, const MPI_Comm &world, const MPI_Comm &comm, const std::string &path)

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...

Protected Member Functions
void	CheckForInterfaceCrossings (Snapshot *, const class CVManager &) override
	Function that checks if interfaces have been crossed (different for each FFS flavor) More...

void	InitializeQueue (Snapshot *, const CVList &) override
	Initialize the Queue.

Protected Member Functions inherited from SSAGES::ForwardFlux
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)
	Function checks if configuration has returned to A.

int	HasCrossedInterface (double, double, unsigned int interface)
	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.

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

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

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.

Additional Inherited Members
Protected Attributes inherited from SSAGES::ForwardFlux
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

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::default_random_engine	_generator
	random number generator

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

uint	iteration_
	Method iteration counter/.

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

mxx::comm	comm_
	Local MPI communicator.

std::vector< uint >	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 35 of file DirectForwardFlux.h.

Constructor & Destructor Documentation

SSAGES::DirectForwardFlux::DirectForwardFlux	(	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.
frequency	Frequency with which this method is invoked.

Create instance of Forward Flux

Definition at line 65 of file DirectForwardFlux.h.

71 : ForwardFlux(world, comm, ninterfaces, interfaces, N0Target, M,

72 initialFluxFlag, saveTrajectories, currentInterface, output_directory, frequency) {}

SSAGES::ForwardFlux::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)

Constructor.

Definition: ForwardFlux.h:246

Member Function Documentation

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

static

void SSAGES::DirectForwardFlux::CheckForInterfaceCrossings	(	Snapshot *	,
		const class CVManager &
	)

overrideprotectedvirtual

Function that checks if interfaces have been crossed (different for each FFS flavor)

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

Implements SSAGES::ForwardFlux.

Definition at line 67 of file DirectForwardFlux.cpp.

Referenced by PostIntegration().

     {
         //This is the main FFS method. The magic happens here!
         auto cvs = cvmanager.GetCVs(cvmask_);
         
         //QUESTION: Whats the difference between world_ and _comm?
         //For now I'll use world_ for everything. But if each driver uses multiple procs then I suspect that this will be wrong.
         _cvvalue = cvs[0]->GetValue();
         
         //if ((myFFSConfigID.l == 2) && (myFFSConfigID.n == 20) && (myFFSConfigID.a ==1)){
         //    std::cout << "stop here\n";
         //}
         //if (myFFSConfigID.l != _current_interface){
         //    std::cout << "stop here\n";
         //}
 
         //check if I've crossed the next interface
         bool hasreturned = HasReturnedToA(_cvvalue);
         int hascrossed = HasCrossedInterface(_cvvalue, _cvvalue_previous, _current_interface + 1);
         unsigned int fail_local=false,success_local=false;
         //std::vector<bool> in MPI were strange, ended up using std::vector<unsigned int>
         std::vector<unsigned int> successes (world_.size());
         std::vector<unsigned int> failures (world_.size());
 
         if (!_pop_tried_but_empty_queue)
         { 
             // make sure this isnt a zombie trajectory that previously failed or succeeded and is just waiting for the queue to get more jobs
             if (hasreturned)
                 fail_local=true;
             else if (hascrossed == 1)
                 success_local=true;
             else if (hascrossed == -1)
             {
               //this should never happen if the interfaces are non-intersecting, it would be wise to throw an error here though
               std::cerr << "Trajectory l"<<myFFSConfigID.l<<"-n"<<myFFSConfigID.n<<"-a"<<myFFSConfigID.a<<" crossed backwards! This shouldnt happen!" << std::endl;
               //world_.abort(EXIT_FAILURE);
             }
             else
             {
               //not sure if anything should needs to be done here        
             }
         }
 
         //for each traj that crossed to lambda+1 need to write it to disk (FFSConfigurationFile)
         //MPIAllgather success_local into successes
         MPI_Allgather(&success_local,1,MPI_UNSIGNED,successes.data(),1,MPI_UNSIGNED,world_);
         MPI_Allgather(&fail_local,1,MPI_UNSIGNED,failures.data(),1,MPI_UNSIGNED,world_);
        
         int success_count = 0, fail_count = 0;
         // I dont pass the queue information between procs but I do syncronize 'successes' and 'failures'
         //   as a reuslt all proc should have the same queue throughout the simulation
         for (int i=0;i<world_.size();i++)
         {
             int l,n,a,lprev,nprev,aprev;
             // write config to lambda+1
             lprev = myFFSConfigID.l;
             nprev = myFFSConfigID.n;
             aprev = myFFSConfigID.a;
 
             if (successes[i] == true)
             { 
                 if (i == world_.rank())
                 {
                     //update ffsconfigid's l,n,a
                     l = _current_interface + 1;
                     n = _S[_current_interface] + success_count;
                     a = 0;
                     FFSConfigID newid = FFSConfigID(l,n,a,lprev,nprev,aprev);
                     WriteFFSConfiguration(snapshot,newid,1);
                 }
                 success_count++;
             }
             if (failures[i] == true)
             { 
                 if (i == world_.rank())
                 {
                     //update ffsconfigid's l,n,a
                     l = 0; //only fail at lambda 0, 
                     n = _nfailure_total + fail_count;
                     a = 0;
                     FFSConfigID newid = FFSConfigID(l,n,a,lprev,nprev,aprev);
                     WriteFFSConfiguration(snapshot,newid,0);
                 }
                 fail_count++;
             }
         }
 
         //update trajectories
         if (_saveTrajectories)
         {
             if (!_pop_tried_but_empty_queue) //dont update trajectory if zombie job
                 AppendTrajectoryFile(snapshot,_trajectory_file);
             if (success_local || fail_local) //if finished then close it
                 _trajectory_file.close();
         }
         
         //update the number of successes and attempts, same for all proc since Allgathered 'successes' and 'failures'
         _S[_current_interface] += success_count;
         _A[_current_interface] += success_count + fail_count;
         // ^ I dont like storing attempts this way (as is its only when they finish). _A should also include jobs in progress (i.e. jobs currently running). THINK ABOUT THIS!.
         _nfailure_total += fail_count;
 
         //------------------------------
         //print info
         if ((success_local) || (fail_local))
         {
             std::cout << "Iteration: "<< iteration_ << ", proc " << world_.rank() << "\n";
             if (success_local)
             {
                 std::cout << "Successful attempt from interface " << _current_interface 
                         << " l"<<myFFSConfigID.l<<"-n"<<myFFSConfigID.n<<"-a"<<myFFSConfigID.a
                         << " (cvvalue_previous: " << _cvvalue_previous << " cvvalue " << _cvvalue << " interface["<<_current_interface+1<<"] = " << _interfaces[_current_interface+1] << "\n";
             }
             if (fail_local)
             {
                 std::cout << "Failed attempt from interface " << _current_interface 
                         << " l"<<myFFSConfigID.l<<"-n"<<myFFSConfigID.n<<"-a"<<myFFSConfigID.a
                         << " (cvvalue_previous: " << _cvvalue_previous << " cvvalue " << _cvvalue << " interface[0] = "<< _interfaces[0] << "\n"
                         << "nfailuretotal: " << _nfailure_total << "\n";
             }
             
             std::cout << "A: ";
             for (auto a : _A)
                 std::cout << a << " "; 
             std::cout << "\n";
 
             std::cout << "S: ";
             for (auto s : _S)
                 std::cout << s << " ";
             std::cout << "\n";
             
             std::cout << "M: ";
             for (auto m : _M)
                 std::cout << m << " ";
             std::cout << "\n";
         }
         //------------------------------
        
         //create new funciton here? (call it SetupNextInterface()
         // Check if this interface is finished, if so add new tasks to queue, and increment _current_interface
         if (_A[_current_interface] >= _M[_current_interface])
         {
             //set N and P
             _N[_current_interface+1] = _S[_current_interface];
             _P[_current_interface] = (double) _S[_current_interface] / _A[_current_interface];
 
             if (_current_interface+2 < _ninterfaces)
             {
                 _current_interface += 1;
                 //_N[_current_interface] = _S[_current_interface-1];
 
                 if (_N[_current_interface] == 0)
                 {
                     std::cerr << "Error! No successes from interface " << _current_interface-1 << " to " << _current_interface <<"! Try turning up M["<<_current_interface-1<<"] or spacing interfaces closer together.\n";
                     MPI_Abort(world_, EXIT_FAILURE);
                 }
 
                 //for DFFS
                 unsigned int npicks = _M[_current_interface];
                 std::vector<unsigned int> picks;
                 picks.resize(npicks);
                 if (world_.rank() == 0)
                 {
                     std::uniform_int_distribution<int> distribution(0,_N[_current_interface]-1);
                     for (unsigned int i=0; i < npicks ; i++)
                         picks[i] = distribution(_generator);
                 }
                 MPI_Bcast(picks.data(),npicks,MPI_UNSIGNED,0,world_);
 
                 //each proc adds to the queue
                 //set correct attempt index if a given ID is picked twice
                 std::vector<unsigned int> attempt_count;
                 attempt_count.resize(_N[_current_interface],0);
 
                 for (unsigned int i=0; i < npicks ; i++)
                 {
                     unsigned int mypick = picks[i];
                     int l,n,a,lprev,nprev,aprev;
                     lprev = myFFSConfigID.l;
                     nprev = myFFSConfigID.n;
                     aprev = myFFSConfigID.a;
                     //update ffsconfigid's l,n,a
                     l = _current_interface;
                     n = mypick;
                     a = attempt_count[mypick]; 
                     attempt_count[mypick]++; //this updates attempt number if same config is picked twice
 
                     FFSConfigIDQueue.emplace_back(l,n,a,lprev,nprev,aprev);
                 }
             }
             else
             {
                 std::cout << "DFFS should be finished here, do something special? like exit?\n";
                 //Hythem said this is "acceptable" until the code is changed
                 PostSimulation(snapshot, cvmanager);
             }
         }
 
         // if succeeded or failed (or zombie job), get a new config from the queue...but need to be careful that no two procs get the same config
 
         // Need to account for zombie jobs that are waiting for a new config
         unsigned int shouldpop_local = false;        
         std::vector<unsigned int> shouldpop(world_.size(),0);
 
         if (success_local || fail_local || _pop_tried_but_empty_queue)
           shouldpop_local = true;
         
         //Pop the queue
         // Need to perform mpi call so that all proc pop the queue in the same way
         PopQueueMPI(snapshot,cvs, shouldpop_local);
                 
         //Anything else to update across mpi?
         //clean up
         _cvvalue_previous = _cvvalue;
         iteration_++;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

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

overridevirtual

Post-integration hook.

Parameters

snapshot	Current simulation snapshot.
cvmanager	Collective variable manager.

Implements SSAGES::ForwardFlux.

Definition at line 32 of file DirectForwardFlux.cpp.

References SSAGES::ForwardFlux::_initialFluxFlag, CheckForInterfaceCrossings(), SSAGES::ForwardFlux::CheckInitialStructure(), SSAGES::ForwardFlux::ComputeInitialFlux(), SSAGES::Method::cvmask_, SSAGES::CVManager::GetCVs(), InitializeQueue(), SSAGES::ForwardFlux::iteration_, and SSAGES::ForwardFlux::PrintQueue().

     {
         //check if we want to check FFS interfaces this timestep
         //for now, do it every time step
         if (iteration_ % 1 != 0) return;
         
         auto cvs = cvmanager.GetCVs(cvmask_);
         // check the structure at the beginning of the simulation
         if (iteration_ == 0)
             CheckInitialStructure(cvs);
 
         // if _computefluxA0
         if (_initialFluxFlag)
         {
             ComputeInitialFlux(snapshot,cvs); 
             if (!_initialFluxFlag)
             { //only enter here once
                 InitializeQueue(snapshot,cvs);
                 PrintQueue();
             }
         }
         else if (initializeQueueFlag)
         {
             InitializeQueue(snapshot,cvs);
             PrintQueue();
         }
         // Else check the FFS interfaces
         else
         {
             CheckForInterfaceCrossings(snapshot, cvmanager);
             //FluxBruteForce(snapshot,cvs);
         }
         // Other modes?
     }

Here is the call graph for this function:

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

/home/cody/SSAGES/src/Methods/DirectForwardFlux.h
/home/cody/SSAGES/src/Methods/DirectForwardFlux.cpp

Public Member Functions

Static Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation