g4objectsFactory.h

Go to the documentation of this file.

#pragma once
 
// c++
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
 
// gemc
#include <gemc/gbase/gbase.h>
#include <gemc/gsystem/gvolume.h>
 
// g4system
#include <gemc/g4system/g4volume.h>
#include <gemc/g4system/g4system_options.h>
 
// geant4
#include "G4LogicalVolume.hh"
#include "G4PVPlacement.hh"
#include "G4RotationMatrix.hh"
#include "G4ThreeVector.hh"
#include "G4VisAttributes.hh"

class G4ObjectsFactory : public GBase<G4ObjectsFactory>
{
public:
    ~G4ObjectsFactory() override = default;

    explicit G4ObjectsFactory(const std::shared_ptr<GOptions>& g) : GBase(g, G4SFACTORY_LOGGER) {
    }

    void initialize_context(int                checkOverlaps,
                            const std::optional<std::string>& backupMaterial);

    [[nodiscard]] bool build_g4volume(const GVolume* s,
                                      std::unordered_map<std::string,
                                                         G4Volume*>* g4s);

    [[nodiscard]] virtual std::string_view className() const = 0;
 
protected:
    // ──────── pure & virtual hooks for subclasses ──────────────────

    virtual G4VSolid* buildSolid(const GVolume*                              s,
                                 std::unordered_map<std::string, G4Volume*>* g4s) = 0;

    virtual G4LogicalVolume* buildLogical(const GVolume*                              s,
                                          std::unordered_map<std::string, G4Volume*>* g4s);

    virtual G4VPhysicalVolume* buildPhysical(const GVolume*                              s,
                                             std::unordered_map<std::string, G4Volume*>* g4s);

    static G4VSolid* getSolidFromMap(const std::string& volume_name, std::unordered_map<std::string, G4Volume*>* g4s);

    static G4LogicalVolume* getLogicalFromMap(const std::string&                          volume_name,
                                              std::unordered_map<std::string, G4Volume*>* g4s);

    static G4VPhysicalVolume* getPhysicalFromMap(const std::string&                          volume_name,
                                                 std::unordered_map<std::string, G4Volume*>* g4s);

    G4Volume* getOrCreateG4Volume(const std::string& volume_name, std::unordered_map<std::string, G4Volume*>* g4s) {
        if (auto it = g4s->find(volume_name); it != g4s->end()) { return it->second; }
        else {
            (*g4s)[volume_name] = new G4Volume();
            return (*g4s)[volume_name];
        }
    }

    G4VisAttributes createVisualAttributes(const GVolume* s);

    bool checkSolidDependencies(const GVolume*                              s,
                                std::unordered_map<std::string, G4Volume*>* g4s);

    static bool checkLogicalDependencies(const GVolume*                              s,
                                         std::unordered_map<std::string, G4Volume*>* g4s);

    bool checkPhysicalDependencies(const GVolume*                              s,
                                   std::unordered_map<std::string, G4Volume*>* g4s);
 
    // ──────── geometric helpers ────────────────────────────────────

    static G4RotationMatrix* getRotation(const GVolume* s);

    static G4ThreeVector getPosition(const GVolume* s);

    int checkOverlaps{0};

    std::optional<std::string> backupMaterial;
};