ActsTrk::MeasurementToTrackParticleDecorationAlg Class Reference

#include <MeasurementToTrackParticleDecorationAlg.h>

Inheritance diagram for ActsTrk::MeasurementToTrackParticleDecorationAlg:

Collaboration diagram for ActsTrk::MeasurementToTrackParticleDecorationAlg:

Public Member Functions
	MeasurementToTrackParticleDecorationAlg (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~MeasurementToTrackParticleDecorationAlg ()=default
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &ctx) const override
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
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	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

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
enum	Subdetector {   INVALID_DETECTOR =-1 , INNERMOST_PIXEL , PIXEL , STRIP ,   N_SUBDETECTORS }
enum	Region { INVALID_REGION =-1 , BARREL , ENDCAP }
enum	MeasurementType {   INVALID_MEASUREMENT =-1 , HIT , OUTLIER , HOLE ,   BIASED , UNBIASED }
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
float	getChi2Contribution (const typename ActsTrk::TrackStateBackend::ConstTrackStateProxy &state) const
std::pair< Acts::BoundVector, Acts::BoundMatrix >	getUnbiasedTrackParameters (const typename ActsTrk::TrackStateBackend::ConstTrackStateProxy &state, bool useSmoothed=true) const
float	evaluatePull (const float residual, const float measurementCovariance, const float trackParameterCovariance, const bool evaluateUnbiased) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
PublicToolHandle< ActsTrk::ITrackingGeometryTool >	m_trackingGeometryTool {this, "TrackingGeometryTool", ""}
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_trackParticlesKey
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_measurementRegionKey
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_measurementDetectorKey
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_measurementLayerKey
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_chi2HitPredictedKey
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_chi2HitFilteredKey
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_measurementTypeKey
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_measurementPhiWidthKey
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_measurementEtaWidthKey
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_residualLocXkey
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_pullLocXkey
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_measurementLocXkey
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_trackParameterLocXkey
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_measurementLocCovXkey
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_trackParameterLocCovXkey
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_residualLocYkey
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_pullLocYkey
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_measurementLocYkey
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_trackParameterLocYkey
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_measurementLocCovYkey
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_trackParameterLocCovYkey
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
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

Definition at line 33 of file MeasurementToTrackParticleDecorationAlg.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

MeasurementType

enum ActsTrk::MeasurementToTrackParticleDecorationAlg::MeasurementType

private

Enumerator
INVALID_MEASUREMENT
HIT
OUTLIER
HOLE
BIASED
UNBIASED

Definition at line 48 of file MeasurementToTrackParticleDecorationAlg.h.

                             {
        INVALID_MEASUREMENT=-1, HIT, OUTLIER, HOLE, BIASED, UNBIASED
        };

Region

enum ActsTrk::MeasurementToTrackParticleDecorationAlg::Region

private

Enumerator
INVALID_REGION
BARREL
ENDCAP

Definition at line 45 of file MeasurementToTrackParticleDecorationAlg.h.

                    {
            INVALID_REGION=-1, BARREL, ENDCAP
        };

Subdetector

enum ActsTrk::MeasurementToTrackParticleDecorationAlg::Subdetector

private

Enumerator
INVALID_DETECTOR
INNERMOST_PIXEL
PIXEL
STRIP
N_SUBDETECTORS

Definition at line 42 of file MeasurementToTrackParticleDecorationAlg.h.

                         {
            INVALID_DETECTOR=-1, INNERMOST_PIXEL, PIXEL, STRIP, N_SUBDETECTORS
        };

Constructor & Destructor Documentation

MeasurementToTrackParticleDecorationAlg()

ActsTrk::MeasurementToTrackParticleDecorationAlg::MeasurementToTrackParticleDecorationAlg	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 24 of file MeasurementToTrackParticleDecorationAlg.cxx.

                                                                       :
      AthReentrantAlgorithm(name,pSvcLocator)
    {}

~MeasurementToTrackParticleDecorationAlg()

virtual ActsTrk::MeasurementToTrackParticleDecorationAlg::~MeasurementToTrackParticleDecorationAlg ( )

virtualdefault

Member Function Documentation

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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; }

evaluatePull()

float ActsTrk::MeasurementToTrackParticleDecorationAlg::evaluatePull ( const float residual, const float measurementCovariance, const float trackParameterCovariance, const bool evaluateUnbiased ) const

private

Definition at line 406 of file MeasurementToTrackParticleDecorationAlg.cxx.

                                                                     {
    float correlation = evaluateUnbiased ? 1. : -1.;
    float residualCovariance = measurementCovariance + correlation*trackParameterCovariance;
    if (residualCovariance<=0.) {
      // If the total covariance is non-positive return 0
      ATH_MSG_DEBUG("--- Total covariance for pull evaluation is non-positive! Returning pulls = 0!");
      return 0.;
    }
    return 0.001 * residual/std::sqrt(residualCovariance);
  }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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; }

execute()

StatusCode ActsTrk::MeasurementToTrackParticleDecorationAlg::execute ( const EventContext & ctx ) const

overridevirtual

Definition at line 62 of file MeasurementToTrackParticleDecorationAlg.cxx.

    {
        ATH_MSG_DEBUG("Executing " << name() << " ...");
 
    auto tgContext = m_trackingGeometryTool->getGeometryContext(ctx).context();
 
    SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<int>> measurementRegionHandle(m_measurementRegionKey, ctx);
    SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<int>> measurementDetectorHandle(m_measurementDetectorKey, ctx);
    SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<int>> measurementLayerHandle(m_measurementLayerKey, ctx);
    SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<int>> measurementTypeHandle(m_measurementTypeKey, ctx);
    SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<float>> chi2HitPredictedHandle(m_chi2HitPredictedKey, ctx);
    SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<float>> chi2HitFilteredHandle(m_chi2HitFilteredKey, ctx);
    
    SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<int>> measurementPhiWidthHandle(m_measurementPhiWidthKey, ctx);
    SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<int>> measurementEtaWidthHandle(m_measurementEtaWidthKey, ctx);
    
    SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<float>> residualLocXhandle(m_residualLocXkey, ctx);
    SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<float>> pullLocXhandle(m_pullLocXkey, ctx);
    SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<float>> measurementLocXhandle(m_measurementLocXkey, ctx);
    SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<float>> trackParameterLocXhandle(m_trackParameterLocXkey, ctx);
    SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<float>> measurementLocCovXhandle(m_measurementLocCovXkey, ctx);
    SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<float>> trackParameterLocCovXhandle(m_trackParameterLocCovXkey, ctx);
    
    SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<float>> residualLocYhandle(m_residualLocYkey, ctx);
    SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<float>> pullLocYhandle(m_pullLocYkey, ctx);
    SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<float>> measurementLocYhandle(m_measurementLocYkey, ctx);
    SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<float>> trackParameterLocYhandle(m_trackParameterLocYkey, ctx);
    SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<float>> measurementLocCovYhandle(m_measurementLocCovYkey, ctx);
    SG::WriteDecorHandle<xAOD::TrackParticleContainer, std::vector<float>> trackParameterLocCovYhandle(m_trackParameterLocCovYkey, ctx);
    
    SG::ReadHandle<xAOD::TrackParticleContainer> trackParticlesHandle = SG::makeHandle(m_trackParticlesKey, ctx);
        ATH_CHECK(trackParticlesHandle.isValid());
        const xAOD::TrackParticleContainer *track_particles = trackParticlesHandle.cptr();
 
        static const SG::AuxElement::ConstAccessor<ElementLink<ActsTrk::TrackContainer> > actsTrackLink("actsTrack");
 
        for (const xAOD::TrackParticle *track_particle : *track_particles) {
            ElementLink<ActsTrk::TrackContainer> link_to_track = actsTrackLink(*track_particle);
            ATH_CHECK(link_to_track.isValid());
 
            // to ensure that the code does not suggest something stupid (i.e. creating an unnecessary copy)
            static_assert( std::is_same<ElementLink<ActsTrk::TrackContainer>::ElementConstReference,
                           std::optional<ActsTrk::TrackContainer::ConstTrackProxy> >::value);
            std::optional<ActsTrk::TrackContainer::ConstTrackProxy> optional_track = *link_to_track;
 
            if ( not optional_track.has_value() ) {
          ATH_MSG_WARNING("Invalid track link for particle  " << track_particle->index() << ". Skipping track..");
          continue;  
            }
        
            ATH_MSG_DEBUG("Track link found for track particle with index  " << track_particle->index());
            ActsTrk::TrackContainer::ConstTrackProxy track = optional_track.value();
 
        std::vector<int>& regions{measurementRegionHandle(*track_particle)};
            regions.reserve(track.nMeasurements());
            std::vector<int>& detectors{measurementDetectorHandle(*track_particle)};
            detectors.reserve(track.nMeasurements());
            std::vector<int>& layers{measurementLayerHandle(*track_particle)};
            layers.reserve(track.nMeasurements());
            std::vector<int>& types{measurementTypeHandle(*track_particle)};
            types.reserve(track.nMeasurements());
        std::vector<float>& predchi2s{chi2HitPredictedHandle(*track_particle)};
        predchi2s.reserve(track.nMeasurements());
        std::vector<float>& filtchi2s{chi2HitFilteredHandle(*track_particle)};
        filtchi2s.reserve(track.nMeasurements());
        
        std::vector<int>& sizesPhi{measurementPhiWidthHandle(*track_particle)};
            sizesPhi.reserve(track.nMeasurements());
            std::vector<int>& sizesEta{measurementEtaWidthHandle(*track_particle)};
            sizesEta.reserve(track.nMeasurements());
            std::vector<float>& residualsLocX{residualLocXhandle(*track_particle)};
            residualsLocX.reserve(track.nMeasurements());
            std::vector<float>& pullsLocX{pullLocXhandle(*track_particle)};
            pullsLocX.reserve(track.nMeasurements());
            std::vector<float>& measurementsLocX{measurementLocXhandle(*track_particle)};
            measurementsLocX.reserve(track.nMeasurements());
            std::vector<float>& trackParametersLocX{trackParameterLocXhandle(*track_particle)};
            trackParametersLocX.reserve(track.nMeasurements());
            std::vector<float>& measurementsLocCovX{measurementLocCovXhandle(*track_particle)};
            measurementsLocCovX.reserve(track.nMeasurements());
            std::vector<float>& trackParametersLocCovX{trackParameterLocCovXhandle(*track_particle)};
            trackParametersLocCovX.reserve(track.nMeasurements());
            std::vector<float>& residualsLocY{residualLocYhandle(*track_particle)};
            residualsLocY.reserve(track.nMeasurements());
            std::vector<float>& pullsLocY{pullLocYhandle(*track_particle)};
            pullsLocY.reserve(track.nMeasurements());
            std::vector<float>& measurementsLocY{measurementLocYhandle(*track_particle)};
            measurementsLocY.reserve(track.nMeasurements());
            std::vector<float>& trackParametersLocY{trackParameterLocYhandle(*track_particle)};
            trackParametersLocY.reserve(track.nMeasurements());
            std::vector<float>& measurementsLocCovY{measurementLocCovYhandle(*track_particle)};
            measurementsLocCovY.reserve(track.nMeasurements());
            std::vector<float>& trackParametersLocCovY{trackParameterLocCovYhandle(*track_particle)};
            trackParametersLocCovY.reserve(track.nMeasurements());
 
            for (const auto state : track.trackStatesReversed()) {
 
                auto flag = state.typeFlags();
        // consider holes and measurements (also outliers)
                bool anyHit = flag.test(Acts::TrackStateFlag::HoleFlag) or flag.test(Acts::TrackStateFlag::MeasurementFlag);
        if (not anyHit) {
                    ATH_MSG_DEBUG("--- This is not a hit measurement, skipping...");
                    continue;
                }
 
        // starting with invalid values and setting them where needed.
 
                int detector = -999;
        int region = -999;
        int layer = -999;
        int type = -999;
        float chi2_hit_predicted = -999.;
        float chi2_hit_filtered = -999.;
        int sizePhi = -999;
        int sizeEta = -999;
                float residualLocX = -999.;
        float pullLocX = -999.;
        float measurementLocX = -999.;
        float trackParameterLocX = -999.;
        float measurementLocCovX = -999.;
        float trackParameterLocCovX = -999;
                float residualLocY = -999.;
        float pullLocY = -999.;
        float measurementLocY = -999.;
        float trackParameterLocY = -999.;
        float measurementLocCovY = -999.;
        float trackParameterLocCovY = -999.;
        bool isAnnulusBound = false;
        
        // Get the measurement type
        if (flag.test(Acts::TrackStateFlag::HoleFlag)) {
          type = MeasurementType::HOLE;
          ATH_MSG_DEBUG("--- This is a hole");
                } else if (flag.test(Acts::TrackStateFlag::OutlierFlag)) {
          type = MeasurementType::OUTLIER;
          ATH_MSG_DEBUG("--- This is an outlier");
                } else {
          type = MeasurementType::HIT;
          ATH_MSG_DEBUG("--- This is a hit");
                }
        
        // Check the location of the state
        if (state.hasReferenceSurface() and state.referenceSurface().associatedDetectorElement()) {
            const ActsDetectorElement * detectorElement = dynamic_cast<const ActsDetectorElement *>(state.referenceSurface().associatedDetectorElement());
            if (!detectorElement) {
              ATH_MSG_WARNING("--- TrackState reference surface returned an invalid associated detector element");
              continue;
            }
            const InDetDD::SiDetectorElement * siliconDetectorElement = dynamic_cast<const InDetDD::SiDetectorElement *>(detectorElement->upstreamDetectorElement());
            if (!siliconDetectorElement) {
              ATH_MSG_WARNING("--- TrackState associated detector element is not silicon");
              continue;
            }
            
            const Acts::AnnulusBounds* annulusBounds = dynamic_cast<const Acts::AnnulusBounds*>(&(state.referenceSurface().bounds()));
                    isAnnulusBound = annulusBounds ? true : false;
            
                    if (siliconDetectorElement) {
                        Identifier detectorIdentifier = siliconDetectorElement->identify();
                        if (siliconDetectorElement->isPixel()) {
              const PixelID* pixel_id = static_cast<const PixelID *>(siliconDetectorElement->getIdHelper());
                            int layer_disk = pixel_id->layer_disk(detectorIdentifier);
                            layer = layer_disk;
                            if (pixel_id->barrel_ec(detectorIdentifier) == 0) {
                              if (layer_disk == 0) {
                                detector = Subdetector::INNERMOST_PIXEL;
                              } else detector = Subdetector::PIXEL;
                              region = Region::BARREL;
                            } else {
                              detector = Subdetector::PIXEL;
                              region = Region::ENDCAP;
                            }
                        } else if (siliconDetectorElement->isSCT()) {
              const SCT_ID* sct_id = static_cast<const SCT_ID *>(siliconDetectorElement->getIdHelper());
              detector = Subdetector::STRIP;
              region =  sct_id->barrel_ec(detectorIdentifier) == 0 ?
                Region::BARREL : Region::ENDCAP;
              layer = sct_id->layer_disk(detectorIdentifier);;
                        } else ATH_MSG_WARNING("--- Unknown detector type - It is not pixel nor strip detecor element!");
                    } else ATH_MSG_WARNING("--- Missing silicon detector element!");
                } else ATH_MSG_WARNING("--- Missing reference surface or associated detector element!");
 
 
        
        // If I have a measurement (hit or outlier) then proceed with computing the residuals / pulls
        
        if (type == MeasurementType::OUTLIER || type == MeasurementType::HIT) {
 
          //Get the Chi2 computation
          
          if (type == MeasurementType::HIT) {
            chi2_hit_filtered = state.chi2();
          }
          
          if (state.hasUncalibratedSourceLink()) {
            chi2_hit_predicted = getChi2Contribution(state);
          }
                  
          // Skip all states without smoothed parameters or without projector
          if (!state.hasSmoothed() || !state.hasProjector())
            continue;
          
          // Calling effective Calibrated has some runtime overhead
          const auto &calibratedParameters = state.effectiveCalibrated();
          const auto &calibratedCovariance = state.effectiveCalibratedCovariance();
          
          // We evaluate the unbiased parameters for:
          // - measurements added to the fit. For outliers, the measurement is not part of the fit, hence track parameters are already unbiased
          // - if the filtered parameters and the projector exist.
          bool evaluateUnbiased = (!flag.test(Acts::TrackStateFlag::OutlierFlag));
          
          if (evaluateUnbiased) {
                    ATH_MSG_DEBUG("--- Good for unbiased parameters evaluation!");
                    type = MeasurementType::UNBIASED;
                    // if unbiased, access the associated uncalibrated measurement and store the size
                    if (state.hasUncalibratedSourceLink()) {
              ATLASUncalibSourceLink sourceLink = state.getUncalibratedSourceLink().template get<ATLASUncalibSourceLink>();
              const xAOD::UncalibratedMeasurement &uncalibratedMeasurement = getUncalibratedMeasurement(sourceLink);
              const xAOD::UncalibMeasType measurementType = uncalibratedMeasurement.type();
              if (measurementType == xAOD::UncalibMeasType::PixelClusterType) {
            auto pixelCluster = static_cast<const xAOD::PixelCluster *>(&uncalibratedMeasurement);
            sizePhi = pixelCluster->channelsInPhi();
            sizeEta = pixelCluster->channelsInEta();
              } else if (measurementType == xAOD::UncalibMeasType::StripClusterType) {
            auto stripCluster = static_cast<const xAOD::StripCluster *>(&uncalibratedMeasurement);
            sizePhi = stripCluster->channelsInPhi();
              } else {
            ATH_MSG_DEBUG("xAOD::UncalibratedMeasurement is neither xAOD::PixelCluster nor xAOD::StripCluster");
              }
                    }
          }
          
          const auto& [unbiasedParameters, unbiasedCovariance] =
            evaluateUnbiased ? Acts::calculateUnbiasedParametersCovariance(state) : std::make_pair(state.parameters(), state.covariance());
          
          measurementLocX = calibratedParameters[Acts::eBoundLoc0];
          measurementLocCovX = calibratedCovariance(Acts::eBoundLoc0, Acts::eBoundLoc0);
          
          if (!isAnnulusBound) {
            
            trackParameterLocX = unbiasedParameters[Acts::eBoundLoc0];
            residualLocX = (measurementLocX - trackParameterLocX) / 1_um; //in um
            trackParameterLocCovX = unbiasedCovariance(Acts::eBoundLoc0, Acts::eBoundLoc0);
          }
          else {
            // TODO:: use directly phi instead of r*phi in the future
            
            float locR    = unbiasedParameters[Acts::eBoundLoc0];
            float covR    = unbiasedCovariance(Acts::eBoundLoc0,Acts::eBoundLoc0);
            float locphi  = unbiasedParameters[Acts::eBoundLoc1];
            float covphi  = unbiasedCovariance(Acts::eBoundLoc1,Acts::eBoundLoc1);
            float covRphi = unbiasedCovariance(Acts::eBoundLoc0,Acts::eBoundLoc1);
            
            trackParameterLocX = locphi;
            residualLocX = locR * (measurementLocX - trackParameterLocX) / 1_um;
            // Compute the error on the local rphi                                                                                                                  
            trackParameterLocCovX = locR*locR*covphi + locphi*locphi*covR + 2*locphi*locR*covRphi;
            
            // Rescale the error of the measurement to Rphi.
            measurementLocCovX = locR*locR * measurementLocCovX;
          }
          
          pullLocX = evaluatePull(residualLocX, measurementLocCovX,
                      trackParameterLocCovX, evaluateUnbiased);
          
          if (state.calibratedSize() == 2) {
            measurementLocY = calibratedParameters[Acts::eBoundLoc1];
            trackParameterLocY = unbiasedParameters[Acts::eBoundLoc1];
            residualLocY = (measurementLocY - trackParameterLocY) / 1_um;
            measurementLocCovY = calibratedCovariance(Acts::eBoundLoc1, Acts::eBoundLoc1);
            trackParameterLocCovY = unbiasedCovariance(Acts::eBoundLoc1, Acts::eBoundLoc1);
            pullLocY = evaluatePull(residualLocY, measurementLocCovY,
                        trackParameterLocCovY, evaluateUnbiased);
          }
          
        } // hit or outliers
 
        else if (type == MeasurementType::HOLE) {
          
          // Get the predicted position on sensor
          auto pred = state.predicted();
          trackParameterLocX = pred[Acts::eBoundLoc0];
          trackParameterLocY = pred[Acts::eBoundLoc1];
        }
        
        // Always fill with this information
        
        regions.push_back(region);
                detectors.push_back(detector);
                layers.push_back(layer);
                types.push_back(type);
        predchi2s.push_back(chi2_hit_predicted);
        filtchi2s.push_back(chi2_hit_filtered);
                sizesPhi.push_back(sizePhi);
                sizesEta.push_back(sizeEta);
                residualsLocX.push_back(residualLocX);
                pullsLocX.push_back(pullLocX);
                measurementsLocX.push_back(measurementLocX);
                trackParametersLocX.push_back(trackParameterLocX);
                measurementsLocCovX.push_back(measurementLocCovX);
                trackParametersLocCovX.push_back(trackParameterLocCovX);
                residualsLocY.push_back(residualLocY);
                pullsLocY.push_back(pullLocY);
                measurementsLocY.push_back(measurementLocY);
                trackParametersLocY.push_back(trackParameterLocY);
                measurementsLocCovY.push_back(measurementLocCovY);
                trackParametersLocCovY.push_back(trackParameterLocCovY);
    
        
            } // loop on states
        
    } // loop on tracks
 
        return StatusCode::SUCCESS;
    }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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

extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

getChi2Contribution()

float ActsTrk::MeasurementToTrackParticleDecorationAlg::getChi2Contribution ( const typename ActsTrk::TrackStateBackend::ConstTrackStateProxy & state ) const

private

Definition at line 378 of file MeasurementToTrackParticleDecorationAlg.cxx.

                                                                                                                                             {
    
    auto pred  = state.predicted();
    auto predC = state.predictedCovariance();
 
    return Acts::visit_measurement(
      state.calibratedSize(),
      [&]<std::size_t measdim>(std::integral_constant<std::size_t, measdim>) {
        Acts::FixedBoundSubspaceHelper<measdim> subspaceHelper =
            state.template projectorSubspaceHelper<measdim>();
 
        // TODO use subspace helper for projection instead
        auto H = subspaceHelper.projector();
 
        const auto calibrated    = state.template calibrated<measdim>();
        const auto calibratedCov = state.template calibratedCovariance<measdim>();
        
        auto residual = (H * pred - calibrated).eval();
        auto rescov   = (H * predC * H.transpose() + calibratedCov).eval();
 
        return ((residual.transpose() * rescov.inverse() * residual).eval())(0,0);
    });
 
 
        
  }

getUnbiasedTrackParameters()

std::pair< Acts::BoundVector, Acts::BoundMatrix > ActsTrk::MeasurementToTrackParticleDecorationAlg::getUnbiasedTrackParameters ( const typename ActsTrk::TrackStateBackend::ConstTrackStateProxy & state, bool useSmoothed = true ) const

private

initialize()

StatusCode ActsTrk::MeasurementToTrackParticleDecorationAlg::initialize ( )

overridevirtual

Definition at line 29 of file MeasurementToTrackParticleDecorationAlg.cxx.

    {
        ATH_MSG_DEBUG("Initializing " << name() << " ...");
    
        ATH_CHECK(m_trackParticlesKey.initialize());
 
    // Decorations
    ATH_CHECK(m_measurementRegionKey.initialize());
    ATH_CHECK(m_measurementDetectorKey.initialize());
        ATH_CHECK(m_measurementLayerKey.initialize());
    ATH_CHECK(m_chi2HitPredictedKey.initialize());
    ATH_CHECK(m_chi2HitFilteredKey.initialize());
        ATH_CHECK(m_measurementTypeKey.initialize());
        ATH_CHECK(m_measurementPhiWidthKey.initialize());
        ATH_CHECK(m_measurementEtaWidthKey.initialize());
        ATH_CHECK(m_residualLocXkey.initialize());
        ATH_CHECK(m_pullLocXkey.initialize());
        ATH_CHECK(m_measurementLocXkey.initialize());
        ATH_CHECK(m_trackParameterLocXkey.initialize());
        ATH_CHECK(m_measurementLocCovXkey.initialize());
        ATH_CHECK(m_trackParameterLocCovXkey.initialize());
        ATH_CHECK(m_residualLocYkey.initialize());
        ATH_CHECK(m_pullLocYkey.initialize());
        ATH_CHECK(m_measurementLocYkey.initialize());
        ATH_CHECK(m_trackParameterLocYkey.initialize());
        ATH_CHECK(m_measurementLocCovYkey.initialize());
        ATH_CHECK(m_trackParameterLocCovYkey.initialize());
 
    ATH_CHECK(m_trackingGeometryTool.retrieve());
    
        return StatusCode::SUCCESS;
    }

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  return true;
}

msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::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< Gaudi::Algorithm > >::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.

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< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

                                                               {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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);
      }
    }
  }

Member Data Documentation

m_chi2HitFilteredKey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_chi2HitFilteredKey

private

Initial value:

{
    this, "Chi2HitFilteredKey", m_trackParticlesKey, "chi2_hit_filtered",
    "Filtered Chi2 contribution for each hit"}

Definition at line 80 of file MeasurementToTrackParticleDecorationAlg.h.

                                                                            {
    this, "Chi2HitFilteredKey", m_trackParticlesKey, "chi2_hit_filtered",
    "Filtered Chi2 contribution for each hit"};

m_chi2HitPredictedKey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_chi2HitPredictedKey

private

Initial value:

{
    this, "Chi2HitPredictedKey", m_trackParticlesKey, "chi2_hit_predicted",
    "Predicted Chi2 contribution for each hit"}

Definition at line 77 of file MeasurementToTrackParticleDecorationAlg.h.

                                                                             {
    this, "Chi2HitPredictedKey", m_trackParticlesKey, "chi2_hit_predicted",
    "Predicted Chi2 contribution for each hit"};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_measurementDetectorKey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_measurementDetectorKey

private

Initial value:

{
    this, "MeasurementDetectorKey", m_trackParticlesKey, "measurement_det",
    "Decorate track particle with measurement detector id (innermost pix, pix, strip)"}

Definition at line 71 of file MeasurementToTrackParticleDecorationAlg.h.

                                                                                {
    this, "MeasurementDetectorKey", m_trackParticlesKey, "measurement_det",
    "Decorate track particle with measurement detector id (innermost pix, pix, strip)"};

m_measurementEtaWidthKey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_measurementEtaWidthKey

private

Initial value:

{
    this, "MeasurementEtaWidthKey", m_trackParticlesKey, "hitResiduals_etaWidth",
    "Decorate track particle with measurement cluster size (in eta)"}

Definition at line 89 of file MeasurementToTrackParticleDecorationAlg.h.

                                                                                {
    this, "MeasurementEtaWidthKey", m_trackParticlesKey, "hitResiduals_etaWidth",
    "Decorate track particle with measurement cluster size (in eta)"};

m_measurementLayerKey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_measurementLayerKey

private

Initial value:

{
    this, "MeasurementLayerKey", m_trackParticlesKey, "measurement_iLayer",
    "Decorate track particle with measurement layer"}

Definition at line 74 of file MeasurementToTrackParticleDecorationAlg.h.

                                                                             {
    this, "MeasurementLayerKey", m_trackParticlesKey, "measurement_iLayer",
    "Decorate track particle with measurement layer"};

m_measurementLocCovXkey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_measurementLocCovXkey

private

Initial value:

{
    this, "MeasurementLocCovXkey", m_trackParticlesKey, "measurementLocCovX",
    "Decorate track particle with local x measurement covariance"}

Definition at line 106 of file MeasurementToTrackParticleDecorationAlg.h.

                                                                               {
    this, "MeasurementLocCovXkey", m_trackParticlesKey, "measurementLocCovX",
    "Decorate track particle with local x measurement covariance"};

m_measurementLocCovYkey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_measurementLocCovYkey

private

Initial value:

{
    this, "MeasurementLocCovYkey", m_trackParticlesKey, "measurementLocCovY",
    "Decorate track particle with local y measurement covariance"}

Definition at line 125 of file MeasurementToTrackParticleDecorationAlg.h.

                                                                               {
    this, "MeasurementLocCovYkey", m_trackParticlesKey, "measurementLocCovY",
    "Decorate track particle with local y measurement covariance"};

m_measurementLocXkey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_measurementLocXkey

private

Initial value:

{
    this, "MeasurementLocXkey", m_trackParticlesKey, "measurementLocX",
    "Decorate track particle with measurement local x"}

Definition at line 100 of file MeasurementToTrackParticleDecorationAlg.h.

                                                                            {
    this, "MeasurementLocXkey", m_trackParticlesKey, "measurementLocX",
    "Decorate track particle with measurement local x"};

m_measurementLocYkey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_measurementLocYkey

private

Initial value:

{
    this, "MeasurementLocYkey", m_trackParticlesKey, "measurementLocY",
    "Decorate track particle with measurement local y"}

Definition at line 119 of file MeasurementToTrackParticleDecorationAlg.h.

                                                                            {
    this, "MeasurementLocYkey", m_trackParticlesKey, "measurementLocY",
    "Decorate track particle with measurement local y"};

m_measurementPhiWidthKey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_measurementPhiWidthKey

private

Initial value:

{
    this, "MeasurementPhiWidthKey", m_trackParticlesKey, "hitResiduals_phiWidth",
    "Decorate track particle with measurement cluster size (in r-phi)"}

Definition at line 86 of file MeasurementToTrackParticleDecorationAlg.h.

                                                                                {
    this, "MeasurementPhiWidthKey", m_trackParticlesKey, "hitResiduals_phiWidth",
    "Decorate track particle with measurement cluster size (in r-phi)"};

m_measurementRegionKey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_measurementRegionKey

private

Initial value:

{
    this, "MeasurementRegionKey", m_trackParticlesKey, "measurement_region",
    "Decorate track particle with region of the measurement (barrel, ec)"}

Definition at line 68 of file MeasurementToTrackParticleDecorationAlg.h.

                                                                              {
    this, "MeasurementRegionKey", m_trackParticlesKey, "measurement_region",
    "Decorate track particle with region of the measurement (barrel, ec)"};

m_measurementTypeKey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_measurementTypeKey

private

Initial value:

{
    this, "MeasurementTypeKey", m_trackParticlesKey, "measurement_type",
    "Decorate track particle with type of track state (outlier,hole, biased/unbiased)"}

Definition at line 83 of file MeasurementToTrackParticleDecorationAlg.h.

                                                                            {
    this, "MeasurementTypeKey", m_trackParticlesKey, "measurement_type",
    "Decorate track particle with type of track state (outlier,hole, biased/unbiased)"};

m_pullLocXkey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_pullLocXkey

private

Initial value:

{
    this, "PullLocXkey", m_trackParticlesKey, "hitResiduals_pullLocX",
    "Decorate track particle with unbiased pull in local x"}

Definition at line 97 of file MeasurementToTrackParticleDecorationAlg.h.

                                                                     {
    this, "PullLocXkey", m_trackParticlesKey, "hitResiduals_pullLocX",
    "Decorate track particle with unbiased pull in local x"};

m_pullLocYkey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_pullLocYkey

private

Initial value:

{
    this, "PullLocYkey", m_trackParticlesKey, "hitResiduals_pullLocY",
    "Decorate track particle with unbiased pull in local y"}

Definition at line 116 of file MeasurementToTrackParticleDecorationAlg.h.

                                                                     {
    this, "PullLocYkey", m_trackParticlesKey, "hitResiduals_pullLocY",
    "Decorate track particle with unbiased pull in local y"};

m_residualLocXkey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_residualLocXkey

private

Initial value:

{
    this, "ResidualLocXkey", m_trackParticlesKey, "hitResiduals_residualLocX",
    "Decorate track particle with unbiased residual in local x"}

Definition at line 94 of file MeasurementToTrackParticleDecorationAlg.h.

                                                                         {
    this, "ResidualLocXkey", m_trackParticlesKey, "hitResiduals_residualLocX",
    "Decorate track particle with unbiased residual in local x"};

m_residualLocYkey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_residualLocYkey

private

Initial value:

{
    this, "ResidualLocYkey", m_trackParticlesKey, "hitResiduals_residualLocY",
    "Decorate track particle with unbiased residual in local y"}

Definition at line 113 of file MeasurementToTrackParticleDecorationAlg.h.

                                                                         {
    this, "ResidualLocYkey", m_trackParticlesKey, "hitResiduals_residualLocY",
    "Decorate track particle with unbiased residual in local y"};

m_trackingGeometryTool

PublicToolHandle<ActsTrk::ITrackingGeometryTool> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_trackingGeometryTool {this, "TrackingGeometryTool", ""}

private

Definition at line 63 of file MeasurementToTrackParticleDecorationAlg.h.

{this, "TrackingGeometryTool", ""};

m_trackParameterLocCovXkey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_trackParameterLocCovXkey

private

Initial value:

{
    this, "TrackParameterLocCovXkey", m_trackParticlesKey, "trackParameterLocCovX",
    "Decorate track particle with unbiased local x prediction covariance"}

Definition at line 109 of file MeasurementToTrackParticleDecorationAlg.h.

                                                                                  {
    this, "TrackParameterLocCovXkey", m_trackParticlesKey, "trackParameterLocCovX",
    "Decorate track particle with unbiased local x prediction covariance"};

m_trackParameterLocCovYkey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_trackParameterLocCovYkey

private

Initial value:

{
    this, "TrackParameterLocCovYkey", m_trackParticlesKey, "trackParameterLocCovY",
    "Decorate track particle with unbiased local y prediction covariance"}

Definition at line 128 of file MeasurementToTrackParticleDecorationAlg.h.

                                                                                  {
    this, "TrackParameterLocCovYkey", m_trackParticlesKey, "trackParameterLocCovY",
    "Decorate track particle with unbiased local y prediction covariance"};

m_trackParameterLocXkey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_trackParameterLocXkey

private

Initial value:

{
    this, "TrackParameterLocXkey", m_trackParticlesKey, "trackParamLocX",
    "Decorate track particle with unbiased prediction in local x"}

Definition at line 103 of file MeasurementToTrackParticleDecorationAlg.h.

                                                                               {
    this, "TrackParameterLocXkey", m_trackParticlesKey, "trackParamLocX",
    "Decorate track particle with unbiased prediction in local x"};

m_trackParameterLocYkey

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_trackParameterLocYkey

private

Initial value:

{
    this, "TrackParameterLocYkey", m_trackParticlesKey, "trackParamLocY",
    "Decorate track particle with unbiased prediction in local y"}

Definition at line 122 of file MeasurementToTrackParticleDecorationAlg.h.

                                                                               {
    this, "TrackParameterLocYkey", m_trackParticlesKey, "trackParamLocY",
    "Decorate track particle with unbiased prediction in local y"};

m_trackParticlesKey

SG::ReadHandleKey<xAOD::TrackParticleContainer> ActsTrk::MeasurementToTrackParticleDecorationAlg::m_trackParticlesKey

private

Initial value:

{
    this, "TrackParticleKey", "", "Input track particle collection"}

Definition at line 65 of file MeasurementToTrackParticleDecorationAlg.h.

                                                                      {
    this, "TrackParticleKey", "", "Input track particle collection"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• MeasurementToTrackParticleDecorationAlg.h
• MeasurementToTrackParticleDecorationAlg.cxx