SSAGES::ResourceHandler Class Reference

Class that handles SSAGES resources for a simulation. More...

#include <ResourceHandler.h>

Public Member Functions
	ResourceHandler (mxx::comm &&world, mxx::comm &&comm, uint walkerid, const std::vector< class Method * > &methods, class CVManager *cvmanager)
	Constructor. More...
std::string	GetInput () const
MPI_Comm	GetLocalComm () const
MPI_Comm	GetWorldComm () const
const mxx::comm &	GetLocalMxxComm () const
const mxx::comm &	GetWorldMxxComm () const
uint	GetWalkerID () const
uint	GetNumWalkers () const
void	ConfigureHook (class Hook *hook)
	~ResourceHandler ()
	Destructor.

Static Public Member Functions
static ResourceHandler *	Build (const Json::Value &json, const MPI_Comm &world)
	Build a new ResourceHandler from JSON. More...

Private Attributes
mxx::comm	world_
	MPI communicator containing all processors.
mxx::comm	comm_
	MPI communicator containing processors for specific walker.
uint	walkerid_
	Walker ID for specific driver.
uint	nwalkers_
	Number of walkers.
class Snapshot *	snapshot_
	Snapshot of system state (pointer).
std::vector< class Method * >	methods_
	Vector of advanced sampling methods.
class Logger *	logger_
	CV logger.
class CVManager *	cvmanager_
	Collective variable manager.
class Hook *	hook_
	Hook pointer.
std::vector< std::string >	inputs_
	Input file vector.

Detailed Description

Class that handles SSAGES resources for a simulation.

ResourceHandler is responsible for intialzing the major components of a simulation including the engine, methods, and collective variables. It is also responsible for the lifetime of the objects it creates.

Each simulation engine must implement a driver which calls this resource handler and passes it the appropriate hook.

Definition at line 44 of file ResourceHandler.h.

Constructor & Destructor Documentation

SSAGES::ResourceHandler::ResourceHandler	(	mxx::comm &&	world,
		mxx::comm &&	comm,
		uint	walkerid,
		const std::vector< class Method * > &	methods,
		class CVManager *	cvmanager
	)

Constructor.

Parameters

world	MPI communicator containing all processors.
comm	MPI communicator containing walker-specific processors.
walkerid	ID of the walker for the current processor.
methods	Vector of pointers to methods.
CVManager	Pointer to CV manager.

Note

ResourceHandler will be responsible for lifetime of methods and CV manager.

Definition at line 35 of file ResourceHandler.cpp.

References comm_, and snapshot_.

Referenced by Build().

                                                                 : 
    world_(std::move(world)), comm_(std::move(comm)), walkerid_(walkerid), nwalkers_(1), 
    methods_(methods), cvmanager_(cvmanager), hook_(nullptr), inputs_(0)
    {
        snapshot_ = new Snapshot(comm_, walkerid);
    }

Here is the caller graph for this function:

Member Function Documentation

ResourceHandler * SSAGES::ResourceHandler::Build ( const Json::Value &  json, const MPI_Comm &  world  )

static

Build a new ResourceHandler from JSON.

Parameters

json	JSON root node containing driver (and children) specifications.
world	MPI communicator containing all processors.

Returns

Pointer to newly created driver.

Note

Object lifetime is caller's responsibility!

Definition at line 54 of file ResourceHandler.cpp.

References SSAGES::CVManager::AddCVtoMap(), SSAGES::Logger::Build(), SSAGES::CollectiveVariable::BuildCV(), SSAGES::Method::BuildMethod(), Json::Requirement::GetErrors(), Json::Requirement::HasErrors(), Json::ObjectRequirement::Parse(), ResourceHandler(), and Json::ObjectRequirement::Validate().

    {
        ObjectRequirement validator;
        Value schema;
        Reader reader;

        // Parse and validate top level schema. This just 
        // makes sure the proper fields exist and the correct 
        // types are specified in the input files.
        reader.parse(JsonSchema::Simulation, schema);
        validator.Parse(schema, "#");
        validator.Validate(json, "#");
        if(validator.HasErrors())
            throw BuildException(validator.GetErrors());
        
        // Get number of desired walkers and create array of input files.
        auto nwalkers = json.get("walkers", 1).asInt();
        if(json["input"].isArray() && json["input"].size() != nwalkers)
            throw BuildException({"#/input: Number of inputs do not match requested walkers."});
        
        std::vector<std::string> inputs;
        for(int i = 0; i < nwalkers; ++i)
        {
            if(json["input"].isArray())
                inputs.push_back(json["input"][i].asString());
            else
                inputs.push_back(json["input"].asString());
        }

        // Get basic MPI info and verify that the total number of 
        // cores are divisble by number of walkers. 
        auto wcomm = mxx::comm(world);
        if(wcomm.size() % nwalkers != 0) 
            throw BuildException({"#/walkers: Allocated processors not divisible by number of walkers."});
        
        // Split communicators.
        int ppw = wcomm.size()/nwalkers;
        int walkerid = wcomm.rank()/ppw;
        auto comm = wcomm.split(walkerid);

        // Build collective variables. 
        auto* cvmanager = new CVManager();
        int icv = 0;
        for(auto& cv : json["CVs"])
        {
            // Register name with CV manager if it exists.
            if(cv.isMember("name"))
                CVManager::AddCVtoMap(cv["name"].asString(), icv);

            // Build CV and add to manager.
            cvmanager->AddCV(CollectiveVariable::BuildCV(cv, "#/CVs"));
            ++icv;
        }

        // Build methods. 
        std::vector<Method*> methods; 
        for(auto& m : json["methods"])
            methods.push_back(Method::BuildMethod(m, world, comm, "#/methods"));
        
        // Build logger. 
        Logger* l = nullptr; 
        if(json.isMember("logger"))
            l = Logger::Build(json["logger"], world, comm, "#/logger");

        auto* rh = new ResourceHandler(std::move(world), std::move(comm), walkerid, methods, cvmanager);
        rh->inputs_ = inputs;
        rh->nwalkers_ = nwalkers;
        rh->logger_ = l;
        return rh;
    }

Here is the call graph for this function:

---

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

• /home/cody/SSAGES/src/ResourceHandler.h
• /home/cody/SSAGES/src/ResourceHandler.cpp