ATLAS Offline Software
TrackDiff.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 // TrackDiff.cxx
7 // Source file for class TrackDiff
9 // (c) ATLAS Detector software
11 // Sebastian.Fleischmann@cern.ch
13 
14 
15 //Gaudi
16 #include "GaudiKernel/ListItem.h"
17 #include "GaudiKernel/ITHistSvc.h"
18 #include "TString.h"
19 #include "TTree.h"
20 
21 // Trk
22 #include "TrkValTools/TrackDiff.h"
23 #include "TrkEventPrimitives/LocalParameters.h"
24 #include "TrkParameters/TrackParameters.h"
25 #include "TrkSurfaces/Surface.h"
26 
27 #include "TrkCompetingRIOsOnTrack/CompetingRIOsOnTrack.h"
28 #include "TrkRIO_OnTrack/RIO_OnTrack.h"
29 #include "TrkTrack/Track.h"
30 
31 #include "AtlasDetDescr/AtlasDetectorID.h"
32 
33 // constructor
34 Trk::TrackDiff::TrackDiff(
35  const std::string& t,
36  const std::string& n,
37  const IInterface* p )
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 }
98 
99 // destructor
100 Trk::TrackDiff::~TrackDiff() = default;
101 
102 
103 
104 // initialize
105 StatusCode Trk::TrackDiff::initialize() {
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 }
211 
215 StatusCode Trk::TrackDiff::finalize() {
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 }
227 
231 StatusCode Trk::TrackDiff::diff (
232  const Trk::Track& referenceTrack,
233  const Trk::Track& comparedTrack ) {
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 }
351 
353 DataVector< const Trk::TrackStateData >* Trk::TrackDiff::extractDataFromTrack( const Trk::Track& track ) const {
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 }
436 
437 
439 void Trk::TrackDiff::resetVariables() {
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 }
494 
496 Trk::TrackState::MeasurementType Trk::TrackDiff::detectorType(const Trk::RIO_OnTrack& ROT,
497  std::string &detTypeName ) const {
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 }
529 
531 bool Trk::TrackDiff::diffStateInfo(const Trk::TrackStateData* refTrackState,
532  const Trk::TrackStateData* compareTrackState) {
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 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
Trk::TrackStateData::detTypeName
const std::string & detTypeName() const
return detector type name
Definition: TrackStateData.cxx:57
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
Trk::TrackStateData::detType
const TrackState::MeasurementType & detType() const
return dectector type
Definition: TrackStateData.cxx:61
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
TrackParameters.h
Trk::TrackState::TRT
@ TRT
Definition: TrackStateDefs.h:30
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
CompetingRIOsOnTrack.h
Surface.h
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
InDetSecVtxTruthMatchUtils::isFake
bool isFake(int matchInfo)
Definition: InDetSecVtxTruthMatchTool.h:60
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
index
Definition: index.py:1
Trk::TrackState::MDT
@ MDT
Definition: TrackStateDefs.h:31
Trk::TrackDiff::initialize
StatusCode initialize()
Definition: TrackDiff.cxx:105
Trk::TrackDiff::finalize
StatusCode finalize()
finalize
Definition: TrackDiff.cxx:215
Trk::TrackStateOnSurface::measurementOnTrack
const MeasurementBase * measurementOnTrack() const
returns MeasurementBase const overload
Trk::RIO_OnTrack
Definition: RIO_OnTrack.h:70
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
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
Trk::Surface::center
const Amg::Vector3D & center() const
Returns the center position of the Surface.
Trk::TrackState::unidentified
@ unidentified
Definition: TrackStateDefs.h:27
Trk::TrackStateData::surface
const Trk::Surface * surface() const
return Trk::Surface pointer
Definition: TrackStateData.cxx:53
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
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
Track.h
Trk::TrackStateOnSurface::type
bool type(const TrackStateOnSurfaceType type) const
Use this method to find out if the TSoS is of a certain type: i.e.
AtlasDetectorID.h
This class provides an interface to generate or decode an identifier for the upper levels of the dete...
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
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::TrackDiff
TrackDiff(const std::string &, const std::string &, const IInterface *)
Definition: TrackDiff.cxx:34
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
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::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
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
Trk::PrepRawData
Definition: PrepRawData.h:62
Trk::MeasurementBase
Definition: MeasurementBase.h:58
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
Trk::Track::perigeeParameters
const Perigee * perigeeParameters() const
return Perigee.
Definition: Tracking/TrkEvent/TrkTrack/src/Track.cxx:163
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.
RIO_OnTrack.h
TrackDiff.h
Trk::TrackStateData::trackStateOnSurface
const Trk::TrackStateOnSurface * trackStateOnSurface() const
return Trk::TrackStateOnSurface pointer
Definition: TrackStateData.cxx:45
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
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.
LocalParameters.h
Trk::MeasurementBase::localParameters
const LocalParameters & localParameters() const
Interface method to get the LocalParameters.
Definition: MeasurementBase.h:132
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
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::TrackStateData
Definition: TrackStateData.h:30
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
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
Trk::TrackStateData::rot
const Trk::RIO_OnTrack * rot() const
return Trk::RIO_OnTrack pointer
Definition: TrackStateData.cxx:49
DEBUG
#define DEBUG
Definition: page_access.h:11
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::~TrackDiff
~TrackDiff()
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
Trk::TrackState::SCT
@ SCT
Definition: TrackStateDefs.h:29
AthAlgTool
Definition: AthAlgTool.h:26
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.
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
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::diff
virtual StatusCode diff(const Trk::Track &referenceTrack, const Trk::Track &comparedTrack)
diff of two given tracks
Definition: TrackDiff.cxx:231
Trk::CompetingRIOsOnTrack::assignmentProbability
AssignmentProb assignmentProbability(unsigned int indx) const
returns the AssignmentProbability depending on the integer.
Definition: CompetingRIOsOnTrack.h:139
Generated on Sun Jun 30 2024 21:29:43 for ATLAS Offline Software by   doxygen 1.8.18