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, size_t walkerid, const std::vector< class Method * > &methods, class CVManager *cvmanager)
	Constructor. More...
std::string	GetInput () const
	Returns inputs of the walker for the current processor. More...
MPI_Comm	GetLocalComm () const
	Returns local (walker-specific) MPI communicator. More...
MPI_Comm	GetWorldComm () const
	Returns world (all processors) MPI communicator. More...
const mxx::comm &	GetLocalMxxComm () const
	Returns local (walker-specific) mxx communicator. More...
const mxx::comm &	GetWorldMxxComm () const
	Returns world (all processors) mxx communicator. More...
size_t	GetWalkerID () const
	Returns processor-specific walker ID. More...
size_t	GetNumWalkers () const
	Returns the total number of walkers across all processors. More...
void	ConfigureHook (class Hook *hook)
	Configure the Hook from given resources. More...
	~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.
size_t	walkerid_
	Walker ID for specific driver.
size_t	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

ResourceHandler()

SSAGES::ResourceHandler::ResourceHandler	(	mxx::comm &&	world,
		mxx::comm &&	comm,
		size_t	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.

                                                                 :
    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);
    }

References comm_, and snapshot_.

Referenced by Build().

Here is the caller graph for this function:

Member Function Documentation

Build()

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.

    {
        ObjectRequirement validator;
        Value schema;
        CharReaderBuilder rbuilder;
        CharReader* reader = rbuilder.newCharReader();
 
        // 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.c_str(),
                      JsonSchema::Simulation.c_str() + JsonSchema::Simulation.size(),
                      &schema, nullptr);
        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).asUInt();
        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(size_t i = 0; i < nwalkers; ++i)
        {
            if(json["input"].isArray())
                inputs.push_back(json["input"][static_cast<int>(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.
            // Otherwise, register index as name to CV manager.
            if(cv.isMember("name"))
            {
                CVManager::AddCVtoMap(cv["name"].asString(), icv);
            }
            else
            {
                CVManager::AddCVtoMap(std::to_string(icv), 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"])
        {
            // Error will be thrown if lookup fails.
            for(auto& cv : m["cvs"])
            {
                CVManager::LookupCV(cv, "#/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;
    }

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

Here is the call graph for this function:

ConfigureHook()

void SSAGES::ResourceHandler::ConfigureHook

(

class Hook *

hook

)

Configure the Hook from given resources.

Parameters

hook	Pointer to specified Hook.

Definition at line 44 of file ResourceHandler.cpp.

    {
        hook->SetSnapshot(snapshot_);
        hook->SetCVManager(cvmanager_);
        for(auto& m : methods_)
            hook->AddListener(m);
        if(logger_ != nullptr) hook->AddListener(logger_);
        hook_ = hook;
    }

References SSAGES::Hook::AddListener(), cvmanager_, hook_, logger_, methods_, SSAGES::Hook::SetCVManager(), SSAGES::Hook::SetSnapshot(), and snapshot_.

Here is the call graph for this function:

GetInput()

std::string SSAGES::ResourceHandler::GetInput ( ) const

inline

Returns inputs of the walker for the current processor.

Returns

Walker inputs of current processor.

Definition at line 95 of file ResourceHandler.h.

        {
            return inputs_[walkerid_];
        }

References inputs_, and walkerid_.

GetLocalComm()

MPI_Comm SSAGES::ResourceHandler::GetLocalComm ( ) const

inline

Returns local (walker-specific) MPI communicator.

Returns

Walker-specific MPI communicator.

Definition at line 104 of file ResourceHandler.h.

        {
            return comm_;
        }

References comm_.

GetLocalMxxComm()

const mxx::comm& SSAGES::ResourceHandler::GetLocalMxxComm ( ) const

inline

Returns local (walker-specific) mxx communicator.

Returns

Walker-specific mxx communicator.

Definition at line 122 of file ResourceHandler.h.

        {
            return comm_;
        }

References comm_.

GetNumWalkers()

size_t SSAGES::ResourceHandler::GetNumWalkers ( ) const

inline

Returns the total number of walkers across all processors.

Returns

Total number of walkers.

Definition at line 149 of file ResourceHandler.h.

        {
            return nwalkers_;
        }

References nwalkers_.

GetWalkerID()

size_t SSAGES::ResourceHandler::GetWalkerID ( ) const

inline

Returns processor-specific walker ID.

Returns

Walker ID.

Definition at line 140 of file ResourceHandler.h.

        {
            return walkerid_;
        }

References walkerid_.

GetWorldComm()

MPI_Comm SSAGES::ResourceHandler::GetWorldComm ( ) const

inline

Returns world (all processors) MPI communicator.

Returns

Overall MPI communicator.

Definition at line 113 of file ResourceHandler.h.

        {
            return world_;
        }

References world_.

GetWorldMxxComm()

const mxx::comm& SSAGES::ResourceHandler::GetWorldMxxComm ( ) const

inline

Returns world (all processors) mxx communicator.

Returns

Overall mxx communicator.

Definition at line 131 of file ResourceHandler.h.

        {
            return world_;
        }

References world_.

---

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

• /home/michael/development/SSAGES/src/ResourceHandler.h
• /home/michael/development/SSAGES/src/ResourceHandler.cpp