gsystem.cc

Go to the documentation of this file.

 
// gsystem
#include "gsystem.h"
#include "gsystemConventions.h"
#include "gsystem_options.h"
 
 
// explicit copy constructor
GSystem::GSystem(const GSystem& other)
    : GBase(other.log),
      dbhost(other.dbhost),
      name(other.name),
      path(other.path),
      factoryName(other.factoryName),
      experiment(other.experiment),
      runno(other.runno),
      variation(other.variation),
      annotations(other.annotations) {
    log->debug(CONSTRUCTOR, "GSystem");
 
    // Deep copy the gvolumesMap
    for (const auto& [key, volumePtr] : other.gvolumesMap) {
        if (volumePtr) {
            gvolumesMap[key] = std::make_shared<GVolume>(*volumePtr); // do not clone, it creates uniqueptr
        }
    }
 
    // Deep copy the gmaterialsMap
    for (const auto& [key, materialPtr] : other.gmaterialsMap) {
        if (materialPtr) {
            gmaterialsMap[key] = std::make_shared<GMaterial>(*materialPtr);
        }
    }
 
    // Deep copy the gmirrorsMap
    for (const auto& [key, mirrorPtr] : other.gmirrorsMap) {
        if (mirrorPtr) {
            gmirrorsMap[key] = std::make_shared<GMirror>(*mirrorPtr);
        }
    }
}
 
 
// See gsystem.h for API docs.
GSystem::GSystem(const std::shared_ptr<GOptions>& gopts,
                 const std::string&               dbh,
                 const std::string&               sname,
                 const std::string&               factory,
                 const std::string&               exp,
                 int                              run,
                 const std::string&               variation,
                 std::optional<std::string>       notes)
    : GBase(gopts, GSYSTEM_LOGGER),
      dbhost(dbh),
      name(gutilities::getFileFromPath(sname)),
      path(gutilities::getDirFromPath(sname)), // Initialize 'path' directly
      factoryName(factory),
      experiment(exp),
      runno(run),
      variation(variation),
      annotations(std::move(notes))
{
    // If the provided name does not include a directory, set the path to empty.
    if (name == path || factoryName == gsystem::GSYSTEMSQLITETFACTORYLABEL) {
        path = "";
        log->info(1, "Instantiating GSystem <%1> using factory <%2>", name, factoryName);
    }
    else {
        log->info(1, "Instantiating GSystem <%1> using path <%2> and factory <%3>", name, path, factoryName);
    }
}
 
// See gsystem.h for API docs.
std::shared_ptr<GSystem> GSystem::descriptorClone(const std::shared_ptr<GOptions>& gopts) const {
    return std::make_shared<GSystem>(gopts, dbhost, getFilePath(), factoryName, experiment, runno, variation,
                                     annotations);
}
 
 
// MARK: GVOLUMES
 
// See gsystem.h for API docs.
void GSystem::addGVolume(std::vector<std::string> pars) {
    // Append variation and run number to parameters so the GVolume stores provenance and filtering context.
    pars.emplace_back(variation);
    pars.emplace_back(std::to_string(runno));
 
    std::string volume_name = pars[0];
 
    // Check if the volume already exists in the map.
    if (!gvolumesMap.contains(volume_name)) {
        // Create and add GVolume to the map.
        gvolumesMap[volume_name] = std::make_shared<GVolume>(log, name, pars);
        log->info(1, "Adding gVolume <%1> to gvolumesMap.", volume_name);
        log->info(2, "%1", *gvolumesMap[volume_name]);
    }
    else {
        log->error(
            gsystem::ERR_GVOLUMEALREADYPRESENT, "gVolume <%1> already exists in gvolumesMap.", volume_name);
    }
}
 
 
// See gsystem.h for API docs.
void GSystem::addROOTVolume(const std::string& rootVolumeDefinition) {
    log->warning("Adding ROOT volume using <%1> to gvolumesMap.", rootVolumeDefinition);
    // gsystem::ROOTWORLDGVOLUMENAME is assumed to be defined in gsystemConventions.h.
    gvolumesMap[gsystem::ROOTWORLDGVOLUMENAME] = std::make_shared<GVolume>(rootVolumeDefinition, log);
}
 
// add volume from a file (CAD or GDML factories)
// includes factory and filename in the definitions
#include <filesystem>
#include <utility>
 
namespace fs = std::filesystem;
 
// See gsystem.h for API docs.
void GSystem::addVolumeFromFile(const std::string& importType, const std::string& filename) {
    std::vector<std::string> pars;
 
    // Extract filename (without the path) and split by delimiter.
    std::vector<std::string> gvpaths = gutilities::getStringVectorFromStringWithDelimiter(
        fs::path(filename).filename().string(),
        ".");
 
    // Use the first item as the volume name.
    const std::string& gvolumeName = gvpaths.front();
 
    // Order is defined in gvolume.cc:
    // 01: name, 03: type, 04: parameters, 05: material, 02: mother, etc.
    pars.emplace_back(gvolumeName);                 // 01 name
    pars.emplace_back(importType);                  // 03 type
    pars.emplace_back(guts::SERIALIZED_NULL_TOKEN); // 04 parameters
    pars.emplace_back("G4_AIR");                    // 05 material: default is air
    pars.emplace_back(gsystem::ROOTWORLDGVOLUMENAME);        // 02 mother: default is gsystem::ROOTWORLDGVOLUMENAME
    pars.emplace_back("0*cm, 0*cm, 0*cm");          // 06 position
    pars.emplace_back("0*deg, 0*deg, 0*deg");       // 07 rotation
    pars.emplace_back(gsystem::DEFAULTG4PLACEMENTTYPE);      // 08 Geant4 placement constructor convention
    pars.emplace_back(guts::SERIALIZED_NULL_TOKEN); // 09 electromagnetic field
    pars.emplace_back("1");                         // 10 visible
    pars.emplace_back("1");                         // 11 style
    pars.emplace_back("999999");                    // 12 color
    pars.emplace_back("1");                         // 13 opacity
    pars.emplace_back(guts::SERIALIZED_NULL_TOKEN); // 14 digitization
    pars.emplace_back(guts::SERIALIZED_NULL_TOKEN); // 15 gidentity
    pars.emplace_back(guts::SERIALIZED_NULL_TOKEN); // 16 copyOf
    pars.emplace_back(guts::SERIALIZED_NULL_TOKEN); // 17 solidsOpr
    pars.emplace_back(guts::SERIALIZED_NULL_TOKEN); // 18 mirror
    pars.emplace_back("1");                         // 19 exist flag
    pars.emplace_back(filename);                    // 20 description: contains full path
 
    addGVolume(pars);
}
 
 
// See gsystem.h for API docs.
GVolume* GSystem::getGVolume(const std::string& volumeName) const {
    auto it = gvolumesMap.find(volumeName);
    if (it != gvolumesMap.end())
        return it->second.get();
    return nullptr;
}
 
 
// MARK: GMATERIALS
 
// See gsystem.h for API docs.
void GSystem::addGMaterial(std::vector<std::string> pars) {
    std::string materialName = pars[0];
 
    if (!gmaterialsMap.contains(materialName)) {
        gmaterialsMap[materialName] = std::make_shared<GMaterial>(name, pars, log);
        log->info(1, "Adding gMaterial <%1> to gmaterialsMap.", materialName);
        log->info(2, "%1", *gmaterialsMap[materialName]);
    }
    else {
        log->error(
            gsystem::ERR_GMATERIALALREADYPRESENT, "gMaterial <%1> already exists in gmaterialsMap.",
            materialName);
    }
}
 
 
// MARK: GMIRRORS
 
// See gsystem.h for API docs.
void GSystem::addGMirror(std::vector<std::string> pars) {
    std::string mirrorName = pars[0];
 
    if (!gmirrorsMap.contains(mirrorName)) {
        gmirrorsMap[mirrorName] = std::make_shared<GMirror>(name, pars, log);
        log->info(1, "Adding gMirror <%1> to gmirrorsMap.", mirrorName);
        log->info(2, "%1", *gmirrorsMap[mirrorName]);
    }
    else {
        log->error(
            gsystem::ERR_GMIRRORALREADYPRESENT, "gMirror <%1> already exists in gmirrorsMap.", mirrorName);
    }
}
 
 
// See gsystem.h for API docs.
const GMirror* GSystem::getGMirror(const std::string& mirrorName) const {
    auto it = gmirrorsMap.find(mirrorName);
    if (it != gmirrorsMap.end())
        return it->second.get();
    return nullptr;
}
 
 
// See gsystem.h for API docs.
const GMaterial* GSystem::getMaterialForGVolume(const std::string& volumeName) const {
    auto it = gvolumesMap.find(volumeName);
    if (it != gvolumesMap.end()) {
        std::string materialName = it->second->getMaterial();
        auto        matIt        = gmaterialsMap.find(materialName);
        if (matIt != gmaterialsMap.end())
            return matIt->second.get();
        else {
            log->error(
                gsystem::ERR_GMATERIALNOTFOUND, "gMaterial <%1> not found for volume <%2>", materialName,
                volumeName);
        }
    }
    return nullptr;
}
 
 
// See gsystem.h for API docs.
std::string GSystem::getFilePath() const {
    if (path.empty())
        return name;
    return path + "/" + name;
}