BDSSDManager.hh

/* 
Beam Delivery Simulation (BDSIM) Copyright (C) BDSIM Collaboration, 2001 - 2026.
 
This file is part of BDSIM.
 
BDSIM 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 version 3 of the License.
 
BDSIM 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 received a copy of the GNU General Public License
along with BDSIM.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef BDSSDMANAGER_H
#define BDSSDMANAGER_H
 
#include "BDSSDSamplerLink.hh"
#include "BDSSDType.hh"
 
#include "G4String.hh"
#include "G4Types.hh"
#include "G4Version.hh"
 
#include <map>
#include <set>
#include <vector>
 
class BDSSDApertureImpacts;
class BDSSDCollimator;
class BDSSDEnergyDeposition;
class BDSSDEnergyDepositionGlobal;
class BDSLinkRegistry;
class BDSMultiSensitiveDetectorOrdered;
class BDSSDFilterPDGIDSet;
class BDSSDSampler;
class BDSSDSamplerCylinder;
class BDSSDSamplerSphere;
class BDSSDTerminator;
class BDSSDThinThing;
class BDSSDVolumeExit;
 
class G4VSDFilter;
 
#if G4VERSION_NUMBER < 1030
// In this case we use only the energy counter SD and return it
// as a base class pointer. Include header so casting works.
#include "BDSSDEnergyDeposition.hh"
#include "BDSSDEnergyDepositionGlobal.hh"
#endif
 
class BDSSDManager
{
public:
  static BDSSDManager* Instance(); 
  
  BDSSDManager(const BDSSDManager&) = delete;
  BDSSDManager& operator=(const BDSSDManager&) = delete;
  ~BDSSDManager();
 
  G4VSensitiveDetector* SensitiveDetector(const BDSSDType sdType,
                                          G4bool applyOptions = false) const;
 
  inline BDSSDSampler* SamplerPlane() const {return samplerPlane;}
 
  inline BDSSDSamplerCylinder* SamplerCylinder() const {return samplerCylinder;}
  
  inline BDSSDSamplerSphere* SamplerSphere() const {return samplerSphere;}
 
  inline BDSSDSamplerLink* SamplerLink() const {return samplerLink;}
 
  inline BDSSDTerminator* Terminator() const {return terminator;}
  
  inline BDSSDEnergyDeposition* EnergyDeposition() const {return energyDeposition;}
 
  inline BDSSDEnergyDeposition* EnergyDepositionFull() const {return energyDepositionFull;}
 
  inline BDSSDEnergyDeposition* EnergyDepositionVacuum() const {return energyDepositionVacuum;}
 
  inline BDSSDEnergyDeposition* EnergyDepositionTunnel() const {return energyDepositionTunnel;}
 
  inline BDSSDEnergyDepositionGlobal* EnergyDepositionWorld() const {return energyDepositionWorld;}
 
  inline BDSSDEnergyDepositionGlobal* EnergyDepositionWorldContents() const {return energyDepositionWorldContents;}
 
  inline BDSSDVolumeExit* WorldExit() const {return worldExit;}
 
  inline BDSSDApertureImpacts* ApertureImpacts() const {return apertureImpacts;}
 
#if G4VERSION_NUMBER > 1029
  inline G4VSensitiveDetector* WorldComplete()        const {return worldCompleteSD;}
  inline G4VSensitiveDetector* ApertureComplete()     const {return apertureCompleteSD;}
#else
  inline G4VSensitiveDetector* WorldComplete()        const {return energyDepositionWorld;}
  inline G4VSensitiveDetector* ApertureComplete()     const {return energyDeposition;}
#endif
 
  inline BDSSDCollimator* Collimator() const {return collimatorSD;}
 
  inline BDSMultiSensitiveDetectorOrdered* CollimatorComplete() const {return collimatorCompleteSD;}
 
  inline BDSSDThinThing* ThinThing() const {return thinThingSD;}
 
  inline BDSMultiSensitiveDetectorOrdered* WireComplete() const {return wireCompleteSD;}
 
  void RegisterPrimitiveScorerName(const G4String& nameIn, G4double unit = 1.0);
 
  void RegisterPrimitiveScorerNames(const std::vector<G4String>& namesIn,
                                    const std::vector<G4double>* units = nullptr);
  
  inline const std::vector<G4String>& PrimitiveScorerNamesComplete() const {return primitiveScorerNamesComplete;}
 
  inline const std::vector<G4String>& PrimitiveScorerNames() const {return primitiveScorerNames;}
 
  inline const std::map<G4String, G4double>& PrimitiveScorerUnits() const {return primitiveScorerNameToUnit;}
 
  void SetLinkRegistry(BDSLinkRegistry* registry);
  inline void SetLinkMinimumEK(G4double minimumEKIn) {samplerLink->SetMinimumEK(minimumEKIn);}
  inline void SetLinkProtonsAndIonsOnly(G4bool protonsAndIonsOnlyIn) {samplerLink->SetProtonsAndIonsOnly(protonsAndIonsOnlyIn);}
  
  void ConstructSamplerSDsForParticleSets(const std::map<int, std::set<int>>& samplerFilterIDtoPDGSetIn);
 
  inline const std::vector<G4String>& ExtraSamplerWithFilterNamesComplete() const {return extraSamplerWithFilterNamesComplete;}
  
  inline const std::vector<G4String>& ExtraSamplerCylinderWithFilterNamesComplete() const {return extraSamplerCylinderWithFilterNamesComplete;}
  
  inline const std::vector<G4String>& ExtraSamplerSphereWithFilterNamesComplete() const {return extraSamplerSphereWithFilterNamesComplete;}
  
  BDSSDSampler* SamplerPlaneWithFilter(G4int ID) const;
  
  BDSSDSamplerCylinder* SamplerCylinderWithFilter(G4int ID) const;
  
  BDSSDSamplerSphere* SamplerSphereWithFilter(G4int ID) const;
  
private:
  BDSSDManager();
 
  static BDSSDManager* instance;
 
  BDSSDSampler*                samplerPlane;
  BDSSDSamplerCylinder*        samplerCylinder;
  BDSSDSamplerSphere*          samplerSphere;
  BDSSDSamplerLink*            samplerLink;
  BDSSDTerminator*             terminator;
  BDSSDEnergyDeposition*       energyDeposition;
  BDSSDEnergyDeposition*       energyDepositionFull;
  BDSSDEnergyDeposition*       energyDepositionVacuum;
  BDSSDEnergyDeposition*       energyDepositionTunnel;
  BDSSDEnergyDepositionGlobal* energyDepositionWorld;
  BDSSDEnergyDepositionGlobal* energyDepositionWorldContents;
  BDSSDVolumeExit*             worldExit;
  BDSSDApertureImpacts*        apertureImpacts;
#if G4VERSION_NUMBER > 1029
  G4VSensitiveDetector* worldCompleteSD;
  G4VSensitiveDetector* apertureCompleteSD;
#endif
  BDSSDCollimator*                  collimatorSD;
  BDSMultiSensitiveDetectorOrdered* collimatorCompleteSD;
  BDSSDThinThing*                   thinThingSD;
  BDSMultiSensitiveDetectorOrdered* wireCompleteSD;
 
  std::map<G4String, G4VSDFilter*> filters;
 
  std::vector<G4String> primitiveScorerNamesComplete;
 
  std::vector<G4String> primitiveScorerNames;
 
  std::map<G4String, G4double> primitiveScorerNameToUnit;
  
  std::map<G4int, BDSSDSampler*> extraSamplersWithFilters;
  std::map<G4int, BDSSDSamplerCylinder*> extraSamplerCylindersWithFilters;
  std::map<G4int, BDSSDSamplerSphere*> extraSamplerSpheresWithFilters;
  std::map<G4int, BDSSDFilterPDGIDSet*> extraSamplerFilters;
  std::vector<G4String> extraSamplerWithFilterNamesComplete;
  std::vector<G4String> extraSamplerCylinderWithFilterNamesComplete;
  std::vector<G4String> extraSamplerSphereWithFilterNamesComplete;
 
  G4bool   storeCollimatorHitsAll;
  G4bool   storeCollimatorHitsIons;
  G4double collimatorHitsMinimumKE;
  G4bool   generateApertureImpacts;
  G4bool   storeApertureImpactsAll;
  G4bool   storeApertureImpactsIons;
  G4double apertureImpactsMinimumKE;
  G4bool   generateELossHits;
  G4bool   generateELossVacuumHits;
  G4bool   generateELossTunnelHits;
  G4bool   generateELossWorldContents;
  G4bool   storeELossWorld;
  G4bool   storeELossExtras;
  G4bool   generateCollimatorHits;
};
 
#endif