McMaterialEffectsUpdator.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ISF_FATRASTOOLS_TRACKONLAYERUPDATOR_H
#define ISF_FATRASTOOLS_TRACKONLAYERUPDATOR_H
 
// GaudiKernel & Athena
#include "AthenaBaseComps/AthAlgTool.h"
#include "AthenaKernel/IAtRndmGenSvc.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
#include "CxxUtils/checker_macros.h"
 
// Trk
#include "TrkDetDescrInterfaces/ITrackingGeometrySvc.h"
#include "TrkDetDescrUtils/GeometrySignature.h"
#include "TrkDetDescrUtils/LayerIndexSampleMap.h"
#include "TrkEventPrimitives/ParticleHypothesis.h"
#include "TrkEventPrimitives/PdgToParticleHypothesis.h"
#include "TrkEventPrimitives/PropDirection.h"
#include "TrkExInterfaces/ITimedMatEffUpdator.h"
#include "TrkExUtils/MaterialUpdateMode.h"
#include "TrkGeometry/TrackingGeometry.h"
#include "TrkParameters/TrackParameters.h"
 
// ISF
#include "ISF_Event/ISFParticleContainer.h"
 
#ifndef MAXHADINTCHILDREN
#define MAXHADINTCHILDREN 20
#endif
 
class StoreGateSvc;
 
class TTree;
 
namespace Trk {
class EnergyLoss;
class CylinderVolumeBounds;
class IEnergyLossUpdator;
class IMultipleScatteringUpdator;
class TrackingGeometry;
}
 
namespace ISF {
class IParticleBroker;
class ISFParticle;
class ITruthSvc;
}
 
namespace iFatras {
 
class McMaterialEffectsUpdatorException : public std::exception
{
  const char* what() const throw()
  {
    return "Problem with TrackingGeometry loading";
  }
};
 
class IProcessSamplingTool;
class IPhysicsValidationTool;
class IHadronicInteractionProcessor;
class IPhotonConversionTool;
class IParticleDecayHelper;
 
class ATLAS_NOT_THREAD_SAFE McMaterialEffectsUpdator  // deprecated: ATLASSIM-6020
  : public extends<AthAlgTool, Trk::ITimedMatEffUpdator>
{
public:
  McMaterialEffectsUpdator(const std::string&,
                           const std::string&,
                           const IInterface*);
  virtual ~McMaterialEffectsUpdator();
 
  StatusCode initialize();
  StatusCode finalize();
 
  std::unique_ptr<Trk::TrackParameters> update(
    const Trk::TrackParameters* parm,
    const Trk::Layer& sf,
    Trk::TimeLimit& time,
    Trk::PathLimit& path,
    Trk::GeometrySignature geoID,
    Trk::PropDirection dir = Trk::alongMomentum,
    Trk::ParticleHypothesis particle = Trk::pion) const;
 
  std::unique_ptr<Trk::TrackParameters> update(
    double time,
    const Trk::TrackParameters* parm,
    const Trk::MaterialEffectsOnTrack& meff,
    Trk::ParticleHypothesis particle = Trk::pion,
    Trk::MaterialUpdateMode matupmode = Trk::addNoise) const;
 
  std::unique_ptr<Trk::TrackParameters> update(
    double time,
    const Trk::TrackParameters& parm,
    const Trk::MaterialProperties& mprop,
    double pathcorrection,
    Trk::PropDirection dir = Trk::alongMomentum,
    Trk::ParticleHypothesis particle = Trk::pion,
    Trk::MaterialUpdateMode matupmode = Trk::addNoise) const;
 
  std::unique_ptr<Trk::TrackParameters> interact(
    double time,
    const Amg::Vector3D& position,
    const Amg::Vector3D& momentum,
    Trk::ParticleHypothesis particle,
    int process,
    const Trk::Material* extMatProp = 0) const;
 
  void recordBremPhoton(double time,
                        double pElectron,
                        double gammaE,
                        const Amg::Vector3D& vertex,
                        Amg::Vector3D& particleDir,
                        Trk::ParticleHypothesis particle) const;
 
private:
  std::unique_ptr<Trk::TrackParameters> updateInLay(
    const ISF::ISFParticle* isp,
    const Trk::TrackParameters* parm,
    double& matFraction,
    Trk::TimeLimit& time,
    Trk::PathLimit& path,
    Trk::PropDirection dir = Trk::alongMomentum,
    Trk::ParticleHypothesis particle = Trk::pion) const;
 
  ISF::ISFParticleVector interactLay(
    const ISF::ISFParticle* isp,
    double time,
    const Trk::TrackParameters& parm,
    Trk::ParticleHypothesis particle,
    int process,
    const Trk::MaterialProperties* extMatProp = 0) const;
 
  void radiate(const ISF::ISFParticle* parent,
               AmgVector(5) & updatedParameters,
               const Amg::Vector3D& pos,
               Amg::Vector3D& dir,
               Trk::TimeLimit time,
               double dX0,
               double& matFraction,
               double matTot,
               Trk::PropDirection pdir,
               Trk::ParticleHypothesis particle) const;
 
  void ionize(const Trk::TrackParameters& parm,
              AmgVector(5) & updatedPar,
              double dInX0,
              Trk::PropDirection pdir,
              Trk::ParticleHypothesis particle) const;
 
  // bool handleEnergyLoss(double time,
  //              const Trk::TrackParameters& parm,
  //                       Amg::Vector3D*       updatedParameter,
  //                       Trk::EnergyLoss* sampldEnergyLoss,
  //                       const Trk::Layer& lay,
  //                       double p, double E, double m,
  //                       Trk::ParticleHypothesis particle=Trk::pion) const;
 
  double msSigma(double dInX0,
                 double p,
                 Trk::ParticleHypothesis particle) const;
 
  void multipleScatteringUpdate(const Trk::TrackParameters& parm,
                                AmgVector(5) & parameters,
                                double sigmaMSproj) const;
 
  void recordBremPhotonLay(const ISF::ISFParticle* parent,
                           Trk::TimeLimit time,
                           double pElectron,
                           double gammaE,
                           const Amg::Vector3D& vertex,
                           Amg::Vector3D& particleDir,
                           double matFraction,
                           Trk::PropDirection dir,
                           Trk::ParticleHypothesis particle) const;
 
  const Trk::LayerIndexSampleMap* layerIndexSampleMap() const;
 
  virtual const Trk::TrackingGeometry* trackingGeometry(
    const EventContext& ctx) const;
 
  bool m_eLoss;
  ToolHandle<Trk::IEnergyLossUpdator> m_eLossUpdator;
 
  bool m_ms;
  ToolHandle<Trk::IMultipleScatteringUpdator> m_msUpdator;
 
  ToolHandle<iFatras::IPhotonConversionTool> m_conversionTool;
 
  int m_processCode;
 
  ToolHandle<iFatras::IProcessSamplingTool> m_samplingTool;
 
  bool m_hadInt;
  ToolHandle<IHadronicInteractionProcessor> m_hadIntProcessor;
 
  ToolHandle<IParticleDecayHelper> m_particleDecayer;
 
  double m_minimumMomentum;
 
  double m_minimumBremPhotonMomentum;
 
  bool m_parametricScattering;
 
  bool m_use_msUpdator;
 
  bool m_uniformHertzDipoleAngle;
 
  bool m_referenceMaterial;
 
  bool m_bendingCorrection;
 
  ServiceHandle<IAtRndmGenSvc> m_rndGenSvc;
  CLHEP::HepRandomEngine* m_randomEngine;
  std::string m_randomEngineName; 
 
  mutable std::atomic<unsigned int> m_recordedBremPhotons;
 
  int m_currentSample;                       
  bool m_recordEnergyDeposition;             
  std::string m_layerIndexCaloSampleMapName; 
  mutable const Trk::LayerIndexSampleMap*
    m_layerIndexCaloSampleMap; 
 
  // ---------------------------- Tracking Geometry ---------------------------
  bool m_useConditions{};
  SG::ReadCondHandleKey<Trk::TrackingGeometry> m_trackingGeometryReadKey{
    this,
    "TrackingGeometryReadKey",
    "ISF_FatrasTrackingGeometry",
    "Key of input TrackingGeometry"
  };
 
  ServiceHandle<Trk::ITrackingGeometrySvc> m_trackingGeometrySvc{
    this,
    "TrackingGeometrySvc",
    "",
    ""
  };
  std::string m_trackingGeometryName{ "ISF_FatrasTrackingGeometry" };
  // --------------------------------------------------------------------------
 
  double m_projectionFactor;
 
 
  // ------------------------ Validation section
  // ------------------------------------
  bool m_validationMode;
  ToolHandle<IPhysicsValidationTool> m_validationTool;
  std::string m_validationTreeName; 
  std::string m_validationTreeDescription; 
  std::string m_validationTreeFolder; 
 
  TTree* m_validationTree; 
 
  // ----------- ntuple branches
  mutable int
    m_layerIndex; 
  mutable float m_tInX0;        
  mutable float m_thetaMSproj;  
  mutable float m_thetaMSphi;   
  mutable float m_thetaMStheta; 
  mutable float m_deltaP;       
  mutable float m_deltaPsigma;  
 
  bool m_bremValidation;
  std::string m_bremValidationTreeName;        
  std::string m_bremValidationTreeDescription; 
  std::string m_bremValidationTreeFolder; 
 
  TTree* m_bremValidationTree; 
 
  // ------ ntuple branches
  mutable float m_bremPointX; 
  mutable float m_bremPointY; 
  mutable float m_bremPointR; 
  mutable float m_bremPointZ; 
  mutable float m_bremMotherEnergy; 
  mutable float m_bremPhotonEnergy; 
  mutable float m_bremPhotonAngle;  
 
  // --------------------------------------------------------------------------------
 
  bool m_edValidation;
  std::string m_edValidationTreeName; 
  std::string m_edValidationTreeDescription; 
  std::string m_edValidationTreeFolder; 
 
  TTree* m_edValidationTree; 
 
  // ------ ntuple branches
  mutable float
    m_edLayerIntersectX; 
  mutable float
    m_edLayerIntersectY; 
  mutable float
    m_edLayerIntersectZ; 
  mutable float
    m_edLayerIntersectR; 
  mutable float
    m_edLayerEnergyDeposit;      
  mutable float m_edLayerSample; 
 
  double m_oneOverThree;
 
  ServiceHandle<ISF::IParticleBroker> m_particleBroker;
  ServiceHandle<ISF::ITruthSvc> m_truthRecordSvc;
 
  mutable const ISF::ISFParticle* m_isp;
 
  mutable const Trk::Layer* m_layer;
  mutable const Trk::MaterialProperties* m_matProp;
  Trk::PdgToParticleHypothesis m_pdgToParticleHypothesis;
};
 
}
 
#endif // ISF_FATRASTOOLS_TRACKONLAYERUPDATOR_H