ResourceHandler.cpp

 
#include <mxx/comm.hpp>
#include "CVs/CVManager.h"
#include "Drivers/DriverException.h"
#include "Loggers/Logger.h"
#include "Validator/ObjectRequirement.h"
#include "Methods/Method.h"
#include "ResourceHandler.h"
#include "Snapshot.h"
#include "Hook.h"
#include "schema.h"
 
using namespace Json;
 
namespace SSAGES
{
    ResourceHandler::ResourceHandler(
        mxx::comm&& world, mxx::comm&& comm, size_t walkerid,
        const std::vector<Method*>& methods, CVManager* cvmanager) :
    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);
    }
 
    void ResourceHandler::ConfigureHook(class Hook* hook)
    {
        hook->SetSnapshot(snapshot_);
        hook->SetCVManager(cvmanager_);
        for(auto& m : methods_)
            hook->AddListener(m);
        if(logger_ != nullptr) hook->AddListener(logger_);
        hook_ = hook;
    }
 
    ResourceHandler* ResourceHandler::Build(const Value& json, const MPI_Comm& world)
    {
        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;
    }
 
    ResourceHandler::~ResourceHandler()
    {
        delete snapshot_;
        delete cvmanager_;
        for(auto& m : methods_)
            delete m;
    }
}