TRestGeant4Metadata.h

/*************************************************************************
 * This file is part of the REST software framework.                     *
 *                                                                       *
 * Copyright (C) 2016 GIFNA/TREX (University of Zaragoza)                *
 * For more information see http://gifna.unizar.es/trex                  *
 *                                                                       *
 * REST is free software: you can redistribute it and/or modify          *
 * it under the terms of the GNU General Public License as published by  *
 * the Free Software Foundation, either version 3 of the License, or     *
 * (at your option) any later version.                                   *
 *                                                                       *
 * REST 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 General Public License for more details.                          *
 *                                                                       *
 * You should have a copy of the GNU General Public License along with   *
 * REST in $REST_PATH/LICENSE.                                           *
 * If not, see http://www.gnu.org/licenses/.                             *
 * For the list of contributors see $REST_PATH/CREDITS.                  *
 *************************************************************************/
 
#ifndef RestCore_TRestGeant4Metadata
#define RestCore_TRestGeant4Metadata
 
#include <TMath.h>
#include <TRestMetadata.h>
#include <TString.h>
#include <TVector2.h>
#include <TVector3.h>
#include <stdio.h>
#include <stdlib.h>
 
#include <cstdio>
#include <cstring>
#include <fstream>
#include <iostream>
#include <vector>
 
#include "TRestGeant4BiasingVolume.h"
#include "TRestGeant4GeometryInfo.h"
#include "TRestGeant4ParticleSource.h"
#include "TRestGeant4PhysicsInfo.h"
#include "TRestGeant4PrimaryGeneratorInfo.h"
 
class TRestGeant4Metadata : public TRestMetadata {
   private:
    void Initialize() override;
 
    void InitFromConfigFile() override;
 
    void ReadGenerator();
    void ReadParticleSource(TRestGeant4ParticleSource* src, TiXmlElement* sourceDefinition);
 
    void ReadDetector();
    void ReadBiasing();
 
    // Metadata is the result of a merge of other metadata
    bool fIsMerge = false;
 
    TRestGeant4GeometryInfo fGeant4GeometryInfo;
 
    TRestGeant4PhysicsInfo fGeant4PhysicsInfo;
 
    TRestGeant4PrimaryGeneratorInfo fGeant4PrimaryGeneratorInfo;
 
    TString fGeant4Version;
 
    TString fGeometryPath;  
 
    TString fGdmlFilename;  
 
    TString fGdmlReference;
 
    TString fMaterialsReference;
 
    TVector2 fEnergyRangeStored = {0, 1E20};
 
    std::vector<TString> fActiveVolumes;
 
    std::vector<Double_t> fChance;
 
    std::vector<Double_t> fMaxStepSize;
 
    std::vector<TRestGeant4ParticleSource*> fParticleSource;  //->
 
    Int_t fNBiasingVolumes = 0;
 
    std::vector<TRestGeant4BiasingVolume> fBiasingVolumes;
 
    Double_t fMaxTargetStepSize = 0;  
 
    Double_t fSubEventTimeDelay = 100;
 
    Bool_t fFullChain = true;
 
    Bool_t fResetGlobalTime = true;
 
    Double_t fResetTimePrecision = 1;
 
    std::set<std::string> fFullChainStopIsotopes;
 
    std::vector<TString> fSensitiveVolumes;
 
    Long64_t fNEvents = 0;
 
    Long64_t fNRequestedEntries = 0;
 
    Double_t fSimulationMaxTimeSeconds = 0;
 
    Double_t fSimulationTime = 0;
 
    Long_t fSeed = 0;
 
    Bool_t fSaveAllEvents = false;
 
    Bool_t fStoreHadronicTargetInfo = false;
 
    Bool_t fActivateAllVolumes = false;  
 
    Bool_t fRemoveUnwantedTracks = false;
 
    Bool_t fStoreTracks = false;
 
    Bool_t fRemoveUnwantedTracksKeepZeroEnergyTracks = false;
 
    std::set<std::string> fRemoveUnwantedTracksVolumesToKeep;
 
    std::set<std::string> fKillVolumes;
 
    Bool_t fPrintProgress = false;  
 
    Bool_t fRegisterEmptyTracks = true;
 
    TVector3 fMagneticField = TVector3(0, 0, 0);
 
   public:
    std::set<std::string> fActiveVolumesSet = {};  
 
    inline Long_t GetSeed() const { return fSeed; }
 
    inline const TRestGeant4GeometryInfo& GetGeant4GeometryInfo() const { return fGeant4GeometryInfo; }
 
    inline const TRestGeant4PhysicsInfo& GetGeant4PhysicsInfo() const { return fGeant4PhysicsInfo; }
 
    inline const TRestGeant4PrimaryGeneratorInfo& GetGeant4PrimaryGeneratorInfo() const {
        return fGeant4PrimaryGeneratorInfo;
    }
 
    inline TString GetGeant4Version() const { return fGeant4Version; }
 
    size_t GetGeant4VersionMajor() const;
 
    bool GetStoreHadronicTargetInfo() const { return fStoreHadronicTargetInfo; }
 
    inline TString GetGeometryPath() const { return fGeometryPath; }
 
    inline TString GetGdmlFilename() const { return fGdmlFilename; }
 
    inline TString GetGdmlReference() const { return fGdmlReference; }
 
    inline TString GetMaterialsReference() const { return fMaterialsReference; }
 
    inline Bool_t isFullChainActivated() const { return fFullChain; }
 
    inline Bool_t isGlobalTimeReset() const { return fResetGlobalTime; }
 
    inline Double_t GetResetTimePrecision() const { return fResetTimePrecision; }
 
    inline std::set<std::string> GetFullChainStopIsotopes() const { return fFullChainStopIsotopes; }
 
    inline Bool_t IsIsotopeFullChainStop(const std::string& isotope) const {
        return fFullChainStopIsotopes.count(isotope) > 0;
    }
 
    inline Double_t GetMaxTargetStepSize() const { return fMaxTargetStepSize; }
 
    inline Double_t GetSubEventTimeDelay() const { return fSubEventTimeDelay; }
 
    inline Bool_t GetSaveAllEvents() const { return fSaveAllEvents; }
 
    inline Bool_t PrintProgress() const { return fPrintProgress; }
 
    inline Bool_t RegisterEmptyTracks() const { return fRegisterEmptyTracks; }
 
    inline void SetSeed(Long_t seed) { fSeed = seed; }
 
    inline void SetSaveAllEvents(const Bool_t value) { fSaveAllEvents = value; }
 
    inline void SetGeant4Version(const TString& versionString) { fGeant4Version = versionString; }
 
    inline void SetFullChain(Bool_t fullChain) { fFullChain = fullChain; }
 
    inline void SetGeometryPath(const std::string& path) { fGeometryPath = path; }
 
    inline void SetGdmlFilename(const std::string& gdmlFile) { fGdmlFilename = gdmlFile; }
 
    inline void SetGdmlReference(const std::string& reference) { fGdmlReference = reference; }
 
    inline void SetMaterialsReference(const std::string& reference) { fMaterialsReference = reference; }
 
    inline Long64_t GetNumberOfEvents() const { return fNEvents; }
 
    inline Long64_t GetNumberOfRequestedEntries() const { return fNRequestedEntries; }
 
    inline Double_t GetSimulationMaxTimeSeconds() const { return fSimulationMaxTimeSeconds; }
 
    // Direct access to sources definition in primary generator
    inline Int_t GetNumberOfSources() const { return fParticleSource.size(); }
 
    inline TRestGeant4ParticleSource* GetParticleSource(size_t n = 0) const { return fParticleSource[n]; }
 
    void RemoveParticleSources();
 
    void AddParticleSource(TRestGeant4ParticleSource* src);
 
    // Direct access to biasing volumes definition
 
    inline size_t GetNumberOfBiasingVolumes() const { return fBiasingVolumes.size(); }
 
    inline TRestGeant4BiasingVolume GetBiasingVolume(int n) { return fBiasingVolumes[n]; }
 
    inline Int_t isBiasingActive() const { return fBiasingVolumes.size(); }
 
    inline TString GetSensitiveVolume(int n = 0) const { return fSensitiveVolumes[n]; }
 
    inline size_t GetNumberOfSensitiveVolumes() const { return fSensitiveVolumes.size(); }
 
    inline const std::vector<TString>& GetSensitiveVolumes() const { return fSensitiveVolumes; }
 
    inline void SetNumberOfEvents(Long64_t n) { fNEvents = n; }
 
    inline void SetNumberOfRequestedEntries(Long64_t n) { fNRequestedEntries = n; }
 
    inline void SetSimulationMaxTimeSeconds(Double_t seconds) { fSimulationMaxTimeSeconds = seconds; }
 
    inline void InsertSensitiveVolume(const TString& volume) {
        for (const auto& sensitiveVolume : fSensitiveVolumes) {
            // Do not add duplicate volumes
            if (volume == sensitiveVolume) {
                return;
            }
        }
        fSensitiveVolumes.push_back(volume);
    }
 
    inline Double_t GetStorageChance(Int_t n) const { return fChance[n]; }
 
    Double_t GetStorageChance(const TString& volume);
 
    Double_t GetMaxStepSize(const TString& volume);
 
    inline Double_t GetMinimumEnergyStored() const { return fEnergyRangeStored.X(); }
 
    inline Double_t GetMaximumEnergyStored() const { return fEnergyRangeStored.Y(); }
 
    inline unsigned int GetNumberOfActiveVolumes() const { return fActiveVolumes.size(); }
 
    inline bool IsActiveVolume(const char* volumeName) const {
        return fActiveVolumesSet.count(volumeName) > 0;
    }  
 
    inline bool IsKeepTracksVolume(const char* volumeName) const {
        return fRemoveUnwantedTracksVolumesToKeep.count(volumeName) > 0;
    }
 
    inline bool IsKillVolume(const char* volumeName) const { return fKillVolumes.count(volumeName) > 0; }
 
    inline std::vector<std::string> GetKillVolumes() const {
        std::vector<std::string> result;
        for (const auto& volume : fKillVolumes) {
            result.emplace_back(volume);
        }
        return result;
    }
 
    inline std::vector<std::string> GetRemoveUnwantedTracksVolumesToKeep() const {
        std::vector<std::string> result;
        for (const auto& volume : fRemoveUnwantedTracksVolumesToKeep) {
            result.emplace_back(volume);
        }
        return result;
    }
 
    double GetGeneratorSurfaceCm2() const;
 
    Double_t GetCosmicFluxInCountsPerCm2PerSecond() const;
    Double_t GetCosmicIntensityInCountsPerSecond() const;
 
    Double_t GetEquivalentSimulatedTime() const;
 
    inline Double_t GetSimulationWallTime() const { return fSimulationTime; }
 
    inline TString GetActiveVolumeName(Int_t n) const { return fActiveVolumes[n]; }
 
    inline std::vector<TString> GetActiveVolumes() const { return fActiveVolumes; }
 
    inline bool GetRemoveUnwantedTracks() const { return fRemoveUnwantedTracks; }
 
    bool GetStoreTracks() const { return fStoreTracks; }
 
    inline bool GetRemoveUnwantedTracksKeepZeroEnergyTracks() const {
        return fRemoveUnwantedTracksKeepZeroEnergyTracks;
    }
 
    inline TVector3 GetMagneticField() const { return fMagneticField; }
 
    Int_t GetActiveVolumeID(const TString& name);
 
    Bool_t isVolumeStored(const TString& volume) const;
 
    void SetActiveVolume(const TString& name, Double_t chance, Double_t maxStep = 0);
 
    void SetSimulationWallTime(Double_t time) { fSimulationTime = time; }
 
    void PrintMetadata() override;
 
    void Merge(const TRestGeant4Metadata&);
 
    TRestGeant4Metadata();
    TRestGeant4Metadata(const char* configFilename, const std::string& name = "");
 
    ~TRestGeant4Metadata();
 
    TRestGeant4Metadata(const TRestGeant4Metadata& metadata);
    TRestGeant4Metadata& operator=(const TRestGeant4Metadata& metadata);
 
    ClassDefOverride(TRestGeant4Metadata, 20);
 
    // Allow modification of otherwise inaccessible / immutable members that shouldn't be modified by the user
    friend class SteppingAction;
    friend class DetectorConstruction;
    friend class TRestGeant4Hits;
};
#endif  // RestCore_TRestGeant4Metadata