G4HadIntProcessor.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ISF_FATRASTOOLSG4_G4HADINTPROCESSOR_H
#define ISF_FATRASTOOLSG4_G4HADINTPROCESSOR_H
 
// GaudiKernel & Athena
#include "AthenaBaseComps/AthAlgTool.h"
#include "AthenaKernel/IAtRndmGenSvc.h"
#include "CxxUtils/checker_macros.h"
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/ServiceHandle.h"
 
// Fatras
#include "ISF_FatrasInterfaces/IHadronicInteractionProcessor.h"
 
// Geant4
#include "G4ThreeVector.hh"
 
// Trk
#include "TrkEventPrimitives/ParticleHypothesis.h"
 
// ISF
#include "ISF_Event/ISFParticleContainer.h"
 
// Forward Declarations
class G4DynamicParticle;
class G4VProcess;
class G4RunManager;
class G4VUserPhysicsList;
class G4LayerDetectorConstruction;
class G4LayerPrimaryGeneratorAction;
class G4LayerTrackingAction;
class G4Step;
class G4StepPoint;
class G4AtlasRunManager;
class G4Material;
class G4MaterialCutsCouple;
 
namespace Trk {
  class Material;
  class MaterialProperties;       // TODO: get rid of MatProp dependence
}
 
namespace ISF {
  class IParticleBroker;
  class ITruthSvc;
  class IG4RunManagerHelper;
}
 
namespace iFatras {

 
  class ATLAS_NOT_THREAD_SAFE G4HadIntProcessor : public extends<AthAlgTool, iFatras::IHadronicInteractionProcessor> {  // deprecated: ATLASSIM-6020
    public:      
      G4HadIntProcessor(const std::string&,const std::string&,const IInterface*);
      virtual ~G4HadIntProcessor();

      StatusCode initialize();
      StatusCode finalize();

      bool hadronicInteraction(const Amg::Vector3D& position, const Amg::Vector3D& momentum, 
                   double p, double E, double charge, 
                               const Trk::MaterialProperties& mprop, double pathCorrection,
                               Trk::ParticleHypothesis particle=Trk::pion) const;
 
      bool doHadronicInteraction(double time, const Amg::Vector3D& position, const Amg::Vector3D& momentum,
                                 const Trk::Material *ematprop,
                 Trk::ParticleHypothesis particle=Trk::pion,
                                 bool  processSecondaries=true) const;

      ISF::ISFParticleVector doHadIntOnLayer(const ISF::ISFParticle* parent, double time, 
                         const Amg::Vector3D& position, const Amg::Vector3D& momentum,
                         const Trk::Material *ematprop,
                         Trk::ParticleHypothesis particle=Trk::pion) const ;
 
    private:
      StatusCode initG4RunManager ATLAS_NOT_THREAD_SAFE ();
                           
      ISF::ISFParticleVector getHadState(const ISF::ISFParticle* parent,
                     double time, const Amg::Vector3D& position, const Amg::Vector3D& momentum, 
                     const Trk::Material *ematprop) const;

      std::map<int,G4VProcess*>::const_iterator  initProcessPDG(int pdg);

      unsigned int retrieveG4MaterialIndex(const Trk::Material* ematprop) const;

      ServiceHandle<IAtRndmGenSvc>         m_rndGenSvc;
 
      ToolHandle<ISF::IG4RunManagerHelper> m_g4RunManagerHelper;

      bool                                 m_doElastic;
 
      /* scale factors for hadronic/electromagnetic interactions */
      double                               m_hadIntProbScale;
 
      // internal steering : clone type
      double                               m_minMomentum;

      std::map<int, G4VProcess*>   m_g4HadrInelasticProcesses;
      std::map<int, G4VProcess*>   m_g4HadrElasticProcesses;
 
      std::vector<std::pair<float,std::pair< G4Material*, G4MaterialCutsCouple> > > m_g4Material;

      ServiceHandle<ISF::IParticleBroker>  m_particleBroker;
      ServiceHandle<ISF::ITruthSvc>        m_truthRecordSvc;

      CLHEP::HepRandomEngine*              m_randomEngine;
      std::string                          m_randomEngineName;       
 
  };
 
}
 
#endif