gdetectorConstruction.h

Go to the documentation of this file.

#pragma once
 
// geant4
#include "G4VUserDetectorConstruction.hh"
 
// gemc
#include <gemc/goptions/goptions.h>
#include <gemc/g4system/g4world.h>
#include <gemc/gfields/gmagneto.h>
#include <gemc/gsd/gsd.h>
#include <gemc/gbase/gbase.h>
 
// c++
#include <map>
#include <string>
#include <vector>
 
class GDetectorConstruction : public GBase<GDetectorConstruction>, public G4VUserDetectorConstruction {
public:
    explicit GDetectorConstruction(std::shared_ptr<GOptions> gopts);
 
public:
    G4VPhysicalVolume* Construct() override;
 
    void ConstructSDandField() override;
 
    [[nodiscard]] bool is_empty() const { return g4world->is_empty(); }
 
    void reload_geometry(SystemList sl);
 
    void prepare_geometry_for_run();
 
    std::shared_ptr<GDynamicDigitization> get_digitization_routines_for_sdname(const std::string &sd_name) const {
        return digitization_routines_map->at(sd_name);
    }
 
    std::shared_ptr<gdynamicdigitization::dRoutinesMap> get_digitization_routines_map() const {
        return digitization_routines_map;
    }
 
    [[nodiscard]] bool has_built_geometry() const {
        return g4world != nullptr;
    }
 
    [[nodiscard]] std::unordered_map<std::string, G4Volume*> get_g4volumes_map() const {
        if (g4world == nullptr) {
            log->error(ERR_G4VOLUMEBUILDFAILED, "No g4world ");
        }
        return g4world->get_g4volumes_map();
    }
 
    [[nodiscard]] std::unordered_map<std::string, const GVolume*> get_gvolumes_flat_map() const {
        std::unordered_map<std::string, const GVolume*> result;
        if (!gworld) return result;
        for (const auto& [sysName, sysPtr] : *gworld->getSystemsMap()) {
            for (const auto& [volName, volPtr] : sysPtr->getGVolumesMap()) {
                const std::string g4name = volPtr->getG4Name();
                if (!g4name.empty())
                    result[g4name] = volPtr.get();
            }
        }
        return result;
    }
 
private:
    std::shared_ptr<GOptions> gopt;    // need options inside Constructs() methods
 
    std::shared_ptr<GWorld>   gworld;
 
    std::shared_ptr<G4World>  g4world;
 
    std::shared_ptr<gdynamicdigitization::dRoutinesMap> digitization_routines_map;
 
    static G4ThreadLocal GMagneto* gmagneto;
 
    static G4ThreadLocal std::map<std::string, GSensitiveDetector*>* tlSDMap;
 
    void loadDigitizationPlugins();
 
    bool digiplugins_need_reload = true;
 
    [[nodiscard]] SystemList cloneSystemDescriptors(const SystemList& systems) const;
 
    SystemList gsystems;
};