gsystem.h

Go to the documentation of this file.

#pragma once
 
// gsystem
#include "gvolume.h"
#include "gmaterial.h"
#include "gmirror.h"
 
// c++
#include <map>
#include <string>
 
class GSystem : public GBase<GSystem>
{
public:
    GSystem(const std::shared_ptr<GOptions>& gopts,
            const std::string&               dbhost,
            const std::string&               sname,
            const std::string&               factory,
            const std::string&               experiment,
            int                              runno,
            const std::string&               variation,
            const std::string&               annotations = "none"
    );
 
    GSystem(const GSystem& other);
 
    // move operations: defaulted
    GSystem(GSystem&&) noexcept            = default;
    GSystem& operator=(GSystem&&) noexcept = default;
 
    // **disable copying**
    GSystem& operator=(const GSystem&) = delete;
 
    [[nodiscard]] std::unique_ptr<GSystem> clone() const {
        return std::make_unique<GSystem>(*this);
    }
 
    [[nodiscard]] std::shared_ptr<GSystem> descriptorClone(const std::shared_ptr<GOptions>& gopts) const;
 
private:
    std::string dbhost;      
    std::string name;        
    std::string path;        
    std::string factoryName; 
    std::string experiment;  
    int         runno{};     
    std::string variation;   
    std::string annotations; 
 
    std::map<std::string, std::shared_ptr<GVolume>>   gvolumesMap;   
    std::map<std::string, std::shared_ptr<GMaterial>> gmaterialsMap; 
    std::map<std::string, std::shared_ptr<GMirror>>   gmirrorsMap;   
 
public:
    [[nodiscard]] inline std::string getName() const { return name; }
    [[nodiscard]] inline std::string getFactoryName() const { return factoryName; }
    [[nodiscard]] inline std::string getVariation() const { return variation; }
    [[nodiscard]] inline std::string getExperiment() const { return experiment; }
    [[nodiscard]] inline std::string getAnnotations() const { return annotations; }
    [[nodiscard]] inline int         getRunno() const { return runno; }
    [[nodiscard]] inline std::string get_dbhost() const { return dbhost; }
 
    std::string getFilePath() const;
 
    inline void set_dbhost(const std::string& dbh) { this->dbhost = dbh; }
 
    void addROOTVolume(const std::string& rootVolumeDefinition);
 
    void addGVolume(std::vector<std::string> pars);
 
    void addVolumeFromFile(const std::string& importType, const std::string& filename);
 
    [[nodiscard]] GVolume* getGVolume(const std::string& volumeName) const;
 
    [[nodiscard]] inline const std::map<std::string, std::shared_ptr<GVolume>>& getGVolumesMap() const {
        return gvolumesMap;
    }
 
    [[nodiscard]] inline const std::map<std::string, std::shared_ptr<GMaterial>>& getGMaterialMap() const {
        return gmaterialsMap;
    }
 
    void addGMaterial(std::vector<std::string> pars);
 
    void addGMirror(std::vector<std::string> pars);
 
    [[nodiscard]] const GMirror* getGMirror(const std::string& mirrorName) const;
 
    [[nodiscard]] inline const std::map<std::string, std::shared_ptr<GMirror>>& getGMirrorsMap() const {
        return gmirrorsMap;
    }
 
    [[nodiscard]] const GMaterial* getMaterialForGVolume(const std::string& volumeName) const;
};
 
// using shared pointers as GSystem could be created from the main
// thread (in dbselect) then dispatched to g4 threads
using SystemPtr  = std::shared_ptr<GSystem>;
using SystemMap  = std::map<std::string, SystemPtr>;
using SystemList = std::vector<SystemPtr>;