This validation tool writes the differences between two tracks into a ntuple. More...

#include <TrackDiff.h>

Inheritance diagram for Trk::TrackDiff:

Collaboration diagram for Trk::TrackDiff:

Public Member Functions
	TrackDiff (const std::string &, const std::string &, const IInterface *)
	~TrackDiff ()
StatusCode	initialize ()
StatusCode	finalize ()
	finalize
virtual StatusCode	diff (const Trk::Track &referenceTrack, const Trk::Track &comparedTrack)
	diff of two given tracks
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

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	Interface ID, declared here, and defined below.

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
DataVector< const Trk::TrackStateData > *	extractDataFromTrack (const Trk::Track &) const
	extract data from a Trk::Track into a list of Trk::TrackStateData
void	resetVariables ()
	reset the ntuple variables
Trk::TrackState::MeasurementType	detectorType (const Trk::RIO_OnTrack &ROT, std::string &detTypeName) const
	get detector type and name by identifier of Trk::RIO_OnTrack
bool	diffStateInfo (const Trk::TrackStateData refTrackStateData, const Trk::TrackStateData compareTrackStateData)
	diff of two given track state data
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
TTree *	m_nt
	Pointer to the NTuple tree.
AtlasDetectorID *	m_idHelper
	Used to find out the sub-det from PRD->identify().
std::string	m_ntupleFileName
	jobOption: Ntuple file name
std::string	m_ntupleDirName
	jobOption: Ntuple directory name
std::string	m_ntupleTreeName
	jobOption: Ntuple tree name
bool	m_compareOutliers
	jobOption: compare track states of type "outlier"
bool	m_compareAll
	jobOption: compare track states of all types
bool	m_writeNtuple
	jobOption: write data to ntuple?
bool	m_writeCompetingROT
	jobOption: write data about TrkCompetingRIOsOnTrack?
int	m_eventNumber
int	m_nRefStates [Trk::TrackState::NumberOfMeasurementTypes]
int	m_nCompStates [Trk::TrackState::NumberOfMeasurementTypes]
int	m_fakes [Trk::TrackState::NumberOfMeasurementTypes]
int	m_missed [Trk::TrackState::NumberOfMeasurementTypes]
int	m_wrongType [Trk::TrackState::NumberOfMeasurementTypes]
int	m_missingType [Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes]
int	m_fakeType [Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes]
int	m_refType [Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes]
int	m_compareType [Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes]
int	m_PRD_Mismatches [Trk::TrackState::NumberOfMeasurementTypes]
int	m_driftCircleSignFlips
int	m_noDriftTime
int	m_nDiffs
std::vector< int > *	m_detectorType
std::vector< int > *	m_isFake
	vector<bool> would be more efficient, but vector<bool> is not a normal vector<> and seems to make trouble
std::vector< int > *	m_isMissing
std::vector< int > *	m_isPRD_Mismatch
std::vector< int > *	m_isFlippedSign
std::vector< int > *	m_isNoDriftTime
std::vector< int > *	m_refIsMeasurement
std::vector< int > *	m_refIsOutlier
std::vector< int > *	m_compIsMeasurement
std::vector< int > *	m_compIsOutlier
std::vector< float > *	m_maxAssignProb
std::vector< float > *	m_sumAssignProb
std::vector< float > *	m_surfX
std::vector< float > *	m_surfY
std::vector< float > *	m_surfZ
float	m_trackEta
float	m_trackPhi
int	m_nRefStatesSum [Trk::TrackState::NumberOfMeasurementTypes]
int	m_nCompStatesSum [Trk::TrackState::NumberOfMeasurementTypes]
int	m_fakesSum [Trk::TrackState::NumberOfMeasurementTypes]
int	m_missedSum [Trk::TrackState::NumberOfMeasurementTypes]
int	m_wrongTypeSum [Trk::TrackState::NumberOfMeasurementTypes]
int	m_PRD_MismatchesSum [Trk::TrackState::NumberOfMeasurementTypes]
int	m_trackSum
SG::ReadHandleKey< xAOD::EventInfo >	m_evt {this, "EvtInfo", "EventInfo", "EventInfo name"}
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

Static Private Attributes
static const int	s_maxHits = 300

Detailed Description

This validation tool writes the differences between two tracks into a ntuple.

A detailed report of the differences found is written to the message stream in DEBUG mode.

In the finalize function a summary of all tracks is given.

Ntuple variables of Trk::TrackDiff

EventNumber	Number of the event the tracks belong to	int
RefTrackPhi0	Phi0 of the reference track	float
RefTrackEta0	Eta0 of the reference track	float
nRefStates	number of reference TSoS for each detector type	int[detTypes]
nCompareStates	number of TSoS of the compared track (for each detector type)	int[detTypes]
nFakeStates	number of TSoS of the compared track which are not included in the reference track (does not include wrong types), (for each detector type)	int[detTypes]
nMissedStates	number of TSoS of the reference track which are not included in the compared track (does not include wrong types, (for each detector type))	int[detTypes]
nWrongType	number of TSoS which have different types in the reference and the compared track (for each detector type)	int[detTypes]
nPRD_Mismatches	number of TSoS on the same detector surface which have different Trk::PrepRawData pointers (for each detector type)	int[detTypes]
nDriftCircleSignFlips	number of Trk::RIO_OnTrack in the TRT which have flipped drift radii signs	int
nRefTypes	number of reference TSoS for each TSoS type	int[tsosTypes]
nCompareTypes	number of compared TSoS for each TSoS type	int[tsosTypes]
nMissedTypes	number of TSoS which are not on the compared track (for each TSoS type)	int[tsosTypes]
nFakeTypes	number of TSoS which are not on the reference track (for each TSoS type)	int[tsosTypes]
nDiffs	number of differences found	int
MeasurementType	detector type in which the difference was found	int[nDiffs]
IsFake	is the difference a fake state?	vector<int> [nDiffs]
IsMissing	is the difference a missing state?	vector<int> [nDiffs]
IsPRD_Mismatch	is the diff as PRD mismatch?	vector<int> [nDiffs]
IsFlippedSign	has the diff flipped sign?	vector<int> [nDiffs]
IsNoDriftTime	has the diff !NoDriftTime?	vector<int> [nDiffs]
RefIsMeasurement	is reference state a measurement?	vector<int> [nDiffs]
RefIsOutlier	is reference state an outlier?	vector<int> [nDiffs]
ComparedIsMeasurement	is compared state a measurement?	vector<int> [nDiffs]
ComparedIsOutlier	is compared state an outlier?	vector<int> [nDiffs]
MaxAssgnProb	just if WriteCompetingROTdata=True: maximum assignment probability of the compared state	vector<float> [nDiffs]
SumAssgnProb	just if WriteCompetingROTdata=True: sum of assignment probabilities of the compared state	vector<float> [nDiffs]

All numbers contain just the Trk::TrackStateOnSurface which have the types selected in the jobOptions, i.e. in the standard configuration only Measurements and Outliers.

Author: Sebas.nosp@m.tian.nosp@m..Flei.nosp@m.schm.nosp@m.ann@c.nosp@m.ern..nosp@m.ch

Definition at line 76 of file TrackDiff.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ TrackDiff()

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

Definition at line 34 of file TrackDiff.cxx.

        :
        AthAlgTool(t,n,p),
        m_nt(nullptr),
        m_idHelper(nullptr),
        //strings initialised in job options
        m_compareOutliers(true),
        m_compareAll(false),
        m_writeNtuple(true),
        m_writeCompetingROT(false),
        m_eventNumber{},
        m_nRefStates{},
        m_nCompStates{},
        m_fakes{},
 
        m_missed{},
        m_wrongType{},
        m_missingType{},
        m_fakeType{},
        m_refType{},
        m_compareType{},
        m_PRD_Mismatches{},
        m_driftCircleSignFlips{},
        m_noDriftTime{},
        m_nDiffs{},
         m_detectorType{},
         m_isFake{},   
         m_isMissing{},
         m_isPRD_Mismatch{},
         m_isFlippedSign{},
         m_isNoDriftTime{},
         m_refIsMeasurement{},
         m_refIsOutlier{},
         m_compIsMeasurement{},
         m_compIsOutlier{},
         m_maxAssignProb{},
         m_sumAssignProb{},
         m_surfX{},
         m_surfY{},
         m_surfZ{},
        m_trackEta{},
        m_trackPhi{},
        m_nRefStatesSum{},
        m_nCompStatesSum{},
        m_fakesSum{},
        m_missedSum{},
        m_wrongTypeSum{},
        m_PRD_MismatchesSum{},
        m_trackSum(0) {
    declareInterface<ITrackDiff>(this);
    // Declare the properties
    //declareProperty("BookNewNtuple", m_bookNewNtuple = true);
    declareProperty("NtupleFileName",       m_ntupleFileName = "/NTUPLES");
    declareProperty("NtupleDirectoryName",  m_ntupleDirName = "TrackValidation");
    declareProperty("NtupleTreeName",       m_ntupleTreeName = "TrackDiff");
    //declareProperty("CompareMeasurements",  m_compareMeasurements = true);
    declareProperty("CompareOutliers",      m_compareOutliers = true);
    declareProperty("CompareAllTSoS",       m_compareAll = false);
    declareProperty("WriteNtuple",          m_writeNtuple = true);
    declareProperty("WriteCompetingROTdata",m_writeCompetingROT = false);
}

◆ ~TrackDiff()

Trk::TrackDiff::~TrackDiff ( )

default

Member Function Documentation

◆ 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());
  }

◆ detectorType()

Trk::TrackState::MeasurementType Trk::TrackDiff::detectorType	(	const Trk::RIO_OnTrack &	ROT,
		std::string &	detTypeName ) const

private

get detector type and name by identifier of Trk::RIO_OnTrack

determine detector type

Definition at line 488 of file TrackDiff.cxx.

                                                                                              {
    // identify by ROT of reference track:
    Identifier id = ROT.identify();
 
    // get dector type
    if ( id.is_valid()) {
        if (m_idHelper->is_pixel(id) ) {
            detTypeName = "Pixel";
            return Trk::TrackState::Pixel;
        } else if (m_idHelper->is_sct(id)) {
            detTypeName = "SCT";
            return Trk::TrackState::SCT;
        } else if (m_idHelper->is_trt(id)) {
            detTypeName = "TRT";
            return Trk::TrackState::TRT;
        } else if (m_idHelper->is_mdt(id)) {
            detTypeName = "MDT";
            return Trk::TrackState::MDT;
        } else if (m_idHelper->is_csc(id)) {
            detTypeName = "CSC";
            return Trk::TrackState::CSC;
        } else if (m_idHelper->is_rpc(id)) {
            detTypeName = "RPC";
            return Trk::TrackState::RPC;
        } else if (m_idHelper->is_tgc(id)) {
            detTypeName = "TGC";
            return Trk::TrackState::TGC;
        }
    }
    detTypeName = "unidentified";
    return Trk::TrackState::unidentified;
}

◆ detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ diff()

StatusCode Trk::TrackDiff::diff	(	const Trk::Track &	referenceTrack,
		const Trk::Track &	comparedTrack )

virtual

diff of two given tracks

diff of two tracks

Implements Trk::ITrackDiff.

Definition at line 223 of file TrackDiff.cxx.

                                        {
 
    ATH_MSG_VERBOSE ( "in diff(trk, trk)" );
    resetVariables();
 
    // ---------------------------------------
    // fill event data
    SG::ReadHandle<xAOD::EventInfo> evt(m_evt);
    if (!evt.isValid()) {
      ATH_MSG_ERROR ("Could not retrieve event info");
      return StatusCode::FAILURE;
    }
 
    m_eventNumber = evt->eventNumber();
    if (referenceTrack.perigeeParameters()) {
        m_trackPhi = referenceTrack.perigeeParameters()->parameters()[Trk::phi0];
        m_trackEta = referenceTrack.perigeeParameters()->eta();
    } else {
        m_trackPhi = -1000.;
        m_trackEta = -1000.;
    }
 
 
    // list of track state data of the reference track
    DataVector< const Trk::TrackStateData > *refTrackStateData;
    // list of track state data of the compared track
    DataVector< const Trk::TrackStateData > *compareTrackStateData;
    // get data from the track states to be able to compare the surfaces and PrepRawData
    refTrackStateData     = extractDataFromTrack(referenceTrack);
    compareTrackStateData = extractDataFromTrack(comparedTrack);
 
    ATH_MSG_VERBOSE ( "number of track states: ref=" << refTrackStateData->size() << ", compare=" << compareTrackStateData->size() );
    ATH_MSG_VERBOSE ( "reference track: eta_0 = " << m_trackEta << ", phi_0 = " << m_trackPhi );
    ATH_MSG_DEBUG ( "     Ref Comp other diffs     detector " );
    //----------------------------------------------
    // loop over the track states of the reference track
    //   and try to find the related measurements on the
    //   comparison track
    DataVector< const Trk::TrackStateData >::iterator refIter = refTrackStateData->begin();
    DataVector< const Trk::TrackStateData >::iterator compIter = compareTrackStateData->begin();
    for (; refIter != refTrackStateData->end(); ++refIter) {
        // count the reference states by detector type
        //m_nRefStates[ refIter->detType() ]++;
        // loop over trackstates of the comparison track till we find
        //    a track state with the same surface or the same PRD
        bool foundMatchingState = false;
        //bool foundDiff = false;
        // cache the pointer to reference PRD, so we do not have get it again and again
        const Trk::PrepRawData* refPRD = nullptr;
        if ((*refIter)->rot()) {
            refPRD = (*refIter)->rot()->prepRawData();
        }
        compIter = compareTrackStateData->begin();
        for ( ; compIter != compareTrackStateData->end(); ++compIter ) {
            // compare the surfaces of the reference and the compared track state
            if ( (*compIter)->surface() == (*refIter)->surface() ) {
                // we found a track state on the same surface!
                foundMatchingState = true;
                //m_nCompStates[ compIter->detType() ]++;
                //if (diffStateInfo( refIter, compIter ) {
                //    foundDiff = true;
                //}
                // there should be at maximum only one track state
                // per surface, so we do not have to search further!
                break;
            } else if ( refPRD && (*compIter)->rot() ) {
                // try to match the PrepRawData, if we did not succeed with the surfaces
                // this is only needed in the case of dynamically created surfaces,
                // which contain track specific corrections (e.g. "wire sagging")
                if ( refPRD == ((*compIter)->rot()->prepRawData()) ) {
                    // we found a track state belonging to the same PrepRawData
                    foundMatchingState = true;
                   
                    // there should be only one track state
                    // belonging to the same PRD, so we can stop searching!
                    break;
                } // end if PRD match
            } // end else if( refPRD && compIter->rot() )
        } // end loop over compared states
        if (!foundMatchingState) {
            // we have a state in the reference, which is not contained in the
            // compared track!
            diffStateInfo((*refIter), nullptr);
        } else {
            diffStateInfo((*refIter), (*compIter));
            // drop the compared track state from our list:
            compareTrackStateData->erase(compIter);
        }
 
    } // end loop over reference states
 
    // loop over the remaining compared states: They are fakes
    compIter = compareTrackStateData->begin();
    for (; compIter != compareTrackStateData->end(); ++compIter) {
        diffStateInfo(nullptr, (*compIter));
    }
    // -----------------------
    // output some statistics:
 
    ATH_MSG_VERBOSE  ( "reference  TSoS  (Pixel/SCT/TRT): " << m_nRefStates[Trk::TrackState::Pixel] << "/" << m_nRefStates[Trk::TrackState::SCT] << "/" << m_nRefStates[Trk::TrackState::TRT] );
    ATH_MSG_VERBOSE  ( "compared   TSoS  (Pixel/SCT/TRT): " << m_nCompStates[Trk::TrackState::Pixel] << "/" << m_nCompStates[Trk::TrackState::SCT] << "/" << m_nCompStates[Trk::TrackState::TRT] );
    ATH_MSG_VERBOSE  ( "missed     TSoS  (Pixel/SCT/TRT): " << m_missed[Trk::TrackState::Pixel] << "/" << m_missed[Trk::TrackState::SCT] << "/" << m_missed[Trk::TrackState::TRT] );
    ATH_MSG_VERBOSE  ( "faked      TSoS  (Pixel/SCT/TRT): " << m_fakes[Trk::TrackState::Pixel] << "/" << m_fakes[Trk::TrackState::SCT] << "/" << m_fakes[Trk::TrackState::TRT] );
    ATH_MSG_VERBOSE  ( "wrong type TSoS  (Pixel/SCT/TRT): " << m_wrongType[Trk::TrackState::Pixel] << "/" << m_wrongType[Trk::TrackState::SCT] << "/" << m_wrongType[Trk::TrackState::TRT] );
    ATH_MSG_VERBOSE  ( "PRD mismatches   (Pixel/SCT/TRT): " << m_PRD_Mismatches[Trk::TrackState::Pixel] << "/" << m_PRD_Mismatches[Trk::TrackState::SCT] << "/" << m_PRD_Mismatches[Trk::TrackState::TRT] );
    ATH_MSG_VERBOSE  ( "missing   TSoS types: (Meas/Outl): " << m_missingType[Trk::TrackStateOnSurface::Measurement] << "/" << m_missingType[Trk::TrackStateOnSurface::Outlier] );
    ATH_MSG_VERBOSE  ( "fake      TSoS types: (Meas/Outl): " << m_fakeType[Trk::TrackStateOnSurface::Measurement] << "/" << m_fakeType[Trk::TrackStateOnSurface::Outlier] );
    if (m_writeNtuple) {
        //----------------------------------------------
        // write the ntuple record out (once per call)
        m_nt->Fill();
    }
    m_trackSum++;
    // clean up
    delete refTrackStateData;
    delete compareTrackStateData;
    return StatusCode::SUCCESS;
}

◆ diffStateInfo()

bool Trk::TrackDiff::diffStateInfo	(	const Trk::TrackStateData *	refTrackStateData,
		const Trk::TrackStateData *	compareTrackStateData )

private

diff of two given track state data

diff two TrackStateData

Definition at line 523 of file TrackDiff.cxx.

                                                                               {
 
    bool foundDiff = false;
 
    bool isFake = false;
    bool isMissing = false;
    bool isPRD_Mismatch = false;
    bool isFlippedSign = false;
    bool isNoDriftTime = false;
    bool refIsMeasurement = false;
    bool refIsOutlier = false;
    bool compIsMeasurement = false;
    bool compIsOutlier = false;
    bool wrongType = false;
    std::string detTypeName = "unidentified";
    Trk::TrackState::MeasurementType detType = Trk::TrackState::unidentified;
    //std::stringstream surfaceCenter;
 
    //ATH_MSG_VERBOSE ( "Writing info for states: " << (refTrackState ? "REF ": "") << (refTrackState ? m_refIndex : 0) << " " << (compareTrackState ?  "CMP " : "" ) << (compareTrackState ? m_compIndex : 0) );
 
    // info about the state types
    if (refTrackState){
        refIsMeasurement = refTrackState->trackStateOnSurface()->type(Trk::TrackStateOnSurface::Measurement);
        refIsOutlier = refTrackState->trackStateOnSurface()->type(Trk::TrackStateOnSurface::Outlier);
        if (!compareTrackState) {
            // we have a ref state without compared state
            isMissing = true;
            foundDiff = true;
            m_missed[ refTrackState->detType() ]++;
        }
        // count the reference states by detector type
        m_nRefStates[ refTrackState->detType() ]++;
        detType = refTrackState->detType();
        detTypeName = refTrackState->detTypeName();
        //surfaceCenter << "(" << refTrackState->surface()->center().x() << ", " << refTrackState->surface()->center().y() << "," <<refTrackState->surface()->center().z() << ")";
    }
    else if (compareTrackState) {
        // we have a compared state without ref state
        isFake = true;
        foundDiff = true;
        m_fakes[ compareTrackState->detType() ]++;
        detType = compareTrackState->detType();
        detTypeName = compareTrackState->detTypeName();
    } // end if (refTrackState)
    if (compareTrackState){
        compIsMeasurement = compareTrackState->trackStateOnSurface()->type(Trk::TrackStateOnSurface::Measurement);
        compIsOutlier = compareTrackState->trackStateOnSurface()->type(Trk::TrackStateOnSurface::Outlier);
        // count the compared states by detector type
        m_nCompStates[ compareTrackState->detType() ]++;
    }//end if (compareTrackState)
 
    // find differences if both states exist
    if (refTrackState && compareTrackState) {
 
        // find differences in the TrackStateOnSurface types:
        if (m_compareAll) {
 
        } else {
            if (m_compareOutliers && (refIsOutlier != compIsOutlier)) {
                foundDiff = true;
                wrongType = true;
                if (refIsOutlier) {
                    m_missingType[Trk::TrackStateOnSurface::Outlier]++;
                } else {
                    m_fakeType[Trk::TrackStateOnSurface::Outlier]++;
                }
            } // end if differ in outlier type
            if (refIsMeasurement != compIsMeasurement ) {
                foundDiff = true;
                wrongType = true;
                if (refIsMeasurement) {
                    m_missingType[Trk::TrackStateOnSurface::Measurement]++;
                } else {
                    m_fakeType[Trk::TrackStateOnSurface::Measurement]++;
                }
            } // end if differ in measurement type
        } // end else (compare all types)
 
        // find differences in the ROTs:
        const Trk::RIO_OnTrack* refROT = refTrackState->rot();
        const Trk::RIO_OnTrack* compareROT = compareTrackState->rot();
        if (refROT && compareROT) {
            if (refROT->prepRawData() != compareROT->prepRawData()) {
                isPRD_Mismatch = true;
                (m_PRD_Mismatches[detType])++;
            }
            if (detType == Trk::TrackState::TRT) {
                isFlippedSign = ((refROT->localParameters()[Trk::locR]) * (compareROT->localParameters()[Trk::locR]) < 0. );
                if (isFlippedSign) m_driftCircleSignFlips++;
                isNoDriftTime = ((refROT->localParameters()[Trk::locR] != 0. ) && (compareROT->localParameters()[Trk::locR] == 0. ) );
                if (isNoDriftTime) m_noDriftTime++;
            }
            foundDiff = (foundDiff || isPRD_Mismatch || isFlippedSign || isNoDriftTime );
        } // end if (both states have ROTs)
    } // end if (both states exist)
    if (foundDiff) {
        double surfX = 0;
        double surfY = 0;
        double surfZ = 0;
        // give some info about the diff:
        msg(MSG::DEBUG) << "Diff:";
        if (isFake){ msg(MSG::DEBUG) << " -- ";}
        else {msg(MSG::DEBUG) << (refIsOutlier ? " O" : "  ") << (refIsMeasurement ? "M " : "  ");}
        if (isMissing){ msg(MSG::DEBUG) << " -- ";}
        else {msg(MSG::DEBUG) << (compIsOutlier ? " O" : "  ") << (compIsMeasurement ? "M " : "  ");}
        msg(MSG::DEBUG) << (isFake          ? " FakeState      " : "")
                        << (isMissing       ? " MissingState   " : "")
                        << (wrongType       ? " Wrong TSoS type" : "")
                        << (isPRD_Mismatch  ? " PRD mismatch   " : "")
                        << (isFlippedSign   ? " Flipped Sign   " : "")
                        << (isNoDriftTime   ? " NoDriftTime    " : "")
                        << " in " << detTypeName
                        << " detector at surface with center " << endmsg; //<< surfaceCenter
        if (refTrackState) {
            surfX = refTrackState->surface()->center().x();
            surfY = refTrackState->surface()->center().y();
            surfZ = refTrackState->surface()->center().z();
        } else {
            surfX = compareTrackState->surface()->center().x();
            surfY = compareTrackState->surface()->center().y();
            surfZ = compareTrackState->surface()->center().z();
        }
       ATH_MSG_DEBUG ( "(" << surfX << ", " << surfY << "," << surfZ << ")");
        if (m_writeNtuple)  {
            if (m_writeCompetingROT) {
                // write some data specific to TrkCompetingRIOsOnTrack
                float maxAssgnProb = -1.;
                float sumAssgnProb = -1.;
                if (compareTrackState) {
                    const Trk::CompetingRIOsOnTrack* competingROT = dynamic_cast< const Trk::CompetingRIOsOnTrack* > (compareTrackState->trackStateOnSurface()->measurementOnTrack());
                    if (competingROT) {
                        maxAssgnProb = competingROT->assignmentProbability(competingROT->indexOfMaxAssignProb());
                        // sum up all assignment probs:
                        sumAssgnProb = 0.;
                        for (unsigned int index = 0; index < competingROT->numberOfContainedROTs(); index++) {
                            sumAssgnProb += competingROT->assignmentProbability(index);
                        }
                    } // end if competingROT
                } // end if compareTrackState
                m_maxAssignProb->push_back(maxAssgnProb);
                m_sumAssignProb->push_back(sumAssgnProb);
            } // end if writeComepetingROT
        
            // push data into the vectors
            m_isFake->push_back(isFake?1:0);
            m_isMissing->push_back(isMissing?1:0);
            m_detectorType->push_back(detType);
            m_isPRD_Mismatch->push_back(isPRD_Mismatch?1:0);
            m_isFlippedSign->push_back(isFlippedSign?1:0);
            m_isNoDriftTime->push_back(isNoDriftTime?1:0);
            m_refIsOutlier->push_back(refIsOutlier?1:0);
            m_refIsMeasurement->push_back(refIsMeasurement?1:0);
            m_compIsOutlier->push_back(compIsOutlier?1:0);
            m_compIsMeasurement->push_back(compIsMeasurement?1:0);
            m_surfX->push_back(surfX);
            m_surfY->push_back(surfY);
            m_surfZ->push_back(surfZ);
        } // end if (writeNtuple)
    m_nDiffs++;
    } // end if (foundDiff) 
    return (foundDiff);
 
}

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

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ extractDataFromTrack()

DataVector< const Trk::TrackStateData > * Trk::TrackDiff::extractDataFromTrack ( const Trk::Track & track ) const

private

extract data from a Trk::Track into a list of Trk::TrackStateData

extract track state data from the track

Definition at line 345 of file TrackDiff.cxx.

                                                                                                       {
 
    // Get pointer to track state on surfaces
    const Trk::TrackStates* trackStates = track.trackStateOnSurfaces();
    if (!trackStates) {
      ATH_MSG_ERROR ( "track containes no track states, diff impossible" );
      return nullptr;
    }
 
    // create the vector of extracted data
    DataVector< const Trk::TrackStateData >* trackStateData = new DataVector< const Trk::TrackStateData >;
 
    // track state iterator
    Trk::TrackStates::const_iterator iter = trackStates->begin();
    // Loop over all track states on surfaces
    //    to extract the measurements
    for (; iter != trackStates->end(); ++iter) {
        if (!(*iter)) {
          ATH_MSG_WARNING ( "TrackStateOnSurface == Null" );
          continue;
        }
        if (!m_compareAll) {
            // just use TSoS of type "measurement" or "outlier"
            if (m_compareOutliers) {
                if (!( (*iter)->type(Trk::TrackStateOnSurface::Measurement) ||
                        (*iter)->type(Trk::TrackStateOnSurface::Outlier) ) ) {
                    continue;
                }
            } else {
                if (!( (*iter)->type(Trk::TrackStateOnSurface::Measurement) ) ) {
                    continue;
                }
            } // end if (compareOutliers)
        } // end if (!compareAll)
 
        // Get pointer to measurement on track
        const Trk::MeasurementBase *measurement = (*iter)->measurementOnTrack();
        if (!measurement && !m_compareAll) {
            ATH_MSG_ERROR ( "measurementOnTrack == Null for a TrackStateOnSurface "
            << "of type Measurement or Outlier" );
            continue;
        } // end if (!measurement)
        const Trk::Surface& surface = measurement ?
                                      (measurement->associatedSurface()) : 
                                      (*iter)->trackParameters()->associatedSurface();
        // we need the RIO_OnTrack to decide if we have the same PrepRawData
        //   on the track
        const Trk::RIO_OnTrack* ROT = dynamic_cast< const Trk::RIO_OnTrack* > (measurement);
        if (!ROT) {
            // try to cast to CompetingRIOsOnTrack
            const Trk::CompetingRIOsOnTrack* compROT = dynamic_cast< const Trk::CompetingRIOsOnTrack* > (measurement);
            if (compROT) {
                ROT = &compROT->rioOnTrack( compROT->indexOfMaxAssignProb() );
//                 // quick hack to identify DAF ouliers:
//                 if (!m_compareOutliers && (compROT->assignmentProbability(compROT->indexOfMaxAssignProb()) < 0.4)) {
//                     continue;
//                 }
                // use surface of the most prob. ROT:
                // FIXME put back in place: surface = compROT->rioOnTrack( compROT->indexOfMaxAssignProb() ).associatedSurface();
            } // end if (compROT)
        }
        // if we just compare Measurements and Outliers, we demand a ROT.
        if ( !ROT && !m_compareAll ) {
            continue;
        }
        // try to identify detector type by ROT
        std::string detTypeName = "unidentified";
        Trk::TrackState::MeasurementType detType = Trk::TrackState::unidentified;
        if ( ROT ) {
            detType = detectorType(*ROT, detTypeName);
        }
        // add the extracted data to the vector:
        const Trk::TrackStateData *tsData = new const Trk::TrackStateData(  (*iter),
                                                                            ROT,
                                                                            &surface,
                                                                            detTypeName,
                                                                            detType);
        trackStateData->push_back(tsData);
        //ATH_MSG_VERBOSE  ( detTypeName << " surf:  " << surface << " (" << surface->center().x() << ", " << surface->center().y() << "," << surface->center().z() << ")" 
        //                      << " ROT: " << ROT << " PRD: " << (ROT ? ROT->prepRawData() : 0) << " PRD detEl: " << (ROT ? ROT->prepRawData()->detectorElement() : 0) );
    } // end for loop over trackstates
    return trackStateData;
}

◆ 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

◆ finalize()

StatusCode Trk::TrackDiff::finalize ( )

finalize

Definition at line 207 of file TrackDiff.cxx.

                                  {
    ATH_MSG_INFO ( "sums for " << m_trackSum << " compared tracks" );
    ATH_MSG_INFO ( "reference  TSoS  (Pixel/SCT/TRT): " << m_nRefStatesSum[Trk::TrackState::Pixel] << "/" << m_nRefStatesSum[Trk::TrackState::SCT] << "/" << m_nRefStatesSum[Trk::TrackState::TRT] );
    ATH_MSG_INFO ( "compared   TSoS  (Pixel/SCT/TRT): " << m_nCompStatesSum[Trk::TrackState::Pixel] << "/" << m_nCompStatesSum[Trk::TrackState::SCT] << "/" << m_nCompStatesSum[Trk::TrackState::TRT] );
    ATH_MSG_INFO ( "missed     TSoS  (Pixel/SCT/TRT): " << m_missedSum[Trk::TrackState::Pixel] << "/" << m_missedSum[Trk::TrackState::SCT] << "/" << m_missedSum[Trk::TrackState::TRT] );
    ATH_MSG_INFO ( "faked      TSoS  (Pixel/SCT/TRT): " << m_fakesSum[Trk::TrackState::Pixel] << "/" << m_fakesSum[Trk::TrackState::SCT] << "/" << m_fakesSum[Trk::TrackState::TRT] );
    ATH_MSG_INFO ( "wrong type TSoS  (Pixel/SCT/TRT): " << m_wrongTypeSum[Trk::TrackState::Pixel] << "/" << m_wrongTypeSum[Trk::TrackState::SCT] << "/" << m_wrongTypeSum[Trk::TrackState::TRT] );
    ATH_MSG_INFO ( "PRD mismatches   (Pixel/SCT/TRT): " << m_PRD_MismatchesSum[Trk::TrackState::Pixel] << "/" << m_PRD_MismatchesSum[Trk::TrackState::SCT] << "/" << m_PRD_MismatchesSum[Trk::TrackState::TRT] );
 
    ATH_MSG_INFO ( "finalize() successful in " << name() );
    return StatusCode::SUCCESS;
}

◆ initialize()

StatusCode Trk::TrackDiff::initialize ( )

Definition at line 105 of file TrackDiff.cxx.

                                    {
 
  ATH_CHECK( m_evt.initialize() );
 
    StatusCode sc;
    if (m_writeNtuple) {
        // ---------------------------
        // retrieve pointer to THistSvc
        SmartIF<ITHistSvc> tHistSvc{service("THistSvc")};
        ATH_CHECK( tHistSvc.isValid() );
 
        // ---------------------------
        // create tree and register it to THistSvc
        m_nt = new TTree(TString(m_ntupleTreeName), "Track diff output");
        // NB: we must not delete the tree, this is done by THistSvc
        std::string fullNtupleName =  "/"+m_ntupleFileName+"/"+m_ntupleDirName+"/"+m_ntupleTreeName;
        ATH_CHECK( tHistSvc->regTree(fullNtupleName, m_nt) );
 
        //-----------------
        // add items
        // event info:
        m_nt->Branch("EventNumber",             &m_eventNumber );
        m_nt->Branch("RefTrackPhi0",            &m_trackPhi    );
        m_nt->Branch("RefTrackEta0",            &m_trackEta    );
        
        m_nt->Branch("nRefStates",              &m_nRefStates, "nRefStates[8]/I");
        m_nt->Branch("nCompareStates",          &m_nCompStates, "nRefStates[8]/I");
        m_nt->Branch("nFakeStates",             &m_fakes, "nFakeStates[8]/I");
        m_nt->Branch("nMissedStates",           &m_missed, "nMissedStates[8]/I");
        m_nt->Branch("nWrongType",              &m_wrongType, "nWrongType[8]/I");
        m_nt->Branch("nPRD_Mismatches",         &m_PRD_Mismatches, "nPRD_Mismatches[8]/I");
        m_nt->Branch("nDriftCircleSignFlips",   &m_driftCircleSignFlips  );
        m_nt->Branch("nNoDriftTime",            &m_noDriftTime           );
        m_nt->Branch("nRefTypes",               &m_refType, "nRefTypes[8]/I");
        m_nt->Branch("nCompareTypes",           &m_compareType, "nCompareTypes[8]/I");
        m_nt->Branch("nMissedTypes",            &m_missingType, "nMissedTypes[8]/I");
        m_nt->Branch("nFakeTypes",              &m_fakeType, "nFakeTypes[8]/I");
        // entries for each difference
        m_nt->Branch("nDiffs",                  &m_nDiffs  );
        m_detectorType      = new std::vector<int>();
        m_isFake            = new std::vector<int>();
        m_isMissing         = new std::vector<int>();
        m_isPRD_Mismatch    = new std::vector<int>();
        m_isFlippedSign     = new std::vector<int>();
        m_isNoDriftTime     = new std::vector<int>();
        m_refIsMeasurement  = new std::vector<int>();
        m_refIsOutlier      = new std::vector<int>();
        m_compIsMeasurement = new std::vector<int>();
        m_compIsOutlier     = new std::vector<int>();
        m_surfX             = new std::vector<float>();
        m_surfY             = new std::vector<float>();
        m_surfZ             = new std::vector<float>();
 
        m_nt->Branch("DetectorType",            &m_detectorType);
        m_nt->Branch("IsFake",                  &m_isFake);
        m_nt->Branch("IsMissing",               &m_isMissing);
        m_nt->Branch("IsPRD_Mismatch",          &m_isPRD_Mismatch);
        m_nt->Branch("IsFlippedSign",           &m_isFlippedSign);
        m_nt->Branch("IsNoDriftTime",           &m_isNoDriftTime);
        m_nt->Branch("RefIsMeasurement",        &m_refIsMeasurement);
        m_nt->Branch("RefIsOutlier",            &m_refIsOutlier);
        m_nt->Branch("ComparedIsMeasurement",   &m_compIsMeasurement);
        m_nt->Branch("ComparedIsOutlier",       &m_compIsOutlier);
        m_nt->Branch("SurfaceX" ,               &m_surfX);
        m_nt->Branch("SurfaceY" ,               &m_surfY);
        m_nt->Branch("SurfaceZ" ,               &m_surfZ);
 
        if (m_writeCompetingROT) {
            m_maxAssignProb = new std::vector<float>();
            m_sumAssignProb = new std::vector<float>();
            m_nt->Branch("MaxAssgnProb",        &m_maxAssignProb);
            m_nt->Branch("SumAssgnProb",        &m_sumAssignProb);
        } // end if writeComepetingROT
    } // end if (m_writeNtuple)
    // ---------------------------------------
    // Get the detector helper to be able to identify sub-det technologies
    if (detStore()->retrieve(m_idHelper, "AtlasID").isFailure()) {
      ATH_MSG_ERROR ("Could not get AtlasDetectorID helper" );
      return StatusCode::FAILURE;
    }
 
    for (int detType = 0; detType < Trk::TrackState::NumberOfMeasurementTypes; detType++) {
        m_fakesSum[detType] = 0;
        m_missedSum[detType] = 0;
        m_PRD_MismatchesSum[detType] = 0;
        m_nRefStatesSum[detType] = 0;
        m_nCompStatesSum[detType] = 0;
        m_wrongTypeSum[detType] = 0;
        m_fakes[detType] = 0;
        m_missed[detType] = 0;
        m_PRD_Mismatches[detType] = 0;
        m_nRefStates[detType] = 0;
        m_nCompStates[detType] = 0;
        m_wrongType[detType] = 0;
    }
 
    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::ITrackDiff::interfaceID ( )

inlinestaticinherited

Interface ID, declared here, and defined below.

Definition at line 40 of file ITrackDiff.h.

                                                     {
    return IID_ITrackDiff;
}

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

◆ 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();
  }

◆ resetVariables()

void Trk::TrackDiff::resetVariables ( )

private

reset the ntuple variables

reset variables

Definition at line 431 of file TrackDiff.cxx.

                                  {
    // reset the counters
    //m_fakes = 0;
    //m_missed = 0;
    m_driftCircleSignFlips = 0;
    m_noDriftTime = 0;
    m_nDiffs = 0;
    for (int detType = 0; detType < Trk::TrackState::NumberOfMeasurementTypes; detType++) {
        m_fakesSum[detType] += m_fakes[detType];
        m_fakes[detType] = 0;
        m_missedSum[detType] += m_missed[detType];
        m_missed[detType] = 0;
        m_PRD_MismatchesSum[detType] += m_PRD_Mismatches[detType];
        m_PRD_Mismatches[detType] = 0;
        m_nRefStatesSum[detType] += m_nRefStates[detType];
        m_nRefStates[detType] = 0;
        m_nCompStatesSum[detType] += m_nCompStates[detType];
        m_nCompStates[detType] = 0;
        m_wrongType[detType] += m_wrongType[detType];
        m_wrongType[detType] = 0;
    }
    for (int TSoSType = 0; TSoSType < Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes; TSoSType++) {
        m_missingType[TSoSType] = 0;
        m_fakeType[TSoSType] = 0;
        m_refType[TSoSType] = 0;
        m_compareType[TSoSType] = 0;
    }
//     m_missingType->clear();
//     m_missingType->resize(Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes, 0);
//     m_fakeType->clear();
//     m_fakeType->resize(Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes, 0);
//     m_PRD_Mismatches->clear();
//     m_PRD_Mismatches->resize(8, 0);
    if (m_writeNtuple) {
        m_detectorType->clear();
        m_isFake->clear();
        m_isMissing->clear();
        m_isPRD_Mismatch->clear();
        m_isFlippedSign->clear();
        m_isNoDriftTime->clear();
        m_refIsMeasurement->clear();
        m_refIsOutlier->clear();
        m_compIsMeasurement->clear();
        m_compIsOutlier->clear();
        m_surfX->clear();
        m_surfY->clear();
        m_surfZ->clear();
 
        if (m_writeCompetingROT) {
            m_maxAssignProb->clear();
            m_sumAssignProb->clear();
        } // end if writeComepetingROT
    }
 
}

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

◆ 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);
      }
    }
  }

Member Data Documentation

◆ m_compareAll

bool Trk::TrackDiff::m_compareAll

private

jobOption: compare track states of all types

Definition at line 108 of file TrackDiff.h.

◆ m_compareOutliers

bool Trk::TrackDiff::m_compareOutliers

private

jobOption: compare track states of type "outlier"

Definition at line 107 of file TrackDiff.h.

◆ m_compareType

int Trk::TrackDiff::m_compareType[Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes]

private

Definition at line 123 of file TrackDiff.h.

◆ m_compIsMeasurement

std::vector<int>* Trk::TrackDiff::m_compIsMeasurement

private

Definition at line 137 of file TrackDiff.h.

◆ m_compIsOutlier

std::vector<int>* Trk::TrackDiff::m_compIsOutlier

private

Definition at line 138 of file TrackDiff.h.

◆ m_detectorType

std::vector<int>* Trk::TrackDiff::m_detectorType

private

Definition at line 129 of file TrackDiff.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_driftCircleSignFlips

int Trk::TrackDiff::m_driftCircleSignFlips

private

Definition at line 125 of file TrackDiff.h.

◆ m_eventNumber

int Trk::TrackDiff::m_eventNumber

private

Definition at line 112 of file TrackDiff.h.

◆ m_evt

SG::ReadHandleKey<xAOD::EventInfo> Trk::TrackDiff::m_evt {this, "EvtInfo", "EventInfo", "EventInfo name"}

private

Definition at line 157 of file TrackDiff.h.

157{this, "EvtInfo", "EventInfo", "EventInfo name"};

◆ 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_fakes

int Trk::TrackDiff::m_fakes[Trk::TrackState::NumberOfMeasurementTypes]

private

Definition at line 116 of file TrackDiff.h.

◆ m_fakesSum

int Trk::TrackDiff::m_fakesSum[Trk::TrackState::NumberOfMeasurementTypes]

private

Definition at line 151 of file TrackDiff.h.

◆ m_fakeType

int Trk::TrackDiff::m_fakeType[Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes]

private

Definition at line 121 of file TrackDiff.h.

◆ m_idHelper

AtlasDetectorID* Trk::TrackDiff::m_idHelper

private

Used to find out the sub-det from PRD->identify().

Definition at line 100 of file TrackDiff.h.

◆ m_isFake

std::vector<int>* Trk::TrackDiff::m_isFake

private

vector<bool> would be more efficient, but vector<bool> is not a normal vector<> and seems to make trouble

Definition at line 130 of file TrackDiff.h.

◆ m_isFlippedSign

std::vector<int>* Trk::TrackDiff::m_isFlippedSign

private

Definition at line 133 of file TrackDiff.h.

◆ m_isMissing

std::vector<int>* Trk::TrackDiff::m_isMissing

private

Definition at line 131 of file TrackDiff.h.

◆ m_isNoDriftTime

std::vector<int>* Trk::TrackDiff::m_isNoDriftTime

private

Definition at line 134 of file TrackDiff.h.

◆ m_isPRD_Mismatch

std::vector<int>* Trk::TrackDiff::m_isPRD_Mismatch

private

Definition at line 132 of file TrackDiff.h.

◆ m_maxAssignProb

std::vector<float>* Trk::TrackDiff::m_maxAssignProb

private

Definition at line 139 of file TrackDiff.h.

◆ m_missed

int Trk::TrackDiff::m_missed[Trk::TrackState::NumberOfMeasurementTypes]

private

Definition at line 118 of file TrackDiff.h.

◆ m_missedSum

int Trk::TrackDiff::m_missedSum[Trk::TrackState::NumberOfMeasurementTypes]

private

Definition at line 152 of file TrackDiff.h.

◆ m_missingType

int Trk::TrackDiff::m_missingType[Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes]

private

Definition at line 120 of file TrackDiff.h.

◆ m_nCompStates

int Trk::TrackDiff::m_nCompStates[Trk::TrackState::NumberOfMeasurementTypes]

private

Definition at line 115 of file TrackDiff.h.

◆ m_nCompStatesSum

int Trk::TrackDiff::m_nCompStatesSum[Trk::TrackState::NumberOfMeasurementTypes]

private

Definition at line 150 of file TrackDiff.h.

◆ m_nDiffs

int Trk::TrackDiff::m_nDiffs

private

Definition at line 128 of file TrackDiff.h.

◆ m_noDriftTime

int Trk::TrackDiff::m_noDriftTime

private

Definition at line 126 of file TrackDiff.h.

◆ m_nRefStates

int Trk::TrackDiff::m_nRefStates[Trk::TrackState::NumberOfMeasurementTypes]

private

Definition at line 114 of file TrackDiff.h.

◆ m_nRefStatesSum

int Trk::TrackDiff::m_nRefStatesSum[Trk::TrackState::NumberOfMeasurementTypes]

private

Definition at line 149 of file TrackDiff.h.

◆ m_nt

TTree* Trk::TrackDiff::m_nt

private

Pointer to the NTuple tree.

Definition at line 98 of file TrackDiff.h.

◆ m_ntupleDirName

std::string Trk::TrackDiff::m_ntupleDirName

private

jobOption: Ntuple directory name

Definition at line 104 of file TrackDiff.h.

◆ m_ntupleFileName

std::string Trk::TrackDiff::m_ntupleFileName

private

jobOption: Ntuple file name

Definition at line 103 of file TrackDiff.h.

◆ m_ntupleTreeName

std::string Trk::TrackDiff::m_ntupleTreeName

private

jobOption: Ntuple tree name

Definition at line 105 of file TrackDiff.h.

◆ m_PRD_Mismatches

int Trk::TrackDiff::m_PRD_Mismatches[Trk::TrackState::NumberOfMeasurementTypes]

private

Definition at line 124 of file TrackDiff.h.

◆ m_PRD_MismatchesSum

int Trk::TrackDiff::m_PRD_MismatchesSum[Trk::TrackState::NumberOfMeasurementTypes]

private

Definition at line 154 of file TrackDiff.h.

◆ m_refIsMeasurement

std::vector<int>* Trk::TrackDiff::m_refIsMeasurement

private

Definition at line 135 of file TrackDiff.h.

◆ m_refIsOutlier

std::vector<int>* Trk::TrackDiff::m_refIsOutlier

private

Definition at line 136 of file TrackDiff.h.

◆ m_refType

int Trk::TrackDiff::m_refType[Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes]

private

Definition at line 122 of file TrackDiff.h.

◆ m_sumAssignProb

std::vector<float>* Trk::TrackDiff::m_sumAssignProb

private

Definition at line 140 of file TrackDiff.h.

◆ m_surfX

std::vector<float>* Trk::TrackDiff::m_surfX

private

Definition at line 141 of file TrackDiff.h.

◆ m_surfY

std::vector<float>* Trk::TrackDiff::m_surfY

private

Definition at line 142 of file TrackDiff.h.

◆ m_surfZ

std::vector<float>* Trk::TrackDiff::m_surfZ

private

Definition at line 143 of file TrackDiff.h.

◆ m_trackEta

float Trk::TrackDiff::m_trackEta

private

Definition at line 145 of file TrackDiff.h.

◆ m_trackPhi

float Trk::TrackDiff::m_trackPhi

private

Definition at line 146 of file TrackDiff.h.

◆ m_trackSum

int Trk::TrackDiff::m_trackSum

private

Definition at line 155 of file TrackDiff.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_writeCompetingROT

bool Trk::TrackDiff::m_writeCompetingROT

private

jobOption: write data about TrkCompetingRIOsOnTrack?

Definition at line 110 of file TrackDiff.h.

◆ m_writeNtuple

bool Trk::TrackDiff::m_writeNtuple

private

jobOption: write data to ntuple?

Definition at line 109 of file TrackDiff.h.

◆ m_wrongType

int Trk::TrackDiff::m_wrongType[Trk::TrackState::NumberOfMeasurementTypes]

private

Definition at line 119 of file TrackDiff.h.

◆ m_wrongTypeSum

int Trk::TrackDiff::m_wrongTypeSum[Trk::TrackState::NumberOfMeasurementTypes]

private

Definition at line 153 of file TrackDiff.h.

◆ s_maxHits

const int Trk::TrackDiff::s_maxHits = 300

staticprivate

Definition at line 96 of file TrackDiff.h.

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ TrackDiff()

◆ ~TrackDiff()

Member Function Documentation

◆ declareGaudiProperty()

◆ declareProperty()

◆ detectorType()

◆ detStore()

◆ diff()

◆ diffStateInfo()

◆ evtStore()

◆ extractDataFromTrack()

◆ extraDeps_update_handler()

◆ finalize()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ resetVariables()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_compareAll

◆ m_compareOutliers

◆ m_compareType

◆ m_compIsMeasurement

◆ m_compIsOutlier

◆ m_detectorType

◆ m_detStore

◆ m_driftCircleSignFlips

◆ m_eventNumber

◆ m_evt

◆ m_evtStore

◆ m_fakes

◆ m_fakesSum

◆ m_fakeType

◆ m_idHelper

◆ m_isFake

◆ m_isFlippedSign

◆ m_isMissing

◆ m_isNoDriftTime

◆ m_isPRD_Mismatch

◆ m_maxAssignProb

◆ m_missed

◆ m_missedSum

◆ m_missingType

◆ m_nCompStates

◆ m_nCompStatesSum

◆ m_nDiffs

◆ m_noDriftTime

◆ m_nRefStates

◆ m_nRefStatesSum

◆ m_nt

◆ m_ntupleDirName

◆ m_ntupleFileName

◆ m_ntupleTreeName

◆ m_PRD_Mismatches

◆ m_PRD_MismatchesSum

◆ m_refIsMeasurement

◆ m_refIsOutlier

◆ m_refType

◆ m_sumAssignProb

◆ m_surfX

◆ m_surfY

◆ m_surfZ