EIC code displayed by LXR master/​include/​G4HepEm/​G4HepEmTrackingManager.hh	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-07-13 08:21:05

 #ifndef G4HepEmTrackingManager_h
 #define G4HepEmTrackingManager_h 1
 
 #include "G4EventManager.hh"
 #include "G4VTrackingManager.hh"
 #include "globals.hh"
 
 class G4HepEmRunManager;
 class G4HepEmRandomEngine;
 class G4HepEmNoProcess;
 class G4HepEmTLData;
 class G4SafetyHelper;
 class G4Step;
 class G4VProcess;
 class G4VParticleChange;
 class G4Region;
 class G4HepEmWoodcockHelper;
 class G4HepEmConfig;
 
 #include <vector>
 
 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 
 class G4HepEmTrackingManager : public G4VTrackingManager {
 public:
   G4HepEmTrackingManager(G4int verbose=1);
   virtual ~G4HepEmTrackingManager();
 
   void BuildPhysicsTable(const G4ParticleDefinition &) override;
 
   void PreparePhysicsTable(const G4ParticleDefinition &) override;
 
   void HandOverOneTrack(G4Track *aTrack) override;
 
   // Allows to set configuration/parameters (even some per region)
   G4HepEmConfig* GetConfig() { return fConfig; }
 
   // Control verbosity (0/1) (propagated to the G4HepEmRuManager)
   void SetVerbose(G4int verbose);
 
   // Rebinds the random engine to the currently used engine by the thread
   // Needed if the random engine was swapped after construction of the HepEm TM
   void RebindG4RandomEngine();
 
   // Returns whether the region for the given region index is using woodcock tracking
   G4bool IsWDTRegion(G4int regionId) const;
 
   // returns the Woodcock tracking kinetic energy limit
   G4double GetWDTKineticEnergyLimit() const;
 
   // For a given region index with Woodcock tracking and root logical volume index, 
   // this function returns the G4HepEm material cut couple index of that volume if it is indeed 
   // a root logical volume of a Woodcock tracking region, -1 otherwise 
   G4int GetWDTCoupleHepEmIndex(G4int regionId, G4int logicalVolumeId) const;
 
   // Returns the vector of e-/e+ G4HepEmNoProcess pointers used only to set a
   // creator and step limiter G4VProcess of the G4Step with an appropriate
   // name and EM process type.
   std::vector<G4HepEmNoProcess *>& GetElectronNoProcessVector() {
     return fElectronNoProcessVector;
   }
   // Same as above for gamma.
   std::vector<G4HepEmNoProcess *>& GetGammaNoProcessVector() {
     return fGammaNoProcessVector;
   }
   // Same as above for transportation.
   G4HepEmNoProcess* GetTransportNoProcess() { return fTransportNoProcess; }
 
   // Returns the pointer to the Geant4 gamma-nuclear process (if any)
   G4VProcess* GetGammaNuclearProcess() { return fGNucProcess; }
   // Returns the pointer to the Geant4 electron-nuclear process (if any)
   G4VProcess* GetElectronNuclearProcess() { return fENucProcess; }
   // Returns the pointer to the Geant4 positron-nuclear process (if any)
   G4VProcess* GetPositronNuclearProcess() { return fPNucProcess; }
 
   // Invokes the G4 electron/positron/gamma-nuclear process (if any and depending
   // on the `particleID`={0/1/2} --> electron/positron/gamma-nuclear) updates the
   // input step and track to the post interaction state, stacks the secondaries to
   // the track vector of the step and returns the energy deposited in the interaction.
   // NOTE: the step is assumed to be the one from the track (need non const. values)
   double PerformNuclear(G4Track* aG4Track, G4Step* theG4Step, int particleID, bool isApplyCuts);
 
 
   // ATLAS XTR RELATED:
   // Set the names of the ATLAS specific transition radiation process and
   // radiator region (only for ATLAS and only if different than init.ed below)
   void SetXTRProcessName(const std::string& name) { fXTRProcessName = name; }
   void SetXTRRegionName(const std::string& name)  { fXTRRegionName  = name; }
 
 protected:
   bool TrackElectron(G4Track *aTrack);
   bool TrackGamma(G4Track *aTrack);
 
   // Pointers to the fast simulation manager processes of the 3 particles if any
   // [0] e-; [1] e+; [2] gamma; nullptr: no fast sim manager process attached
   G4VProcess* fFastSimProcess[3];
 
 private:
   // Stacks secondaries created by HepEm physics (if any) and returns with the
   // energy deposit while stacking due to applying secondary production cuts
   double StackSecondaries(G4HepEmTLData* aTLData, G4Track* aG4PrimaryTrack,
                           const G4VProcess* aG4CreatorProcess, int aG4IMC,
                           bool isApplyCuts);
 
   // Stacks secondaries created by Geant4 physics (if any) and returns with the
   // energy deposit while stacking due to applying secondary production cuts
   double StackG4Secondaries(G4VParticleChange* particleChange,
                             G4Track* aG4PrimaryTrack, G4Step* theStep,
                             const G4VProcess* aG4CreatorProcess, int aG4IMC,
                             bool isApplyCuts);
 
   void InitNuclearProcesses(int particleID);
 
   // Checks if the particles has fast simulation maanger process attached and
   // stores in the local `fFastSimProcess` array (indexed by HepEm particle ID)
   void InitFastSimRelated(int particleID);
 
   // ATLAS XTR RELATED:
   // Called at init to find the ATLAS specific,Athena local transition radiation
   // process, detector region pointers and store them in field variables allowing
   // to invoke that process during the e-/e+ tracking
   // NOTE: the fields stays nullptr if no such process/region are found causing
   //       no harm outside Athena.
   void InitXTRRelated();
 
   // Reports the extra physics configuration, i.e. nuclear and fast sim. processes
   void ReportExtraProcesses(int particleID);
 
 #ifdef G4HepEm_EARLY_TRACKING_EXIT
   // Virtual function to check early tracking exit. This function allows user
   // implementations to intercept the G4HepEm tracking loop based on
   // user-defined conditions, e.g., when entering a GPU region To be implemented
   // in derived classes by users, base implementation does nothing and returns
   // false
   virtual bool CheckEarlyTrackingExit(G4Track *track, G4EventManager *evtMgr,
                                       G4UserTrackingAction *userTrackingAction,
                                       G4TrackVector &secondaries) const {
     return false;
   }
 #endif
 
   G4HepEmRunManager *fRunManager;
   G4HepEmRandomEngine *fRandomEngine;
   G4SafetyHelper *fSafetyHelper;
   G4Step *fStep;
 
   const std::vector<G4double> *theCutsGamma = nullptr;
   const std::vector<G4double> *theCutsElectron = nullptr;
   const std::vector<G4double> *theCutsPositron = nullptr;
 
   // A set of empty processes with the correct names and types just to be able
   // to set them as process limiting the step and creating secondaries as some
   // user codes rely on this information.
   std::vector<G4HepEmNoProcess *> fElectronNoProcessVector;
   std::vector<G4HepEmNoProcess *> fGammaNoProcessVector;
   G4HepEmNoProcess* fTransportNoProcess;
 
   // Pointers to the Gamma-nuclear process (if any)
   G4VProcess* fGNucProcess;
 
   // Pointers to the Electron/Positron-nuclear processes (if any)
   G4VProcess* fENucProcess;
   G4VProcess* fPNucProcess;
 
   // ATLAS XTR RELATED:
   // Fields to store ptrs to the ATLAS XTR (transition radiation) process and
   // detector region that contain the tradiator volumes
   G4VProcess* fXTRProcess;
   G4Region*   fXTRRegion;
   // The names that will be used to find the XTR process and detector region.
   std::string fXTRProcessName = {"XTR"};
   std::string fXTRRegionName  = {"TRT_RADIATOR"};
 
   // A vector of Woodcock tracking region names (set by user if any) and a helper.
   G4HepEmWoodcockHelper*   fWDTHelper;
 
   // Configuration parameters (allows different parameters/configuration per region.
   G4HepEmConfig* fConfig;
 
   // Vebosity level (only 0/1 at the moment)
   G4int  fVerbose;
 };
 
 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team