iFatras::McMaterialEffectsUpdator Class Reference

Updator for a track on a Trk::Layer, it extends the IMaterialEffecsUpdator to be used inside the Extrapolator with an update based on a Random number. More...

#include <McMaterialEffectsUpdator.h>

Inheritance diagram for iFatras::McMaterialEffectsUpdator:

Public Member Functions
	McMaterialEffectsUpdator (const std::string &, const std::string &, const IInterface *)
	AlgTool constructor for McMaterialEffectsUpdator.
virtual	~McMaterialEffectsUpdator ()
	Destructor.
StatusCode	initialize ()
	AlgTool initailize method.
StatusCode	finalize ()
	AlgTool finalize method.
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
	Updator interface (full update for a layer): A unique_ptr to Trk::TrackParameters is returned it could be a clone of the input if now update has happened.
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
	Updator interface: The parmeters are given as a reference, MaterialProperties based material update.
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
	the helper function for a brem photon record

Private Member Functions
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
double	msSigma (double dInX0, double p, Trk::ParticleHypothesis particle) const
	handle the Energy loss
void	multipleScatteringUpdate (const Trk::TrackParameters &parm, AmgVector(5) &parameters, double sigmaMSproj) const
	the private multiple Scattering update method, thetaMs is the projected random number
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
	the helper function for a brem photon record
const Trk::LayerIndexSampleMap *	layerIndexSampleMap () const
	return the TrackingGeometry used
virtual const Trk::TrackingGeometry *	trackingGeometry (const EventContext &ctx) const

Private Attributes
bool	m_eLoss
	IEnergyLossUpdator.
ToolHandle< Trk::IEnergyLossUpdator >	m_eLossUpdator
bool	m_ms
	IMultipleScatteringUpdator.
ToolHandle< Trk::IMultipleScatteringUpdator >	m_msUpdator
ToolHandle< iFatras::IPhotonConversionTool >	m_conversionTool
	IPhotonConversionTool.
int	m_processCode
	MCTruth process code for TruthIncidents created by this tool.
ToolHandle< iFatras::IProcessSamplingTool >	m_samplingTool
	MCTruth process sampling.
bool	m_hadInt
	hadronic interaction setting
ToolHandle< IHadronicInteractionProcessor >	m_hadIntProcessor
ToolHandle< IParticleDecayHelper >	m_particleDecayer
	Particle Decay.
double	m_minimumMomentum
	Minimum momentum cut.
double	m_minimumBremPhotonMomentum
	Minimum momentum for brem photons.
bool	m_parametricScattering
	describe deflection parametric/do real deflection
bool	m_use_msUpdator
	switch between MSUpdator and local parametrization
bool	m_uniformHertzDipoleAngle
	use the relativistic hertz dipole for brem photon radiation
bool	m_referenceMaterial
	Switch to use reference material.
bool	m_bendingCorrection
	Switch to use bending correction.
ServiceHandle< IAtRndmGenSvc >	m_rndGenSvc
	Random Generator service.
CLHEP::HepRandomEngine *	m_randomEngine
	Random engine.
std::string	m_randomEngineName
	Name of the random number stream.
std::atomic< unsigned int >	m_recordedBremPhotons
	for statistics output
int	m_currentSample
	for the calo energy recording
bool	m_recordEnergyDeposition
	for deposition methods
std::string	m_layerIndexCaloSampleMapName
	name to record it
const Trk::LayerIndexSampleMap *	m_layerIndexCaloSampleMap
	the map for the calo-layer index map
bool	m_useConditions {}
SG::ReadCondHandleKey< Trk::TrackingGeometry >	m_trackingGeometryReadKey
ServiceHandle< Trk::ITrackingGeometrySvc >	m_trackingGeometrySvc
	ToolHandle to the TrackingGeometrySvc.
std::string	m_trackingGeometryName { "ISF_FatrasTrackingGeometry" }
	Name of the TrackingGeometry as given in Detector Store.
double	m_projectionFactor
	projection factor for the non-parametric scattering
bool	m_validationMode
ToolHandle< IPhysicsValidationTool >	m_validationTool
std::string	m_validationTreeName
	validation tree name - to be acessed by this from root
std::string	m_validationTreeDescription
	validation tree description - second argument in TTree
std::string	m_validationTreeFolder
	stream/folder to for the TTree to be written out
TTree *	m_validationTree
	Root Validation Tree.
int	m_layerIndex
	ntuple variable : layer index of material effects update
float	m_tInX0
	nutple variable : t/X0
float	m_thetaMSproj
	ntuple variable : projected ms
float	m_thetaMSphi
	ntuple variable : ms in phi
float	m_thetaMStheta
	ntuple variable : ms in theta
float	m_deltaP
	nutple variable : energy loss
float	m_deltaPsigma
	ntuple variable : stragling on energy loss
bool	m_bremValidation
std::string	m_bremValidationTreeName
	validation tree name - to be acessed by this from root
std::string	m_bremValidationTreeDescription
	validation tree description
std::string	m_bremValidationTreeFolder
	stream/folder to for the TTree to be written out
TTree *	m_bremValidationTree
	Root Validation Tree.
float	m_bremPointX
	ntuple variable : brem point x coordinate
float	m_bremPointY
	ntuple variable : brem point y coordinate
float	m_bremPointR
	ntuple variable : brem point r distance
float	m_bremPointZ
	ntuple variable : brem point z coordinate
float	m_bremMotherEnergy
	ntuple variable : brem mother energy
float	m_bremPhotonEnergy
	ntuple variable : brem photon energy
float	m_bremPhotonAngle
	ntuple variable : brem photon angle
bool	m_edValidation
std::string	m_edValidationTreeName
	validation tree name - to be acessed by this from root
std::string	m_edValidationTreeDescription
	validation tree description - second argument in TTree
std::string	m_edValidationTreeFolder
	stream/folder to for the TTree to be written out
TTree *	m_edValidationTree
	Root Validation Tree.
float	m_edLayerIntersectX
	ntuple variable : energy deposit x coordinate
float	m_edLayerIntersectY
	ntuple variable : energy deposit y coordinate
float	m_edLayerIntersectZ
	ntuple variable : energy deposit z coordinate
float	m_edLayerIntersectR
	ntuple variable : energy deposit r coordinate
float	m_edLayerEnergyDeposit
	ntuple variable : energy despoit - value
float	m_edLayerSample
	ntuple variable : layer sample
double	m_oneOverThree
	useful for the angle calculation of the brem photon
ServiceHandle< ISF::IParticleBroker >	m_particleBroker
ServiceHandle< ISF::ITruthSvc >	m_truthRecordSvc
const ISF::ISFParticle *	m_isp
	cache incoming particle
const Trk::Layer *	m_layer
	cache layer properties
const Trk::MaterialProperties *	m_matProp
Trk::PdgToParticleHypothesis	m_pdgToParticleHypothesis

Detailed Description

Updator for a track on a Trk::Layer, it extends the IMaterialEffecsUpdator to be used inside the Extrapolator with an update based on a Random number.

The McMaterialEffectsUpdator uses both an extended EnergyLossUpdator and the standard ATLAS MultipleScatteringUpdator configured for the Gaussian-Mixture-Model.

Author

Andre.nosp@m.as.S.nosp@m.alzbu.nosp@m.rger.nosp@m.@cern.nosp@m..ch, Carst.nosp@m.en.M.nosp@m.agass.nosp@m.@cer.nosp@m.n.ch

Definition at line 81 of file McMaterialEffectsUpdator.h.

Constructor & Destructor Documentation

McMaterialEffectsUpdator()

iFatras::McMaterialEffectsUpdator::McMaterialEffectsUpdator	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

AlgTool constructor for McMaterialEffectsUpdator.

Definition at line 53 of file McMaterialEffectsUpdator.cxx.

                                                                                                                     :
  base_class(t,n,p),
  m_eLoss(true),
  m_eLossUpdator("iFatras::McEnergyLossUpdator/FatrasEnergyLossUpdator"),
  m_ms(true),
  m_msUpdator("Trk::MultipleScatteringUpdator/AtlasMultipleScatteringUpdator"),
  m_conversionTool("iFatras::McConversionCreator/FatrasConversionCreator"),
  m_processCode(3),
  m_hadInt(true),
  //m_hadIntProcessor("iFatras::HadIntProcessorParametric/FatrasHadIntProcessorParametric"),
  m_hadIntProcessor("iFatras::G4HadIntProcessor/FatrasG4HadIntProcessor"),
  m_particleDecayer(),
  m_minimumMomentum(50.*CLHEP::MeV),
  m_minimumBremPhotonMomentum(50.*CLHEP::MeV),
  m_parametricScattering(false),
  m_use_msUpdator(false),
  m_uniformHertzDipoleAngle(false),
  m_referenceMaterial(true),
  m_bendingCorrection(false),
  m_rndGenSvc("AtDSFMTGenSvc", n),
  m_randomEngine(nullptr),
  m_randomEngineName("FatrasRnd"),
  m_recordedBremPhotons(0),
  m_currentSample(-1),
  m_recordEnergyDeposition(false),
  m_layerIndexCaloSampleMapName("LayerIndexCaloSampleMap"),
  m_layerIndexCaloSampleMap(nullptr),
  m_projectionFactor(sqrt(2.)),
  m_validationMode(false),
  m_validationTool(""),
  m_validationTreeName("FatrasMaterialEffects"),
  m_validationTreeDescription("Validation output from the McMaterialEffectsUpdator"),
  m_validationTreeFolder("/val/FatrasSimulationMaterial"),
  m_validationTree(nullptr),
  m_layerIndex(0),
  m_tInX0(0.),
  m_thetaMSproj(0.),
  m_thetaMSphi(0.),
  m_thetaMStheta(0.),
  m_deltaP(0.),
  m_deltaPsigma(0.),
  m_bremValidation(false),
  m_bremValidationTreeName("FatrasBremPhotons"),
  m_bremValidationTreeDescription("Validation output from the McMaterialEffectsUpdator"),
  m_bremValidationTreeFolder("/val/FatrasBremPhotons"),
  m_bremValidationTree(nullptr),
  m_bremPointX(0.),
  m_bremPointY(0.),
  m_bremPointR(0.),
  m_bremPointZ(0.),
  m_bremMotherEnergy(0.),
  m_bremPhotonEnergy(0.),
  m_bremPhotonAngle(0.),
  m_edValidation(false),
  m_edValidationTreeName("FatrasEnergyInCaloDeposit"),
  m_edValidationTreeDescription("Validation output from the McMaterialEffectUpdator"),
  m_edValidationTreeFolder("/val/FatrasEnergyInCaloDeposit"),
  m_edValidationTree(nullptr),
  m_edLayerIntersectX(0.),
  m_edLayerIntersectY(0.),
  m_edLayerIntersectZ(0.),
  m_edLayerIntersectR(0.),
  m_edLayerEnergyDeposit(0.),
  m_edLayerSample(0.),
  m_oneOverThree(1./3.),
  m_particleBroker("ISF_ParticleParticleBroker", n),
  m_truthRecordSvc("ISF_TruthRecordSvc", n),
  m_isp(nullptr),
  m_layer(nullptr),
  m_matProp(nullptr)
{
      // the tool parameters -----------------------------------------------------
      declareProperty("EnergyLoss"                          , m_eLoss);
      declareProperty("EnergyLossUpdator"                   , m_eLossUpdator);
      declareProperty("MultipleScattering"                  , m_ms);
      declareProperty("MultipleScatteringUpdator"           , m_msUpdator);
      declareProperty("ProcessSamplingTool"                 , m_samplingTool);
      declareProperty("PhotonConversionTool"                , m_conversionTool);
      // tool handle for the particle decayer
      declareProperty( "ParticleDecayHelper"                , m_particleDecayer      );
      // MC Truth Properties
      declareProperty("BremProcessCode"                     , m_processCode, "MCTruth Physics Process Code");
      // the steering --------------------------------------------------------------
      declareProperty("HadronicInteraction"                 , m_hadInt);
      declareProperty("HadronicInteractionProcessor"        , m_hadIntProcessor);
      // the steering --------------------------------------------------------------
      declareProperty("ParametericScattering"               , m_parametricScattering);
      declareProperty("UseMultipleScatteringUpdator"        , m_use_msUpdator);
      declareProperty("MomentumCut"                         , m_minimumMomentum);
      declareProperty("MinimumBremPhotonMomentum"           , m_minimumBremPhotonMomentum);
      // the steering --------------------------------------------------------------
      declareProperty("ReferenceMaterial"                   , m_referenceMaterial);
      declareProperty("BendingCorrection"                   , m_bendingCorrection);
      // validation mode ------------------------------------------------------------
      declareProperty("RecordEnergyDeposition"              , m_recordEnergyDeposition);
      declareProperty("LayerIndexCaloSampleMap"             , m_layerIndexCaloSampleMapName);
      // validation mode ------------------------------------------------------------
      declareProperty("ValidationMode"                      , m_validationMode);
      declareProperty("PhysicsValidationTool"               , m_validationTool);
      declareProperty("BremPhotonValidation"                , m_bremValidation);
      declareProperty("EnergyDepositValidation"             , m_edValidation);
      declareProperty("RandomNumberService"                 , m_rndGenSvc               , "Random number generator");
      declareProperty("RandomStreamName"                    , m_randomEngineName        , "Name of the random number stream");
 
      // ISF Services and Tools
      declareProperty("ParticleBroker"                      , m_particleBroker        , "ISF Particle Broker Svc");
      declareProperty("TruthRecordSvc"                      , m_truthRecordSvc        , "ISF Particle Truth Svc");
}

~McMaterialEffectsUpdator()

iFatras::McMaterialEffectsUpdator::~McMaterialEffectsUpdator ( )

virtualdefault

Destructor.

Member Function Documentation

finalize()

StatusCode iFatras::McMaterialEffectsUpdator::finalize

(

)

AlgTool finalize method.

Definition at line 360 of file McMaterialEffectsUpdator.cxx.

{
 
    ATH_MSG_INFO( " ---------- Statistics output -------------------------- " );
    ATH_MSG_INFO( "                     Minimum energy cut for brem photons : " <<   m_minimumBremPhotonMomentum  );
    ATH_MSG_INFO( "                     Brem photons (above cut, recorded)  : " <<   m_recordedBremPhotons        );
 
    ATH_MSG_DEBUG( "finalize() successful" );
    return StatusCode::SUCCESS;
}

initialize()

StatusCode iFatras::McMaterialEffectsUpdator::initialize

(

)

AlgTool initailize method.

Definition at line 168 of file McMaterialEffectsUpdator.cxx.

{
 
    ATH_MSG_DEBUG( "initialize()" );
 
    // retrieve the process sampling tool
    if (m_samplingTool.retrieve().isFailure()){
      ATH_MSG_FATAL( "Could not retrieve " << m_samplingTool );
      return StatusCode::FAILURE;
    } else
      ATH_MSG_VERBOSE( "Successfully retrieved " << m_samplingTool );
 
    // retrieve the energy loss updator
    if (m_eLoss){
      if (m_eLossUpdator.retrieve().isFailure()){
          ATH_MSG_FATAL( "Could not retrieve " << m_eLossUpdator );
          return StatusCode::FAILURE;
      } else
         ATH_MSG_VERBOSE( "Successfully retrieved " << m_eLossUpdator );
    } else {
      m_eLossUpdator.disable();
    }
 
    // retrieve the multiple scattering updator tool
    if (m_ms && m_use_msUpdator){
      if (m_msUpdator.retrieve().isFailure()){
          ATH_MSG_FATAL( "Could not retrieve " << m_msUpdator );
          return StatusCode::FAILURE;
      } else
          ATH_MSG_VERBOSE( "Successfully retrieved " << m_msUpdator );
    } else {
      m_msUpdator.disable();
    }
 
    // retrieve the photon conversion tool
    if (m_conversionTool.retrieve().isFailure()){
      ATH_MSG_FATAL( "Could not retrieve " << m_conversionTool );
      return StatusCode::FAILURE;
    } else
      ATH_MSG_VERBOSE( "Successfully retrieved " << m_conversionTool );
 
    // retrieve the hadronic interaction tool
    if (m_hadInt){
      if (m_hadIntProcessor.retrieve().isFailure()){
          ATH_MSG_FATAL( "Could not retrieve " << m_hadIntProcessor );
          return StatusCode::FAILURE;
      } else
          ATH_MSG_VERBOSE( "Successfully retrieved " << m_hadIntProcessor );
    } else {
      m_hadIntProcessor.disable();
    }
 
    // get the random generator serice
     if (m_rndGenSvc.retrieve().isFailure()){
          ATH_MSG_FATAL( "Could not retrieve " << m_rndGenSvc );
          return StatusCode::FAILURE;
     } else
          ATH_MSG_VERBOSE( "Successfully retrieved " << m_rndGenSvc );
 
    //Get own engine with own seeds:
    m_randomEngine = m_rndGenSvc->GetEngine(m_randomEngineName);
    if (!m_randomEngine) {
        ATH_MSG_FATAL( "Could not get random engine '" << m_randomEngineName << "'" );
        return StatusCode::FAILURE;
    }
 
    //We can use conditions when the key is not empty
    m_useConditions=!m_trackingGeometryReadKey.key().empty();
 
    // get the TrackingGeometrySvc
    if (!m_useConditions) {
      if (m_trackingGeometrySvc.retrieve().isSuccess()) {
        ATH_MSG_DEBUG("Successfully retrieved " << m_trackingGeometrySvc);
        m_trackingGeometryName = m_trackingGeometrySvc->trackingGeometryName();
      } else {
        ATH_MSG_WARNING("Couldn't retrieve " << m_trackingGeometrySvc << ". ");
        ATH_MSG_WARNING(" -> Trying to retrieve default '"
                        << m_trackingGeometryName << "' from DetectorStore.");
      }
    }
 
    // get the tracking geometry for layer lookup
    // init the TrackingGeometryReadKey
    ATH_CHECK(m_trackingGeometryReadKey.initialize(m_useConditions));
 
    // Particle decayer
    if (m_particleDecayer.retrieve().isFailure()){
      ATH_MSG_FATAL( "Could not retrieve " << m_particleDecayer );
      return StatusCode::FAILURE;
    } else
      ATH_MSG_VERBOSE( "Successfully retrieved " << m_particleDecayer );
 
    // ISF Services
    if (m_particleBroker.retrieve().isFailure()){
        ATH_MSG_FATAL( "Could not retrieve " << m_particleBroker );
        return StatusCode::FAILURE;
    }
    if (m_truthRecordSvc.retrieve().isFailure()){
        ATH_MSG_FATAL( "Could not retrieve " << m_truthRecordSvc );
        return StatusCode::FAILURE;
    }
 
    // the validation setup -------------------------------- PART 1: General ----------------------------------
 
    // retrieve the physics validation tool
    ATH_CHECK( m_validationTool.retrieve( DisableTool{ m_validationTool.empty() || !m_validationMode } ) );
 
    if (m_validationMode || m_bremValidation || m_edValidation) {
      SmartIF<ITHistSvc> tHistSvc{service("THistSvc")};
      if (!tHistSvc) {
        ATH_MSG_ERROR( "initialize() Could not find Hist Service -> Switching ValidationMode Off !" );
      }
 
      if (m_validationMode) {
        ATH_MSG_VERBOSE( "Booking material validation TTree ... " );
 
        // create the new Tree
        m_validationTree = new TTree(m_validationTreeName.c_str(), m_validationTreeDescription.c_str());
 
        // counter for material effects
        m_validationTree->Branch("LayerIndex"      ,  &m_layerIndex,   "layerIdx/I");
        m_validationTree->Branch("PathInX0"        ,  &m_tInX0,        "tInX0/F");
        m_validationTree->Branch("ThetaMS"         ,  &m_thetaMSproj,  "thetaMS/F");
        m_validationTree->Branch("ThetaMSphi"      ,  &m_thetaMSphi,   "thetaMSphi/F");
        m_validationTree->Branch("ThetaMStheta"    ,  &m_thetaMStheta, "thetaMStheta/F");
        m_validationTree->Branch("DeltaP"          ,  &m_deltaP,       "deltaP/F");
        m_validationTree->Branch("DeltaPsigma"     ,  &m_deltaPsigma,  "deltaPsigma/F");
 
 
        if ((tHistSvc->regTree(m_validationTreeFolder, m_validationTree)).isFailure()) {
          ATH_MSG_ERROR( "initialize() Could not register the validation Tree -> Switching ValidationMode Off !" );
          delete m_validationTree; m_validationTree = nullptr;
        } else {
          ATH_MSG_INFO( "TTree for MaterialEffects validation booked." );
        }
      }
      // the validation setup -------------------------------- PART 2: Brem Photons -----------------------------
      if (m_bremValidation){
 
        ATH_MSG_VERBOSE( "Booking bremstrahlung validation TTree ... " );
 
        // create the new Tree
        m_bremValidationTree = new TTree(m_bremValidationTreeName.c_str(), m_bremValidationTreeDescription.c_str());
 
        // counter for bremstrahlung
        m_bremValidationTree->Branch("BremPositionX"    ,  &m_bremPointX, "bremX/F");
        m_bremValidationTree->Branch("BremPositionY"    ,  &m_bremPointY, "bremY/F");
        m_bremValidationTree->Branch("BremPositionR"    ,  &m_bremPointR, "bremR/F");
        m_bremValidationTree->Branch("BremPositionZ"    ,  &m_bremPointZ, "bremZ/F");
        m_bremValidationTree->Branch("BremMotherEnergy" ,  &m_bremMotherEnergy,   "bremMotherE/F");
        m_bremValidationTree->Branch("BremPhotonEnergy" ,  &m_bremPhotonEnergy,   "bremPhotonE/F");
        m_bremValidationTree->Branch("BremPhotonAngle"  ,  &m_bremPhotonAngle,    "bremPhotondA/F");
 
        if ((tHistSvc->regTree(m_bremValidationTreeFolder, m_bremValidationTree)).isFailure()) {
          ATH_MSG_ERROR("initialize() Could not register the validation Tree -> Switching ValidationMode Off !" );
          delete m_bremValidationTree; m_bremValidationTree = nullptr;
        } else
          ATH_MSG_INFO( "TTree for Bremsstrahlung validation booked." );
 
      } // ------------- end of validation mode -----------------------------------------------------------------
 
      // the validation setup -------------------------------- PART 3: Brem Photons -----------------------------
      if (m_edValidation){
 
        ATH_MSG_VERBOSE( "Booking Energy deposition validation TTree ... " );
 
        // create the new Tree
        m_edValidationTree = new TTree(m_edValidationTreeName.c_str(), m_edValidationTreeDescription.c_str());
 
        // counter for boundary surfaces
        m_edValidationTree->Branch("EdepositPositionX"    ,  &m_edLayerIntersectX,    "edX/F");
        m_edValidationTree->Branch("EdepositPositionY"    ,  &m_edLayerIntersectY,    "edY/F");
        m_edValidationTree->Branch("EdepositPositionR"    ,  &m_edLayerIntersectR,    "edR/F");
        m_edValidationTree->Branch("EdepositPositionZ"    ,  &m_edLayerIntersectZ,    "edZ/F");
        m_edValidationTree->Branch("Edeposit"             ,  &m_edLayerEnergyDeposit, "ed/F");
        m_edValidationTree->Branch("EdepositLayerSample"  ,  &m_edLayerSample,        "edLayerSample/F");
 
        if ((tHistSvc->regTree(m_edValidationTreeFolder, m_edValidationTree)).isFailure()) {
          ATH_MSG_ERROR("initialize() Could not register the validation Tree -> Switching ValidationMode Off !" );
          delete m_edValidationTree; m_edValidationTree = nullptr;
        } else
          ATH_MSG_INFO( "TTree for Energy deposition validation booked." );
 
 
 
      } // ------------- end of validation mode -----------------------------------------------------------------
    }
    ATH_MSG_DEBUG( "finalize() successful" );
    return StatusCode::SUCCESS;
}

interact()

std::unique_ptr< Trk::TrackParameters > iFatras::McMaterialEffectsUpdator::interact	(	double	time,
		const Amg::Vector3D &	position,
		const Amg::Vector3D &	momentum,
		Trk::ParticleHypothesis	particle,
		int	process,
		const Trk::Material *	extMatProp = 0 ) const

Definition at line 1580 of file McMaterialEffectsUpdator.cxx.

{
  // Responsible for registering TruthIncidents
  if (process == 0)
    return nullptr;
 
  // get parent particle
  // @TODO: replace by Fatras internal bookkeeping
  const ISF::ISFParticle *parent = ISF::ParticleClipboard::getInstance().getParticle();
  // something is seriously wrong if there is no parent particle
  assert(parent);
 
  double mass = Trk::ParticleMasses::mass[particle];
  double p = momentum.mag();
  /*double E = sqrt( p*p + mass*mass);*/
 
  if ( process == 201 ) {    // decay
    // update parent before decay
    ISF::ISFParticleVector childVector = m_particleDecayer->decayParticle(*parent,position,momentum,time);
 
     // register TruthIncident
    ISF::ISFTruthIncident truth( const_cast<ISF::ISFParticle&>(*parent),
                                 childVector,
                                 process,
                                 parent->nextGeoID(),  // inherits from the parent
                                 ISF::fKillsPrimary );
    m_truthRecordSvc->registerTruthIncident( truth);
    // At this point we need to update the properties of the
    // ISFParticles produced in the interaction
    truth.updateChildParticleProperties();
 
   for (unsigned int i=0; i<childVector.size(); i++) {
      // in the validation mode, add process info
      if (m_validationMode) {
        ISF::ParticleUserInformation* validInfo = new ISF::ParticleUserInformation();
        validInfo->setProcess(process);
        if (parent->getUserInformation()) validInfo->setGeneration(parent->getUserInformation()->generation()+1);
        else validInfo->setGeneration(1);     // assume parent is a primary track
        childVector[i]->setUserInformation(validInfo);
      }
      // register next geo (is current), next flavor can be defined by filter
      childVector[i]->setNextGeoID( parent->nextGeoID() );
      // feed it the particle broker with parent information
      m_particleBroker->push(childVector[i], parent);
    }
 
    // save info for validation
    if (m_validationMode && m_validationTool.isEnabled()) {
      Amg::Vector3D* nMom = nullptr;
      m_validationTool->saveISFVertexInfo(process,position,*parent,momentum,nMom,childVector);
      delete nMom;
    }
 
    return nullptr;
  }
 
  if ( process == 5 ) {     // positron annihilation
 
    ISF::ISFParticleVector children(2);
 
    double fmin = mass/p;
 
    double fr = 1.-pow(fmin,CLHEP::RandFlat::shoot(m_randomEngine));
 
    // double cTh = 1.-fmin/(1.-fr)/fr;
 
    // first implementation: ctH=1
    const int status = 1 + HepMC::SIM_STATUS_THRESHOLD;
    const int id = HepMC::UNDEFINED_ID; // This will be set if the child particle is saved to the GenEvent
 
    children[0] = new ISF::ISFParticle( position,
                                        fr*momentum,
                                        0.,
                                        0.,
                                        MC::PHOTON,
                                        status,
                                        time,
                                        *parent,
                                        id
                                        );
 
    children[1] = new ISF::ISFParticle( position,
                                        (1-fr)*momentum,
                                        0.,
                                        0.,
                                        MC::PHOTON,
                                        status,
                                        time,
                                        *parent,
                                        id
                                        );
 
    // register TruthIncident
    ISF::ISFTruthIncident truth( const_cast<ISF::ISFParticle&>(*parent),
                                 children,
                                 process,
                                 parent->nextGeoID(),  // inherits from the parent
                                 ISF::fPrimarySurvives );
    m_truthRecordSvc->registerTruthIncident( truth);
    // At this point we need to update the properties of the
    // ISFParticles produced in the interaction
    truth.updateParentAfterIncidentProperties();
    truth.updateChildParticleProperties();
 
    // Check that the new/updated ISFParticles have a valid TruthBinding
    if (!parent->getTruthBinding()) {
      ATH_MSG_ERROR("Could not retrieve TruthBinding from parent ISFParticle "<< *parent);
    }
    for (auto *childParticle : children) {
      if (!childParticle->getTruthBinding()) {
        ATH_MSG_ERROR("Could not retrieve TruthBinding from child ISFParticle "<< *childParticle);
      }
    }
 
    // in the validation mode, add process info
    if (m_validationMode) {
      ISF::ParticleUserInformation* validInfo1 = new ISF::ParticleUserInformation();
      validInfo1->setProcess(process);
      if (parent->getUserInformation()) validInfo1->setGeneration(parent->getUserInformation()->generation()+1);
      else validInfo1->setGeneration(1);     // assume parent is a primary track
      children[0]->setUserInformation(validInfo1);
      ISF::ParticleUserInformation* validInfo2 = new ISF::ParticleUserInformation();
      validInfo2->setProcess(process);
      if (parent->getUserInformation()) validInfo2->setGeneration(parent->getUserInformation()->generation()+1);
      else validInfo2->setGeneration(1);     // assume parent is a primary track
      children[1]->setUserInformation(validInfo2);
    }
 
    // push child particles onto stack
    m_particleBroker->push( children[0], parent);
    m_particleBroker->push( children[1], parent);
 
    // save info for validation
    if (m_validationMode && m_validationTool.isEnabled()) {
      Amg::Vector3D* nMom = nullptr;
      m_validationTool->saveISFVertexInfo(process,position,*parent,momentum,nMom,children);
      delete nMom;
    }
 
    // kill the track -----------------------------
    return nullptr;
  }
 
  if (process==14) {  // photon conversion
 
    auto parm = std::make_unique<Trk::NeutralCurvilinearParameters>(position,momentum,parent->charge());
 
    bool cStat = m_conversionTool->doConversion(time, *parm); // Registers TruthIncident internally
 
    if (!cStat) ATH_MSG_WARNING( "Conversion failed, killing photon anyway ");
 
    // kill the mother particle
    return nullptr;
  }
 
  if (process==121) {    // hadronic interaction
 
    //const Amg::Vector3D pDir = momentum.unit();
 
    auto parm = std::make_unique<Trk::CurvilinearParameters>(position,momentum,parent->charge());
 
    bool recHad = m_hadIntProcessor->doHadronicInteraction(time, position, momentum, extMatProp, particle, true); // Registers TruthIncident internally
    // eventually : bool recHad =  m_hadIntProcessor->recordHadState( time, p, position, pDir, particle);
 
    // kill the track if interaction recorded --------------------------
    if (recHad) {
      return nullptr;
    } else {
      return parm;
    }
  }
 
  return nullptr;
}

interactLay()

ISF::ISFParticleVector iFatras::McMaterialEffectsUpdator::interactLay ( const ISF::ISFParticle * isp, double time, const Trk::TrackParameters & parm, Trk::ParticleHypothesis particle, int process, const Trk::MaterialProperties * extMatProp = 0 ) const

private

Definition at line 1760 of file McMaterialEffectsUpdator.cxx.

                                                                                                                      {
  ISF::ISFParticleVector childVector(0);
 
  if ( process==0 ) return childVector;
 
  double mass = Trk::ParticleMasses::mass[particle];
  double p = parm.momentum().mag();
  /*double E = sqrt( p*p + mass*mass);*/
  const Amg::Vector3D& position=parm.position();
  const Amg::Vector3D& momentum=parm.momentum();
 
  if ( process == 5 ) {     // positron annihilation
 
    ISF::ISFParticleVector children(2);
 
    double fmin = mass/p;
 
    double fr = 1.-pow(fmin,CLHEP::RandFlat::shoot(m_randomEngine));
 
    // double cTh = 1.-fmin/(1.-fr)/fr;
 
    // first implementation: ctH=1
    const int status = 1 + HepMC::SIM_STATUS_THRESHOLD;
    const int id = HepMC::UNDEFINED_ID; // This will be set if the child particle is saved to the GenEvent
 
    children[0] = new ISF::ISFParticle( position,
                                        fr*momentum,
                                        0.,
                                        0.,
                                        MC::PHOTON,
                                        status,
                                        time,
                                        *parent,
                                        id
                                        );
 
    children[1] = new ISF::ISFParticle( position,
                                        (1-fr)*momentum,
                                        0.,
                                        0.,
                                        MC::PHOTON,
                                        status,
                                        time,
                                        *parent,
                                        id
                                        );
 
    // in the validation mode, add process info
    if (m_validationMode) {
      ISF::ParticleUserInformation* validInfo1 = new ISF::ParticleUserInformation();
      validInfo1->setProcess(process);
      if (parent->getUserInformation()) validInfo1->setGeneration(parent->getUserInformation()->generation()+1);
      else validInfo1->setGeneration(1);     // assume parent is a primary track
      children[0]->setUserInformation(validInfo1);
      ISF::ParticleUserInformation* validInfo2 = new ISF::ParticleUserInformation();
      validInfo2->setProcess(process);
      if (parent->getUserInformation()) validInfo2->setGeneration(parent->getUserInformation()->generation()+1);
      else validInfo2->setGeneration(-1);     // assume parent is a primary track
      children[1]->setUserInformation(validInfo2);
    }
 
    // register TruthIncident
    ISF::ISFTruthIncident truth( const_cast<ISF::ISFParticle&>(*parent),
                                 children,
                                 process,
                                 parent->nextGeoID(),  // inherits from the parent
                                 ISF::fPrimarySurvives );
    m_truthRecordSvc->registerTruthIncident( truth);
    // At this point we need to update the properties of the
    // ISFParticles produced in the interaction
    truth.updateParentAfterIncidentProperties();
    truth.updateChildParticleProperties();
 
    // save info for validation
    if (m_validationMode && m_validationTool.isEnabled()) {
      Amg::Vector3D* nMom = nullptr;
      m_validationTool->saveISFVertexInfo(process,position,*parent,momentum,nMom,children);
      delete nMom;
    }
 
    // Check that the new/updated ISFParticles have a valid TruthBinding
    if (!parent->getTruthBinding()) {
      ATH_MSG_ERROR("Could not retrieve TruthBinding from parent ISFParticle "<< *parent);
    }
    for (auto *childParticle : children) {
      if (!childParticle->getTruthBinding()) {
        ATH_MSG_ERROR("Could not retrieve TruthBinding from child ISFParticle "<< *childParticle);
      }
    }
 
    return children;
  }
 
  if (process==14) {  // photon conversion
 
    Trk::NeutralCurvilinearParameters neu(position,momentum,parent->charge());
    childVector=m_conversionTool->doConversionOnLayer(parent, time, neu); // Registers TruthIncident internally
 
    // validation mode
    if (m_validationMode && m_validationTool.isEnabled()) {
 
      // add process info for children
      for (unsigned int i=0; i<childVector.size(); i++) {
        ISF::ParticleUserInformation* validInfo = new ISF::ParticleUserInformation();
        validInfo->setProcess(process);
        if (parent->getUserInformation()) validInfo->setGeneration(parent->getUserInformation()->generation()+1);
        else validInfo->setGeneration(1);     // assume parent is a primary track
        childVector[i]->setUserInformation(validInfo);
      }
      // save interaction info
      Amg::Vector3D* nMom = nullptr;
      m_validationTool->saveISFVertexInfo(process, position,*parent,momentum,nMom,childVector);
      delete nMom;
    }
 
    // Check that the new ISFParticles have a valid TruthBinding
    for (auto *childParticle : childVector) {
      if (!childParticle->getTruthBinding()) {
        ATH_MSG_ERROR("Could not retrieve TruthBinding from child ISFParticle "<< *childParticle);
      }
    }
 
    return childVector;
  }
 
  if (process==121) {    // hadronic interaction
 
    return ( m_hadIntProcessor->doHadIntOnLayer(parent, time, position, momentum,
                                                extMatProp? &extMatProp->material() : nullptr, particle) );
 
  }
 
  if ( process == 201 ) {    // decay
    childVector = m_particleDecayer->decayParticle(*parent,parm.position(),parm.momentum(),time);
    // in the validation mode, add process info
    if (m_validationMode) {
      for (unsigned int i=0; i<childVector.size(); i++) {
        ISF::ParticleUserInformation* validInfo = new ISF::ParticleUserInformation();
        validInfo->setProcess(process);
        if (parent->getUserInformation()) validInfo->setGeneration(parent->getUserInformation()->generation()+1);
        else validInfo->setGeneration(1);     // assume parent is a primary track
        childVector[i]->setUserInformation(validInfo);
      }
    }
 
    // register TruthIncident
    ISF::ISFTruthIncident truth( const_cast<ISF::ISFParticle&>(*parent),
                                 childVector,
                                 process,
                                 parent->nextGeoID(),  // inherits from the parent
                                 ISF::fKillsPrimary );
    m_truthRecordSvc->registerTruthIncident( truth);
    // At this point we need to update the properties of the
    // ISFParticles produced in the interaction
    truth.updateChildParticleProperties();
 
    // save info for validation
    if (m_validationMode && m_validationTool.isEnabled()) {
      Amg::Vector3D* nMom = nullptr;
      m_validationTool->saveISFVertexInfo(process,parm.position(),*parent,parm.momentum(),nMom,childVector);
      delete nMom;
    }
  }
 
  // Check that the new ISFParticles have a valid TruthBinding
  for (auto *childParticle : childVector) {
    if (!childParticle->getTruthBinding()) {
      ATH_MSG_ERROR("Could not retrieve TruthBinding from child ISFParticle "<< *childParticle);
    }
  }
 
  return childVector;
}

ionize()

void iFatras::McMaterialEffectsUpdator::ionize ( const Trk::TrackParameters & parm, AmgVector(5) & updatedPar, double dInX0, Trk::PropDirection pdir, Trk::ParticleHypothesis particle ) const

private

Definition at line 767 of file McMaterialEffectsUpdator.cxx.

{
 
  double p = parm.momentum().mag();
  double m    = Trk::ParticleMasses::mass[particle];
  double E    = sqrt(p*p+m*m);
 
  // the following formulas are imported from STEP
  // preparation of kinetic constants
 
  double me    = Trk::ParticleMasses::mass[Trk::electron];
  double mfrac = me/m;
  double beta  = p/E;
  double gamma = E/m;
  double Ionization = 0.;
 
  //Ionization - Bethe-Bloch
  double I = 16.e-6 * std::pow(m_matProp->averageZ(),0.9); //16 eV * Z**0.9 - bring to MeV
 
  //K/A*Z = 0.5 * 30.7075MeV/(g/mm2) * Z/A * rho[g/mm3]  / scale to mm by this
  double kaz = 0.5*30.7075*m_matProp->zOverAtimesRho();
 
  if (particle == Trk::electron){
    // for electrons use slightly different BetheBloch adaption
    // see Stampfer, et al, "Track Fitting With Energy Loss", Comp. Pyhs. Comm. 79 (1994), 157-164
    Ionization = -kaz*(2.*log(2.*me/I)+3.*log(gamma) - 1.95);
  }
  else {
    double eta2 = beta*gamma; eta2 *= eta2;
    // density effect, only valid for high energies (gamma > 10 -> p > 1GeV for muons)
    double delta = 0.;
    if (gamma > 10.) {
      double eplasma = 28.816e-6 * sqrt(1000.*m_matProp->zOverAtimesRho());
      delta = 2.*log(eplasma/I) + log(eta2) - 1.;
    }
    // tmax - cut off energy
    double tMax = 2.*eta2*me/(1.+2.*gamma*mfrac+mfrac*mfrac);
    // divide by beta^2 for non-electrons
    kaz /= beta*beta;
    Ionization = -kaz*(log(2.*me*eta2*tMax/(I*I)) - 2.*(beta*beta) - delta);
  }
 
  double energyLoss = Ionization*dInX0*m_matProp->x0();
  double newP = sqrt(fmax(0.,(E+energyLoss)*(E+energyLoss)-m*m));
 
  newP = newP <= 0.5*m_minimumMomentum ? 0.5*m_minimumMomentum : newP;      // arbitrary regularization;
 
  (updatedPar)[Trk::qOverP] = parm.charge()/newP;
 
}

layerIndexSampleMap()

const Trk::LayerIndexSampleMap * iFatras::McMaterialEffectsUpdator::layerIndexSampleMap ( ) const

private

return the TrackingGeometry used

Definition at line 1562 of file McMaterialEffectsUpdator.cxx.

{
  // no layer index map --- retrieve it
  if (!m_layerIndexCaloSampleMap){
      // try to retrieve it from detector store
      if ((detStore()->retrieve(m_layerIndexCaloSampleMap, m_layerIndexCaloSampleMapName).isFailure())){
            ATH_MSG_WARNING( "Could not retrieve '" << m_layerIndexCaloSampleMapName << "' from DetectorStore." );
            ATH_MSG_WARNING( " -> switching recording of energy deposit off." );
      }
 
  if (m_layerIndexCaloSampleMap)
        ATH_MSG_VERBOSE( "Successfully retrieved '" << m_layerIndexCaloSampleMapName << "' with entries:"
              << m_layerIndexCaloSampleMap->size() );
  }
  return m_layerIndexCaloSampleMap;
}

msSigma()

double iFatras::McMaterialEffectsUpdator::msSigma ( double dInX0, double p, Trk::ParticleHypothesis particle ) const

private

handle the Energy loss

the private multiple scattering sigma calculation

Definition at line 1155 of file McMaterialEffectsUpdator.cxx.

                                                                                                          {
 
  double m    = Trk::ParticleMasses::mass[particle];
  double E    = sqrt(p*p+m*m);
  double beta = p/E;
 
  // PDG Particle Review, Phys.Rev.D86,010001(2012), chapter 30.3, page 328
 
  double sigmaMSproj = 13.6/beta/p*sqrt(dInX0)*(1.+0.038*log(dInX0));
 
  return sigmaMSproj;
}

multipleScatteringUpdate()

void iFatras::McMaterialEffectsUpdator::multipleScatteringUpdate ( const Trk::TrackParameters & parm, AmgVector(5) & parameters, double sigmaMSproj ) const

private

the private multiple Scattering update method, thetaMs is the projected random number

Definition at line 1168 of file McMaterialEffectsUpdator.cxx.

{
 
  // parametric scattering - independent in x/y
  if (m_parametricScattering){
    // the initial values
    double theta =  parameters[Trk::theta];
    double phi   =  parameters[Trk::phi];
    double sinTheta   = (theta*theta > 10e-10) ? sin(theta) : 1.;
 
    // sample them in an independent way
    double deltaTheta = m_projectionFactor*sigmaMSproj*CLHEP::RandGaussZiggurat::shoot(m_randomEngine);
    double deltaPhi   = m_projectionFactor*sigmaMSproj*CLHEP::RandGaussZiggurat::shoot(m_randomEngine)/sinTheta;
 
    phi += deltaPhi;
    if (phi >= M_PI) phi -= M_PI;
    else if (phi < -M_PI) phi += M_PI;
    if (theta > M_PI) theta -= M_PI;
 
    ATH_MSG_VERBOSE( "  [+] deltaPhi / deltaTheta = " << deltaPhi << " / " << deltaTheta );
 
    // assign the new values
    parameters[Trk::phi]   = phi;
    parameters[Trk::theta] = fabs(theta + deltaTheta);
 
    // for the validation
    m_thetaMStheta = deltaTheta;
    m_thetaMSphi = deltaPhi;
 
  } else {
    // scale the projected out of the plane
    double thetaMs = m_projectionFactor*sigmaMSproj*CLHEP::RandGaussZiggurat::shoot(m_randomEngine);
    double psi     = 2.*M_PI*CLHEP::RandFlat::shoot(m_randomEngine);
    // more complex but "more true" -
    CLHEP::Hep3Vector parsMomHep( pars.momentum().x(), pars.momentum().y(), pars.momentum().z() );
    CLHEP::Hep3Vector newDirectionHep( parsMomHep.unit().x(), parsMomHep.unit().y(), parsMomHep.unit().z());
    double x = -newDirectionHep.y();
    double y = newDirectionHep.x();
    double z = 0.;
    // if it runs along the z axis - no good ==> take the x axis
    if (newDirectionHep.z()*newDirectionHep.z() > 0.999999) {
      x = 1.;
      y = 0.;
    }
    // deflector direction
    CLHEP::Hep3Vector deflector(x,y,z);
    // rotate the new direction for scattering
    newDirectionHep.rotate(thetaMs, deflector);
    // and arbitrarily in psi
    newDirectionHep.rotate(psi, parsMomHep);
    // assign the new values
    parameters[Trk::phi]   = newDirectionHep.phi();
    parameters[Trk::theta] = newDirectionHep.theta();
 
    if (m_validationMode){
      m_thetaMStheta = pars.parameters()[Trk::theta] - parameters[Trk::theta];
      m_thetaMSphi = pars.parameters()[Trk::phi] - parameters[Trk::phi];
   }
  }
 
}

radiate()

void iFatras::McMaterialEffectsUpdator::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

private

Definition at line 823 of file McMaterialEffectsUpdator.cxx.

                                                                                     {
 
  // sample energy loss and free path independently
  double path = 0.;
  double p = 1./ fabs(parm[Trk::qOverP]);
 
 
  while ( path < pathLim && p>m_minimumMomentum ) {
 
    double rndx = CLHEP::RandFlat::shoot(m_randomEngine);
 
    // sample visible fraction of the mother momentum taken according to 1/f
 
    double eps = fmin(10.,m_minimumMomentum)/p;
 
    double z = pow(eps,pow(rndx,exp(1.1)));          // adjustment here ?
 
    // convert into scaling factor for mother momentum
    z = (1.- z);
 
    // turn into path
    double dx = -log(z)*0.65;     // adjust for mean of exp(-x)
 
    // resolve the case when there is not enough material left in the layer
    if ( path+dx > pathLim ) {
      double rndp = CLHEP::RandFlat::shoot(m_randomEngine);
      if (rndp > (pathLim-path)/dx){
    (parm)[Trk::qOverP] = (parm)[Trk::qOverP]>0 ? 1/p : -1/p;
        path = pathLim;
        matFraction = 1.;
    return;                   // radiation loop ended
      }
      path += dx*rndp;
      matFraction += dx*rndp/matTot;
 
    } else {
      path+=dx;
      matFraction += dx/matTot;
    }
 
    /*
    // sample free path
    double dx   = -log(rndx)/2.;               // can be adjusted here
    //double dx   = log(1./rndx)/2.;               // can be adjusted here
    // there may not be enough material to proceed - sample
    //std::cout <<"brem in layer:"<< path<<"," << dx <<","<< pathLim<< std::endl;
    if ( path+dx > pathLim ) {
      double rndp = CLHEP::RandFlat::shoot(m_randomEngine);
      if (rndp > (pathLim-path)/dx){
        (parm)[Trk::qOverP] = (parm)[Trk::qOverP]>0 ? 1/p : -1/p;
        path = pathLim;
        matFraction = 1.;
    return;            // radiation loop ended
      }
      path += dx*rndp;
      matFraction += dx*rndp/matTot;
    } else {
      path+=dx;
      matFraction += dx/matTot;
    }
 
    // radiate
    double z = exp(-dx);
    // resample according to 1/f
    //double rr = CLHEP::RandFlat::shoot(m_randomEngine);
    //if (rr*fxx > 1/z ) z=1./rr/fxx ;
 
    */
 
    // additional adjustement
    //double rndp = CLHEP::RandFlat::shoot(m_randomEngine);
    //if ( p*(1-z) > m_minimumBremPhotonMomentum && rndp>0.5 ) {
    if ( p*(1-z) > m_minimumBremPhotonMomentum ) {
 
      double deltaP = (1-z)*p;
      recordBremPhotonLay(parent,timeLim,p,deltaP, pos,dir,matFraction,pdir,particle);
      // recordEnergyDeposit(-deltaP,p,particle);
      p *=z ;
    }
 
  }
 
  (parm)[Trk::qOverP] = (parm)[Trk::qOverP] > 0 ? 1/p : -1./p;
  (parm)[Trk::theta]  = dir.theta();
  (parm)[Trk::phi]    = dir.phi();
}

recordBremPhoton()

void iFatras::McMaterialEffectsUpdator::recordBremPhoton	(	double	time,
		double	pElectron,
		double	gammaE,
		const Amg::Vector3D &	vertex,
		Amg::Vector3D &	particleDir,
		Trk::ParticleHypothesis	particle ) const

the helper function for a brem photon record

< mass

< charge

< pdg code

< time

<

Todo

fix non-static

Definition at line 1233 of file McMaterialEffectsUpdator.cxx.

{
    // get parent particle
    // @TODO: replace by Fatras internal bookkeeping
    const ISF::ISFParticle *parent = ISF::ParticleClipboard::getInstance().getParticle();
    // something is seriously wrong if there is no parent particle
    assert(parent);
 
    // statistics
    ++m_recordedBremPhotons;
    // ------------------------------------------------------
    // simple approach
    // (a) simulate theta uniform within the opening angle of the relativistic Hertz dipole
    //      theta_max = 1/gamma
    // (b)Following the Geant4 approximation from L. Urban -> encapsulate that later
    //      the azimutal angle
 
    double psi    =  2.*M_PI*CLHEP::RandFlat::shoot(m_randomEngine);
 
    // the start of the equation
    double theta = 0.;
    double m = Trk::ParticleMasses::mass[particle];
    double E = sqrt(pElectron*pElectron + m*m);
 
    if (m_uniformHertzDipoleAngle) {
       // the simplest simulation
       theta = m/E * CLHEP::RandFlat::shoot(m_randomEngine);
    } else {
      // ----->
      theta = m/E;
      // follow
      double a = 0.625; // 5/8
 
      double r1 = CLHEP::RandFlat::shoot(m_randomEngine);
      double r2 = CLHEP::RandFlat::shoot(m_randomEngine);
      double r3 = CLHEP::RandFlat::shoot(m_randomEngine);
 
      double u =  -log(r2*r3)/a;
 
      theta *= (r1 < 0.25 ) ? u : u*m_oneOverThree; // 9./(9.+27) = 0.25
    }
 
    ATH_MSG_VERBOSE( "  [ brem ] Simulated angle to electron    = " << theta << "." );
 
    /*
    // more complex but "more true"
    Amg::Vector3D newDirection(particleDir);
    double x = -newDirection.y();
    double y = newDirection.x();
    double z = 0.;
    // if it runs along the z axis - no good ==> take the x axis
    if (newDirection.z()*newDirection.z() > 0.999999)
         x = 1.;
    // deflector direction
    Amg::Vector3D deflector(x,y,z);
    // rotate the new direction for scattering
    newDirection.rotate(theta, deflector);
    // and arbitrarily in psi
    newDirection.rotate(psi,particleDir);
    */
    // resample
    //double rand = CLHEP::RandFlat::shoot(m_randomEngine);
    //double eps = 0.001;
    //theta = eps/(1.-rand*(1-eps)) - eps;
 
    double th = particleDir.theta()-theta;
    double ph = particleDir.phi();
    if ( th<0.) { th *=-1; ph += M_PI; }
    CLHEP::Hep3Vector newDirectionHep( sin(th)*cos(ph),sin(th)*sin(ph),cos(th) );
    CLHEP::Hep3Vector particleDirHep( particleDir.x(), particleDir.y(), particleDir.z() );
    newDirectionHep.rotate(psi,particleDirHep);
    Amg::Vector3D newDirection( newDirectionHep.x(), newDirectionHep.y(), newDirectionHep.z() );
 
    // recoil / save input momentum for validation
    Amg::Vector3D inEl(pElectron*particleDir);
    particleDir = (particleDir*pElectron- gammaE*newDirection).unit();
 
    //std::cout <<"brem opening angle:in:out:"<< cos(theta) <<","<<newDirection*particleDir<< std::endl;
 
    // -------> create the brem photon <--------------------
    const int status = 1 + HepMC::SIM_STATUS_THRESHOLD;
    const int id = HepMC::UNDEFINED_ID; // This will be set if the child particle is saved to the GenEvent
    ISF::ISFParticle *bremPhoton = new ISF::ISFParticle( vertex,
                                                         gammaE*newDirection,
                                                         0,   
                                                         0,   
                                                         MC::PHOTON,  
                                                         status,
                                                         time,  
                                                         *parent,
                                                         id
                                                         );
 
    // in the validation mode, add process info
    if (m_validationMode) {
      ISF::ParticleUserInformation* validInfo = new ISF::ParticleUserInformation();
      validInfo->setProcess(m_processCode);
      if (parent->getUserInformation()) validInfo->setGeneration(parent->getUserInformation()->generation()+1);
      else validInfo->setGeneration(1);     // assume parent is a primary
      bremPhoton->setUserInformation(validInfo);
    }
 
    // register TruthIncident
    ISF::ISFParticleVector children(1, bremPhoton);
    ISF::ISFTruthIncident truth( const_cast<ISF::ISFParticle&>(*parent),
                                 children,
                                 m_processCode ,
                                 parent->nextGeoID(),
                                 ISF::fPrimarySurvives );
    m_truthRecordSvc->registerTruthIncident( truth);
    // At this point we need to update the properties of the
    // ISFParticles produced in the interaction
    truth.updateParentAfterIncidentProperties();
    truth.updateChildParticleProperties();
 
    // Check that the new/updated ISFParticles have a valid TruthBinding before pushing into the particle broker
    if (!parent->getTruthBinding()) {
      ATH_MSG_ERROR("Could not retrieve TruthBinding from parent ISFParticle "<< *parent);
    }
    for (auto *childParticle : children) {
      if (!childParticle->getTruthBinding()) {
        ATH_MSG_ERROR("Could not retrieve TruthBinding from child ISFParticle "<< *childParticle);
      }
      m_particleBroker->push(childParticle, parent);
    }
 
    // save info for validation
    if (m_validationMode && m_validationTool.isEnabled()) {
      Amg::Vector3D* nMom = new Amg::Vector3D((pElectron-gammaE)*particleDir);
      m_validationTool->saveISFVertexInfo(3,vertex,*parent,inEl,nMom,children);
      delete nMom;
    }
 
 
    // if validation is turned on - go for it
    if (m_bremValidationTree){
      //
      ATH_MSG_VERBOSE( "  [ brem ] Filling bremsstrahlung validation TTree ..." );
      // spatical information
      m_bremPointX = float(vertex.x());
      m_bremPointY = float(vertex.y());
      m_bremPointR = float(vertex.perp());
      m_bremPointZ = float(vertex.z());
      // photon energyEnergy
      m_bremPhotonEnergy = float(gammaE);
      m_bremPhotonAngle  = float(theta);
      // fill the tree
      m_bremValidationTree->Fill();
   } else {
      ATH_MSG_VERBOSE( "  [ brem ] No TTree booked ! " );
   }
 
}

recordBremPhotonLay()

void iFatras::McMaterialEffectsUpdator::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

private

the helper function for a brem photon record

retrieve or provide the layerIndexSampleMap *‍/

< mass

< charge

< pdg code

< time

< @TODO fix non-static

Definition at line 1392 of file McMaterialEffectsUpdator.cxx.

{
    // statistics
    ++m_recordedBremPhotons;
    // ------------------------------------------------------
    // simple approach
    // (a) simulate theta uniform within the opening angle of the relativistic Hertz dipole
    //      theta_max = 1/gamma
    // (b)Following the Geant4 approximation from L. Urban -> encapsulate that later
    //      the azimutal angle
 
    double psi    =  2.*M_PI*CLHEP::RandFlat::shoot(m_randomEngine);
 
    // the start of the equation
    double theta = 0.;
    double m = Trk::ParticleMasses::mass[particle];
    double E = sqrt(pElectron*pElectron + m*m);
 
    if (m_uniformHertzDipoleAngle) {
       // the simplest simulation
       theta = m/E * CLHEP::RandFlat::shoot(m_randomEngine);
    } else {
      // ----->
      theta = m/E;
      // follow
      double a = 0.625; // 5/8
 
      double r1 = CLHEP::RandFlat::shoot(m_randomEngine);
      double r2 = CLHEP::RandFlat::shoot(m_randomEngine);
      double r3 = CLHEP::RandFlat::shoot(m_randomEngine);
 
      double u =  -log(r2*r3)/a;
 
      theta *= (r1 < 0.25 ) ? u : u*m_oneOverThree; // 9./(9.+27) = 0.25
    }
 
    ATH_MSG_VERBOSE( "  [ brem ] Simulated angle to electron    = " << theta << "." );
 
    // more complex but "more true"
    CLHEP::Hep3Vector particleDirHep( particleDir.x(), particleDir.y(), particleDir.z() );
    CLHEP::Hep3Vector newDirectionHep( particleDirHep );
    double x = -newDirectionHep.y();
    double y = newDirectionHep.x();
    double z = 0.;
    // if it runs along the z axis - no good ==> take the x axis
    if (newDirectionHep.z()*newDirectionHep.z() > 0.999999)
         x = 1.;
    // deflector direction
    CLHEP::Hep3Vector deflectorHep(x,y,z);
    // rotate the new direction for scattering
    newDirectionHep.rotate(theta, deflectorHep);
    // and arbitrarily in psi
    newDirectionHep.rotate(psi,particleDirHep);
 
    // recoil
    Amg::Vector3D newDirection( newDirectionHep.x(), newDirectionHep.y(), newDirectionHep.z() );
    particleDir = (particleDir*pElectron- gammaE*newDirection).unit();
 
    // -------> create the brem photon <--------------------
    const int status = 1 + HepMC::SIM_STATUS_THRESHOLD;
    const int id = HepMC::UNDEFINED_ID; // This will be set if the child particle is saved to the GenEvent
    ISF::ISFParticle *bremPhoton = new ISF::ISFParticle( vertex,
                                                         gammaE*newDirection,
                                                         0,   
                                                         0,   
                                                         MC::PHOTON,  
                                                         status,
                                                         timeLim.time,  
                                                         *parent,
                                                         id
                                                         );
 
 
    // in the validation mode, add process info
    if (m_validationMode) {
      ISF::ParticleUserInformation* validInfo = new ISF::ParticleUserInformation();
      validInfo->setProcess(m_processCode);
      if (parent->getUserInformation()) validInfo->setGeneration(parent->getUserInformation()->generation()+1);
      else validInfo->setGeneration(1);     // assume parent is a primary track
      bremPhoton->setUserInformation(validInfo);
    }
 
    // register TruthIncident
    ISF::ISFParticleVector children(1, bremPhoton);
    ISF::ISFTruthIncident truth( const_cast<ISF::ISFParticle&>(*parent),
                                 children,
                                 m_processCode ,
                                 parent->nextGeoID(),
                                 ISF::fPrimarySurvives );
    m_truthRecordSvc->registerTruthIncident( truth);
    // At this point we need to update the properties of the
    // ISFParticles produced in the interaction
    truth.updateParentAfterIncidentProperties();
    truth.updateChildParticleProperties();
 
    // Check that the new/updated ISFParticles have a valid TruthBinding
    if (!parent->getTruthBinding()) {
      ATH_MSG_ERROR("Could not retrieve TruthBinding from parent ISFParticle "<< *parent);
    }
    for (auto *childParticle : children) {
      if (!childParticle->getTruthBinding()) {
        ATH_MSG_ERROR("Could not retrieve TruthBinding from child ISFParticle "<< *childParticle);
      }
    }
 
    // save info for validation
    if (m_validationMode && m_validationTool.isEnabled()) {
      Amg::Vector3D* nMom = new Amg::Vector3D((pElectron-gammaE)*particleDir);
      m_validationTool->saveISFVertexInfo(3,vertex,*parent,pElectron*particleDir,nMom,children);
      delete nMom;
    }
 
 
    // layer update : don't push into particle stack untill destiny resolved
    Trk::PathLimit pLim = m_samplingTool->sampleProcess(m_randomEngine, bremPhoton->momentum().mag(),0.,Trk::photon);
 
    // material fraction : flip if direction of propagation changed
    double ci = m_layer->surfaceRepresentation().normal().dot(particleDir);
    double co = m_layer->surfaceRepresentation().normal().dot(newDirection);
 
    double remMat =  ci*co <0 ? (1-matFraction)    : matFraction;
 
    // decide if photon leaves the layer
    // amount of material to traverse
    double pathCorrection = m_layer->surfaceRepresentation().normal().dot(bremPhoton->momentum()) !=0 ?
      fabs(m_layer->surfaceRepresentation().pathCorrection(bremPhoton->position(),bremPhoton->momentum())) : 1.;
 
    double mTot = m_matProp->thicknessInX0()*pathCorrection*(1.-remMat);
 
    if (mTot < pLim.x0Max) {  // release
 
      m_particleBroker->push( bremPhoton, parent);
 
      //std::cout <<"brem photon:"<<bremPhoton<<" registered for extrapolation from "<< vertex << "; presampled pathLim, layer dx:"<< pLim.x0Max<<","<< mTot <<std::endl;
 
    } else {  //  interaction within the layer
      auto cparm = std::make_unique<Trk::CurvilinearParameters>(bremPhoton->position(),bremPhoton->momentum(),bremPhoton->charge());
      std::unique_ptr<Trk::TrackParameters> uPar = updateInLay(bremPhoton,cparm.get(),remMat,timeLim, pLim, dir, Trk::photon);
      if (uPar) { ATH_MSG_VERBOSE( "Check this: parameters should be dummy here (brem.photon) " <<","<<uPar->position() ); }
    }
 
    // if validation is turned on - go for it
    if (m_bremValidationTree){
      //
      ATH_MSG_VERBOSE( "  [ brem ] Filling bremsstrahlung validation TTree ..." );
      // spatical information
      m_bremPointX = float(vertex.x());
      m_bremPointY = float(vertex.y());
      m_bremPointR = float(vertex.perp());
      m_bremPointZ = float(vertex.z());
      // photon energyEnergy
      m_bremPhotonEnergy = float(gammaE);
      m_bremPhotonAngle  = float(theta);
      // fill the tree
      m_bremValidationTree->Fill();
   } else {
      ATH_MSG_VERBOSE( "  [ brem ] No TTree booked ! " );
   }
 
}

trackingGeometry()

const Trk::TrackingGeometry * iFatras::McMaterialEffectsUpdator::trackingGeometry ( const EventContext & ctx ) const

privatevirtual

Definition at line 1940 of file McMaterialEffectsUpdator.cxx.

{
  if (m_useConditions) {
    SG::ReadCondHandle<Trk::TrackingGeometry> handle(m_trackingGeometryReadKey, ctx);
    if (!handle.isValid()) {
      ATH_MSG_FATAL(
        "Could not retrieve TrackingGeometry from Conditions Store.");
      throw iFatras::McMaterialEffectsUpdatorException();
    }
    return handle.cptr();
  } else {
    const Trk::TrackingGeometry* trackingGeometry = nullptr;
    if (detStore()
          ->retrieve(trackingGeometry, m_trackingGeometryName)
          .isFailure()) {
      ATH_MSG_FATAL("Could not retrieve TrackingGeometry from DetectorStore.");
      throw iFatras::McMaterialEffectsUpdatorException();
    }
    return trackingGeometry;
  }
}

update() [1/3]

std::unique_ptr< Trk::TrackParameters > iFatras::McMaterialEffectsUpdator::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

Updator interface (full update for a layer): A unique_ptr to Trk::TrackParameters is returned it could be a clone of the input if now update has happened.

The imput is handled by the client.

Definition at line 372 of file McMaterialEffectsUpdator.cxx.

{
 
  // the call should work for particles created on the layer, too
  // + additional parameter for material scaling
 
  double traversedMatFraction = 0.;
 
  m_layer = &lay;
 
  // get parent particle
  const ISF::ISFParticle *parent = ISF::ParticleClipboard::getInstance().getParticle();
  // something is seriously wrong if there is no parent particle
  assert(parent);
 
  m_isp = parent;
 
  // get the material properties
  m_matProp =  nullptr;
 
  if (m_referenceMaterial){
    // very first go : get the Surface
    const Trk::Surface &parmSurface = parm->associatedSurface();
    // only go on if the parmSurface has an associatedDetectorElement
    if (parmSurface.associatedDetectorElement()){
      // first get the LayerMaterialProperties
      const Trk::LayerMaterialProperties* layerMaterial = m_layer->layerMaterialProperties();
      // assign the material properties
      m_matProp = layerMaterial ? layerMaterial->fullMaterial( parm->position() ) : nullptr;
    }
  }
 
 
  return updateInLay(parent,parm,traversedMatFraction,timeLim, pathLim,dir, particle);
}

update() [2/3]

std::unique_ptr< Trk::TrackParameters > iFatras::McMaterialEffectsUpdator::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

Updator interface: The parmeters are given as a reference, MaterialProperties based material update.

Definition at line 916 of file McMaterialEffectsUpdator.cxx.

{
  // no material properties - pass them back
  if (particle==Trk::geantino || (!m_ms && !m_eLoss) ) return nullptr;
 
  // get the kinematics
  double p    = parm.momentum().mag();
  double m    = Trk::ParticleMasses::mass[particle];
  double E    = sqrt(p*p+m*m);
 
  // Hadronic Interaction section ----------------------------------------------------------------------------------------------
  // ST add hadronic interaction for secondaries
  if (particle == Trk::pion && m_hadInt &&
      m_hadIntProcessor->hadronicInteraction(parm.position(),
                                             parm.momentum(),
                                             p,
                                             E,
                                             parm.charge(),
                                             matprop,
                                             pathCorrection,
                                             particle)) {
    ATH_MSG_VERBOSE("  [+] Hadronic interaction killed initial hadron ... stop "
                    "simulation, tackle childs.");
    return nullptr;
  }
 
  if (particle == Trk::neutron || particle == Trk::pi0 || particle == Trk::k0) {
    return parm.uniqueClone();
  }
 
  // the updatedParameters - first a copy
  AmgVector(5) updatedParameters(parm.parameters());
 
  double newP = p;
  if (m_eLoss){
    // get the momentum change plus the according sigma
    Trk::EnergyLoss sampledEnergyLoss( m_eLossUpdator->energyLoss(matprop, p, pathCorrection, dir, particle));
 
    double energyLoss = sampledEnergyLoss.deltaE();
    // protection against NaN
    if (E + energyLoss < m) {
      ATH_MSG_VERBOSE(
          "  [+] particle momentum fell under momentum cut - stop simulation");
      return nullptr;
    }
    // smear the mometnum change with the sigma
    newP = sqrt((E + energyLoss) * (E + energyLoss) - m * m);
 
    if (m_recordEnergyDeposition && m_currentSample > 0){
        if (m_edValidationTree){
                // fill the variables
                m_edLayerIntersectX = parm.position().x();
                m_edLayerIntersectY = parm.position().y();
                m_edLayerIntersectZ = parm.position().z();
                m_edLayerIntersectR = parm.position().perp();
                // the layer and the deposited energy
                m_edLayerSample     = m_currentSample;
                m_edLayerEnergyDeposit = -1*sampledEnergyLoss.deltaE();
                // and fill it
                m_edValidationTree->Fill();
            }
    }
 
    // the deltaP
    double deltaP = newP - p;
 
    // validation
    if (m_bremValidation && particle==Trk::electron) m_bremMotherEnergy = p;
    // record the brem
    if (particle == Trk::electron && deltaP < -1.*m_minimumBremPhotonMomentum) {
      Amg::Vector3D recoilDir = parm.momentum().unit(); // to be used for recoil
      recordBremPhoton(time,p,-deltaP,
               parm.position(),
           recoilDir,
               Trk::electron);
    }
    // bail out if the update drops below the momentum cut
    if ( newP < m_minimumMomentum) {
      ATH_MSG_VERBOSE( "  [+] particle momentum fell under momentum cut - stop simulation" );
      return nullptr;
    }
    ATH_MSG_VERBOSE( "  [+] delta(P)   =  " << deltaP );
    // continue
    // TOM - The random number generator for energy loss is now controlled by MC versions of the energy loss updator
    //double sigmaDeltaP = (p+deltaP)*deltaPsigmaQoP.second;
    (updatedParameters)[Trk::qOverP] = parm.charge()/(p+deltaP);
    // for the validation
    m_deltaP = deltaP;
  }
 
  if (m_ms && matprop.x0()>0 ){
    // get the projected scattering angle
    double sigmaMSproj   = (m_use_msUpdator && m_msUpdator) ? sqrt(m_msUpdator->sigmaSquare(matprop, p, pathCorrection, particle)) :
                                                              msSigma(pathCorrection*matprop.thicknessInX0(),p,particle);
    // do the update
    multipleScatteringUpdate(parm,updatedParameters,sigmaMSproj);
  }
 
   // validation mode ---------------------------------------------------------------
   if (m_validationMode) {
     m_tInX0           = pathCorrection * matprop.thicknessInX0();
     m_validationTree->Fill();
  }
  // -------------------------------------------------------------------------------
 
  std::optional<AmgSymMatrix(5)> errorMatrix =
    (parm.covariance()) ? std::optional<AmgSymMatrix(5)>(*parm.covariance())
                        : std::nullopt;
 
  return parm.associatedSurface()
    .createUniqueTrackParameters(updatedParameters[0],
                                 updatedParameters[1],
                                 updatedParameters[2],
                                 updatedParameters[3],
                                 updatedParameters[4],
                                 errorMatrix);
}

update() [3/3]

std::unique_ptr< Trk::TrackParameters > iFatras::McMaterialEffectsUpdator::update	(	double	time,
		const Trk::TrackParameters *	parm,
		const Trk::MaterialEffectsOnTrack &	meff,
		Trk::ParticleHypothesis	particle = Trk::pion,
		Trk::MaterialUpdateMode	matupmode = Trk::addNoise ) const

Definition at line 1042 of file McMaterialEffectsUpdator.cxx.

{
 
   if (particle != Trk::muon) {
      ATH_MSG_WARNING( "  [ ---- ] Only implemented for muons yet. No parameterisation for other particles." );
      parm->uniqueClone();
   }
 
   // the updatedParameters - first a copy
   AmgVector(5) updatedParameters(parm->parameters());
 
   // get the path correciton --- is 1. for dynamic layers
   double pathCorrection = 1.;
 
   // get the kinematics
   double p    = parm->momentum().mag();
   double m    = Trk::ParticleMasses::mass[particle];
   double E    = sqrt(p*p+m*m);
   // the updatedParameters - first a d
 
 
   // MaterialEffectsOnTrack object should contain
   // a) multiple scattering part
   // b) energy loss part for Landau simulation
 
   // (a)
   if (m_ms){
      //If the meff has scattering angles use those, otherwise use MEffUpdator
      if(!meff.scatteringAngles()){
        //Trick to keep using existing MultipleScatteringUpdator interface
        //and create a dummy materialProperties with the properties we are interested in
        Trk::MaterialProperties mprop(meff.thicknessInX0(),1.,10.e-10,10.e-10,10.e-10,10.e-10);
 
        // get the projected scattering angle
       double sigmaMSproj   = (m_use_msUpdator && m_msUpdator) ? sqrt(m_msUpdator->sigmaSquare(mprop, p, pathCorrection, particle)) :
                                                                 msSigma(pathCorrection*mprop.thicknessInX0(),p,particle);
        // do the update
        multipleScatteringUpdate(*parm,updatedParameters,sigmaMSproj);
     }
 
 
   }
 
  // (b)
  if (m_eLoss && meff.energyLoss()){
    // energy loss update
    double energyLossMPV = meff.energyLoss()->deltaE();
    double energyLossSigma = meff.energyLoss()->sigmaDeltaE();
 
    double simulatedEnergyLoss = -1.*(energyLossMPV+energyLossSigma*CLHEP::RandLandau::shoot(m_randomEngine));
 
    if (m_recordEnergyDeposition){
 
       ATH_MSG_VERBOSE( "  [+] try to record deposited energy (if mapped with a calo sample) " );
       const EventContext& ctx = Gaudi::Hive::currentContext(); // FIXME This is slow, but can't change the interface.
       const Trk::TrackingGeometry* pTrackingGeometry = trackingGeometry(ctx);
       if (pTrackingGeometry) {
         const Trk::LayerIndexSampleMap* lism     = layerIndexSampleMap();
 
        if (lism){
          // get the Volume and then get the layer
          const Trk::TrackingVolume* currentVolume = pTrackingGeometry->lowestTrackingVolume(parm->position());
          const Trk::Layer* associatedLayer = currentVolume ? currentVolume->associatedLayer(parm->position()) : nullptr;
 
           // only go on if you have found an associated Layer && the guy has an index
           if (associatedLayer && associatedLayer->layerIndex().value()){
              // now try to find it
              Trk::LayerIndexSampleMap::const_iterator layerIndexCaloSample = lism->find(associatedLayer->layerIndex());
              // layerindex could be found
              if (layerIndexCaloSample != lism->end()){
               // the validation section
               if (m_edValidationTree){
                 // fill the variables
                 const Amg::Vector3D& edeposition = parm->position();
                 m_edLayerIntersectX = edeposition.x();
                 m_edLayerIntersectY = edeposition.y();
                 m_edLayerIntersectZ = edeposition.z();
                 m_edLayerIntersectR = edeposition.perp();
                 // the layer and the deposited energy
                 m_edLayerSample     = layerIndexCaloSample->second;
                 m_edLayerEnergyDeposit = -1*simulatedEnergyLoss;
                 // and fill it
                 m_edValidationTree->Fill();
             } // end of validation section
            } // end of  calo sample found
          } // end of associatedLayer
         } // end of lism
       } // else -> trackingGeometry exists
    } // end of recordEnergyDeposition
 
    double newP = sqrt((E+simulatedEnergyLoss)*(E+simulatedEnergyLoss)-m*m);
 
    // set the new momentum
    updatedParameters[Trk::qOverP] = parm->charge()/newP;
 
  }
 
  // use the manipulator to update the track parameters -------> get ridd of 0!
  return parm->associatedSurface()
    .createUniqueTrackParameters(updatedParameters[0],
                                 updatedParameters[1],
                                 updatedParameters[2],
                                 updatedParameters[3],
                                 updatedParameters[4],
                                 std::nullopt);
}

updateInLay()

std::unique_ptr< Trk::TrackParameters > iFatras::McMaterialEffectsUpdator::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

private

Definition at line 416 of file McMaterialEffectsUpdator.cxx.

{
 
  if (!inParm)
  {
    ATH_MSG_WARNING("Trk::TrackParameters parm is null -- will not proceed. Returning nullptr.");
    return nullptr;
  }
 
  std::unique_ptr<Trk::TrackParameters> currPar = inParm->uniqueClone();
  // recalculate if missing
  m_matProp = m_matProp ? m_matProp : m_layer->fullUpdateMaterialProperties(*currPar);
  if (!m_matProp)
  {
    ATH_MSG_WARNING("Something went wrong -- m_matProp is missing but Trk::TrackParameters is not null! Returning nullptr.");
    return nullptr;
  }
  double pathCorrection =
    m_layer->surfaceRepresentation().normal().dot(currPar->momentum()) != 0
      ? std::abs(m_layer->surfaceRepresentation().pathCorrection(currPar->position(), dir * (currPar->momentum())))
      : 1.;
 
  // check if a bending correction has to be applied
  if (m_bendingCorrection) {
    ATH_MSG_WARNING("BendingCorrection not implemented!! (McMaterialEffectsUpdator.cxx)");
  }
 
  //--------------------------------------------------------------------------------------------------
  if (msgLvl(MSG::VERBOSE) && dir != Trk::PropDirection::anyDirection){
    const Trk::TrackingVolume* enclosingVolume = m_layer->enclosingTrackingVolume();
    std::string volumeName = enclosingVolume ? enclosingVolume->volumeName() : "Unknown";
    double layerR = m_layer->surfaceRepresentation().bounds().r();
    double layerZ = m_layer->surfaceRepresentation().center().z();
    ATH_MSG_VERBOSE( "  [M] Material effects update() on layer with index "<< m_layer->layerIndex() );
    ATH_MSG_VERBOSE( "                        -> path/X0 on layer [r/z] = [ " << layerR << " / " << layerZ << " ] :"
        << pathCorrection*m_matProp->thicknessInX0() );
    ATH_MSG_VERBOSE( "                        -> path correctin factor  =   " << pathCorrection );
  }
  //--------------------------------------------------------------------------------------------------
 
  // validation mode ---------------------------------------------------------------
  if (m_validationMode) {
    m_tInX0           = (1-matFraction)*pathCorrection * m_matProp->thicknessInX0();
    m_layerIndex      = m_layer->layerIndex().value();
    m_validationTree->Fill();
  }
  // -------------------------------------------------------------------------------
 
  // prepare material collection
  const Trk::MaterialProperties* extMatProp = nullptr;
  double dInL0 = 0.;
  extMatProp = dynamic_cast<const Trk::MaterialProperties*>(m_matProp);
  dInL0 = extMatProp ? (1-matFraction)*pathCorrection*extMatProp->thicknessInL0() :
    (1-matFraction)*pathCorrection*m_matProp->thicknessInX0()/0.37/m_matProp->averageZ();
 
  // figure out if particle stopped in the layer and recalculate path limit
  int iStatus = 0;
  double dX0 = (1.-matFraction)*pathCorrection*m_matProp->thicknessInX0();
 
  if (particle == Trk::geantino || particle == Trk::nonInteracting || dX0 == 0.) {
    // non-interacting - pass the input  back after checks
    pathLim.updateMat(dX0, m_matProp->averageZ(), dInL0);
    // register particle if not in the stack already
    if (isp != m_isp) {
      ISF::TruthBinding *regTruthBinding{};
      if (isp->getTruthBinding()) {
        regTruthBinding = new ISF::TruthBinding(*(isp->getTruthBinding()));
      }
      else {
        ATH_MSG_WARNING("Incomming ISParticle had no TruthBinding " << *isp);
        regTruthBinding = new ISF::TruthBinding(nullptr, nullptr, nullptr);
      }
      HepMcParticleLink *regHMPL{};
      if (isp->getParticleLink()) {
        regHMPL = new HepMcParticleLink(*(isp->getParticleLink()));
      }
      else {
        ATH_MSG_WARNING("Incomming ISParticle had no ParticleLink: " << *isp);
        regHMPL = new HepMcParticleLink(isp->id(), 0, HepMcParticleLink::IS_POSITION, HepMcParticleLink::IS_ID);
      }
      ISF::ISFParticle* regisp = new ISF::ISFParticle(isp->position(),
                                                      currPar->momentum(),
                                                      isp->mass(),
                                                      isp->charge(),
                                                      isp->pdgCode(),
                                                      HepMC::status(isp),
                                                      isp->timeStamp(),
                                                      *m_isp,
                                                      HepMC::uniqueID(isp),
                                                      HepMC::barcode(isp), // FIXME barcode-based
                                                      regTruthBinding,
                                                      regHMPL
                                                      );
      // add presampled process info
      if (isp->getUserInformation() && isp->getUserInformation()->materialLimit()) {
        const ISF::MaterialPathInfo* matLim = isp->getUserInformation()->materialLimit();
        ISF::ParticleUserInformation* validInfo = new ISF::ParticleUserInformation();
        validInfo->setMaterialLimit(
          matLim->process, matLim->dMax, matLim->process == 121 ? pathLim.l0Collected : pathLim.x0Collected);
        regisp->setUserInformation(validInfo);
      }
      // in the validation mode, add process info
      if (m_validationMode) {
        ISF::ParticleUserInformation* validInfo = regisp->getUserInformation();
        if (!validInfo) {
          validInfo = new ISF::ParticleUserInformation();
          regisp->setUserInformation(validInfo);
        }
        if (isp->getUserInformation()) {
          validInfo->setProcess(isp->getUserInformation()->process());
        } else {
          validInfo->setProcess(-2); // signal problem in the validation chain}
        }
        if (isp->getUserInformation()) {
          validInfo->setGeneration(isp->getUserInformation()->generation());
        } else {
          validInfo->setGeneration(-1); // signal problem in the validation chain}
        }
        regisp->setUserInformation(validInfo);
      }
      // Check that the returned ISFParticle has a valid TruthBinding
      // before pushing into the particle broker
      if (!regisp->getTruthBinding()) {
        ATH_MSG_ERROR("Could not retrieve TruthBinding from non-interacting ISFParticle "<< *regisp);
      }
      m_particleBroker->push(regisp, m_isp);
    }
    if (isp != m_isp) {
      delete isp;
      return nullptr;
    }
    // non-interacting - pass the input  back
    return currPar;
  } else {
    if (pathLim.x0Max > 0 && pathLim.process < 100 && pathLim.x0Collected + dX0 >= pathLim.x0Max) { // elmg. interaction
      float x0rem = pathLim.x0Max - pathLim.x0Collected;
      dInL0 *= x0rem > 0 ? x0rem / dX0 : 1.;
      if (x0rem > 0)
        dX0 = x0rem;
      iStatus = 1;
    } else if (pathLim.x0Max > 0 && extMatProp && pathLim.process > 100 &&
               pathLim.l0Collected + dInL0 >= pathLim.x0Max) { // hadronic interaction
      float l0rem = pathLim.x0Max - pathLim.l0Collected;
      dX0 *= l0rem > 0 ? l0rem / dInL0 : 1.;
      if (l0rem > 0)
        dInL0 = l0rem;
      iStatus = 2;
    }
    pathLim.updateMat(dX0, m_matProp->averageZ(), dInL0);
  }
 
  // get the kinematics
  double p    = currPar->momentum().mag();
 
  // radiation and ionization preceed the presampled interaction (if any)
  // the updatedParameters - first a deep copy
  AmgVector(5) updatedParameters(currPar->parameters());
  std::unique_ptr<Trk::TrackParameters> updated = nullptr;
 
  if (m_eLoss && particle == Trk::electron && dX0 > 0.) {
 
    double matTot = (1 - matFraction) * pathCorrection * m_matProp->thicknessInX0();
    Amg::Vector3D edir = currPar->momentum().unit();
    radiate(isp, updatedParameters, currPar->position(), edir, timeLim, dX0, matFraction, matTot, dir, particle);
    // update parent parameters:
    updated = currPar->associatedSurface().createUniqueTrackParameters(updatedParameters[0],
                                                                       updatedParameters[1],
                                                                       updatedParameters[2],
                                                                       updatedParameters[3],
                                                                       updatedParameters[4],
                                                                       std::nullopt);
 
    currPar = std::move(updated);
 
    if (currPar->momentum().mag() < m_minimumMomentum) {
      if (isp != m_isp) {
        delete isp;
      }
      return nullptr;
    }
  } else {
    matFraction += dX0 / pathCorrection / m_matProp->thicknessInX0();
  }
 
  if (isp->charge() != 0 && dX0 > 0.) {
    if (m_eLoss) {
      ionize(*currPar, updatedParameters, dX0, dir, particle);
    }
 
    if (m_ms && m_matProp->thicknessInX0() > 0.) {
      double sigmaMSproj =
        (m_use_msUpdator && m_msUpdator)
          ? sqrt(m_msUpdator->sigmaSquare(*m_matProp, p, dX0 / m_matProp->thicknessInX0(), particle))
          : msSigma(dX0, p, particle);
 
      multipleScatteringUpdate(*currPar, updatedParameters, sigmaMSproj);
    }
 
    // use the manipulator to update the track parameters -------> get rid of 0!
    updated = currPar->associatedSurface().createUniqueTrackParameters(updatedParameters[0],
                                                                       updatedParameters[1],
                                                                       updatedParameters[2],
                                                                       updatedParameters[3],
                                                                       updatedParameters[4],
                                                                       std::nullopt);
    currPar = std::move(updated);
 
    if (currPar->momentum().mag() < m_minimumMomentum) {
      if (isp != m_isp) {
        delete isp;
      }
      return nullptr;
    }
  }
 
  if (iStatus == 1 || iStatus == 2) { // interaction
    ISF::ISFParticleVector childs;
 
    if (iStatus == 1) {
      childs = interactLay(isp, timeLim.time, *currPar, particle, pathLim.process); // Registers TruthIncident internally
    } else {
      if (extMatProp) {
        childs = m_hadIntProcessor->doHadIntOnLayer(
          isp, timeLim.time, currPar->position(), currPar->momentum(), &extMatProp->material(), particle);
      } else {
        childs = m_hadIntProcessor->doHadIntOnLayer(
          isp, timeLim.time, currPar->position(), currPar->momentum(), nullptr, particle);
      }
    }
    // save info for locally created particles
    if (m_validationMode && m_validationTool.isEnabled() && !childs.empty() && isp != m_isp) {
      ATH_MSG_VERBOSE("  saving interaction info for locally produced particle " << isp->pdgCode());
      m_validationTool->saveISFParticleInfo(*isp, pathLim.process, currPar.get(), timeLim.time, pathLim.x0Max);
    }
 
    // loop over childrens and decide about their fate
 
    for (unsigned ic = 0; ic < childs.size(); ic++) {
      double mom = childs[ic]->momentum().mag();
 
      if (mom < m_minimumMomentum) {
        continue;
      }
      Trk::ParticleHypothesis pHypothesis =
        m_pdgToParticleHypothesis.convert(childs[ic]->pdgCode(), childs[ic]->charge());
      auto cparm = std::make_unique<Trk::CurvilinearParameters>(childs[ic]->position(), childs[ic]->momentum(), childs[ic]->charge());
      Trk::PathLimit pLim = m_samplingTool->sampleProcess(m_randomEngine, mom, childs[ic]->charge(), pHypothesis);
 
      // TODO sample decays and save the material collection & path limits at the exit from the layer
      // (ISFFatrasParticle ?)
 
      // material fraction : flip if direction of propagation changed
      double ci = m_layer->surfaceRepresentation().normal().dot(currPar->momentum().unit());
      double co = m_layer->surfaceRepresentation().normal().dot(childs[ic]->momentum().unit());
      double remMat = ci * co < 0 ? (1 - matFraction) : matFraction;
 
      // loop back
      std::unique_ptr<Trk::TrackParameters> uPar =
        updateInLay(childs[ic], cparm.get(), remMat, timeLim, pLim, dir, pHypothesis);
      if (uPar)
        ATH_MSG_VERBOSE("Check this: parameters should be dummy here " << isp->pdgCode() << ","
                                                                       << uPar->position());
    }
    if (!childs.empty()) { // assume that interaction processing failed if no children
      if (isp!=m_isp) { 
        delete isp;
      }
      return nullptr;
    }
  }
 
  // register particle if not in the stack already
  if (isp != m_isp) {
    ISF::TruthBinding *regTruthBinding{};
    if (isp->getTruthBinding()) {
      regTruthBinding = new ISF::TruthBinding(*(isp->getTruthBinding()));
    }
    else {
      ATH_MSG_WARNING("Incomming ISParticle had no TruthBinding " << *isp);
      regTruthBinding = new ISF::TruthBinding(nullptr, nullptr, nullptr);
    }
    HepMcParticleLink *regHMPL{};
    if (isp->getParticleLink()) {
      regHMPL = new HepMcParticleLink(*(isp->getParticleLink()));
    }
    else {
      ATH_MSG_WARNING("Incomming ISParticle had no ParticleLink: " << *isp);
      regHMPL = new HepMcParticleLink(isp->id(), 0, HepMcParticleLink::IS_POSITION, HepMcParticleLink::IS_ID);
    }
    ISF::ISFParticle* regisp = new ISF::ISFParticle(isp->position(),
                                                    currPar->momentum(),
                                                    isp->mass(),
                                                    isp->charge(),
                                                    isp->pdgCode(),
                                                    HepMC::status(isp),
                                                    isp->timeStamp(),
                                                    *m_isp,
                                                    HepMC::uniqueID(isp),
                                                    HepMC::barcode(isp), // FIXME barcode-based
                                                    regTruthBinding,
                                                    regHMPL
                                                    );
    // add presampled process info
    if (isp->getUserInformation() && isp->getUserInformation()->materialLimit()) {
      const ISF::MaterialPathInfo* matLim = isp->getUserInformation()->materialLimit();
      ISF::ParticleUserInformation* validInfo = new ISF::ParticleUserInformation();
      validInfo->setMaterialLimit(
        matLim->process, matLim->dMax, matLim->process == 121 ? pathLim.l0Collected : pathLim.x0Collected);
      regisp->setUserInformation(validInfo);
    }
    // in the validation mode, add process info
    if (m_validationMode) {
      ISF::ParticleUserInformation* validInfo = regisp->getUserInformation();
      if (!validInfo) {
        validInfo = new ISF::ParticleUserInformation();
        regisp->setUserInformation(validInfo);
      }
      if (isp->getUserInformation())
        validInfo->setProcess(isp->getUserInformation()->process());
      else
        validInfo->setProcess(-2); // signal problem in the validation chain
      if (isp->getUserInformation())
        validInfo->setGeneration(isp->getUserInformation()->generation());
      else
        validInfo->setGeneration(-1); // signal problem in the validation chain
    }
    // Check that the returned ISFParticle has a valid TruthBinding
    // before pushing into the particle broker
    if (!regisp->getTruthBinding()) {
      ATH_MSG_ERROR("Could not retrieve TruthBinding from non-interacting ISFParticle "<< *regisp);
    }
    m_particleBroker->push(regisp, m_isp);
  }
 
  if (isp!=m_isp)
  {
    delete isp;
    return nullptr;
  }
 
  return currPar;
}

Member Data Documentation

m_bendingCorrection

bool iFatras::McMaterialEffectsUpdator::m_bendingCorrection

private

Switch to use bending correction.

Definition at line 263 of file McMaterialEffectsUpdator.h.

m_bremMotherEnergy

float iFatras::McMaterialEffectsUpdator::m_bremMotherEnergy

mutableprivate

ntuple variable : brem mother energy

Definition at line 343 of file McMaterialEffectsUpdator.h.

m_bremPhotonAngle

float iFatras::McMaterialEffectsUpdator::m_bremPhotonAngle

mutableprivate

ntuple variable : brem photon angle

Definition at line 345 of file McMaterialEffectsUpdator.h.

m_bremPhotonEnergy

float iFatras::McMaterialEffectsUpdator::m_bremPhotonEnergy

mutableprivate

ntuple variable : brem photon energy

Definition at line 344 of file McMaterialEffectsUpdator.h.

m_bremPointR

float iFatras::McMaterialEffectsUpdator::m_bremPointR

mutableprivate

ntuple variable : brem point r distance

Definition at line 341 of file McMaterialEffectsUpdator.h.

m_bremPointX

float iFatras::McMaterialEffectsUpdator::m_bremPointX

mutableprivate

ntuple variable : brem point x coordinate

Definition at line 339 of file McMaterialEffectsUpdator.h.

m_bremPointY

float iFatras::McMaterialEffectsUpdator::m_bremPointY

mutableprivate

ntuple variable : brem point y coordinate

Definition at line 340 of file McMaterialEffectsUpdator.h.

m_bremPointZ

float iFatras::McMaterialEffectsUpdator::m_bremPointZ

mutableprivate

ntuple variable : brem point z coordinate

Definition at line 342 of file McMaterialEffectsUpdator.h.

m_bremValidation

bool iFatras::McMaterialEffectsUpdator::m_bremValidation

private

Definition at line 328 of file McMaterialEffectsUpdator.h.

m_bremValidationTree

TTree* iFatras::McMaterialEffectsUpdator::m_bremValidationTree

private

Root Validation Tree.

Definition at line 336 of file McMaterialEffectsUpdator.h.

m_bremValidationTreeDescription

std::string iFatras::McMaterialEffectsUpdator::m_bremValidationTreeDescription

private

validation tree description

• second argument in TTree

Definition at line 331 of file McMaterialEffectsUpdator.h.

m_bremValidationTreeFolder

std::string iFatras::McMaterialEffectsUpdator::m_bremValidationTreeFolder

private

stream/folder to for the TTree to be written out

Definition at line 333 of file McMaterialEffectsUpdator.h.

m_bremValidationTreeName

std::string iFatras::McMaterialEffectsUpdator::m_bremValidationTreeName

private

validation tree name - to be acessed by this from root

Definition at line 329 of file McMaterialEffectsUpdator.h.

m_conversionTool

ToolHandle<iFatras::IPhotonConversionTool> iFatras::McMaterialEffectsUpdator::m_conversionTool

private

IPhotonConversionTool.

Definition at line 229 of file McMaterialEffectsUpdator.h.

m_currentSample

int iFatras::McMaterialEffectsUpdator::m_currentSample

private

for the calo energy recording

the currentSample

Definition at line 275 of file McMaterialEffectsUpdator.h.

m_deltaP

float iFatras::McMaterialEffectsUpdator::m_deltaP

mutableprivate

nutple variable : energy loss

Definition at line 325 of file McMaterialEffectsUpdator.h.

m_deltaPsigma

float iFatras::McMaterialEffectsUpdator::m_deltaPsigma

mutableprivate

ntuple variable : stragling on energy loss

Definition at line 326 of file McMaterialEffectsUpdator.h.

m_edLayerEnergyDeposit

float iFatras::McMaterialEffectsUpdator::m_edLayerEnergyDeposit

mutableprivate

ntuple variable : energy despoit - value

Definition at line 369 of file McMaterialEffectsUpdator.h.

m_edLayerIntersectR

float iFatras::McMaterialEffectsUpdator::m_edLayerIntersectR

mutableprivate

ntuple variable : energy deposit r coordinate

Definition at line 367 of file McMaterialEffectsUpdator.h.

m_edLayerIntersectX

float iFatras::McMaterialEffectsUpdator::m_edLayerIntersectX

mutableprivate

ntuple variable : energy deposit x coordinate

Definition at line 361 of file McMaterialEffectsUpdator.h.

m_edLayerIntersectY

float iFatras::McMaterialEffectsUpdator::m_edLayerIntersectY

mutableprivate

ntuple variable : energy deposit y coordinate

Definition at line 363 of file McMaterialEffectsUpdator.h.

m_edLayerIntersectZ

float iFatras::McMaterialEffectsUpdator::m_edLayerIntersectZ

mutableprivate

ntuple variable : energy deposit z coordinate

Definition at line 365 of file McMaterialEffectsUpdator.h.

m_edLayerSample

float iFatras::McMaterialEffectsUpdator::m_edLayerSample

mutableprivate

ntuple variable : layer sample

Definition at line 370 of file McMaterialEffectsUpdator.h.

m_edValidation

bool iFatras::McMaterialEffectsUpdator::m_edValidation

private

Definition at line 349 of file McMaterialEffectsUpdator.h.

m_edValidationTree

TTree* iFatras::McMaterialEffectsUpdator::m_edValidationTree

private

Root Validation Tree.

Definition at line 357 of file McMaterialEffectsUpdator.h.

m_edValidationTreeDescription

std::string iFatras::McMaterialEffectsUpdator::m_edValidationTreeDescription

private

validation tree description - second argument in TTree

Definition at line 352 of file McMaterialEffectsUpdator.h.

m_edValidationTreeFolder

std::string iFatras::McMaterialEffectsUpdator::m_edValidationTreeFolder

private

stream/folder to for the TTree to be written out

Definition at line 354 of file McMaterialEffectsUpdator.h.

m_edValidationTreeName

std::string iFatras::McMaterialEffectsUpdator::m_edValidationTreeName

private

validation tree name - to be acessed by this from root

Definition at line 350 of file McMaterialEffectsUpdator.h.

m_eLoss

bool iFatras::McMaterialEffectsUpdator::m_eLoss

private

IEnergyLossUpdator.

Definition at line 221 of file McMaterialEffectsUpdator.h.

m_eLossUpdator

ToolHandle<Trk::IEnergyLossUpdator> iFatras::McMaterialEffectsUpdator::m_eLossUpdator

private

Definition at line 222 of file McMaterialEffectsUpdator.h.

m_hadInt

bool iFatras::McMaterialEffectsUpdator::m_hadInt

private

hadronic interaction setting

Definition at line 238 of file McMaterialEffectsUpdator.h.

m_hadIntProcessor

ToolHandle<IHadronicInteractionProcessor> iFatras::McMaterialEffectsUpdator::m_hadIntProcessor

private

Definition at line 239 of file McMaterialEffectsUpdator.h.

m_isp

const ISF::ISFParticle* iFatras::McMaterialEffectsUpdator::m_isp

mutableprivate

cache incoming particle

Definition at line 379 of file McMaterialEffectsUpdator.h.

m_layer

const Trk::Layer* iFatras::McMaterialEffectsUpdator::m_layer

mutableprivate

cache layer properties

Definition at line 382 of file McMaterialEffectsUpdator.h.

m_layerIndex

int iFatras::McMaterialEffectsUpdator::m_layerIndex

mutableprivate

ntuple variable : layer index of material effects update

Definition at line 320 of file McMaterialEffectsUpdator.h.

m_layerIndexCaloSampleMap

const Trk::LayerIndexSampleMap* iFatras::McMaterialEffectsUpdator::m_layerIndexCaloSampleMap

mutableprivate

the map for the calo-layer index map

Definition at line 279 of file McMaterialEffectsUpdator.h.

m_layerIndexCaloSampleMapName

std::string iFatras::McMaterialEffectsUpdator::m_layerIndexCaloSampleMapName

private

name to record it

Definition at line 277 of file McMaterialEffectsUpdator.h.

m_matProp

const Trk::MaterialProperties* iFatras::McMaterialEffectsUpdator::m_matProp

mutableprivate

Definition at line 383 of file McMaterialEffectsUpdator.h.

m_minimumBremPhotonMomentum

double iFatras::McMaterialEffectsUpdator::m_minimumBremPhotonMomentum

private

Minimum momentum for brem photons.

Definition at line 248 of file McMaterialEffectsUpdator.h.

m_minimumMomentum

double iFatras::McMaterialEffectsUpdator::m_minimumMomentum

private

Minimum momentum cut.

Definition at line 245 of file McMaterialEffectsUpdator.h.

m_ms

bool iFatras::McMaterialEffectsUpdator::m_ms

private

IMultipleScatteringUpdator.

Definition at line 225 of file McMaterialEffectsUpdator.h.

m_msUpdator

ToolHandle<Trk::IMultipleScatteringUpdator> iFatras::McMaterialEffectsUpdator::m_msUpdator

private

Definition at line 226 of file McMaterialEffectsUpdator.h.

m_oneOverThree

double iFatras::McMaterialEffectsUpdator::m_oneOverThree

private

useful for the angle calculation of the brem photon

Definition at line 373 of file McMaterialEffectsUpdator.h.

m_parametricScattering

bool iFatras::McMaterialEffectsUpdator::m_parametricScattering

private

describe deflection parametric/do real deflection

Definition at line 251 of file McMaterialEffectsUpdator.h.

m_particleBroker

ServiceHandle<ISF::IParticleBroker> iFatras::McMaterialEffectsUpdator::m_particleBroker

private

Definition at line 375 of file McMaterialEffectsUpdator.h.

m_particleDecayer

ToolHandle<IParticleDecayHelper> iFatras::McMaterialEffectsUpdator::m_particleDecayer

private

Particle Decay.

Definition at line 242 of file McMaterialEffectsUpdator.h.

m_pdgToParticleHypothesis

Trk::PdgToParticleHypothesis iFatras::McMaterialEffectsUpdator::m_pdgToParticleHypothesis

private

Definition at line 384 of file McMaterialEffectsUpdator.h.

m_processCode

int iFatras::McMaterialEffectsUpdator::m_processCode

private

MCTruth process code for TruthIncidents created by this tool.

Definition at line 232 of file McMaterialEffectsUpdator.h.

m_projectionFactor

double iFatras::McMaterialEffectsUpdator::m_projectionFactor

private

projection factor for the non-parametric scattering

Definition at line 302 of file McMaterialEffectsUpdator.h.

m_randomEngine

CLHEP::HepRandomEngine* iFatras::McMaterialEffectsUpdator::m_randomEngine

private

Random engine.

Definition at line 268 of file McMaterialEffectsUpdator.h.

m_randomEngineName

std::string iFatras::McMaterialEffectsUpdator::m_randomEngineName

private

Name of the random number stream.

Definition at line 269 of file McMaterialEffectsUpdator.h.

m_recordedBremPhotons

std::atomic<unsigned int> iFatras::McMaterialEffectsUpdator::m_recordedBremPhotons

mutableprivate

for statistics output

Definition at line 272 of file McMaterialEffectsUpdator.h.

m_recordEnergyDeposition

bool iFatras::McMaterialEffectsUpdator::m_recordEnergyDeposition

private

for deposition methods

Definition at line 276 of file McMaterialEffectsUpdator.h.

m_referenceMaterial

bool iFatras::McMaterialEffectsUpdator::m_referenceMaterial

private

Switch to use reference material.

Definition at line 260 of file McMaterialEffectsUpdator.h.

m_rndGenSvc

ServiceHandle<IAtRndmGenSvc> iFatras::McMaterialEffectsUpdator::m_rndGenSvc

private

Random Generator service.

Definition at line 266 of file McMaterialEffectsUpdator.h.

m_samplingTool

ToolHandle<iFatras::IProcessSamplingTool> iFatras::McMaterialEffectsUpdator::m_samplingTool

private

MCTruth process sampling.

Definition at line 235 of file McMaterialEffectsUpdator.h.

m_thetaMSphi

float iFatras::McMaterialEffectsUpdator::m_thetaMSphi

mutableprivate

ntuple variable : ms in phi

Definition at line 323 of file McMaterialEffectsUpdator.h.

m_thetaMSproj

float iFatras::McMaterialEffectsUpdator::m_thetaMSproj

mutableprivate

ntuple variable : projected ms

Definition at line 322 of file McMaterialEffectsUpdator.h.

m_thetaMStheta

float iFatras::McMaterialEffectsUpdator::m_thetaMStheta

mutableprivate

ntuple variable : ms in theta

Definition at line 324 of file McMaterialEffectsUpdator.h.

m_tInX0

float iFatras::McMaterialEffectsUpdator::m_tInX0

mutableprivate

nutple variable : t/X0

Definition at line 321 of file McMaterialEffectsUpdator.h.

m_trackingGeometryName

std::string iFatras::McMaterialEffectsUpdator::m_trackingGeometryName { "ISF_FatrasTrackingGeometry" }

private

Name of the TrackingGeometry as given in Detector Store.

Definition at line 298 of file McMaterialEffectsUpdator.h.

{ "ISF_FatrasTrackingGeometry" };

m_trackingGeometryReadKey

SG::ReadCondHandleKey<Trk::TrackingGeometry> iFatras::McMaterialEffectsUpdator::m_trackingGeometryReadKey

private

Initial value:

{
    this,
    "TrackingGeometryReadKey",
    "ISF_FatrasTrackingGeometry",
    "Key of input TrackingGeometry"
  }

Definition at line 283 of file McMaterialEffectsUpdator.h.

                                                                    {
    this,
    "TrackingGeometryReadKey",
    "ISF_FatrasTrackingGeometry",
    "Key of input TrackingGeometry"
  };

m_trackingGeometrySvc

ServiceHandle<Trk::ITrackingGeometrySvc> iFatras::McMaterialEffectsUpdator::m_trackingGeometrySvc

private

Initial value:

{
    this,
    "TrackingGeometrySvc",
    "",
    ""
  }

ToolHandle to the TrackingGeometrySvc.

Definition at line 291 of file McMaterialEffectsUpdator.h.

                                                              {
    this,
    "TrackingGeometrySvc",
    "",
    ""
  };

m_truthRecordSvc

ServiceHandle<ISF::ITruthSvc> iFatras::McMaterialEffectsUpdator::m_truthRecordSvc

private

Definition at line 376 of file McMaterialEffectsUpdator.h.

m_uniformHertzDipoleAngle

bool iFatras::McMaterialEffectsUpdator::m_uniformHertzDipoleAngle

private

use the relativistic hertz dipole for brem photon radiation

Definition at line 257 of file McMaterialEffectsUpdator.h.

m_use_msUpdator

bool iFatras::McMaterialEffectsUpdator::m_use_msUpdator

private

switch between MSUpdator and local parametrization

Definition at line 254 of file McMaterialEffectsUpdator.h.

m_useConditions

bool iFatras::McMaterialEffectsUpdator::m_useConditions {}

private

Definition at line 282 of file McMaterialEffectsUpdator.h.

{};

m_validationMode

bool iFatras::McMaterialEffectsUpdator::m_validationMode

private

Definition at line 307 of file McMaterialEffectsUpdator.h.

m_validationTool

ToolHandle<IPhysicsValidationTool> iFatras::McMaterialEffectsUpdator::m_validationTool

private

Definition at line 308 of file McMaterialEffectsUpdator.h.

m_validationTree

TTree* iFatras::McMaterialEffectsUpdator::m_validationTree

private

Root Validation Tree.

Definition at line 316 of file McMaterialEffectsUpdator.h.

m_validationTreeDescription

std::string iFatras::McMaterialEffectsUpdator::m_validationTreeDescription

private

validation tree description - second argument in TTree

Definition at line 311 of file McMaterialEffectsUpdator.h.

m_validationTreeFolder

std::string iFatras::McMaterialEffectsUpdator::m_validationTreeFolder

private

stream/folder to for the TTree to be written out

Definition at line 313 of file McMaterialEffectsUpdator.h.

m_validationTreeName

std::string iFatras::McMaterialEffectsUpdator::m_validationTreeName

private

validation tree name - to be acessed by this from root

Definition at line 309 of file McMaterialEffectsUpdator.h.

---

The documentation for this class was generated from the following files:

• McMaterialEffectsUpdator.h
• McMaterialEffectsUpdator.cxx