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>
#include <gemc/gsystem/gsystemConventions.h>
 
// c++
#include <optional>
#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,
            std::optional<std::string>      importPath = std::nullopt);

    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::optional<std::string> importFilename; 
 
    // solid parameters
    std::string type;       
    std::optional<std::string> parameters; 
 
    // solid visualization style
    bool        visible{}; 
    int         style{};   
    std::string color;     
    double      opacity{}; 
 
    // logical attributes
    std::string                material; 
    std::optional<std::string> emfield;  
 
    // physical attributes
    std::string pos;     
    std::string rot;     
    std::string g4placementType; 
    std::optional<std::string> shift; 
    std::optional<std::string> tilt;  
    bool        exist{}; 
 
    std::optional<std::string> digitization; 
    std::optional<std::string> gidentity;    
 
    // special cases
    std::optional<std::string> copyOf;    
    std::optional<std::string> solidsOpr; 
 
    int pCopyNo{}; 
 
    // mirrors
    std::optional<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::optional<std::string> g4name;       
    std::optional<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]] const std::string& getG4Name() const;
    [[nodiscard]] const std::string& getG4MotherName() const;

    [[nodiscard]] std::vector<double> getDetectorDimensions() const {
        if (!parameters || type == gsystem::GSYSTEMCADTFACTORYLABEL) return {};
        return gutilities::getG4NumbersFromString(*parameters);
    }

    [[nodiscard]] std::string getType() const { return type; }
    [[nodiscard]] const std::optional<std::string>& getParameters() const { return parameters; }

    [[nodiscard]] std::string getMaterial() const { return material; }
    [[nodiscard]] const std::optional<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]] const std::optional<std::string>& getShift() const { return shift; }
    [[nodiscard]] const std::optional<std::string>& getTilt() const { return tilt; }

    [[nodiscard]] const std::optional<std::string>& getDigitization() const { return digitization; }
    [[nodiscard]] const std::optional<std::string>& getGIdentity() const { return gidentity; }

    [[nodiscard]] const std::optional<std::string>& getCopyOf() const { return copyOf; }
    [[nodiscard]] const std::optional<std::string>& getSolidsOpr() const { return solidsOpr; }
    [[nodiscard]] const std::optional<std::string>& getMirror() const { return mirror; }
    [[nodiscard]] std::string getDescription() const { return description; }


    void applyShift(std::optional<std::string> s) { shift = std::move(s); }

    void applyTilt(std::optional<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::optional<std::string> d);

    void setGIdentity(std::optional<std::string> g);

    [[nodiscard]] const std::optional<std::string>& getImportedFile() const { return importFilename; }

    inline void assignG4Names(const std::string& g4n, const std::string& g4m) {
        g4name       = g4n;
        g4motherName = g4m;
    }
};