Configuration.cc

/*
 *  MoMEMta: a modular implementation of the Matrix Element Method
 *  Copyright (C) 2016  Universite catholique de Louvain (UCL), Belgium
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <momemta/Configuration.h>
#include <momemta/ConfigurationReader.h>
#include <momemta/ParameterSet.h>

#include <ExecutionPath.h>

Configuration::ModuleDecl::ModuleDecl(const Configuration::ModuleDecl& other) {
    name = other.name;
    type = other.type;

    if (other.parameters)
        parameters.reset(other.parameters->clone());
}

Configuration::ModuleDecl::ModuleDecl(const Configuration::ModuleDecl&& other) {
    name = std::move(other.name);
    type = std::move(other.type);
    parameters = std::move(other.parameters);
}

Configuration::ModuleDecl& Configuration::ModuleDecl::operator=(Configuration::ModuleDecl other) {
    std::swap(name, other.name);
    std::swap(type, other.type);
    std::swap(parameters, other.parameters);

    return *this;
}

Configuration::Configuration(const Configuration& other) {
    modules = other.modules;
    if (other.global_parameters)
        global_parameters.reset(other.global_parameters->clone());
    if (other.cuba_configuration)
        cuba_configuration.reset(other.cuba_configuration->clone());
    integrands = other.integrands;
    paths = other.paths;
    n_dimensions = other.n_dimensions;
    inputs = other.inputs;
}

Configuration::Configuration(const Configuration&& other) {
    modules = std::move(other.modules);
    global_parameters = std::move(other.global_parameters);
    cuba_configuration = std::move(other.cuba_configuration);
    integrands = std::move(other.integrands);
    paths = std::move(other.paths);
    n_dimensions = other.n_dimensions;
    inputs = std::move(other.inputs);
}

Configuration& Configuration::operator=(Configuration other) {
    std::swap(*this, other);
    return *this;
}

const std::vector<Configuration::ModuleDecl>& Configuration::getModules() const {
    return modules;
}

const ParameterSet& Configuration::getCubaConfiguration() const {
    return *cuba_configuration;
}

const ParameterSet& Configuration::getGlobalParameters() const {
    return *global_parameters;
}

std::vector<InputTag> Configuration::getIntegrands() const {
    return integrands;
}

std::vector<std::shared_ptr<ExecutionPath>> Configuration::getPaths() const {
    return paths;
}

std::size_t Configuration::getNDimensions() const {
    return n_dimensions;
}

std::vector<std::string> Configuration::getInputs() const {
    return inputs;
}

Configuration Configuration::freeze() const {
    Configuration c = *this;

    c.global_parameters->freeze();
    c.cuba_configuration->freeze();
    for (auto& module: c.modules) {
        module.parameters->freeze();
        // Attach global configuration to each module
        module.parameters->setGlobalParameters(*c.global_parameters);
    }

    // Insert internal modules inside the list of modules
    // See the full list of internal modules in modules/InternalModules.cc

    auto insert_internal_module = [&c](const std::string& type,
                                       const std::string& name,
                                       const ParameterSet& parameters) {
        Configuration::ModuleDecl internal_module;
        internal_module.type = type;
        internal_module.name = name;
        internal_module.parameters = std::make_shared<ParameterSet>(parameters);

        c.modules.push_back(internal_module);
    };

    insert_internal_module("_met", "met", ParameterSet());
    insert_internal_module("_cuba", "cuba", ParameterSet());

    auto inputs = c.getInputs();
    for (const auto& input: inputs) {
        insert_internal_module("_input", input, ParameterSet());
    }

    // Insert the MoMEMta module, fetching the integrands
    std::vector<InputTag> integrands = c.getIntegrands();
    ParameterSet pset;
    pset.set("integrands", integrands);
    insert_internal_module("_momemta", "momemta", pset);

    return c;
}