Trk::MaterialEffectsUpdator Class Reference

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

#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.
virtual	~MaterialEffectsUpdator ()
	Virtual destructor.
virtual StatusCode	initialize () override
	AlgTool initailize method.
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.
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.
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.
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.
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.
virtual void	validationAction (ICache &cache) const override final
	Validation Action - calls the writing and resetting of the TTree variables.
virtual void	modelAction (ICache &cache, const TrackParameters *parm=nullptr) const override final
	Only has an effect if m_landauMode == true.
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):
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):
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):
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):
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.
virtual void	validationAction () const override final
	Validation Action: outside access to internal validation steps Optional.
virtual void	modelAction (const TrackParameters *parm=nullptr) const override final
	Model Action: Provides the possibility of doing non-local MaterialEffectsUpdates for different models Optional.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
virtual ICache	getCache () const
	Creates an instance of the cache to be used.

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

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

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.
TrackParameters *	finalLandauCovarianceUpdate (const TrackParameters *parm) const
ICache &	getTLSCache () const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static void	validationActionImpl (ICache &cache)
static void	modelActionImpl (ICache &cache, const TrackParameters *parm=nullptr)

Private Attributes
BooleanProperty	m_doEloss
BooleanProperty	m_doMs
BooleanProperty	m_forceMomentum
BooleanProperty	m_useMostProbableEloss
BooleanProperty	m_msgOutputValidationDirection
BooleanProperty	m_msgOutputCorrections
BooleanProperty	m_validationMode
BooleanProperty	m_validationIgnoreUnmeasured
BooleanProperty	m_landauMode
IntegerProperty	m_validationDirection
DoubleProperty	m_momentumCut
DoubleProperty	m_momentumMax
DoubleProperty	m_forcedMomentum {this, "ForcedMomentumValue", 2000. * Gaudi::Units::MeV, "Forced momentum value"}
ToolHandle< IEnergyLossUpdator >	m_eLossUpdator
ToolHandle< IMultipleScatteringUpdator >	m_msUpdator
ToolHandle< IMaterialMapper >	m_materialMapper
boost::thread_specific_ptr< ICache >	m_cache_tls
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
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 63 of file MaterialEffectsUpdator.h.

Member Typedef Documentation

ICache

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

Definition at line 83 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 40 of file MaterialEffectsUpdator.cxx.

  : AthAlgTool(t, n, p)
{
  declareInterface<IMaterialEffectsUpdator>(this);
}

~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 766 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()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & 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());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & 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.

{ return m_detStore; }

evtStore()

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.

{ 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.

{ return {}; }

getTLSCache()

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

inlineprivate

Definition at line 357 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 52 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()

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 237 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 164 of file MaterialEffectsUpdator.h.

  {
    modelActionImpl(cache, parm);
  }

modelActionImpl()

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

staticprivate

Definition at line 761 of file MaterialEffectsUpdator.cxx.

{
  cache.accumulatedElossSigma = 0;
}

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

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 207 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 129 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 363 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 196 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 114 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 309 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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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 218 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 174 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 186 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 140 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 87 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 101 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 590 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.value() : 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_landauMode) {
        COVARIANCEUPDATEWITHCHECK((*updatedCovariance)(Trk::qOverP, Trk::qOverP), sign, sigmaQoverP * sigmaQoverP);
      } 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;
      }
      // -------------------------------------- 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.value())) {
 
        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)
    );
  }
  //default if we have not returned before
  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 101 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 132 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.value() : 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_landauMode) {
        COVARIANCEUPDATEWITHCHECK((*updatedCovariance)(Trk::qOverP, Trk::qOverP), sign, sigmaQoverPSq);
      } 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 / (newP * newP), 2);
      }
      // the checks for the remove Noise mode -----------------------------------------------------
      if (matupmode == Trk::removeNoise && !checkCovariance(*updatedCovariance)) {
        // the covariance is invalid
        return nullptr;
      }
      // -------------------------------------- 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 419 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.value() : 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_landauMode) {
          COVARIANCEUPDATEWITHCHECK((*updatedCovariance)(Trk::qOverP, Trk::qOverP), sign, sigmaQoverP * sigmaQoverP);
        } 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;
        }
 
        // -------------------------------------- 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.value()) && 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 231 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 155 of file MaterialEffectsUpdator.h.

  {
    validationActionImpl(cache);
  }

validationActionImpl()

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

staticprivate

Definition at line 753 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 356 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_doEloss

BooleanProperty Trk::MaterialEffectsUpdator::m_doEloss

private

Initial value:

{this, "EnergyLoss", true,
    "steer energy loss On/Off from outside"}

Definition at line 307 of file MaterialEffectsUpdator.h.

                           {this, "EnergyLoss", true,
    "steer energy loss On/Off from outside"};

m_doMs

BooleanProperty Trk::MaterialEffectsUpdator::m_doMs

private

Initial value:

{this, "MultipleScattering", true,
    "steer multiple scattering On/Off from outside"}

Definition at line 309 of file MaterialEffectsUpdator.h.

                        {this, "MultipleScattering", true,
    "steer multiple scattering On/Off from outside"};

m_eLossUpdator

ToolHandle<IEnergyLossUpdator> Trk::MaterialEffectsUpdator::m_eLossUpdator

private

Initial value:

{this, "EnergyLossUpdator", "Trk::EnergyLossUpdator/AtlasEnergyLossUpdator",
    "AlgoTool for EnergyLoss updates"}

Definition at line 342 of file MaterialEffectsUpdator.h.

    {this, "EnergyLossUpdator", "Trk::EnergyLossUpdator/AtlasEnergyLossUpdator",
    "AlgoTool for EnergyLoss updates"};

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

DoubleProperty Trk::MaterialEffectsUpdator::m_forcedMomentum {this, "ForcedMomentumValue", 2000. * Gaudi::Units::MeV, "Forced momentum value"}

private

Definition at line 339 of file MaterialEffectsUpdator.h.

{this, "ForcedMomentumValue", 2000. * Gaudi::Units::MeV, "Forced momentum value"};

m_forceMomentum

BooleanProperty Trk::MaterialEffectsUpdator::m_forceMomentum

private

Initial value:

{this, "ForceMomentum", false,
    "Force the momentum to be a specific value"}

Definition at line 312 of file MaterialEffectsUpdator.h.

                                 {this, "ForceMomentum", false,
    "Force the momentum to be a specific value"};

m_landauMode

BooleanProperty Trk::MaterialEffectsUpdator::m_landauMode

private

Initial value:

{this, "LandauMode", false,
    "If in Landau mode, error propagation is done as for landaus"}

Definition at line 330 of file MaterialEffectsUpdator.h.

                              {this, "LandauMode", false,
    "If in Landau mode, error propagation is done as for landaus"};

m_materialMapper

ToolHandle<IMaterialMapper> Trk::MaterialEffectsUpdator::m_materialMapper

private

Initial value:

{this, "ValidationMaterialMapper", "Trk::MaterialMapper/AtlasMaterialMapper",
     "the material mapper for recording the layer material"}

Definition at line 349 of file MaterialEffectsUpdator.h.

    {this, "ValidationMaterialMapper", "Trk::MaterialMapper/AtlasMaterialMapper",
     "the material mapper for recording the layer material"};

m_momentumCut

DoubleProperty Trk::MaterialEffectsUpdator::m_momentumCut

private

Initial value:

{this, "MinimalMomentum", 50. * Gaudi::Units::MeV,
    "Minimal momentum cut for update"}

Definition at line 335 of file MaterialEffectsUpdator.h.

                              {this, "MinimalMomentum", 50. * Gaudi::Units::MeV,
    "Minimal momentum cut for update"};

m_momentumMax

DoubleProperty Trk::MaterialEffectsUpdator::m_momentumMax

private

Initial value:

{this, "MaximalMomentum", 10. * Gaudi::Units::TeV,
    "Maximal momentum cut for update"}

Definition at line 337 of file MaterialEffectsUpdator.h.

                              {this, "MaximalMomentum", 10. * Gaudi::Units::TeV,
    "Maximal momentum cut for update"};

m_msgOutputCorrections

BooleanProperty Trk::MaterialEffectsUpdator::m_msgOutputCorrections

private

Initial value:

{this, "ScreenOutputCorrections", false,
    "screen output of actual corrections"}

Definition at line 320 of file MaterialEffectsUpdator.h.

                                        {this, "ScreenOutputCorrections", false,
    "screen output of actual corrections"};

m_msgOutputValidationDirection

BooleanProperty Trk::MaterialEffectsUpdator::m_msgOutputValidationDirection

private

Initial value:

{this, "ScreenOutputValidationDirection", true,
     "validation direction used for screen output"}

Definition at line 317 of file MaterialEffectsUpdator.h.

    {this, "ScreenOutputValidationDirection", true,
     "validation direction used for screen output"};

m_msUpdator

ToolHandle<IMultipleScatteringUpdator> Trk::MaterialEffectsUpdator::m_msUpdator

private

Initial value:

{this, "MultipleScatteringUpdator",
     "Trk::MultipleScatteringUpdator/AtlasMultipleScatteringUpdator",
     "AlgoTool for MultipleScatterin effects"}

Definition at line 345 of file MaterialEffectsUpdator.h.

    {this, "MultipleScatteringUpdator",
     "Trk::MultipleScatteringUpdator/AtlasMultipleScatteringUpdator",
     "AlgoTool for MultipleScatterin effects"};

m_useMostProbableEloss

BooleanProperty Trk::MaterialEffectsUpdator::m_useMostProbableEloss

private

Initial value:

{this, "MostProbableEnergyLoss", false,
    "use the most probable energy loss"}

Definition at line 314 of file MaterialEffectsUpdator.h.

                                        {this, "MostProbableEnergyLoss", false,
    "use the most probable energy loss"};

m_validationDirection

IntegerProperty Trk::MaterialEffectsUpdator::m_validationDirection

private

Initial value:

{this, "ValidationDirection", 1,
    "validation direction"}

Definition at line 332 of file MaterialEffectsUpdator.h.

                                       {this, "ValidationDirection", 1,
    "validation direction"};

m_validationIgnoreUnmeasured

BooleanProperty Trk::MaterialEffectsUpdator::m_validationIgnoreUnmeasured

private

Initial value:

{this, "ValidationIgnoreUnmeasured", false,
     "Ignore unmeasured TrackParameters (Navigation!)"}

Definition at line 327 of file MaterialEffectsUpdator.h.

    {this, "ValidationIgnoreUnmeasured", false,
     "Ignore unmeasured TrackParameters (Navigation!)"};

m_validationMode

BooleanProperty Trk::MaterialEffectsUpdator::m_validationMode

private

Initial value:

{this, "ValidationMode", false,
    "Switch for validation mode"}

Definition at line 325 of file MaterialEffectsUpdator.h.

                                  {this, "ValidationMode", false,
    "Switch for validation mode"};

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.

---

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

• MaterialEffectsUpdator.h
• MaterialEffectsUpdator.cxx