gsystem_options.cc

Go to the documentation of this file.

 
// gemc
#include "gfactory_options.h"
 
// gsystem
#include "gsystem_options.h"
#include "gsystemConventions.h"
 
// project goption to a system
namespace gsystem {
// See gsystem_options.h for API docs.
SystemList getSystems(const std::shared_ptr<GOptions>& gopts) {
    auto gsystem_node = gopts->getOptionNode("gsystem");
 
    SystemList systems;
    systems.reserve(gsystem_node.size());
 
    auto exp      = gopts->getRequiredScalarString("experiment");
    auto run      = gopts->getRequiredScalarInt("runno");
    auto dbhost   = gopts->getRequiredScalarString("sql");
    auto ascii_db = gopts->getRequiredScalarString("ascii_db");
 
    for (auto gsystem_item : gsystem_node) {
        auto factory = gopts->get_variable_in_option<std::string>(gsystem_item, "factory",
                                                                  gsystem::GSYSTEMSQLITETFACTORYLABEL);
 
        // ASCII factory can use an alternate search root (ascii_db).
        if (factory == gsystem::GSYSTEMASCIIFACTORYLABEL) { dbhost = ascii_db; }
 
        systems.emplace_back(
            std::make_shared<GSystem>(
                gopts,
                dbhost,
                gopts->get_required_variable_in_option<std::string>(gsystem_item, "name"),
                factory,
                exp,
                run,
                gopts->get_variable_in_option<std::string>(gsystem_item, "variation", "default"),
                gopts->get_optional_variable_in_option<std::string>(gsystem_item, "annotations")
            ));
    }
 
    return systems;
}
 
 
// See gsystem_options.h for API docs.
std::vector<GModifier> getModifiers(const std::shared_ptr<GOptions>& gopts) {
    std::vector<GModifier> gmods;
 
    auto gmodifier_node = gopts->getOptionNode("gmodifier");
 
    for (auto gmodifier_item : gmodifier_node) {
        gmods.emplace_back(
            gopts->get_required_variable_in_option<std::string>(gmodifier_item, "name"),
            gopts->get_optional_variable_in_option<std::string>(gmodifier_item, "shift"),
            gopts->get_optional_variable_in_option<std::string>(gmodifier_item, "tilt"),
            gopts->get_variable_in_option<bool>(gmodifier_item, "isPresent", true));
    }
 
    return gmods;
}
 
 
// See gsystem_options.h for API docs.
GOptions defineOptions() {
    GOptions goptions(GVOLUME_LOGGER);
    goptions += GOptions(GMATERIAL_LOGGER);
    goptions += GOptions(GSYSTEM_LOGGER);
    goptions += GOptions(GWORLD_LOGGER);
    goptions += GOptions(GSFACTORY_LOGGER);
    goptions += gfactory::defineOptions();
 
    // System
    std::string help;
    help = "A system definition includes the geometry location, factory and variation \n \n";
    help += "Possible factories are: \n";
    help += " - " + std::string(gsystem::GSYSTEMASCIIFACTORYLABEL) + "\n";
    help += " - " + std::string(gsystem::GSYSTEMSQLITETFACTORYLABEL) + "\n";
    help += " - " + std::string(gsystem::GSYSTEMMYSQLTFACTORYLABEL) + "\n";
    help += " - " + std::string(gsystem::GSYSTEMCADTFACTORYLABEL) + "\n";
    help +=
        R"RAWS(Example: -gsystem="[{name: b1}]")RAWS";
 
    std::vector<GVariable> gsystem = {
        {"name", goptions::REQUIRED,
         "system name (mandatory). For ascii factories, it may include the path to the file"},
        {"factory", gsystem::GSYSTEMSQLITETFACTORYLABEL, "factory name."},
        {"variation", "default", "geometry variation"},
        {"annotations", std::nullopt,
         "optional system annotations. Examples: \"mats_only\" "},
        {"digitization", std::nullopt,
         "optional digitization plugin name when it differs from the system name (shared plugin, e.g. \"ecal\" "
         "for the EC and PCAL systems)"}};
    goptions.defineOption(GSYSTEM_LOGGER, "defines the group of volumes in a system", gsystem, help);
 
    // Modifier
    help = "The volume modifier can shift, tilt, or delete a volume from the gworld \n \n";
    help += R"RAWS(Example: -gmodifier="[{name: targetCell, tilt: '0*deg, 0*deg, -10*deg'}]")RAWS";
 
    std::vector<GVariable> gmodifier = {
        {"name", goptions::REQUIRED, "volume name (mandatory)"},
        {"shift", std::nullopt, "volume shift added to existing position"},
        {"tilt", std::nullopt, "volume tilt added to existing rotation"},
        {"isPresent", true, "If set to false, remove the volume from the world"}
    };
    goptions.defineOption("gmodifier", "modify volume existence or placement", gmodifier, help);
 
    help = "root volume definition. Default is: " + std::string(gsystem::ROOTDEFINITION) + ". \n\n";
    help += "Command line Example: -root=\"G4Box 25*cm 24*cm 40*cm G4_WATER\"\n";
    help += "YAML file example: root: G4Box, 24*cm, 24*cm, 40*cm, G4_WATER\n";
    goptions.defineOption(
        GVariable(gsystem::ROOTWORLDGVOLUMENAME, gsystem::ROOTDEFINITION, "root volume definition"), help);
 
    // add sql option to define host or sqlite file
    help = "sqlite file or sql host. Default is: " + std::string(gsystem::GSYSTEMSQLITETDEFAULTFILE) + ". \n\n";
    help += "Example (sqlite file): -sql=myGeometry.sqlite\n";
    goptions.defineOption(GVariable("sql", gsystem::GSYSTEMSQLITETDEFAULTFILE, "sql host or sqlite file"),
                          help);
 
    // add ascii_db option to define an alternative search path for the ascii factory
    help = "ascii search path. Default is: " + std::string(gsystem::GSYSTEMSASCIISEARCHDIR) + ". \n\n";
    help += "Example: -ascii_db=/path/to/geometry/text/files\n";
    goptions.defineOption(GVariable("ascii_db", gsystem::GSYSTEMSASCIISEARCHDIR, "ascii factory search path"),
                          help);
 
    // add the experiment option to define the experiment, common for all systems
    goptions.defineOption(GVariable("experiment", "examples", "experiment selection"),
                          "Each experiment has a subset of unique systems.\n \nExample: -experiment=clas12\n");
 
    // add run number options, common for all systems
    goptions.defineOption(GVariable("runno", 1, "geometry/conditions run number"),
                          "Run number used to select the geometry/conditions variation loaded from the\n"
                          "database; all systems share it. This is distinct from -run, the run number\n"
                          "assigned to generated events.\n \nExample: -runno=11\n");
 
    return goptions;
}
}