RMGHardware.hh

// Copyright (C) 2022 Luigi Pertoldi <https://orcid.org/0000-0002-0467-2571>
//
// This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option) any
// later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
// details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
#ifndef _RMG_HARDWARE_HH_
#define _RMG_HARDWARE_HH_
 
#include <map>
#include <memory>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "G4GenericMessenger.hh"
#include "G4Region.hh"
#include "G4VUserDetectorConstruction.hh"
 
#include "RMGDetectorMetadata.hh"
#include "RMGHardwareMessenger.hh"
#include "RMGLog.hh"
#include "RMGNavigationTools.hh"
#include "RMGVOutputScheme.hh"

class G4LogicalVolume;
class G4VPhysicalVolume;
class RMGHardware : public G4VUserDetectorConstruction {
 
  public:

    RMGHardware();
    ~RMGHardware() = default;
 
    RMGHardware(RMGHardware const&) = delete;
    RMGHardware& operator=(RMGHardware const&) = delete;
    RMGHardware(RMGHardware&&) = delete;
    RMGHardware& operator=(RMGHardware&&) = delete;

    G4VPhysicalVolume* Construct() override;

    void ConstructSDandField() override;

    void RegisterDetector(
        RMGDetectorType type,
        const std::string& pv_name,
        int uid,
        int copy_nr = 0,
        bool allow_uid_reuse = false,
        const std::string& ntuple_name = ""
    );

    void StageDetector(
        RMGDetectorType type,
        const std::string& pv_name,
        int uid,
        const std::string& copy_nr = "0",
        bool allow_uid_reuse = false,
        const std::string& ntuple_name = ""
    );

    const auto& GetDetectorMetadataMap() { return fDetectorMetadata; }

    const auto& GetDetectorMetadata(const std::pair<std::string, int>& det) {
      return fDetectorMetadata.at(det);
    }
 
 
    const auto& GetActiveDetectorList() { return fActiveDetectors; }
    [[nodiscard]] const auto& GetAllActiveOutputSchemes() { return fActiveOutputSchemes; }

    void IncludeGDMLFile(std::string filename) { fGDMLFiles.emplace_back(filename); }

    [[nodiscard]] const G4VPhysicalVolume* GetDefinedWorldVolume() const { return fWorld; }

    G4VPhysicalVolume* GetDefinedWorldVolume() { return fWorld; }

    void SetMaxStepLimit(double max_step, std::string name);

    void SetEminLimitForParticle(double ekin_min, std::string name, std::string particle_name);

    static bool IsEminLimitParticleSelected(
        const G4LogicalVolume* logical,
        const std::string& particle_name
    );
 
    void PrintListOfLogicalVolumes() { RMGNavigationTools::PrintListOfLogicalVolumes(); }
    void PrintListOfPhysicalVolumes() { RMGNavigationTools::PrintListOfPhysicalVolumes(); }
 
  protected:

    virtual G4VPhysicalVolume* DefineGeometry() { return nullptr; }
 
  private:

    std::vector<std::string> fGDMLFiles;
    bool fGDMLDisableOverlapCheck = false;
    int fGDMLOverlapCheckNumPoints = 3000;
    bool fGDMLDisableXmlCheck = false;
    std::map<std::string, double> fPhysVolStepLimits;
 
    struct RMGSelectiveEminLimit {
        double ekin_min;
        std::set<std::string> particles;
    };
    std::map<std::string, RMGSelectiveEminLimit> fPhysVolEminLimits;
    static std::unordered_map<const G4LogicalVolume*, std::set<std::string>> fLogicalVolEminParticles;
 
    // one element for each sensitive detector physical volume
    std::map<std::pair<std::string, int>, RMGDetectorMetadata> fDetectorMetadata;
 
    std::set<RMGDetectorType> fActiveDetectors;
    static G4ThreadLocal std::vector<std::shared_ptr<RMGVOutputScheme>> fActiveOutputSchemes;
    static G4ThreadLocal bool fActiveDetectorsInitialized;
 
    std::set<RMGDetectorType> fRegisterDetectorsFromGDML;
    void RegisterDetectorsFromGDML(std::string s);
 
    std::unique_ptr<G4GenericMessenger> fMessenger;
    std::unique_ptr<RMGHardwareMessenger> fHwMessenger;
    void DefineCommands();

    G4VPhysicalVolume* fWorld = nullptr;

    G4Region* fSensitiveRegion = new G4Region("SensitiveRegion");
 
    struct RMGStagedDetector {
        RMGDetectorType type;
        std::string name;
        int uid;
        std::string copy_nr;
        bool allow_uid_reuse;
        std::string ntuple_name;
    };
 
    // Holds detector info before initialization
    std::map<std::pair<std::string, std::string>, RMGStagedDetector> fStagedDetectors;
};
 
#endif
 
// vim: tabstop=2 shiftwidth=2 expandtab