gvolume.h

Go to the documentation of this file.

#pragma once
 
// namespace needed for the inline functions below
#include <gemc/guts/gutilities.h>
#include <gemc/gbase/gbase.h>
 
// c++
#include <string>
#include <utility>
 
class GVolume : public GBase<GVolume>
{
public:
    GVolume(const std::shared_ptr<GLogger>& log,
            const std::string&              system,
            std::vector<std::string>        pars,
            const std::string&              importPath = UNINITIALIZEDSTRINGQUANTITY);
 
    explicit GVolume(const std::string& rootVolumeDefinition, const std::shared_ptr<GLogger>& log);
 
    [[nodiscard]] virtual std::unique_ptr<GVolume> clone() const {
        return std::make_unique<GVolume>(*this);
    }
 
    virtual ~GVolume() = default;
 
private:
    std::string system;         
    std::string name;           
    std::string motherName;     
    std::string description;    
    std::string importFilename; 
 
    // solid parameters
    std::string type;       
    std::string parameters; 
 
    // solid visualization style
    bool        visible{}; 
    int         style{};   
    std::string color;     
    double      opacity{}; 
 
    // logical attributes
    std::string material; 
    std::string emfield;  
 
    // physical attributes
    std::string pos;     
    std::string rot;     
    std::string g4placementType; 
    std::string shift;   
    std::string tilt;    
    bool        exist{}; 
 
    std::string digitization; 
    std::string gidentity;    
 
    // special cases
    std::string copyOf;    
    std::string solidsOpr; 
 
    int pCopyNo{}; 
 
    // mirrors
    std::string mirror; 
 
    // the map key names used in geant4 contain the system name
    // these are assigned by gworld after all volumes are loaded
    std::string g4name;       
    std::string g4motherName; 
 
    // variation and run number for this gvolume
    std::string variation; 
    int         runno{};   
 
    friend std::ostream& operator<<(std::ostream& stream, const GVolume&);
 
public:
    [[nodiscard]] std::string getSystem() const { return system; }
    [[nodiscard]] std::string getName() const { return name; }
    [[nodiscard]] std::string getMotherName() const { return motherName; }
    [[nodiscard]] std::string getG4Name() const { return g4name; }
    [[nodiscard]] std::string getG4MotherName() const { return g4motherName; }
 
    [[nodiscard]] std::vector<double> getDetectorDimensions() const {
        if (parameters == UNINITIALIZEDSTRINGQUANTITY) { return {0}; }
        return gutilities::getG4NumbersFromString(parameters);
    }
 
    [[nodiscard]] std::string getType() const { return type; }
    [[nodiscard]] std::string getParameters() const { return parameters; }
 
    [[nodiscard]] std::string getMaterial() const { return material; }
    [[nodiscard]] std::string getEMField() const { return emfield; }
 
    [[nodiscard]] int              getPCopyNo() const { return pCopyNo; }
    [[nodiscard]] std::string_view getColor() const { return color; }
    [[nodiscard]] double           getOpacity() const { return opacity; }
    [[nodiscard]] bool             isVisible() const { return visible; }
    [[nodiscard]] int              getStyle() const { return style; }
 
    [[nodiscard]] bool        getExistence() const { return exist; }
    [[nodiscard]] std::string getPos() const { return pos; }
    [[nodiscard]] std::string getRot() const { return rot; }
    [[nodiscard]] std::string getG4PlacementType() const { return g4placementType; }
    [[nodiscard]] std::string getShift() const { return shift; }
    [[nodiscard]] std::string getTilt() const { return tilt; }
 
    [[nodiscard]] std::string getDigitization() const { return digitization; }
    [[nodiscard]] std::string getGIdentity() const { return gidentity; }
 
    [[nodiscard]] std::string getCopyOf() const { return copyOf; }
    [[nodiscard]] std::string getSolidsOpr() const { return solidsOpr; }
    [[nodiscard]] std::string getDescription() const { return description; }
 
 
    void applyShift(std::string s) { shift = std::move(s); }
 
    void applyTilt(std::string t) { tilt = std::move(t); }
 
    void modifyExistence(bool e) { exist = e; }
 
    void resetMotherName(std::string m) { motherName = std::move(m); }
 
    void setColor(std::string c) { color = std::move(c); }
 
    void setMaterial(std::string m) { material = std::move(m); }
 
    void setDigitization(std::string d) { digitization = std::move(d); }
 
    void setGIdentity(std::string g) { gidentity = std::move(g); }
 
    std::string getImportedFile() { return importFilename; }
 
    inline void assignG4Names(const std::string& g4n, const std::string& g4m) {
        g4name       = g4n;
        g4motherName = g4m;
    }
};