gdetectorConstruction.h

Go to the documentation of this file.

#pragma once
 
// geant4
#include "G4VUserDetectorConstruction.hh"
#include "G4UserLimits.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(g4system::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;
    }

    [[nodiscard]] std::unordered_map<std::string, const GMirror*> get_gmirrors_flat_map() const {
        std::unordered_map<std::string, const GMirror*> result;
        if (!gworld) return result;
        for (const auto& [sysName, sysPtr] : *gworld->getSystemsMap()) {
            for (const auto& [mirrorName, mirrorPtr] : sysPtr->getGMirrorsMap()) {
                result[sysName + "/" + mirrorName] = mirrorPtr.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();

    void assignUserLimits();

    std::vector<std::unique_ptr<G4UserLimits>> user_limits;

    bool digiplugins_need_reload = true;

    [[nodiscard]] SystemList cloneSystemDescriptors(const SystemList& systems) const;

    SystemList gsystems;
};