#include <MaterialEffectsUpdator.h>

Inheritance diagram for Trk::MaterialEffectsUpdator:

Collaboration diagram for Trk::MaterialEffectsUpdator:

Public Types
typedef IMaterialEffectsUpdator::ICache	ICache

Public Member Functions
	MaterialEffectsUpdator (const std::string &, const std::string &, const IInterface *)
	AlgTool like constructor. More...

virtual	~MaterialEffectsUpdator ()
	Virtual destructor. More...

virtual StatusCode	initialize () override
	AlgTool initailize method. More...

virtual std::unique_ptr< TrackParameters >	update (ICache &cache, const TrackParameters *parm, const Layer &sf, PropDirection dir=alongMomentum, ParticleHypothesis particle=pion, MaterialUpdateMode matupmode=addNoise) const override
	Updator interface (full update for a layer) —> ALWAYS pointer to new TrackParameters is returned. More...

virtual std::unique_ptr< TrackParameters >	update (ICache &cache, const TrackParameters *parm, const MaterialEffectsOnTrack &meff, Trk::ParticleHypothesis particle=pion, MaterialUpdateMode matupmode=addNoise) const override
	Updator interface (full update for a layer) according to user input through MaterialEffectsOnTrack —> ALWAYS pointer to new TrackParameters is returned. More...

virtual std::unique_ptr< TrackParameters >	preUpdate (ICache &cache, const TrackParameters *parm, const Layer &sf, PropDirection dir=alongMomentum, ParticleHypothesis particle=pion, MaterialUpdateMode matupmode=addNoise) const override
	Updator interface (pre-update for a layer): —> ALWAYS pointer to new TrackParameters is returned. More...

virtual std::unique_ptr< TrackParameters >	postUpdate (ICache &cache, const TrackParameters &parm, const Layer &sf, PropDirection dir=alongMomentum, ParticleHypothesis particle=pion, MaterialUpdateMode matupmode=addNoise) const override final
	Updator interface (post-update for a layer): —> ALWAYS pointer to new TrackParameters is returned if no postUpdate is to be done : return nullptr. More...

virtual std::unique_ptr< TrackParameters >	update (ICache &cache, const TrackParameters &parm, const MaterialProperties &mprop, double pathcorrection, PropDirection dir=alongMomentum, ParticleHypothesis particle=pion, MaterialUpdateMode matupmode=addNoise) const override final
	Dedicated Updator interface:-> create new track parameters. More...

virtual void	validationAction (ICache &cache) const override final
	Validation Action - calls the writing and resetting of the TTree variables. More...

virtual void	modelAction (ICache &cache, const TrackParameters *parm=nullptr) const override final
	Only has an effect if m_landauMode == true. More...

virtual std::unique_ptr< TrackParameters >	update (const TrackParameters *parm, const Layer &sf, PropDirection dir=alongMomentum, ParticleHypothesis particle=pion, MaterialUpdateMode matupmode=addNoise) const override final
	Updator interface (full update for a layer): More...

virtual std::unique_ptr< TrackParameters >	update (const TrackParameters *parm, const MaterialEffectsOnTrack &meff, Trk::ParticleHypothesis particle=pion, MaterialUpdateMode matupmode=addNoise) const override final
	User updator interface (full update for a layer): More...

virtual std::unique_ptr< TrackParameters >	preUpdate (const TrackParameters *parm, const Layer &sf, PropDirection dir=alongMomentum, ParticleHypothesis particle=pion, MaterialUpdateMode matupmode=addNoise) const override final
	Updator interface (pre-update for a layer): More...

virtual std::unique_ptr< TrackParameters >	postUpdate (const TrackParameters &parm, const Layer &sf, PropDirection dir=alongMomentum, ParticleHypothesis particle=pion, MaterialUpdateMode matupmode=addNoise) const override final
	Updator interface (pre-update for a layer): More...

virtual std::unique_ptr< TrackParameters >	update (const TrackParameters &parm, const MaterialProperties &mprop, double pathcorrection, PropDirection dir=alongMomentum, ParticleHypothesis particle=pion, MaterialUpdateMode matupmode=addNoise) const override final
	Updator interface: MaterialProperties based material update. More...

virtual void	validationAction () const override final
	Validation Action: outside access to internal validation steps Optional. More...

virtual void	modelAction (const TrackParameters *parm=nullptr) const override final
	Model Action: Provides the possibility of doing non-local MaterialEffectsUpdates for different models Optional. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

virtual ICache	getCache () const
	Creates an instance of the cache to be used. More...

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	AlgTool and IAlgTool interface methods. More...

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)

void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
std::unique_ptr< TrackParameters >	updateImpl (ICache &cache, const TrackParameters *parm, const Layer &sf, PropDirection dir=alongMomentum, ParticleHypothesis particle=pion, MaterialUpdateMode matupmode=addNoise) const

std::unique_ptr< TrackParameters >	updateImpl (ICache &cache, const TrackParameters *parm, const MaterialEffectsOnTrack &meff, Trk::ParticleHypothesis particle=pion, MaterialUpdateMode matupmode=addNoise) const

std::unique_ptr< TrackParameters >	preUpdateImpl (ICache &cache, const TrackParameters *parm, const Layer &sf, PropDirection dir=alongMomentum, ParticleHypothesis particle=pion, MaterialUpdateMode matupmode=addNoise) const

std::unique_ptr< TrackParameters >	postUpdateImpl (ICache &cache, const TrackParameters &parm, const Layer &sf, PropDirection dir=alongMomentum, ParticleHypothesis particle=pion, MaterialUpdateMode matupmode=addNoise) const

std::unique_ptr< TrackParameters >	updateImpl (ICache &cache, const TrackParameters *parm, const MaterialProperties &mprop, double pathcorrection, PropDirection dir=alongMomentum, ParticleHypothesis particle=pion, MaterialUpdateMode matupmode=addNoise) const

std::unique_ptr< TrackParameters >	updateImpl (ICache &cache, const TrackParameters &parm, const MaterialProperties &mprop, double pathcorrection, PropDirection dir=alongMomentum, ParticleHypothesis particle=pion, MaterialUpdateMode matupmode=addNoise) const

bool	checkCovariance (AmgSymMatrix(5) &updated) const
	A simple check method for the 'removeNoise' update model. More...

TrackParameters *	finalLandauCovarianceUpdate (const TrackParameters *parm) const

ICache &	getTLSCache () const

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Static Private Member Functions
static void	validationActionImpl (ICache &cache)

static void	modelActionImpl (ICache &cache, const TrackParameters *parm=nullptr)

Private Attributes
bool	m_doCompoundLayerCheck
	turn on/off the necessary checks when we may have compound layers More...

bool	m_doEloss
	steer energy loss On/Off from outside More...

bool	m_doMs
	steer multiple scattering On/Off from outside More...

bool	m_forceMomentum
	Force the momentum to be a specific value. More...

bool	m_xKalmanStraggling
	the momentum Error as calculated in xKalman More...

bool	m_useMostProbableEloss
	use the most probable energy loss More...

bool	m_msgOutputValidationDirection
	validation direction used for screen output More...

bool	m_msgOutputCorrections
	screen output of actual corrections More...

bool	m_validationMode
	Switch for validation mode. More...

bool	m_validationIgnoreUnmeasured
	Ignore unmeasured TrackParameters (Navigation!) More...

bool	m_landauMode
	If in Landau mode, error propagation is done as for landaus. More...

int	m_validationDirection
	validation direction More...

double	m_momentumCut
	Minimal momentum cut for update. More...

double	m_momentumMax
	Maximal momentum cut for update. More...

double	m_forcedMomentum
	Forced momentum value. More...

ToolHandle< IEnergyLossUpdator >	m_eLossUpdator
	AlgoTool for EnergyLoss updates. More...

ToolHandle< IMultipleScatteringUpdator >	m_msUpdator
	AlgoTool for MultipleScatterin effects. More...

ToolHandle< IMaterialMapper >	m_materialMapper
	the material mapper for recording the layer material More...

boost::thread_specific_ptr< ICache >	m_cache_tls

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

Point-like (also called surface-based) update of TrackParameters and the associated covariance

Pre/Post/update notation.

Given a sensitive detector element, it can be (e.g silicon sensors) that most of the material corresponds to the sensor itself or is located behind it.

In this case the material effects would be post-update with respect to the measurement update on the given surface, e.g in a Kalman filter procedure. The same material would have to be taken into account before, pre-update, the measurement update in the smoothing/ backward filtering kalman filtering process.

Pre/Post update make sense in these specific contexts. For a uniform detector or non-sensitive material a full update is applied.

Author: Andre.nosp@m.as.S.nosp@m.alzbu.nosp@m.rger.nosp@m.@cern.nosp@m..ch; AthenaMT modifications Christos Anastopoulos

Definition at line 69 of file MaterialEffectsUpdator.h.

Member Typedef Documentation

◆ ICache

typedef IMaterialEffectsUpdator::ICache Trk::MaterialEffectsUpdator::ICache

Definition at line 89 of file MaterialEffectsUpdator.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ MaterialEffectsUpdator()

Trk::MaterialEffectsUpdator::MaterialEffectsUpdator	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

AlgTool like constructor.

Definition at line 39 of file MaterialEffectsUpdator.cxx.

   : AthAlgTool(t, n, p)
   ,
   //  TrkParametersManipulator(),
   m_doCompoundLayerCheck(false)
   , m_doEloss(true)
   , m_doMs(true)
   , m_forceMomentum(false)
   , m_xKalmanStraggling(false)
   , m_useMostProbableEloss(false)
   , m_msgOutputValidationDirection(true)
   , m_msgOutputCorrections(false)
   , m_validationMode(false)
   , m_validationIgnoreUnmeasured(true)
   , m_landauMode(false)
   , m_validationDirection(1)
   , m_momentumCut(50. * Gaudi::Units::MeV)
   , m_momentumMax(10. * Gaudi::Units::TeV)
   , m_forcedMomentum(2000. * Gaudi::Units::MeV)
   , m_eLossUpdator("Trk::EnergyLossUpdator/AtlasEnergyLossUpdator")
   , m_msUpdator("Trk::MultipleScatteringUpdator/AtlasMultipleScatteringUpdator")
   , m_materialMapper("Trk::MaterialMapper/AtlasMaterialMapper")
 {
   declareInterface<IMaterialEffectsUpdator>(this);
   // configuration (to be changed to new genconf style)
   declareProperty("CheckForCompoundLayers", m_doCompoundLayerCheck);
   declareProperty("EnergyLoss", m_doEloss);
   declareProperty("EnergyLossUpdator", m_eLossUpdator);
   declareProperty("MultipleScattering", m_doMs);
   declareProperty("MultipleScatteringUpdator", m_msUpdator);
   // the momentum cut for particle interactions
   declareProperty("MinimalMomentum", m_momentumCut);
   declareProperty("MaximalMomentum", m_momentumMax);
   declareProperty("ForceMomentum", m_forceMomentum);
   declareProperty("ForcedMomentumValue", m_forcedMomentum);
   declareProperty("MostProbableEnergyLoss", m_useMostProbableEloss);
   declareProperty("ScreenOutputValidationDirection", m_msgOutputValidationDirection);
   declareProperty("ScreenOutputCorrections", m_msgOutputCorrections);
   // run vaidation mode true/false
   declareProperty("ValidationMode", m_validationMode);
   declareProperty("ValidationIgnoreUnmeasured", m_validationIgnoreUnmeasured);
   declareProperty("ValidationDirection", m_validationDirection);
   declareProperty("ValidationMaterialMapper", m_materialMapper);
   declareProperty("LandauMode", m_landauMode);
 }

◆ ~MaterialEffectsUpdator()

Trk::MaterialEffectsUpdator::~MaterialEffectsUpdator ( )

virtualdefault

Virtual destructor.

Member Function Documentation

◆ checkCovariance()

bool Trk::MaterialEffectsUpdator::checkCovariance ( AmgSymMatrix(5) & updated ) const

private

A simple check method for the 'removeNoise' update model.

Definition at line 819 of file MaterialEffectsUpdator.cxx.

 {
   if (updated(Trk::phi, Trk::phi) > 0. && updated(Trk::theta, Trk::theta) > 0. &&
       updated(Trk::qOverP, Trk::qOverP) > 0.) {
     return true;
   }
  
   // given an update
   ATH_MSG_DEBUG("  [-] update material with 'removeNoise' results in negative covariance entries. Skipping update.");
   return false;
 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyArrayType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
   }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                  {
     typedef typename SG::HandleClassifier<T>::type htype;
     return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
   }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ finalLandauCovarianceUpdate()

TrackParameters* Trk::MaterialEffectsUpdator::finalLandauCovarianceUpdate ( const TrackParameters * parm ) const

private

◆ getCache()

virtual ICache Trk::IMaterialEffectsUpdator::getCache ( ) const

inlinevirtualinherited

Creates an instance of the cache to be used.

by the client.

Definition at line 87 of file IMaterialEffectsUpdator.h.

87 { return {}; }

◆ getTLSCache()

ICache& Trk::MaterialEffectsUpdator::getTLSCache ( ) const

inlineprivate

Definition at line 347 of file MaterialEffectsUpdator.h.

   {
     ICache* cache = m_cache_tls.get();
     if (!cache) {
       cache = new ICache();
       m_cache_tls.reset(cache);
     }
     return *cache;
   }

◆ initialize()

StatusCode Trk::MaterialEffectsUpdator::initialize ( )

overridevirtual

AlgTool initailize method.

Definition at line 91 of file MaterialEffectsUpdator.cxx.

 {
  
   ATH_MSG_DEBUG("Minimal momentum cut for material update : " << m_momentumCut << " MeV");
  
   // retrieve the EnergyLoss Updator and Material Effects updator
   if (m_doEloss) {
     if (m_eLossUpdator.retrieve().isFailure()) {
       ATH_MSG_FATAL("Failed to retrieve tool " << m_eLossUpdator
                                                << ". No multiple scattering effects will be taken into account.");
       m_doEloss = false;
       return StatusCode::FAILURE;
     }
     ATH_MSG_DEBUG("Retrieved tool " << m_eLossUpdator);
  
   } else {
     m_eLossUpdator.disable();
   }
  
   if (m_doMs) {
     if (m_msUpdator.retrieve().isFailure()) {
       ATH_MSG_FATAL("Failed to retrieve tool " << m_msUpdator
                                                << ". No energy loss effects will be taken into account.");
       m_doMs = false;
       return StatusCode::FAILURE;
     }
     ATH_MSG_DEBUG("Retrieved tool " << m_msUpdator);
  
   } else {
     m_msUpdator.disable();
   }
  
   // retrieve the material mapper for the validation mode
   if (m_validationMode) {
     if (m_materialMapper.retrieve().isFailure()) {
       ATH_MSG_FATAL("Failed to retrieve tool " << m_materialMapper << ". No material recording.");
       return StatusCode::FAILURE;
     }
     ATH_MSG_DEBUG("Retrieved tool " << m_materialMapper);
  
   } else {
     m_materialMapper.disable();
   }
  
   return StatusCode::SUCCESS;
 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ interfaceID()

static const InterfaceID& Trk::IMaterialEffectsUpdator::interfaceID ( )

inlinestaticinherited

AlgTool and IAlgTool interface methods.

Definition at line 52 of file IMaterialEffectsUpdator.h.

   {
     return IID_IMaterialEffectsUpdator;
   }

◆ modelAction() [1/2]

virtual void Trk::MaterialEffectsUpdator::modelAction ( const TrackParameters * param = nullptr ) const

inlinefinaloverridevirtual

Model Action: Provides the possibility of doing non-local MaterialEffectsUpdates for different models Optional.

Implements Trk::IMaterialEffectsUpdator.

Definition at line 243 of file MaterialEffectsUpdator.h.

   {
     ICache& cache = getTLSCache();
     modelActionImpl(cache, parm);
   }

◆ modelAction() [2/2]

virtual void Trk::MaterialEffectsUpdator::modelAction	(	ICache &	cache,
		const TrackParameters *	parm = `nullptr`
	)		const

inlinefinaloverridevirtual

Only has an effect if m_landauMode == true.

Resets mutable variables used for non-local calculation of energy loss if parm == 0. Otherwise, modifies parm with the final update of the covariance matrix

Implements Trk::IMaterialEffectsUpdator.

Definition at line 170 of file MaterialEffectsUpdator.h.

   {
     modelActionImpl(cache, parm);
   }

◆ modelActionImpl()

void Trk::MaterialEffectsUpdator::modelActionImpl	(	ICache &	cache,
		const TrackParameters *	parm = `nullptr`
	)

staticprivate

Definition at line 814 of file MaterialEffectsUpdator.cxx.

 {
   cache.accumulatedElossSigma = 0;
 }

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ postUpdate() [1/2]

virtual std::unique_ptr<TrackParameters> Trk::MaterialEffectsUpdator::postUpdate	(	const TrackParameters &	param,
		const Layer &	sf,
		PropDirection	dir = `alongMomentum`,
		ParticleHypothesis	particle = `pion`,
		MaterialUpdateMode	matupmode = `addNoise`
	)		const

inlinefinaloverridevirtual

Updator interface (pre-update for a layer):

Implements Trk::IMaterialEffectsUpdator.

Definition at line 213 of file MaterialEffectsUpdator.h.

   {
     ICache& cache = getTLSCache();
     return postUpdateImpl(cache, parm, sf, dir, particle, matupmode);
   }

◆ postUpdate() [2/2]

virtual std::unique_ptr<TrackParameters> Trk::MaterialEffectsUpdator::postUpdate	(	ICache &	cache,
		const TrackParameters &	parm,
		const Layer &	sf,
		PropDirection	dir = `alongMomentum`,
		ParticleHypothesis	particle = `pion`,
		MaterialUpdateMode	matupmode = `addNoise`
	)		const

inlinefinaloverridevirtual

Updator interface (post-update for a layer): —> ALWAYS pointer to new TrackParameters is returned if no postUpdate is to be done : return nullptr.

Implements Trk::IMaterialEffectsUpdator.

Definition at line 135 of file MaterialEffectsUpdator.h.

   {
     return postUpdateImpl(cache, parm, sf, dir, particle, matupmode);
   }

◆ postUpdateImpl()

std::unique_ptr< Trk::TrackParameters > Trk::MaterialEffectsUpdator::postUpdateImpl	(	ICache &	cache,
		const TrackParameters &	parm,
		const Layer &	sf,
		PropDirection	dir = `alongMomentum`,
		ParticleHypothesis	particle = `pion`,
		MaterialUpdateMode	matupmode = `addNoise`
	)		const

private

Definition at line 408 of file MaterialEffectsUpdator.cxx.

         {
   // no material properties - pass the parameters back
   if (particle == Trk::geantino || particle == Trk::nonInteractingMuon || (!m_doMs && !m_doEloss) ||
       !lay.isOnLayer(parm.position())) {
     return parm.uniqueClone();
   }
  
   // get the quantities
   const Trk::MaterialProperties* mprop = nullptr;
   double postFactor = lay.postUpdateMaterialFactor(parm, dir);
  
   // no material properties - pass them back
   if (postFactor < 0.01) {
     return parm.uniqueClone();
   }
  
   // set the output if restricted to the validation direction
   bool outputFlag = m_msgOutputValidationDirection ? dir == int(m_validationDirection) : true;
  
   mprop = lay.fullUpdateMaterialProperties(parm);
   double pathCorrection = std::abs(lay.surfaceRepresentation().pathCorrection(parm.position(), parm.momentum()));
   pathCorrection *= postFactor;
  
   // exit if no material properties
   if (!mprop) {
     return parm.uniqueClone();
   }
  
   // --------------------------------------------------------------------------------------------------
   if (outputFlag) {
     double layerR = lay.surfaceRepresentation().bounds().r();
     double layerZ = lay.surfaceRepresentation().center().z();
     double eta = parm.momentum().eta();
     double sX0 = mprop->thicknessInX0();
     double tX0 = pathCorrection * mprop->thicknessInX0();
     ATH_MSG_VERBOSE("  [M] post material update,  layer with [r,z] = [ " << layerR << ", " << layerZ << " ] - Index "
                                                                          << lay.layerIndex());
     ATH_MSG_VERBOSE("      thickness/X0 , path/X0  (eta: g.factor) = " << sX0 << " , " << tX0 << " (" << eta << ": "
                                                                        << pathCorrection << ")");
   }
   // --------------------------------------------------------------------------------------------------
   if (m_validationMode) {
     cache.validationLayer = &lay;
   }
   return updateImpl(cache, parm, *mprop, pathCorrection, dir, particle, matupmode);
 }

◆ preUpdate() [1/2]

virtual std::unique_ptr<TrackParameters> Trk::MaterialEffectsUpdator::preUpdate	(	const TrackParameters *	param,
		const Layer &	sf,
		PropDirection	dir = `alongMomentum`,
		ParticleHypothesis	particle = `pion`,
		MaterialUpdateMode	matupmode = `addNoise`
	)		const

inlinefinaloverridevirtual

Updator interface (pre-update for a layer):

Implements Trk::IMaterialEffectsUpdator.

Definition at line 202 of file MaterialEffectsUpdator.h.

   {
     ICache& cache = getTLSCache();
     return preUpdateImpl(cache, parm, sf, dir, particle, matupmode);
   }

◆ preUpdate() [2/2]

virtual std::unique_ptr<TrackParameters> Trk::MaterialEffectsUpdator::preUpdate	(	ICache &	cache,
		const TrackParameters *	parm,
		const Layer &	sf,
		PropDirection	dir = `alongMomentum`,
		ParticleHypothesis	particle = `pion`,
		MaterialUpdateMode	matupmode = `addNoise`
	)		const

inlineoverridevirtual

Updator interface (pre-update for a layer): —> ALWAYS pointer to new TrackParameters is returned.

Implements Trk::IMaterialEffectsUpdator.

Definition at line 120 of file MaterialEffectsUpdator.h.

   {
     return preUpdateImpl(cache, parm, sf, dir, particle, matupmode);
   }

◆ preUpdateImpl()

std::unique_ptr< Trk::TrackParameters > Trk::MaterialEffectsUpdator::preUpdateImpl	(	ICache &	cache,
		const TrackParameters *	parm,
		const Layer &	sf,
		PropDirection	dir = `alongMomentum`,
		ParticleHypothesis	particle = `pion`,
		MaterialUpdateMode	matupmode = `addNoise`
	)		const

private

Definition at line 354 of file MaterialEffectsUpdator.cxx.

         {
   // no material properties - pass the parameters back
   if (particle == Trk::geantino || particle == Trk::nonInteractingMuon || (!m_doMs && !m_doEloss)) {
     return parm->uniqueClone();
   }
  
   // get the split factor
   double preFactor = lay.preUpdateMaterialFactor(*parm, dir);
   // return if the preFactor is less than one
   if (preFactor < 0.01) {
     return parm->uniqueClone();
   }
  
   // get the material properties
   const Trk::MaterialProperties* mprop = nullptr;
  
   // set the output if restricted to the validation direction
   bool outputFlag = m_msgOutputValidationDirection ? dir == int(m_validationDirection) : true;
  
   mprop = lay.fullUpdateMaterialProperties(*parm);
   double pathCorrection = std::abs(lay.surfaceRepresentation().pathCorrection(parm->position(), parm->momentum()));
   pathCorrection *= preFactor;
  
   // exit if no mprop could be assigned
   if (!mprop) {
     return parm->uniqueClone();
   }
   // --------------------------------------------------------------------------------------------------
   if (outputFlag) {
     double layerR = lay.surfaceRepresentation().bounds().r();
     double layerZ = lay.surfaceRepresentation().center().z();
     double eta = parm->momentum().eta();
     double sX0 = mprop->thicknessInX0();
     double tX0 = pathCorrection * mprop->thicknessInX0();
     ATH_MSG_VERBOSE("  [M] pre material update at layer with [r,z] = [ " << layerR << ", " << layerZ << " ] - Index "
                                                                          << lay.layerIndex());
     ATH_MSG_VERBOSE("      thickness/X0 , path/X0  (eta: g.factor) = " << sX0 << " , " << tX0 << " (" << eta << ": "
                                                                        << pathCorrection << ")");
   }
   // --------------------------------------------------------------------------------------------------
   if (m_validationMode) {
     cache.validationLayer = &lay;
   }
   return updateImpl(cache, parm, *mprop, pathCorrection, dir, particle, matupmode);
 }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

   {
     h.renounce();
     PBASE::renounce (h);
   }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ update() [1/6]

virtual std::unique_ptr<TrackParameters> Trk::MaterialEffectsUpdator::update	(	const TrackParameters &	param,
		const MaterialProperties &	mprop,
		double	pathcorrection,
		PropDirection	dir = `alongMomentum`,
		ParticleHypothesis	particle = `pion`,
		MaterialUpdateMode	matupmode = `addNoise`
	)		const

inlinefinaloverridevirtual

Updator interface: MaterialProperties based material update.

used by all Layer-based methods

Implements Trk::IMaterialEffectsUpdator.

Definition at line 224 of file MaterialEffectsUpdator.h.

   {
     ICache& cache = getTLSCache();
     return updateImpl(
       cache, parm, mprop, pathcorrection, dir, particle, matupmode);
   }

◆ update() [2/6]

virtual std::unique_ptr<TrackParameters> Trk::MaterialEffectsUpdator::update	(	const TrackParameters *	param,
		const Layer &	sf,
		PropDirection	dir = `alongMomentum`,
		ParticleHypothesis	particle = `pion`,
		MaterialUpdateMode	matupmode = `addNoise`
	)		const

inlinefinaloverridevirtual

Updator interface (full update for a layer):

Implements Trk::IMaterialEffectsUpdator.

Definition at line 180 of file MaterialEffectsUpdator.h.

   {
  
     ICache& cache = getTLSCache();
     return updateImpl(cache, parm, sf, dir, particle, matupmode);
   }

◆ update() [3/6]

virtual std::unique_ptr<TrackParameters> Trk::MaterialEffectsUpdator::update	(	const TrackParameters *	param,
		const MaterialEffectsOnTrack &	meff,
		Trk::ParticleHypothesis	particle = `pion`,
		MaterialUpdateMode	matupmode = `addNoise`
	)		const

inlinefinaloverridevirtual

User updator interface (full update for a layer):

Implements Trk::IMaterialEffectsUpdator.

Definition at line 192 of file MaterialEffectsUpdator.h.

   {
     ICache& cache = getTLSCache();
     return updateImpl(cache, parm, meff, particle, matupmode);
   }

◆ update() [4/6]

virtual std::unique_ptr<TrackParameters> Trk::MaterialEffectsUpdator::update	(	ICache &	cache,
		const TrackParameters &	parm,
		const MaterialProperties &	mprop,
		double	pathcorrection,
		PropDirection	dir = `alongMomentum`,
		ParticleHypothesis	particle = `pion`,
		MaterialUpdateMode	matupmode = `addNoise`
	)		const

inlinefinaloverridevirtual

Dedicated Updator interface:-> create new track parameters.

Implements Trk::IMaterialEffectsUpdator.

Definition at line 146 of file MaterialEffectsUpdator.h.

   {
     return updateImpl(
       cache, parm, mprop, pathcorrection, dir, particle, matupmode);
   }

◆ update() [5/6]

virtual std::unique_ptr<TrackParameters> Trk::MaterialEffectsUpdator::update	(	ICache &	cache,
		const TrackParameters *	parm,
		const Layer &	sf,
		PropDirection	dir = `alongMomentum`,
		ParticleHypothesis	particle = `pion`,
		MaterialUpdateMode	matupmode = `addNoise`
	)		const

inlineoverridevirtual

Updator interface (full update for a layer) —> ALWAYS pointer to new TrackParameters is returned.

Implements Trk::IMaterialEffectsUpdator.

Definition at line 93 of file MaterialEffectsUpdator.h.

   {
     return updateImpl(cache, parm, sf, dir, particle, matupmode);
   }

◆ update() [6/6]

virtual std::unique_ptr<TrackParameters> Trk::MaterialEffectsUpdator::update	(	ICache &	cache,
		const TrackParameters *	parm,
		const MaterialEffectsOnTrack &	meff,
		Trk::ParticleHypothesis	particle = `pion`,
		MaterialUpdateMode	matupmode = `addNoise`
	)		const

inlineoverridevirtual

Updator interface (full update for a layer) according to user input through MaterialEffectsOnTrack —> ALWAYS pointer to new TrackParameters is returned.

Implements Trk::IMaterialEffectsUpdator.

Definition at line 107 of file MaterialEffectsUpdator.h.

   {
     return updateImpl(cache, parm, meff, particle, matupmode);
   }

◆ updateImpl() [1/4]

std::unique_ptr< Trk::TrackParameters > Trk::MaterialEffectsUpdator::updateImpl	(	ICache &	cache,
		const TrackParameters &	parm,
		const MaterialProperties &	mprop,
		double	pathcorrection,
		PropDirection	dir = `alongMomentum`,
		ParticleHypothesis	particle = `pion`,
		MaterialUpdateMode	matupmode = `addNoise`
	)		const

private

Definition at line 641 of file MaterialEffectsUpdator.cxx.

         {
   // no material properties - pass them back
   if (particle == Trk::geantino || (!m_doMs && !m_doEloss)) {
     return parm.uniqueClone();
   }
  
   // get the kinematics
   double p = parm.momentum().mag();
   double updateMomentum = (m_forceMomentum) ? m_forcedMomentum : p;
   double m = Trk::ParticleMasses::mass[particle];
   double E = std::sqrt(p * p + m * m);
   double beta = p / E;
  
   // set the output if restricted to the validation direction
   bool outputFlag = m_msgOutputValidationDirection ? dir == int(m_validationDirection) : true;
  
   // no material update below or above a certain cut value
   if (p > m_momentumCut && p < m_momentumMax) {
     // the updatedParameters - first a copy
     AmgVector(5) updatedParameters(parm.parameters());
  
     // get the delta of the Energy
     EnergyLoss energyLoss =
       (m_doEloss)
         ? m_eLossUpdator->energyLoss(matprop, updateMomentum, pathcorrection, dir, particle, m_useMostProbableEloss)
         : EnergyLoss{};
     // update for mean energy loss
     double deltaE = energyLoss.deltaE() ;
     double sigmaDeltaE = energyLoss.sigmaDeltaE();
     if (m_landauMode && cache.accumulatedElossSigma != 0 && sigmaDeltaE != 0) {
       if (dir == Trk::oppositeMomentum) {
         deltaE += sigmaDeltaE * std::log(1 + cache.accumulatedElossSigma / sigmaDeltaE) +
                   cache.accumulatedElossSigma * std::log(1 + sigmaDeltaE / cache.accumulatedElossSigma);
       } else {
         deltaE -= sigmaDeltaE * std::log(1 + cache.accumulatedElossSigma / sigmaDeltaE) +
                   cache.accumulatedElossSigma * std::log(1 + sigmaDeltaE / cache.accumulatedElossSigma);
       }
  
       cache.accumulatedElossSigma += sigmaDeltaE;
     } else if (m_landauMode) {
       cache.accumulatedElossSigma += sigmaDeltaE;
     }
  
     double newP2 = (E + deltaE) * (E + deltaE) - m * m;
     if (E + deltaE < -m) {
       return nullptr; // protect against flip in correction
     }
     if (newP2 < m_momentumCut * m_momentumCut) {
       return nullptr; // protect against FPE
     }
     double deltaP = std::sqrt(newP2) - p;
     double sigmaQoverP = sigmaDeltaE / std::pow(beta * p, 2);
  
     updatedParameters[Trk::qOverP] = parm.charge() / (p + deltaP);
  
     // check if Parameters are measured parameters
     std::optional<AmgSymMatrix(5)> updatedCovariance = std::nullopt;
     if (parm.covariance() || (m_validationMode && !m_validationIgnoreUnmeasured)) {
       // the new CovarianceMatrix - a copy first
       updatedCovariance = AmgSymMatrix(5)(*parm.covariance());
       // only update if msUpdator exists
       double angularVariation =
         (m_doMs) ? m_msUpdator->sigmaSquare(matprop, updateMomentum, pathcorrection, particle) : 0.;
       // update the covariance entries - angular variation in phi has dependency on theta direction
       // sign of the noise adding ----------------------------------------------------------------
       int sign = int(matupmode);
       // checks will only be done in the removeNoise mode
       double sigmaDeltaPhiSq =
         angularVariation / (std::sin(parm.parameters()[Trk::theta]) * std::sin(parm.parameters()[Trk::theta]));
       double sigmaDeltaThetaSq = angularVariation;
       // checks will only be done in the removeNoise mode
       COVARIANCEUPDATEWITHCHECK((*updatedCovariance)(Trk::phi, Trk::phi), sign, sigmaDeltaPhiSq);
       COVARIANCEUPDATEWITHCHECK((*updatedCovariance)(Trk::theta, Trk::theta), sign, sigmaDeltaThetaSq);
       if (!m_xKalmanStraggling && !m_landauMode) {
         COVARIANCEUPDATEWITHCHECK((*updatedCovariance)(Trk::qOverP, Trk::qOverP), sign, sigmaQoverP * sigmaQoverP);
       } else if (m_xKalmanStraggling) { /* to be filled in*/
       } else if (m_landauMode) {
         // subtract what we added up till now and add what we should add up till now
         // Landau's 68% limit is best modeled by 1.6*sigmaParameter
         (*updatedCovariance)(Trk::qOverP, Trk::qOverP) -=
           sign * std::pow(1.6 * (cache.accumulatedElossSigma - p * p * sigmaQoverP) / (p * p), 2);
         (*updatedCovariance)(Trk::qOverP, Trk::qOverP) +=
           sign * std::pow(1.6 * cache.accumulatedElossSigma / ((p + deltaP) * (p + deltaP)), 2);
       }
  
       // the checks for the remove Noise mode -----------------------------------------------------
       if (matupmode == Trk::removeNoise && !checkCovariance(*updatedCovariance)) {
         // the covariance is invalid
         return nullptr;
       }
  
       // create the ErrorMatrix         // -------------------------------------- screen output
       // --------------------------------------
       if (outputFlag && m_msgOutputCorrections) {
         double sigmaAngle = std::sqrt(angularVariation);
         ATH_MSG_VERBOSE("    sigma(phi) / sigma(theta) = " << sigmaAngle / std::sin(parm.parameters()[Trk::theta]) << " / "
                                                            << sigmaAngle);
         ATH_MSG_VERBOSE("    deltaP / sigmaQoverP      = " << deltaP << " / " << sigmaQoverP);
       }
       // ----------------------------------------- validation section ----------------------------------
       // validation if configured
       if (m_validationMode && dir == Trk::PropDirection(m_validationDirection)) {
  
         if (cache.validationLayer) {
           // all you have from MaterialProperties
           double pathInX0 = pathcorrection * matprop.thicknessInX0();
           double A = 0.;
           double Z = 0.;
           double rho = 0.;
           double l0 = 0.;
           // or better take the extended version for more information
           const Trk::MaterialProperties* extProperties = dynamic_cast<const Trk::MaterialProperties*>(&matprop);
  
           if (extProperties) {
             A = extProperties->averageA();
             Z = extProperties->averageZ();
             rho = extProperties->averageRho();
             l0 = extProperties->l0();
           }
  
           Trk::AssociatedMaterial assMatHit(parm.position(),
                                             pathInX0,
                                             matprop.x0(),
                                             l0,
                                             A,
                                             Z,
                                             rho,
                                             pathcorrection,
                                             cache.validationLayer->enclosingTrackingVolume(),
                                             cache.validationLayer);
  
           // record the Material hit ----------------------------------------------------------------
           m_materialMapper->recordMaterialHit(assMatHit, parm.position());
  
           // the steps
           cache.validationSteps++;
           cache.validationPhi += parm.position().phi();
           cache.validationEta += parm.position().eta();
           // reset the validation layer
           cache.validationLayer = nullptr;
         }
       }
       // ------------------------------------------validation section ----------------------------------
     }
     return parm.associatedSurface().createUniqueTrackParameters(
         updatedParameters[Trk::loc1],
         updatedParameters[Trk::loc2],
         updatedParameters[Trk::phi],
         updatedParameters[Trk::theta],
         updatedParameters[Trk::qOverP],
         std::move(updatedCovariance)
     );
   }
   return parm.uniqueClone();
 }

◆ updateImpl() [2/4]

std::unique_ptr< Trk::TrackParameters > Trk::MaterialEffectsUpdator::updateImpl	(	ICache &	cache,
		const TrackParameters *	parm,
		const Layer &	sf,
		PropDirection	dir = `alongMomentum`,
		ParticleHypothesis	particle = `pion`,
		MaterialUpdateMode	matupmode = `addNoise`
	)		const

private

Definition at line 140 of file MaterialEffectsUpdator.cxx.

         {
   // no material properties - pass them back
   if (particle == Trk::geantino || particle == Trk::nonInteractingMuon || (!m_doMs && !m_doEloss) ||
       !lay.isOnLayer(parm->position())) {
     return parm->uniqueClone();
   }
  
   // get the quantities
   const Trk::MaterialProperties* mprop = lay.fullUpdateMaterialProperties(*parm);
   if (!mprop) {
     return parm->uniqueClone();
   }
  
   // get the real pathlength
   double pathCorrection = std::abs(lay.surfaceRepresentation().pathCorrection(parm->position(), parm->momentum()));
   
   // --------------------------------------------------------------------------------------------------
   if (m_validationMode) {
     cache.validationLayer = &lay;
   }
   return updateImpl(cache, parm, *mprop, pathCorrection, dir, particle, matupmode);
 }

◆ updateImpl() [3/4]

std::unique_ptr< Trk::TrackParameters > Trk::MaterialEffectsUpdator::updateImpl	(	ICache &	cache,
		const TrackParameters *	parm,
		const MaterialEffectsOnTrack &	meff,
		Trk::ParticleHypothesis	particle = `pion`,
		MaterialUpdateMode	matupmode = `addNoise`
	)		const

private

Definition at line 171 of file MaterialEffectsUpdator.cxx.

         {
   // no material properties - pass them back
   // TODO, if the parm doesn't have a surface (i.e. its in
   // curvilinear) then should we fall through?
   if (particle == Trk::geantino || particle == Trk::nonInteractingMuon || (!m_doMs && !m_doEloss) ||
       parm->associatedSurface() != meff.associatedSurface()) {
     return parm->uniqueClone();
   }
  
   // get the kinematics
   double p = parm->momentum().mag();
   double updateMomentum = (m_forceMomentum) ? m_forcedMomentum : p;
   double m = Trk::ParticleMasses::mass[particle];
   double E = std::sqrt(p * p + m * m);
   double beta = p / E;
  
   double pathcorrection = 1.; // Trick the MultipleScatteringUpdator interface
  
   double energyLoss = 0;
   double energyLossSigma = 0;
  
   if (meff.energyLoss() != nullptr) {
     energyLoss = meff.energyLoss()->deltaE();
     energyLossSigma = meff.energyLoss()->sigmaDeltaE();
   }
  
   // update for mean energy loss
   double newP = p;
   double sigmaQoverP = 0;
   double sigmaQoverPSq = 0;
   // Landaus mpvs don't just add, if in Landau mode we need to do a different update
   if (m_landauMode && cache.accumulatedElossSigma != 0 && energyLossSigma != 0) {
     if (energyLoss > 0) {
       energyLoss += energyLossSigma * std::log(1 + cache.accumulatedElossSigma / (energyLossSigma)) +
                     cache.accumulatedElossSigma * std::log(1 + energyLossSigma / cache.accumulatedElossSigma);
     } else {
       energyLoss -= energyLossSigma * std::log(1 + cache.accumulatedElossSigma / energyLossSigma) +
                     cache.accumulatedElossSigma * std::log(1 + energyLossSigma / cache.accumulatedElossSigma);
     }
     cache.accumulatedElossSigma += energyLossSigma;
   } else if (m_landauMode) {
     cache.accumulatedElossSigma += energyLossSigma;
   }
   double qOverPnew = parm->parameters()[Trk::qOverP];
  
   if (p > m_momentumCut && p < m_momentumMax && m_doEloss) {
     double newP2 = (E + energyLoss) * (E + energyLoss) - m * m;
     if (newP2 < m_momentumCut * m_momentumCut) {
       return nullptr; // protect FPE
     }
     if (E + energyLoss < -m) {
       return nullptr; // protect against flip in correction
     }
     newP = std::sqrt(newP2);
     sigmaQoverP = energyLossSigma / (beta * p * p);
     sigmaQoverPSq = sigmaQoverP * sigmaQoverP;
     qOverPnew = parm->charge() / newP;
   }
   Trk::DefinedParameter qOverPmod(qOverPnew, Trk::qOverP);
  
   // check if Parameters are measured parameters
   // the updatedParameters - first a copy
   const Trk::TrackParameters* mpars = parm;
   AmgVector(5) updatedParameters(mpars->parameters());
   std::optional<AmgSymMatrix(5)> updatedCovariance = std::nullopt;
   // initialize ErrorMatrix pointer
   if (m_validationMode && !m_validationIgnoreUnmeasured) {
     // the new CovarianceMatrix - a copy first
     updatedCovariance = mpars->covariance()
                           ? std::optional<AmgSymMatrix(5)>(*mpars->covariance())
                           : std::nullopt;
     double angularVariation = 0;
     double sigmaDeltaPhiSq = 0;
     double sigmaDeltaThetaSq = 0;
  
     if (m_doMs) {
       // If the meff has scattering angles use those, otherwise use MEffUpdator
       if (meff.scatteringAngles() == nullptr) {
         // Trick to keep using existing MultipleScatteringUpdator interface
         // Here we know the path length to be meff.thicknessX0, so we set pathcorrection = 1
         // and create a dummy materialProperties with the properties we are interested in
         MaterialProperties mprop(meff.thicknessInX0(), 1., 1., 0., 0., 0.);
         angularVariation = m_msUpdator->sigmaSquare(mprop, updateMomentum, pathcorrection, Trk::muon);
         // sigmaDeltaPhiSq = angularVariation/(parm->sinTheta()*parm->sinTheta());
         sigmaDeltaPhiSq =
           angularVariation / (std::sin(parm->parameters()[Trk::theta]) * std::sin(parm->parameters()[Trk::theta]));
         sigmaDeltaThetaSq = angularVariation;
       } else {
         // material update from mefots -> D.L.
         sigmaDeltaPhiSq = meff.scatteringAngles()->sigmaDeltaPhi();
         sigmaDeltaPhiSq *= sigmaDeltaPhiSq;
         sigmaDeltaThetaSq = meff.scatteringAngles()->sigmaDeltaTheta();
         sigmaDeltaThetaSq *= sigmaDeltaThetaSq;
         updatedParameters[Trk::phi] = parm->position().phi() + meff.scatteringAngles()->deltaPhi();
         updatedParameters[Trk::theta] = parm->position().theta() + meff.scatteringAngles()->deltaTheta();
       }
     }
     // update the covariance entries - angular variation in phi has dependency on theta direction
     if (updatedCovariance) {
       // sign of the noise adding -----------------------
       int sign = int(matupmode);
       // check for non-zero covariance matrix
       COVARIANCEUPDATEWITHCHECK((*updatedCovariance)(Trk::phi, Trk::phi), sign, sigmaDeltaPhiSq);
       COVARIANCEUPDATEWITHCHECK((*updatedCovariance)(Trk::theta, Trk::theta), sign, sigmaDeltaThetaSq);
       if (!m_xKalmanStraggling && !m_landauMode) {
         COVARIANCEUPDATEWITHCHECK((*updatedCovariance)(Trk::qOverP, Trk::qOverP), sign, sigmaQoverPSq);
       } else if (m_xKalmanStraggling) { /* to be filled in*/
       } else if (m_landauMode) {
         // subtract what we added up till now and add what we should add up till now
         // Landau's 68% limit is approx 1.6*sigmaParameter
  
         /* Get the TLS to a local here once and use it for calculation*/
         (*updatedCovariance)(Trk::qOverP, Trk::qOverP) -=
           sign * std::pow(1.6 * (cache.accumulatedElossSigma - p * p * sigmaQoverP) / (p * p), 2);
         (*updatedCovariance)(Trk::qOverP, Trk::qOverP) +=
           sign * std::pow(1.6 * cache.accumulatedElossSigma / (newP * newP), 2);
       }
       // the checks for the remove Noise mode -----------------------------------------------------
       if (matupmode == Trk::removeNoise && !checkCovariance(*updatedCovariance)) {
         // the covariance is invalid
         return nullptr;
       }
  
       // create the ErrorMatrix
       // updatedError = new Trk::ErrorMatrix(updatedCovariance);
       // -------------------------------------- screen output --------------------------------------
       if (m_msgOutputCorrections) {
         double sigmaAngle = std::sqrt(angularVariation);
         ATH_MSG_VERBOSE("    sigma(phi) / sigma(theta) = " << sigmaAngle / std::sin(parm->parameters()[Trk::theta]) << " / "
                                                            << sigmaAngle);
         ATH_MSG_VERBOSE("    deltaP / sigmaQoverP      = " << energyLoss << " / " << sigmaQoverP);
       }
       // -------------------------------------------------------------------------------------------
     }
     // ----------------------------------------- validation section ----------------------------------
     // validation if configured
     if (m_validationMode) {
       if (cache.validationLayer) {
         // all you have from MaterialProperties
         double pathInX0 = meff.thicknessInX0();
  
         Trk::AssociatedMaterial assMatHit(parm->position(),
                                           pathInX0,
                                           pathInX0,
                                           0,
                                           0,
                                           0,
                                           0,
                                           pathcorrection,
                                           cache.validationLayer->enclosingTrackingVolume(),
                                           cache.validationLayer);
  
         // record the Material hit ----------------------------------------------------------------
         m_materialMapper->recordMaterialHit(assMatHit, parm->position());
  
         // the steps
         cache.validationSteps++;
         cache.validationPhi += parm->position().phi();
         cache.validationEta += parm->position().eta();
         // reset the validation layer
         cache.validationLayer = nullptr;
       }
     }
     // ----------------------------------------- validation section ----------------------------------
   }
   updatedParameters[Trk::qOverP] = qOverPnew;
   return  parm->associatedSurface().createUniqueTrackParameters(
       updatedParameters[Trk::loc1],
       updatedParameters[Trk::loc2],
       updatedParameters[Trk::phi],
       updatedParameters[Trk::theta],
       updatedParameters[Trk::qOverP],
       updatedCovariance
   );
 }

◆ updateImpl() [4/4]

std::unique_ptr< Trk::TrackParameters > Trk::MaterialEffectsUpdator::updateImpl	(	ICache &	cache,
		const TrackParameters *	parm,
		const MaterialProperties &	mprop,
		double	pathcorrection,
		PropDirection	dir = `alongMomentum`,
		ParticleHypothesis	particle = `pion`,
		MaterialUpdateMode	matupmode = `addNoise`
	)		const

private

Definition at line 464 of file MaterialEffectsUpdator.cxx.

         {
   // no material properties - pass them back
   if (particle == Trk::geantino || particle == Trk::nonInteractingMuon || (!m_doMs && !m_doEloss)) {
     return parm->uniqueClone();
   }
  
   // get the kinematics
   double p = parm->momentum().mag();
   double updateMomentum = (m_forceMomentum) ? m_forcedMomentum : p;
   double m = Trk::ParticleMasses::mass[particle];
   double E = std::sqrt(p * p + m * m);
   double beta = p / E;
  
   // set the output if restricted to the validation direction
   bool outputFlag = m_msgOutputValidationDirection ? dir == int(m_validationDirection) : true;
  
   // no material update below/above a certain cut value
   if (p > m_momentumCut && p < m_momentumMax) {
     // get the delta of the Energy
     EnergyLoss energyLoss =
         (m_doEloss) ? m_eLossUpdator->energyLoss(matprop, updateMomentum,
                                                  pathcorrection, dir, particle,
                                                  m_useMostProbableEloss)
                     : EnergyLoss{};
     // update for mean energy loss
     double deltaE = energyLoss.deltaE();
     double sigmaDeltaE = energyLoss.sigmaDeltaE();
  
     if (m_landauMode && cache.accumulatedElossSigma != 0 && sigmaDeltaE != 0) {
       if (dir == Trk::oppositeMomentum) {
         deltaE += sigmaDeltaE * std::log(1 + cache.accumulatedElossSigma / sigmaDeltaE) +
                   cache.accumulatedElossSigma * std::log(1 + sigmaDeltaE / cache.accumulatedElossSigma);
       } else {
         deltaE -= sigmaDeltaE * std::log(1 + cache.accumulatedElossSigma / sigmaDeltaE) +
                   cache.accumulatedElossSigma * std::log(1 + sigmaDeltaE / cache.accumulatedElossSigma);
       }
       cache.accumulatedElossSigma += sigmaDeltaE;
     } else if (m_landauMode) {
       cache.accumulatedElossSigma += sigmaDeltaE;
     }
  
     double newP2 = (E + deltaE) * (E + deltaE) - m * m;
     if (E + deltaE < -m) {
       return nullptr; // protect against flip in correction
     }
     if (newP2 < m_momentumCut * m_momentumCut) {
       return nullptr; // protect against FPE
     }
     double deltaP = std::sqrt(newP2) - p;
     double sigmaQoverP = sigmaDeltaE / std::pow(beta * p, 2);
  
     Trk::DefinedParameter qOverPmod(parm->charge() / (p + deltaP), Trk::qOverP);
  
     // check if Parameters are measured parameters
     const Trk::TrackParameters* mpars = parm;
     AmgVector(5) updatedParameters(mpars->parameters());
     // initialize ErrorMatrix pointer
     std::optional<AmgSymMatrix(5)> updatedCovariance = std::nullopt;
     {
       // the new CovarianceMatrix - a copy first
       updatedCovariance =
         mpars->covariance()
           ? std::optional<AmgSymMatrix(5)>(*mpars->covariance())
           : std::nullopt;
       // only update if msUpdator exists
       double angularVariation =
         (m_doMs) ? m_msUpdator->sigmaSquare(matprop, updateMomentum, pathcorrection, particle) : 0.;
       // update the covariance entries - angular variation in phi has dependency on theta direction
       if (updatedCovariance) {
         // sign of the noise adding ----------------------------------------------------------------
         int sign = int(matupmode);
  
         double sigmaDeltaPhiSq =
           angularVariation / (std::sin(parm->parameters()[Trk::theta]) * std::sin(parm->parameters()[Trk::theta]));
         double sigmaDeltaThetaSq = angularVariation;
         // checks will only be done in the removeNoise mode
         COVARIANCEUPDATEWITHCHECK((*updatedCovariance)(Trk::phi, Trk::phi), sign, sigmaDeltaPhiSq);
         COVARIANCEUPDATEWITHCHECK((*updatedCovariance)(Trk::theta, Trk::theta), sign, sigmaDeltaThetaSq);
         if (!m_xKalmanStraggling && !m_landauMode) {
           COVARIANCEUPDATEWITHCHECK((*updatedCovariance)(Trk::qOverP, Trk::qOverP), sign, sigmaQoverP * sigmaQoverP);
         } else if (m_xKalmanStraggling) {
           double q = parm->charge();
           COVARIANCEUPDATEWITHCHECK(
             (*updatedCovariance)(Trk::qOverP, Trk::qOverP), sign, 0.2 * deltaP * deltaP * q * q * q * q);
         } else if (m_landauMode) {
           // subtract what we added up till now and add what we should add up till now
           // Landau's 68% limit is approx 1.6*sigmaParameter
           (*updatedCovariance)(Trk::qOverP, Trk::qOverP) -=
             sign * std::pow(1.6 * (cache.accumulatedElossSigma - p * p * sigmaQoverP) / (p * p), 2);
           (*updatedCovariance)(Trk::qOverP, Trk::qOverP) +=
             sign * std::pow(1.6 * cache.accumulatedElossSigma / ((p + deltaP) * (p + deltaP)), 2);
         }
         // the checks for the remove Noise mode -----------------------------------------------------
         if (matupmode == Trk::removeNoise && !checkCovariance(*updatedCovariance)) {
           // the covariance is invalid
           return nullptr;
         }
  
         // create the ErrorMatrix
  
         // -------------------------------------- screen output --------------------------------------
         if (outputFlag && m_msgOutputCorrections) {
           double sigmaAngle = std::sqrt(angularVariation);
           ATH_MSG_VERBOSE("    sigma(phi) / sigma(theta) = " << sigmaAngle / std::sin(parm->parameters()[Trk::theta])
                                                              << " / " << sigmaAngle);
           ATH_MSG_VERBOSE("    deltaP / sigmaQoverP      = " << deltaP << " / " << sigmaQoverP);
         }
         // -------------------------------------------------------------------------------------------
       }
       // ----------------------------------------- validation section ----------------------------------
       // validation if configured
       if (m_validationMode && dir == Trk::PropDirection(m_validationDirection) && updatedCovariance) {
  
         if (cache.validationLayer) {
           // all you have from MaterialProperties
           double pathInX0 = pathcorrection * matprop.thicknessInX0();
           double A = 0.;
           double Z = 0.;
           double rho = 0.;
           double l0 = 0.;
           // or better take the extended version for more information
           const Trk::MaterialProperties* extProperties = dynamic_cast<const Trk::MaterialProperties*>(&matprop);
  
           if (extProperties) {
             A = extProperties->averageA();
             Z = extProperties->averageZ();
             rho = extProperties->averageRho();
             l0 = extProperties->l0();
           }
  
           Trk::AssociatedMaterial assMatHit(parm->position(),
                                             pathInX0,
                                             matprop.x0(),
                                             l0,
                                             A,
                                             Z,
                                             rho,
                                             pathcorrection,
                                             cache.validationLayer->enclosingTrackingVolume(),
                                             cache.validationLayer);
  
           // record the Material hit ----------------------------------------------------------------
           m_materialMapper->recordMaterialHit(assMatHit, parm->position());
           // the steps
           cache.validationSteps++;
           cache.validationPhi += parm->position().phi();
           cache.validationEta += parm->position().eta();
           // reset the cache.tion layer
           cache.validationLayer = nullptr;
         }
       }
       // ----------------------------------------- validation section ----------------------------------
     }
     updatedParameters[Trk::qOverP] = parm->charge() / (p + deltaP);
     return parm->associatedSurface().createUniqueTrackParameters(
         updatedParameters[Trk::loc1],
         updatedParameters[Trk::loc2],
         updatedParameters[Trk::phi],
         updatedParameters[Trk::theta],
         updatedParameters[Trk::qOverP],
         std::move(updatedCovariance)
     );
   }
   //default if we have not returned just above
   return parm->uniqueClone();
 }

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                                {
     // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
     //         << "  size: " << m_vhka.size() << endmsg;
     for (auto &a : m_vhka) {
       std::vector<SG::VarHandleKey*> keys = a->keys();
       for (auto k : keys) {
         k->setOwner(this);
       }
     }
   }

◆ validationAction() [1/2]

virtual void Trk::MaterialEffectsUpdator::validationAction ( ) const

inlinefinaloverridevirtual

Validation Action: outside access to internal validation steps Optional.

Implements Trk::IMaterialEffectsUpdator.

Definition at line 237 of file MaterialEffectsUpdator.h.

   {
     ICache& cache = getTLSCache();
     validationActionImpl(cache);
   }

◆ validationAction() [2/2]

virtual void Trk::MaterialEffectsUpdator::validationAction ( ICache & cache ) const

inlinefinaloverridevirtual

Validation Action - calls the writing and resetting of the TTree variables.

Implements Trk::IMaterialEffectsUpdator.

Definition at line 161 of file MaterialEffectsUpdator.h.

   {
     validationActionImpl(cache);
   }

◆ validationActionImpl()

void Trk::MaterialEffectsUpdator::validationActionImpl ( ICache & cache )

staticprivate

Definition at line 806 of file MaterialEffectsUpdator.cxx.

 {
   cache.validationEta = 0.;
   cache.validationPhi = 0.;
   cache.validationSteps = 0;
 }

Member Data Documentation

◆ m_cache_tls

boost::thread_specific_ptr<ICache> Trk::MaterialEffectsUpdator::m_cache_tls

mutableprivate

Definition at line 346 of file MaterialEffectsUpdator.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doCompoundLayerCheck

bool Trk::MaterialEffectsUpdator::m_doCompoundLayerCheck

private

turn on/off the necessary checks when we may have compound layers

Definition at line 313 of file MaterialEffectsUpdator.h.

◆ m_doEloss

bool Trk::MaterialEffectsUpdator::m_doEloss

private

steer energy loss On/Off from outside

Definition at line 315 of file MaterialEffectsUpdator.h.

◆ m_doMs

bool Trk::MaterialEffectsUpdator::m_doMs

private

steer multiple scattering On/Off from outside

Definition at line 316 of file MaterialEffectsUpdator.h.

◆ m_eLossUpdator

ToolHandle<IEnergyLossUpdator> Trk::MaterialEffectsUpdator::m_eLossUpdator

private

AlgoTool for EnergyLoss updates.

Definition at line 339 of file MaterialEffectsUpdator.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_forcedMomentum

double Trk::MaterialEffectsUpdator::m_forcedMomentum

private

Forced momentum value.

Definition at line 337 of file MaterialEffectsUpdator.h.

◆ m_forceMomentum

bool Trk::MaterialEffectsUpdator::m_forceMomentum

private

Force the momentum to be a specific value.

Definition at line 318 of file MaterialEffectsUpdator.h.

◆ m_landauMode

bool Trk::MaterialEffectsUpdator::m_landauMode

private

If in Landau mode, error propagation is done as for landaus.

Definition at line 331 of file MaterialEffectsUpdator.h.

◆ m_materialMapper

ToolHandle<IMaterialMapper> Trk::MaterialEffectsUpdator::m_materialMapper

private

the material mapper for recording the layer material

Definition at line 341 of file MaterialEffectsUpdator.h.

◆ m_momentumCut

double Trk::MaterialEffectsUpdator::m_momentumCut

private

Minimal momentum cut for update.

Definition at line 335 of file MaterialEffectsUpdator.h.

◆ m_momentumMax

double Trk::MaterialEffectsUpdator::m_momentumMax

private

Maximal momentum cut for update.

Definition at line 336 of file MaterialEffectsUpdator.h.

◆ m_msgOutputCorrections

bool Trk::MaterialEffectsUpdator::m_msgOutputCorrections

private

screen output of actual corrections

Definition at line 324 of file MaterialEffectsUpdator.h.

◆ m_msgOutputValidationDirection

bool Trk::MaterialEffectsUpdator::m_msgOutputValidationDirection

private

validation direction used for screen output

Definition at line 322 of file MaterialEffectsUpdator.h.

◆ m_msUpdator

ToolHandle<IMultipleScatteringUpdator> Trk::MaterialEffectsUpdator::m_msUpdator

private

AlgoTool for MultipleScatterin effects.

Definition at line 340 of file MaterialEffectsUpdator.h.

◆ m_useMostProbableEloss

bool Trk::MaterialEffectsUpdator::m_useMostProbableEloss

private

use the most probable energy loss

Definition at line 320 of file MaterialEffectsUpdator.h.

◆ m_validationDirection

int Trk::MaterialEffectsUpdator::m_validationDirection

private

validation direction

Definition at line 333 of file MaterialEffectsUpdator.h.

◆ m_validationIgnoreUnmeasured

bool Trk::MaterialEffectsUpdator::m_validationIgnoreUnmeasured

private

Ignore unmeasured TrackParameters (Navigation!)

Definition at line 329 of file MaterialEffectsUpdator.h.

◆ m_validationMode

bool Trk::MaterialEffectsUpdator::m_validationMode

private

Switch for validation mode.

Definition at line 328 of file MaterialEffectsUpdator.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_xKalmanStraggling

bool Trk::MaterialEffectsUpdator::m_xKalmanStraggling

private

the momentum Error as calculated in xKalman

Definition at line 319 of file MaterialEffectsUpdator.h.

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

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ICache

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ MaterialEffectsUpdator()

◆ ~MaterialEffectsUpdator()

Member Function Documentation

◆ checkCovariance()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ finalLandauCovarianceUpdate()

◆ getCache()

◆ getTLSCache()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ modelAction() [1/2]

◆ modelAction() [2/2]

◆ modelActionImpl()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ postUpdate() [1/2]

◆ postUpdate() [2/2]

◆ postUpdateImpl()

◆ preUpdate() [1/2]

◆ preUpdate() [2/2]

◆ preUpdateImpl()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ update() [1/6]

◆ update() [2/6]

◆ update() [3/6]

◆ update() [4/6]

◆ update() [5/6]

◆ update() [6/6]

◆ updateImpl() [1/4]

◆ updateImpl() [2/4]

◆ updateImpl() [3/4]

◆ updateImpl() [4/4]

◆ updateVHKA()

◆ validationAction() [1/2]

◆ validationAction() [2/2]

◆ validationActionImpl()

Member Data Documentation

◆ m_cache_tls

◆ m_detStore

◆ m_doCompoundLayerCheck

◆ m_doEloss

◆ m_doMs

◆ m_eLossUpdator

◆ m_evtStore

◆ m_forcedMomentum

◆ m_forceMomentum

◆ m_landauMode

◆ m_materialMapper