ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
Trk::TrackDiff Class Reference

#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 More...
 
virtual StatusCode diff (const Trk::Track &referenceTrack, const Trk::Track &comparedTrack)
 diff of two given tracks More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Static Public Member Functions

static const InterfaceID & interfaceID ()
 Interface ID, declared here, and defined below. More...
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

DataVector< const Trk::TrackStateData > * extractDataFromTrack (const Trk::Track &) const
 extract data from a Trk::Track into a list of Trk::TrackStateData More...
 
void resetVariables ()
 reset the ntuple variables More...
 
Trk::TrackState::MeasurementType detectorType (const Trk::RIO_OnTrack &ROT, std::string &detTypeName) const
 get detector type and name by identifier of Trk::RIO_OnTrack More...
 
bool diffStateInfo (const Trk::TrackStateData *refTrackStateData, const Trk::TrackStateData *compareTrackStateData)
 diff of two given track state data More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

TTree * m_nt
 Pointer to the NTuple tree. More...
 
AtlasDetectorID * m_idHelper
 Used to find out the sub-det from PRD->identify(). More...
 
std::string m_ntupleFileName
 jobOption: Ntuple file name More...
 
std::string m_ntupleDirName
 jobOption: Ntuple directory name More...
 
std::string m_ntupleTreeName
 jobOption: Ntuple tree name More...
 
bool m_compareOutliers
 jobOption: compare track states of type "outlier" More...
 
bool m_compareAll
 jobOption: compare track states of all types More...
 
bool m_writeNtuple
 jobOption: write data to ntuple? More...
 
bool m_writeCompetingROT
 jobOption: write data about TrkCompetingRIOsOnTrack? More...
 
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 More...
 
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) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
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.

38  :
39  AthAlgTool(t,n,p),
40  m_nt(nullptr),
41  m_idHelper(nullptr),
42  //strings initialised in job options
43  m_compareOutliers(true),
44  m_compareAll(false),
45  m_writeNtuple(true),
46  m_writeCompetingROT(false),
47  m_eventNumber{},
48  m_nRefStates{},
49  m_nCompStates{},
50  m_fakes{},
51 
52  m_missed{},
53  m_wrongType{},
54  m_missingType{},
55  m_fakeType{},
56  m_refType{},
57  m_compareType{},
58  m_PRD_Mismatches{},
59  m_driftCircleSignFlips{},
60  m_noDriftTime{},
61  m_nDiffs{},
62  m_detectorType{},
63  m_isFake{},
64  m_isMissing{},
65  m_isPRD_Mismatch{},
66  m_isFlippedSign{},
67  m_isNoDriftTime{},
68  m_refIsMeasurement{},
69  m_refIsOutlier{},
70  m_compIsMeasurement{},
71  m_compIsOutlier{},
72  m_maxAssignProb{},
73  m_sumAssignProb{},
74  m_surfX{},
75  m_surfY{},
76  m_surfZ{},
77  m_trackEta{},
78  m_trackPhi{},
79  m_nRefStatesSum{},
80  m_nCompStatesSum{},
81  m_fakesSum{},
82  m_missedSum{},
83  m_wrongTypeSum{},
84  m_PRD_MismatchesSum{},
85  m_trackSum(0) {
86  declareInterface<ITrackDiff>(this);
87  // Declare the properties
88  //declareProperty("BookNewNtuple", m_bookNewNtuple = true);
89  declareProperty("NtupleFileName", m_ntupleFileName = "/NTUPLES");
90  declareProperty("NtupleDirectoryName", m_ntupleDirName = "TrackValidation");
91  declareProperty("NtupleTreeName", m_ntupleTreeName = "TrackDiff");
92  //declareProperty("CompareMeasurements", m_compareMeasurements = true);
93  declareProperty("CompareOutliers", m_compareOutliers = true);
94  declareProperty("CompareAllTSoS", m_compareAll = false);
95  declareProperty("WriteNtuple", m_writeNtuple = true);
96  declareProperty("WriteCompetingROTdata",m_writeCompetingROT = false);
97 }

◆ ~TrackDiff()

Trk::TrackDiff::~TrackDiff ( )
default

Member Function Documentation

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

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

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

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

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ 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 496 of file TrackDiff.cxx.

497  {
498  // identify by ROT of reference track:
499  Identifier id = ROT.identify();
500 
501  // get dector type
502  if ( id.is_valid()) {
503  if (m_idHelper->is_pixel(id) ) {
504  detTypeName = "Pixel";
505  return Trk::TrackState::Pixel;
506  } else if (m_idHelper->is_sct(id)) {
507  detTypeName = "SCT";
508  return Trk::TrackState::SCT;
509  } else if (m_idHelper->is_trt(id)) {
510  detTypeName = "TRT";
511  return Trk::TrackState::TRT;
512  } else if (m_idHelper->is_mdt(id)) {
513  detTypeName = "MDT";
514  return Trk::TrackState::MDT;
515  } else if (m_idHelper->is_csc(id)) {
516  detTypeName = "CSC";
517  return Trk::TrackState::CSC;
518  } else if (m_idHelper->is_rpc(id)) {
519  detTypeName = "RPC";
520  return Trk::TrackState::RPC;
521  } else if (m_idHelper->is_tgc(id)) {
522  detTypeName = "TGC";
523  return Trk::TrackState::TGC;
524  }
525  }
526  detTypeName = "unidentified";
527  return Trk::TrackState::unidentified;
528 }

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

◆ 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 231 of file TrackDiff.cxx.

233  {
234 
235  ATH_MSG_VERBOSE ( "in diff(trk, trk)" );
236  resetVariables();
237 
238  // ---------------------------------------
239  // fill event data
240  SG::ReadHandle<xAOD::EventInfo> evt(m_evt);
241  if (!evt.isValid()) {
242  ATH_MSG_ERROR ("Could not retrieve event info");
243  return StatusCode::FAILURE;
244  }
245 
246  m_eventNumber = evt->eventNumber();
247  if (referenceTrack.perigeeParameters()) {
248  m_trackPhi = referenceTrack.perigeeParameters()->parameters()[Trk::phi0];
249  m_trackEta = referenceTrack.perigeeParameters()->eta();
250  } else {
251  m_trackPhi = -1000.;
252  m_trackEta = -1000.;
253  }
254 
255 
256  // list of track state data of the reference track
257  DataVector< const Trk::TrackStateData > *refTrackStateData;
258  // list of track state data of the compared track
259  DataVector< const Trk::TrackStateData > *compareTrackStateData;
260  // get data from the track states to be able to compare the surfaces and PrepRawData
261  refTrackStateData = extractDataFromTrack(referenceTrack);
262  compareTrackStateData = extractDataFromTrack(comparedTrack);
263 
264  ATH_MSG_VERBOSE ( "number of track states: ref=" << refTrackStateData->size() << ", compare=" << compareTrackStateData->size() );
265  ATH_MSG_VERBOSE ( "reference track: eta_0 = " << m_trackEta << ", phi_0 = " << m_trackPhi );
266  ATH_MSG_DEBUG ( " Ref Comp other diffs detector " );
267  //----------------------------------------------
268  // loop over the track states of the reference track
269  // and try to find the related measurements on the
270  // comparison track
271  DataVector< const Trk::TrackStateData >::iterator refIter = refTrackStateData->begin();
272  DataVector< const Trk::TrackStateData >::iterator compIter = compareTrackStateData->begin();
273  for (; refIter != refTrackStateData->end(); ++refIter) {
274  // count the reference states by detector type
275  //m_nRefStates[ refIter->detType() ]++;
276  // loop over trackstates of the comparison track till we find
277  // a track state with the same surface or the same PRD
278  bool foundMatchingState = false;
279  //bool foundDiff = false;
280  // cache the pointer to reference PRD, so we do not have get it again and again
281  const Trk::PrepRawData* refPRD = nullptr;
282  if ((*refIter)->rot()) {
283  refPRD = (*refIter)->rot()->prepRawData();
284  }
285  compIter = compareTrackStateData->begin();
286  for ( ; compIter != compareTrackStateData->end(); ++compIter ) {
287  // compare the surfaces of the reference and the compared track state
288  if ( (*compIter)->surface() == (*refIter)->surface() ) {
289  // we found a track state on the same surface!
290  foundMatchingState = true;
291  //m_nCompStates[ compIter->detType() ]++;
292  //if (diffStateInfo( refIter, compIter ) {
293  // foundDiff = true;
294  //}
295  // there should be at maximum only one track state
296  // per surface, so we do not have to search further!
297  break;
298  } else if ( refPRD && (*compIter)->rot() ) {
299  // try to match the PrepRawData, if we did not succeed with the surfaces
300  // this is only needed in the case of dynamically created surfaces,
301  // which contain track specific corrections (e.g. "wire sagging")
302  if ( refPRD == ((*compIter)->rot()->prepRawData()) ) {
303  // we found a track state belonging to the same PrepRawData
304  foundMatchingState = true;
305 
306  // there should be only one track state
307  // belonging to the same PRD, so we can stop searching!
308  break;
309  } // end if PRD match
310  } // end else if( refPRD && compIter->rot() )
311  } // end loop over compared states
312  if (!foundMatchingState) {
313  // we have a state in the reference, which is not contained in the
314  // compared track!
315  diffStateInfo((*refIter), nullptr);
316  } else {
317  diffStateInfo((*refIter), (*compIter));
318  // drop the compared track state from our list:
319  compareTrackStateData->erase(compIter);
320  }
321 
322  } // end loop over reference states
323 
324  // loop over the remaining compared states: They are fakes
325  compIter = compareTrackStateData->begin();
326  for (; compIter != compareTrackStateData->end(); ++compIter) {
327  diffStateInfo(nullptr, (*compIter));
328  }
329  // -----------------------
330  // output some statistics:
331 
332  ATH_MSG_VERBOSE ( "reference TSoS (Pixel/SCT/TRT): " << m_nRefStates[Trk::TrackState::Pixel] << "/" << m_nRefStates[Trk::TrackState::SCT] << "/" << m_nRefStates[Trk::TrackState::TRT] );
333  ATH_MSG_VERBOSE ( "compared TSoS (Pixel/SCT/TRT): " << m_nCompStates[Trk::TrackState::Pixel] << "/" << m_nCompStates[Trk::TrackState::SCT] << "/" << m_nCompStates[Trk::TrackState::TRT] );
334  ATH_MSG_VERBOSE ( "missed TSoS (Pixel/SCT/TRT): " << m_missed[Trk::TrackState::Pixel] << "/" << m_missed[Trk::TrackState::SCT] << "/" << m_missed[Trk::TrackState::TRT] );
335  ATH_MSG_VERBOSE ( "faked TSoS (Pixel/SCT/TRT): " << m_fakes[Trk::TrackState::Pixel] << "/" << m_fakes[Trk::TrackState::SCT] << "/" << m_fakes[Trk::TrackState::TRT] );
336  ATH_MSG_VERBOSE ( "wrong type TSoS (Pixel/SCT/TRT): " << m_wrongType[Trk::TrackState::Pixel] << "/" << m_wrongType[Trk::TrackState::SCT] << "/" << m_wrongType[Trk::TrackState::TRT] );
337  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] );
338  ATH_MSG_VERBOSE ( "missing TSoS types: (Meas/Outl): " << m_missingType[Trk::TrackStateOnSurface::Measurement] << "/" << m_missingType[Trk::TrackStateOnSurface::Outlier] );
339  ATH_MSG_VERBOSE ( "fake TSoS types: (Meas/Outl): " << m_fakeType[Trk::TrackStateOnSurface::Measurement] << "/" << m_fakeType[Trk::TrackStateOnSurface::Outlier] );
340  if (m_writeNtuple) {
341  //----------------------------------------------
342  // write the ntuple record out (once per call)
343  m_nt->Fill();
344  }
345  m_trackSum++;
346  // clean up
347  delete refTrackStateData;
348  delete compareTrackStateData;
349  return StatusCode::SUCCESS;
350 }

◆ 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 531 of file TrackDiff.cxx.

532  {
533 
534  bool foundDiff = false;
535 
536  bool isFake = false;
537  bool isMissing = false;
538  bool isPRD_Mismatch = false;
539  bool isFlippedSign = false;
540  bool isNoDriftTime = false;
541  bool refIsMeasurement = false;
542  bool refIsOutlier = false;
543  bool compIsMeasurement = false;
544  bool compIsOutlier = false;
545  bool wrongType = false;
546  std::string detTypeName = "unidentified";
547  Trk::TrackState::MeasurementType detType = Trk::TrackState::unidentified;
548  //std::stringstream surfaceCenter;
549 
550  //ATH_MSG_VERBOSE ( "Writing info for states: " << (refTrackState ? "REF ": "") << (refTrackState ? m_refIndex : 0) << " " << (compareTrackState ? "CMP " : "" ) << (compareTrackState ? m_compIndex : 0) );
551 
552  // info about the state types
553  if (refTrackState){
554  refIsMeasurement = refTrackState->trackStateOnSurface()->type(Trk::TrackStateOnSurface::Measurement);
555  refIsOutlier = refTrackState->trackStateOnSurface()->type(Trk::TrackStateOnSurface::Outlier);
556  if (!compareTrackState) {
557  // we have a ref state without compared state
558  isMissing = true;
559  foundDiff = true;
560  m_missed[ refTrackState->detType() ]++;
561  }
562  // count the reference states by detector type
563  m_nRefStates[ refTrackState->detType() ]++;
564  detType = refTrackState->detType();
565  detTypeName = refTrackState->detTypeName();
566  //surfaceCenter << "(" << refTrackState->surface()->center().x() << ", " << refTrackState->surface()->center().y() << "," <<refTrackState->surface()->center().z() << ")";
567  } else {
568  // we have a compared state without ref state
569  isFake = true;
570  foundDiff = true;
571  m_fakes[ compareTrackState->detType() ]++;
572  detType = compareTrackState->detType();
573  detTypeName = compareTrackState->detTypeName();
574  } // end if (refTrackState)
575  if (compareTrackState){
576  compIsMeasurement = compareTrackState->trackStateOnSurface()->type(Trk::TrackStateOnSurface::Measurement);
577  compIsOutlier = compareTrackState->trackStateOnSurface()->type(Trk::TrackStateOnSurface::Outlier);
578  // count the compared states by detector type
579  m_nCompStates[ compareTrackState->detType() ]++;
580  }//end if (compareTrackState)
581 
582  // find differences if both states exist
583  if (refTrackState && compareTrackState) {
584 
585  // find differences in the TrackStateOnSurface types:
586  if (m_compareAll) {
587 
588  } else {
589  if (m_compareOutliers && (refIsOutlier != compIsOutlier)) {
590  foundDiff = true;
591  wrongType = true;
592  if (refIsOutlier) {
593  m_missingType[Trk::TrackStateOnSurface::Outlier]++;
594  } else {
595  m_fakeType[Trk::TrackStateOnSurface::Outlier]++;
596  }
597  } // end if differ in outlier type
598  if (refIsMeasurement != compIsMeasurement ) {
599  foundDiff = true;
600  wrongType = true;
601  if (refIsMeasurement) {
602  m_missingType[Trk::TrackStateOnSurface::Measurement]++;
603  } else {
604  m_fakeType[Trk::TrackStateOnSurface::Measurement]++;
605  }
606  } // end if differ in measurement type
607  } // end else (compare all types)
608 
609  // find differences in the ROTs:
610  const Trk::RIO_OnTrack* refROT = refTrackState->rot();
611  const Trk::RIO_OnTrack* compareROT = compareTrackState->rot();
612  if (refROT && compareROT) {
613  if (refROT->prepRawData() != compareROT->prepRawData()) {
614  isPRD_Mismatch = true;
615  (m_PRD_Mismatches[detType])++;
616  }
617  if (detType == Trk::TrackState::TRT) {
618  isFlippedSign = ((refROT->localParameters()[Trk::locR]) * (compareROT->localParameters()[Trk::locR]) < 0. );
619  if (isFlippedSign) m_driftCircleSignFlips++;
620  isNoDriftTime = ((refROT->localParameters()[Trk::locR] != 0. ) && (compareROT->localParameters()[Trk::locR] == 0. ) );
621  if (isNoDriftTime) m_noDriftTime++;
622  }
623  foundDiff = (foundDiff || isPRD_Mismatch || isFlippedSign || isNoDriftTime );
624  } // end if (both states have ROTs)
625  } // end if (both states exist)
626  if (foundDiff) {
627  double surfX = 0;
628  double surfY = 0;
629  double surfZ = 0;
630  // give some info about the diff:
631  msg(MSG::DEBUG) << "Diff:";
632  if (isFake){ msg(MSG::DEBUG) << " -- ";}
633  else {msg(MSG::DEBUG) << (refIsOutlier ? " O" : " ") << (refIsMeasurement ? "M " : " ");}
634  if (isMissing){ msg(MSG::DEBUG) << " -- ";}
635  else {msg(MSG::DEBUG) << (compIsOutlier ? " O" : " ") << (compIsMeasurement ? "M " : " ");}
636  msg(MSG::DEBUG) << (isFake ? " FakeState " : "")
637  << (isMissing ? " MissingState " : "")
638  << (wrongType ? " Wrong TSoS type" : "")
639  << (isPRD_Mismatch ? " PRD mismatch " : "")
640  << (isFlippedSign ? " Flipped Sign " : "")
641  << (isNoDriftTime ? " NoDriftTime " : "")
642  << " in " << detTypeName
643  << " detector at surface with center " << endmsg; //<< surfaceCenter
644  if (refTrackState) {
645  surfX = refTrackState->surface()->center().x();
646  surfY = refTrackState->surface()->center().y();
647  surfZ = refTrackState->surface()->center().z();
648  } else {
649  surfX = compareTrackState->surface()->center().x();
650  surfY = compareTrackState->surface()->center().y();
651  surfZ = compareTrackState->surface()->center().z();
652  }
653  ATH_MSG_DEBUG ( "(" << surfX << ", " << surfY << "," << surfZ << ")");
654  if (m_writeNtuple) {
655  if (m_writeCompetingROT) {
656  // write some data specific to TrkCompetingRIOsOnTrack
657  float maxAssgnProb = -1.;
658  float sumAssgnProb = -1.;
659  if (compareTrackState) {
660  const Trk::CompetingRIOsOnTrack* competingROT = dynamic_cast< const Trk::CompetingRIOsOnTrack* > (compareTrackState->trackStateOnSurface()->measurementOnTrack());
661  if (competingROT) {
662  maxAssgnProb = competingROT->assignmentProbability(competingROT->indexOfMaxAssignProb());
663  // sum up all assignment probs:
664  sumAssgnProb = 0.;
665  for (unsigned int index = 0; index < competingROT->numberOfContainedROTs(); index++) {
666  sumAssgnProb += competingROT->assignmentProbability(index);
667  }
668  } // end if competingROT
669  } // end if compareTrackState
670  m_maxAssignProb->push_back(maxAssgnProb);
671  m_sumAssignProb->push_back(sumAssgnProb);
672  } // end if writeComepetingROT
673 
674  // push data into the vectors
675  m_isFake->push_back(isFake?1:0);
676  m_isMissing->push_back(isMissing?1:0);
677  m_detectorType->push_back(detType);
678  m_isPRD_Mismatch->push_back(isPRD_Mismatch?1:0);
679  m_isFlippedSign->push_back(isFlippedSign?1:0);
680  m_isNoDriftTime->push_back(isNoDriftTime?1:0);
681  m_refIsOutlier->push_back(refIsOutlier?1:0);
682  m_refIsMeasurement->push_back(refIsMeasurement?1:0);
683  m_compIsOutlier->push_back(compIsOutlier?1:0);
684  m_compIsMeasurement->push_back(compIsMeasurement?1:0);
685  m_surfX->push_back(surfX);
686  m_surfY->push_back(surfY);
687  m_surfZ->push_back(surfZ);
688  } // end if (writeNtuple)
689  m_nDiffs++;
690  } // end if (foundDiff)
691  return (foundDiff);
692 
693 }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ 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 353 of file TrackDiff.cxx.

353  {
354 
355  // Get pointer to track state on surfaces
356  const Trk::TrackStates* trackStates = track.trackStateOnSurfaces();
357  if (!trackStates) {
358  ATH_MSG_ERROR ( "track containes no track states, diff impossible" );
359  return nullptr;
360  }
361 
362  // create the vector of extracted data
363  DataVector< const Trk::TrackStateData >* trackStateData = new DataVector< const Trk::TrackStateData >;
364 
365  // track state iterator
366  Trk::TrackStates::const_iterator iter = trackStates->begin();
367  // Loop over all track states on surfaces
368  // to extract the measurements
369  for (; iter != trackStates->end(); ++iter) {
370  if (!(*iter)) {
371  ATH_MSG_WARNING ( "TrackStateOnSurface == Null" );
372  continue;
373  }
374  if (!m_compareAll) {
375  // just use TSoS of type "measurement" or "outlier"
376  if (m_compareOutliers) {
377  if (!( (*iter)->type(Trk::TrackStateOnSurface::Measurement) ||
378  (*iter)->type(Trk::TrackStateOnSurface::Outlier) ) ) {
379  continue;
380  }
381  } else {
382  if (!( (*iter)->type(Trk::TrackStateOnSurface::Measurement) ) ) {
383  continue;
384  }
385  } // end if (compareOutliers)
386  } // end if (!compareAll)
387 
388  // Get pointer to measurement on track
389  const Trk::MeasurementBase *measurement = (*iter)->measurementOnTrack();
390  if (!measurement && !m_compareAll) {
391  ATH_MSG_ERROR ( "measurementOnTrack == Null for a TrackStateOnSurface "
392  << "of type Measurement or Outlier" );
393  continue;
394  } // end if (!measurement)
395  const Trk::Surface& surface = measurement ?
396  (measurement->associatedSurface()) :
397  (*iter)->trackParameters()->associatedSurface();
398  // we need the RIO_OnTrack to decide if we have the same PrepRawData
399  // on the track
400  const Trk::RIO_OnTrack* ROT = dynamic_cast< const Trk::RIO_OnTrack* > (measurement);
401  if (!ROT) {
402  // try to cast to CompetingRIOsOnTrack
403  const Trk::CompetingRIOsOnTrack* compROT = dynamic_cast< const Trk::CompetingRIOsOnTrack* > (measurement);
404  if (compROT) {
405  ROT = &compROT->rioOnTrack( compROT->indexOfMaxAssignProb() );
406 // // quick hack to identify DAF ouliers:
407 // if (!m_compareOutliers && (compROT->assignmentProbability(compROT->indexOfMaxAssignProb()) < 0.4)) {
408 // continue;
409 // }
410  // use surface of the most prob. ROT:
411  // FIXME put back in place: surface = compROT->rioOnTrack( compROT->indexOfMaxAssignProb() ).associatedSurface();
412  } // end if (compROT)
413  }
414  // if we just compare Measurements and Outliers, we demand a ROT.
415  if ( !ROT && !m_compareAll ) {
416  continue;
417  }
418  // try to identify detector type by ROT
419  std::string detTypeName = "unidentified";
420  Trk::TrackState::MeasurementType detType = Trk::TrackState::unidentified;
421  if ( ROT ) {
422  detType = detectorType(*ROT, detTypeName);
423  }
424  // add the extracted data to the vector:
425  const Trk::TrackStateData *tsData = new const Trk::TrackStateData( (*iter),
426  ROT,
427  &surface,
428  detTypeName,
429  detType);
430  trackStateData->push_back(tsData);
431  //ATH_MSG_VERBOSE ( detTypeName << " surf: " << surface << " (" << surface->center().x() << ", " << surface->center().y() << "," << surface->center().z() << ")"
432  // << " ROT: " << ROT << " PRD: " << (ROT ? ROT->prepRawData() : 0) << " PRD detEl: " << (ROT ? ROT->prepRawData()->detectorElement() : 0) );
433  } // end for loop over trackstates
434  return trackStateData;
435 }

◆ 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 215 of file TrackDiff.cxx.

215  {
216  ATH_MSG_INFO ( "sums for " << m_trackSum << " compared tracks" );
217  ATH_MSG_INFO ( "reference TSoS (Pixel/SCT/TRT): " << m_nRefStatesSum[Trk::TrackState::Pixel] << "/" << m_nRefStatesSum[Trk::TrackState::SCT] << "/" << m_nRefStatesSum[Trk::TrackState::TRT] );
218  ATH_MSG_INFO ( "compared TSoS (Pixel/SCT/TRT): " << m_nCompStatesSum[Trk::TrackState::Pixel] << "/" << m_nCompStatesSum[Trk::TrackState::SCT] << "/" << m_nCompStatesSum[Trk::TrackState::TRT] );
219  ATH_MSG_INFO ( "missed TSoS (Pixel/SCT/TRT): " << m_missedSum[Trk::TrackState::Pixel] << "/" << m_missedSum[Trk::TrackState::SCT] << "/" << m_missedSum[Trk::TrackState::TRT] );
220  ATH_MSG_INFO ( "faked TSoS (Pixel/SCT/TRT): " << m_fakesSum[Trk::TrackState::Pixel] << "/" << m_fakesSum[Trk::TrackState::SCT] << "/" << m_fakesSum[Trk::TrackState::TRT] );
221  ATH_MSG_INFO ( "wrong type TSoS (Pixel/SCT/TRT): " << m_wrongTypeSum[Trk::TrackState::Pixel] << "/" << m_wrongTypeSum[Trk::TrackState::SCT] << "/" << m_wrongTypeSum[Trk::TrackState::TRT] );
222  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] );
223 
224  ATH_MSG_INFO ( "finalize() successful in " << name() );
225  return StatusCode::SUCCESS;
226 }

◆ initialize()

StatusCode Trk::TrackDiff::initialize ( )

Definition at line 105 of file TrackDiff.cxx.

105  {
106 
107  ATH_CHECK( m_evt.initialize() );
108 
109  StatusCode sc;
110  if (m_writeNtuple) {
111  // ---------------------------
112  // retrive pointer to THistSvc
113  ITHistSvc *tHistSvc;
114  sc = service("THistSvc", tHistSvc);
115  if (sc.isFailure()) {
116  ATH_MSG_ERROR ( "Unable to retrieve pointer to THistSvc" );
117  return sc;
118  }
119 
120  // ---------------------------
121  // create tree and register it to THistSvc
122  m_nt = new TTree(TString(m_ntupleTreeName), "Track diff output");
123  // NB: we must not delete the tree, this is done by THistSvc
124  std::string fullNtupleName = "/"+m_ntupleFileName+"/"+m_ntupleDirName+"/"+m_ntupleTreeName;
125  sc = tHistSvc->regTree(fullNtupleName, m_nt);
126  if (sc.isFailure()) {
127  ATH_MSG_ERROR ("Unable to register TTree : " << fullNtupleName);
128  return sc;
129  }
130 
131  //-----------------
132  // add items
133  // event info:
134  m_nt->Branch("EventNumber", &m_eventNumber );
135  m_nt->Branch("RefTrackPhi0", &m_trackPhi );
136  m_nt->Branch("RefTrackEta0", &m_trackEta );
137 
138  m_nt->Branch("nRefStates", &m_nRefStates, "nRefStates[8]/I");
139  m_nt->Branch("nCompareStates", &m_nCompStates, "nRefStates[8]/I");
140  m_nt->Branch("nFakeStates", &m_fakes, "nFakeStates[8]/I");
141  m_nt->Branch("nMissedStates", &m_missed, "nMissedStates[8]/I");
142  m_nt->Branch("nWrongType", &m_wrongType, "nWrongType[8]/I");
143  m_nt->Branch("nPRD_Mismatches", &m_PRD_Mismatches, "nPRD_Mismatches[8]/I");
144  m_nt->Branch("nDriftCircleSignFlips", &m_driftCircleSignFlips );
145  m_nt->Branch("nNoDriftTime", &m_noDriftTime );
146  m_nt->Branch("nRefTypes", &m_refType, "nRefTypes[8]/I");
147  m_nt->Branch("nCompareTypes", &m_compareType, "nCompareTypes[8]/I");
148  m_nt->Branch("nMissedTypes", &m_missingType, "nMissedTypes[8]/I");
149  m_nt->Branch("nFakeTypes", &m_fakeType, "nFakeTypes[8]/I");
150  // entries for each difference
151  m_nt->Branch("nDiffs", &m_nDiffs );
152  m_detectorType = new std::vector<int>();
153  m_isFake = new std::vector<int>();
154  m_isMissing = new std::vector<int>();
155  m_isPRD_Mismatch = new std::vector<int>();
156  m_isFlippedSign = new std::vector<int>();
157  m_isNoDriftTime = new std::vector<int>();
158  m_refIsMeasurement = new std::vector<int>();
159  m_refIsOutlier = new std::vector<int>();
160  m_compIsMeasurement = new std::vector<int>();
161  m_compIsOutlier = new std::vector<int>();
162  m_surfX = new std::vector<float>();
163  m_surfY = new std::vector<float>();
164  m_surfZ = new std::vector<float>();
165 
166  m_nt->Branch("DetectorType", &m_detectorType);
167  m_nt->Branch("IsFake", &m_isFake);
168  m_nt->Branch("IsMissing", &m_isMissing);
169  m_nt->Branch("IsPRD_Mismatch", &m_isPRD_Mismatch);
170  m_nt->Branch("IsFlippedSign", &m_isFlippedSign);
171  m_nt->Branch("IsNoDriftTime", &m_isNoDriftTime);
172  m_nt->Branch("RefIsMeasurement", &m_refIsMeasurement);
173  m_nt->Branch("RefIsOutlier", &m_refIsOutlier);
174  m_nt->Branch("ComparedIsMeasurement", &m_compIsMeasurement);
175  m_nt->Branch("ComparedIsOutlier", &m_compIsOutlier);
176  m_nt->Branch("SurfaceX" , &m_surfX);
177  m_nt->Branch("SurfaceY" , &m_surfY);
178  m_nt->Branch("SurfaceZ" , &m_surfZ);
179 
180  if (m_writeCompetingROT) {
181  m_maxAssignProb = new std::vector<float>();
182  m_sumAssignProb = new std::vector<float>();
183  m_nt->Branch("MaxAssgnProb", &m_maxAssignProb);
184  m_nt->Branch("SumAssgnProb", &m_sumAssignProb);
185  } // end if writeComepetingROT
186  } // end if (m_writeNtuple)
187  // ---------------------------------------
188  // Get the detector helper to be able to identify sub-det technologies
189  if (detStore()->retrieve(m_idHelper, "AtlasID").isFailure()) {
190  ATH_MSG_ERROR ("Could not get AtlasDetectorID helper" );
191  return StatusCode::FAILURE;
192  }
193 
194  for (int detType = 0; detType < Trk::TrackState::NumberOfMeasurementTypes; detType++) {
195  m_fakesSum[detType] = 0;
196  m_missedSum[detType] = 0;
197  m_PRD_MismatchesSum[detType] = 0;
198  m_nRefStatesSum[detType] = 0;
199  m_nCompStatesSum[detType] = 0;
200  m_wrongTypeSum[detType] = 0;
201  m_fakes[detType] = 0;
202  m_missed[detType] = 0;
203  m_PRD_Mismatches[detType] = 0;
204  m_nRefStates[detType] = 0;
205  m_nCompStates[detType] = 0;
206  m_wrongType[detType] = 0;
207  }
208 
209  return StatusCode::SUCCESS;
210 }

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

40  {
41  return IID_ITrackDiff;
42 }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

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

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

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

364  {
365  handlesArray.renounce();
366  }

◆ resetVariables()

void Trk::TrackDiff::resetVariables ( )
private

reset the ntuple variables

reset variables

Definition at line 439 of file TrackDiff.cxx.

439  {
440  // reset the counters
441  //m_fakes = 0;
442  //m_missed = 0;
443  m_driftCircleSignFlips = 0;
444  m_noDriftTime = 0;
445  m_nDiffs = 0;
446  for (int detType = 0; detType < Trk::TrackState::NumberOfMeasurementTypes; detType++) {
447  m_fakesSum[detType] += m_fakes[detType];
448  m_fakes[detType] = 0;
449  m_missedSum[detType] += m_missed[detType];
450  m_missed[detType] = 0;
451  m_PRD_MismatchesSum[detType] += m_PRD_Mismatches[detType];
452  m_PRD_Mismatches[detType] = 0;
453  m_nRefStatesSum[detType] += m_nRefStates[detType];
454  m_nRefStates[detType] = 0;
455  m_nCompStatesSum[detType] += m_nCompStates[detType];
456  m_nCompStates[detType] = 0;
457  m_wrongType[detType] += m_wrongType[detType];
458  m_wrongType[detType] = 0;
459  }
460  for (int TSoSType = 0; TSoSType < Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes; TSoSType++) {
461  m_missingType[TSoSType] = 0;
462  m_fakeType[TSoSType] = 0;
463  m_refType[TSoSType] = 0;
464  m_compareType[TSoSType] = 0;
465  }
466 // m_missingType->clear();
467 // m_missingType->resize(Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes, 0);
468 // m_fakeType->clear();
469 // m_fakeType->resize(Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes, 0);
470 // m_PRD_Mismatches->clear();
471 // m_PRD_Mismatches->resize(8, 0);
472  if (m_writeNtuple) {
473  m_detectorType->clear();
474  m_isFake->clear();
475  m_isMissing->clear();
476  m_isPRD_Mismatch->clear();
477  m_isFlippedSign->clear();
478  m_isNoDriftTime->clear();
479  m_refIsMeasurement->clear();
480  m_refIsOutlier->clear();
481  m_compIsMeasurement->clear();
482  m_compIsOutlier->clear();
483  m_surfX->clear();
484  m_surfY->clear();
485  m_surfZ->clear();
486 
487  if (m_writeCompetingROT) {
488  m_maxAssignProb->clear();
489  m_sumAssignProb->clear();
490  } // end if writeComepetingROT
491  }
492 
493 }

◆ sysInitialize()

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

Perform system initialization for an algorithm.

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

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

◆ sysStart()

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

Handle START transition.

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

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.

◆ 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:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
AtlasDetectorID::is_pixel
bool is_pixel(Identifier id) const
Definition: AtlasDetectorID.h:760
Trk::TrackDiff::m_refIsOutlier
std::vector< int > * m_refIsOutlier
Definition: TrackDiff.h:136
Trk::TrackDiff::m_fakesSum
int m_fakesSum[Trk::TrackState::NumberOfMeasurementTypes]
Definition: TrackDiff.h:151
AtlasDetectorID::is_rpc
bool is_rpc(Identifier id) const
Definition: AtlasDetectorID.h:875
Trk::TrackState::RPC
@ RPC
Definition: TrackStateDefs.h:33
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
Trk::TrackState::Pixel
@ Pixel
Definition: TrackStateDefs.h:28
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
Trk::TrackDiff::m_driftCircleSignFlips
int m_driftCircleSignFlips
Definition: TrackDiff.h:125
Trk::TrackDiff::m_compIsOutlier
std::vector< int > * m_compIsOutlier
Definition: TrackDiff.h:138
Trk::TrackState::TRT
@ TRT
Definition: TrackStateDefs.h:30
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
AtlasDetectorID::is_csc
bool is_csc(Identifier id) const
Definition: AtlasDetectorID.h:891
Trk::TrackDiff::m_missedSum
int m_missedSum[Trk::TrackState::NumberOfMeasurementTypes]
Definition: TrackDiff.h:152
InDetSecVtxTruthMatchUtils::isFake
bool isFake(int matchInfo)
Definition: InDetSecVtxTruthMatchTool.h:60
AtlasDetectorID::is_sct
bool is_sct(Identifier id) const
Definition: AtlasDetectorID.h:770
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
index
Definition: index.py:1
Trk::TrackDiff::m_PRD_MismatchesSum
int m_PRD_MismatchesSum[Trk::TrackState::NumberOfMeasurementTypes]
Definition: TrackDiff.h:154
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Trk::TrackDiff::m_eventNumber
int m_eventNumber
Definition: TrackDiff.h:112
Trk::TrackState::MDT
@ MDT
Definition: TrackStateDefs.h:31
Trk::TrackDiff::m_PRD_Mismatches
int m_PRD_Mismatches[Trk::TrackState::NumberOfMeasurementTypes]
Definition: TrackDiff.h:124
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
Trk::TrackDiff::m_surfY
std::vector< float > * m_surfY
Definition: TrackDiff.h:142
Trk::RIO_OnTrack
Definition: RIO_OnTrack.h:70
Trk::TrackDiff::m_compareAll
bool m_compareAll
jobOption: compare track states of all types
Definition: TrackDiff.h:108
LArG4FSStartPointFilter.evt
evt
Definition: LArG4FSStartPointFilter.py:42
Trk::TrackState::TGC
@ TGC
Definition: TrackStateDefs.h:34
Trk::TrackDiff::diffStateInfo
bool diffStateInfo(const Trk::TrackStateData *refTrackStateData, const Trk::TrackStateData *compareTrackStateData)
diff of two given track state data
Definition: TrackDiff.cxx:531
Trk::locR
@ locR
Definition: ParamDefs.h:50
AtlasDetectorID::is_trt
bool is_trt(Identifier id) const
Definition: AtlasDetectorID.h:782
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
Trk::TrackDiff::m_trackEta
float m_trackEta
Definition: TrackDiff.h:145
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
Trk::TrackDiff::m_detectorType
std::vector< int > * m_detectorType
Definition: TrackDiff.h:129
Trk::TrackState::unidentified
@ unidentified
Definition: TrackStateDefs.h:27
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
Trk::TrackDiff::m_nCompStatesSum
int m_nCompStatesSum[Trk::TrackState::NumberOfMeasurementTypes]
Definition: TrackDiff.h:150
Trk::TrackStateOnSurface::Outlier
@ Outlier
This TSoS contains an outlier, that is, it contains a MeasurementBase/RIO_OnTrack which was not used ...
Definition: TrackStateOnSurface.h:122
Trk::TrackDiff::m_isFlippedSign
std::vector< int > * m_isFlippedSign
Definition: TrackDiff.h:133
Trk::TrackDiff::m_trackSum
int m_trackSum
Definition: TrackDiff.h:155
Trk::CompetingRIOsOnTrack::rioOnTrack
virtual const RIO_OnTrack & rioOnTrack(unsigned int) const =0
returns the RIO_OnTrack (also known as ROT) objects depending on the integer.
Trk::TrackDiff::resetVariables
void resetVariables()
reset the ntuple variables
Definition: TrackDiff.cxx:439
Trk::TrackDiff::m_ntupleFileName
std::string m_ntupleFileName
jobOption: Ntuple file name
Definition: TrackDiff.h:103
Trk::TrackDiff::m_refType
int m_refType[Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes]
Definition: TrackDiff.h:122
AthCommonDataStore
Definition: AthCommonDataStore.h:52
Trk::TrackDiff::m_writeNtuple
bool m_writeNtuple
jobOption: write data to ntuple?
Definition: TrackDiff.h:109
Trk::TrackDiff::m_wrongType
int m_wrongType[Trk::TrackState::NumberOfMeasurementTypes]
Definition: TrackDiff.h:119
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
DataModel_detail::iterator
(Non-const) Iterator class for DataVector/DataList.
Definition: DVLIterator.h:184
Trk::CompetingRIOsOnTrack::numberOfContainedROTs
virtual unsigned int numberOfContainedROTs() const =0
Number of RIO_OnTracks to be contained by this CompetingRIOsOnTrack.
Trk::TrackDiff::m_missingType
int m_missingType[Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes]
Definition: TrackDiff.h:120
Trk::TrackDiff::m_isFake
std::vector< int > * m_isFake
vector<bool> would be more efficient, but vector<bool> is not a normal vector<> and seems to make tro...
Definition: TrackDiff.h:130
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
AtlasDetectorID::is_tgc
bool is_tgc(Identifier id) const
Definition: AtlasDetectorID.h:902
beamspotman.n
n
Definition: beamspotman.py:731
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Trk::TrackDiff::m_trackPhi
float m_trackPhi
Definition: TrackDiff.h:146
Trk::TrackDiff::m_compareType
int m_compareType[Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes]
Definition: TrackDiff.h:123
Trk::CompetingRIOsOnTrack
Base class for all CompetingRIOsOnTack implementations, extends the common MeasurementBase.
Definition: CompetingRIOsOnTrack.h:64
Trk::TrackState::MeasurementType
MeasurementType
enum describing the flavour of MeasurementBase
Definition: TrackStateDefs.h:26
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
Trk::TrackDiff::m_surfZ
std::vector< float > * m_surfZ
Definition: TrackDiff.h:143
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
Trk::TrackDiff::m_wrongTypeSum
int m_wrongTypeSum[Trk::TrackState::NumberOfMeasurementTypes]
Definition: TrackDiff.h:153
Trk::TrackDiff::m_ntupleDirName
std::string m_ntupleDirName
jobOption: Ntuple directory name
Definition: TrackDiff.h:104
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
Trk::PrepRawData
Definition: PrepRawData.h:62
Trk::TrackDiff::m_isNoDriftTime
std::vector< int > * m_isNoDriftTime
Definition: TrackDiff.h:134
Trk::MeasurementBase
Definition: MeasurementBase.h:58
Trk::Track::perigeeParameters
const Perigee * perigeeParameters() const
return Perigee.
Definition: Tracking/TrkEvent/TrkTrack/src/Track.cxx:163
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
Trk::MeasurementBase::associatedSurface
virtual const Surface & associatedSurface() const =0
Interface method to get the associated Surface.
Trk::TrackDiff::m_writeCompetingROT
bool m_writeCompetingROT
jobOption: write data about TrkCompetingRIOsOnTrack?
Definition: TrackDiff.h:110
Trk::TrackDiff::m_refIsMeasurement
std::vector< int > * m_refIsMeasurement
Definition: TrackDiff.h:135
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
Trk::TrackDiff::m_isPRD_Mismatch
std::vector< int > * m_isPRD_Mismatch
Definition: TrackDiff.h:132
Trk::RIO_OnTrack::prepRawData
virtual const Trk::PrepRawData * prepRawData() const =0
returns the PrepRawData (also known as RIO) object to which this RIO_OnTrack is associated.
Trk::TrackDiff::m_maxAssignProb
std::vector< float > * m_maxAssignProb
Definition: TrackDiff.h:139
Trk::TrackDiff::m_sumAssignProb
std::vector< float > * m_sumAssignProb
Definition: TrackDiff.h:140
Trk::TrackDiff::m_missed
int m_missed[Trk::TrackState::NumberOfMeasurementTypes]
Definition: TrackDiff.h:118
Trk::MeasurementBase::localParameters
const LocalParameters & localParameters() const
Interface method to get the LocalParameters.
Definition: MeasurementBase.h:132
Trk::TrackDiff::m_compareOutliers
bool m_compareOutliers
jobOption: compare track states of type "outlier"
Definition: TrackDiff.h:107
Trk::TrackDiff::m_nCompStates
int m_nCompStates[Trk::TrackState::NumberOfMeasurementTypes]
Definition: TrackDiff.h:115
Trk::TrackDiff::m_compIsMeasurement
std::vector< int > * m_compIsMeasurement
Definition: TrackDiff.h:137
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
Trk::TrackDiff::m_fakeType
int m_fakeType[Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes]
Definition: TrackDiff.h:121
Trk::TrackDiff::detectorType
Trk::TrackState::MeasurementType detectorType(const Trk::RIO_OnTrack &ROT, std::string &detTypeName) const
get detector type and name by identifier of Trk::RIO_OnTrack
Definition: TrackDiff.cxx:496
Trk::TrackDiff::m_idHelper
AtlasDetectorID * m_idHelper
Used to find out the sub-det from PRD->identify().
Definition: TrackDiff.h:100
Trk::TrackDiff::m_ntupleTreeName
std::string m_ntupleTreeName
jobOption: Ntuple tree name
Definition: TrackDiff.h:105
a
TList * a
Definition: liststreamerinfos.cxx:10
Trk::TrackStateData
Definition: TrackStateData.h:30
h
Trk::TrackDiff::m_surfX
std::vector< float > * m_surfX
Definition: TrackDiff.h:141
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Trk::TrackDiff::m_nRefStates
int m_nRefStates[Trk::TrackState::NumberOfMeasurementTypes]
Definition: TrackDiff.h:114
Trk::TrackDiff::m_fakes
int m_fakes[Trk::TrackState::NumberOfMeasurementTypes]
Definition: TrackDiff.h:116
Trk::TrackDiff::extractDataFromTrack
DataVector< const Trk::TrackStateData > * extractDataFromTrack(const Trk::Track &) const
extract data from a Trk::Track into a list of Trk::TrackStateData
Definition: TrackDiff.cxx:353
DEBUG
#define DEBUG
Definition: page_access.h:11
Trk::TrackDiff::m_isMissing
std::vector< int > * m_isMissing
Definition: TrackDiff.h:131
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
Trk::TrackState::CSC
@ CSC
Definition: TrackStateDefs.h:32
Trk::RIO_OnTrack::identify
virtual Identifier identify() const final
return the identifier -extends MeasurementBase
Definition: RIO_OnTrack.h:155
Trk::TrackDiff::m_nRefStatesSum
int m_nRefStatesSum[Trk::TrackState::NumberOfMeasurementTypes]
Definition: TrackDiff.h:149
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
Trk::TrackDiff::m_nDiffs
int m_nDiffs
Definition: TrackDiff.h:128
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
Trk::TrackState::SCT
@ SCT
Definition: TrackStateDefs.h:29
Trk::TrackDiff::m_noDriftTime
int m_noDriftTime
Definition: TrackDiff.h:126
DataVector::erase
iterator erase(iterator position)
Remove element at a given position.
Trk::CompetingRIOsOnTrack::indexOfMaxAssignProb
unsigned int indexOfMaxAssignProb() const
Index of the ROT with the highest assignment probability.
Definition: CompetingRIOsOnTrack.cxx:101
Trk::Surface
Definition: Tracking/TrkDetDescr/TrkSurfaces/TrkSurfaces/Surface.h:75
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
Trk::phi0
@ phi0
Definition: ParamDefs.h:71
Trk::TrackStateOnSurface::Measurement
@ Measurement
This is a measurement, and will at least contain a Trk::MeasurementBase.
Definition: TrackStateOnSurface.h:101
Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes
@ NumberOfTrackStateOnSurfaceTypes
Definition: TrackStateOnSurface.h:152
Trk::TrackState::NumberOfMeasurementTypes
@ NumberOfMeasurementTypes
Definition: TrackStateDefs.h:43
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
Trk::TrackDiff::m_nt
TTree * m_nt
Pointer to the NTuple tree.
Definition: TrackDiff.h:98
AtlasDetectorID::is_mdt
bool is_mdt(Identifier id) const
Definition: AtlasDetectorID.h:859
fitman.k
k
Definition: fitman.py:528
Trk::TrackDiff::m_evt
SG::ReadHandleKey< xAOD::EventInfo > m_evt
Definition: TrackDiff.h:157
Trk::CompetingRIOsOnTrack::assignmentProbability
AssignmentProb assignmentProbability(unsigned int indx) const
returns the AssignmentProbability depending on the integer.
Definition: CompetingRIOsOnTrack.h:139
Generated on Fri Jun 28 2024 22:31:54 for ATLAS Offline Software by   doxygen 1.8.18