ATLAS Offline Software
SiSPSeededTrackFinder.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 
13 
15 #include "InDetIdentifier/SCT_ID.h"
16 #include "Identifier/Identifier.h"
17 
18 #include <set>
19 #include <fstream>
20 
21 namespace {
30 double trackQuality(const Trk::Track* Tr) {
31 
32  double quality = 0.;
33  double baseScorePerHit = 17.;
35  for (const Trk::TrackStateOnSurface* m : *(Tr->trackStateOnSurfaces())) {
38  continue;
40  const Trk::FitQualityOnSurface fq = m->fitQualityOnSurface();
41  if (!fq)
42  continue;
43 
44  double x2 = fq.chiSquared();
45  double hitQualityScore;
48  if (fq.numberDoF() == 2)
49  hitQualityScore = (1.2 * (baseScorePerHit - x2 * .5)); // pix
50  else
51  hitQualityScore = (baseScorePerHit - x2); // sct
52  if (hitQualityScore < 0.)
53  hitQualityScore =
54  0.; // do not allow a bad hit to decrement the overall score
55  quality += hitQualityScore;
56  }
59  quality *= 0.7;
60 
61  return quality;
62 }
63 } // namespace
64 
68 
70 (const std::string& name,ISvcLocator* pSvcLocator) : AthReentrantAlgorithm(name, pSvcLocator)
71 {
72 }
73 
77 
79 {
81  ATH_CHECK(m_mbtsKey.initialize(m_useMBTS));
84  ATH_CHECK(m_outputTracksKey.initialize());
85 
88 
90 
92  ATH_CHECK( m_seedsmaker.retrieve() );
93  ATH_CHECK( m_zvertexmaker.retrieve( DisableTool{ not m_useZvertexTool } ));
94 
96  ATH_CHECK( m_trackmaker.retrieve());
97 
98  ATH_CHECK( m_regsel_strip.retrieve( DisableTool{ not m_useITkConvSeeded } ) );
99 
101 
102  ATH_CHECK( m_trackSummaryTool.retrieve( DisableTool{ m_trackSummaryTool.name().empty()} ));
103 
104  if (m_useNewStrategy and m_beamSpotKey.key().empty()) {
105  m_useNewStrategy = false;
106  m_useZBoundaryFinding = false;
107  }
108 
111 
112  if (not m_beamSpotKey.key().empty()) {
114  ATH_CHECK( m_proptool.retrieve() );
115 
118 
120  if (m_histsize < 100) m_histsize = 100;
121  m_zstep = static_cast<double>(m_histsize)/(2.*m_zcut);
122  } else {
123  m_proptool.disable();
124  m_useNewStrategy = false;
125  m_useZBoundaryFinding = false;
126  }
127  } else {
128  m_proptool.disable();
129  }
130 
132  if (msgLvl(MSG::DEBUG)) {
133  dump(MSG::DEBUG, nullptr);
134  }
135  m_neventsTotal = 0;
136  m_neventsTotalV = 0;
137  m_problemsTotal = 0;
138  m_problemsTotalV = 0;
139  return StatusCode::SUCCESS;
140 }
141 
145 
146 StatusCode InDet::SiSPSeededTrackFinder::execute(const EventContext& ctx) const
147 {
153  else if (m_useITkConvSeeded) return itkConvStrategy(ctx);
154  else if (not m_useNewStrategy and not m_useZBoundaryFinding and not m_ITKGeometry) {
155  return oldStrategy(ctx);
156  }
157  return newStrategy(ctx);
158 }
159 
163 
164 namespace InDet {
166  {
167  public:
169  if (!key.key().empty()) {
172  }
173  }
174  private:
176  };
177 }
178 
179 
181 {
183  ATH_CHECK(outputTracks.record(std::make_unique<TrackCollection>()));
185  if (not isGoodEvent(ctx)) {
186  return StatusCode::SUCCESS;
187  }
188 
189  SiSpacePointsSeedMakerEventData seedEventData;
190  bool ZVE = false;
191  if (m_useZvertexTool) {
192  std::list<Trk::Vertex> vertices = m_zvertexmaker->newEvent(ctx, seedEventData);
193  if (not vertices.empty()) ZVE = true;
194  m_seedsmaker->find3Sp(ctx, seedEventData, vertices);
195  } else {
196  m_seedsmaker->newEvent(ctx, seedEventData, -1);
197  std::list<Trk::Vertex> vertexList;
198  m_seedsmaker->find3Sp(ctx, seedEventData, vertexList);
199  }
200 
201  const bool PIX = true;
202  const bool SCT = true;
204  m_trackmaker->newEvent(ctx, trackEventData, PIX, SCT);
205 
206  bool ERR = false;
207  Counter_t counter{};
208  const InDet::SiSpacePointsSeed* seed = nullptr;
209  std::multimap<double, Trk::Track*> qualitySortedTrackCandidates;
210  // Loop through all seed and reconsrtucted tracks collection preparation
211  //
212  while ((seed = m_seedsmaker->next(ctx, seedEventData))) {
213  ++counter[kNSeeds];
214  std::list<Trk::Track*> trackList = m_trackmaker->getTracks(ctx, trackEventData, seed->spacePoints());
215  for (Trk::Track* t: trackList) {
216  qualitySortedTrackCandidates.insert(std::make_pair(-trackQuality(t), t));
217  }
218  if (not ZVE and (counter[kNSeeds] >= m_maxNumberSeeds)) {
219  ERR = true;
220  ++m_problemsTotal;
221  break;
222  }
223  }
224  m_trackmaker->endEvent(trackEventData);
225 
226  // Remove shared tracks with worse quality
227  //
228  filterSharedTracks(qualitySortedTrackCandidates);
229 
230  // Save good tracks in track collection
231  //
232  for (const std::pair<const double, Trk::Track*> & qualityAndTrack: qualitySortedTrackCandidates) {
233  ++counter[kNTracks];
234  if (m_trackSummaryTool.isEnabled()) {
235  m_trackSummaryTool->computeAndReplaceTrackSummary(*(qualityAndTrack.second),
236  false /* DO NOT suppress hole search*/);
237  }
238  outputTracks->push_back(qualityAndTrack.second);
239  }
240 
241  m_counterTotal[kNSeeds] += counter[kNSeeds];
242 
243  if (ZVE) ++m_neventsTotalV;
244  else ++m_neventsTotal;
245 
246  if (ERR) {
247  outputTracks->clear();
248  } else {
249  m_counterTotal[kNTracks] += counter[kNTracks];
250  }
251 
252  // Print common event information
253  //
254  if (msgLvl(MSG::DEBUG)) {
256  }
257 
258  return StatusCode::SUCCESS;
259 }
260 
262 // Execute with new strategy
264 
266 {
268  ATH_CHECK(outputTracks.record(std::make_unique<TrackCollection>()));
270  if (not isGoodEvent(ctx)) {
271  return StatusCode::SUCCESS;
272  }
273 
276  Trk::PerigeeSurface beamPosPerigee(beamSpotHandle->beamPos());
277 
278  SiSpacePointsSeedMakerEventData seedEventData;
279 
294  m_seedsmaker->newEvent(ctx, seedEventData, 0);
296  std::list<Trk::Vertex> vertexList;
298  m_seedsmaker->find3Sp(ctx, seedEventData, vertexList);
299 
300  const bool PIX = true ;
301  const bool SCT = true ;
304  m_trackmaker->newEvent(ctx, trackEventData, PIX, SCT);
305 
307  std::vector<int> numberHistogram(m_histsize, 0);
308  std::vector<double> zWeightedHistogram(m_histsize, 0.);
309  std::vector<double> ptWeightedHistogram(m_histsize, 0.);
310 
311  bool ERR = false;
312  Counter_t counter{};
313  const InDet::SiSpacePointsSeed* seed = nullptr;
314 
316  std::multimap<double, Trk::Track*> qualitySortedTrackCandidates;
317 
319  bool doWriteNtuple = m_seedsmaker->getWriteNtupleBoolProperty();
320  long EvNumber = 0.; //Event number variable to be used for the validation ntuple
321 
322  if (doWriteNtuple) {
324  if(!eventInfo.isValid()) {EvNumber = -1.0;} else {EvNumber = eventInfo->eventNumber();}
325  }
326 
328  while ((seed = m_seedsmaker->next(ctx, seedEventData))) {
329 
330  ++counter[kNSeeds];
332  bool firstTrack{true};
333 
335  std::list<Trk::Track*> trackList = m_trackmaker->getTracks(ctx, trackEventData, seed->spacePoints());
337  for (Trk::Track* t: trackList) {
338 
339  qualitySortedTrackCandidates.insert(std::make_pair(-trackQuality(t), t));
340 
341  if (firstTrack && m_doDumpGBTSTrainingDataLRT) {
343  }
344 
346  if (firstTrack and not m_ITKGeometry) {
347  fillZHistogram(t, beamPosPerigee, numberHistogram, zWeightedHistogram, ptWeightedHistogram);
348  }
349  firstTrack = false;
350  }
352  if(doWriteNtuple) { m_seedsmaker->writeNtuple(seed, !trackList.empty() ? trackList.front() : nullptr, ISiSpacePointsSeedMaker::StripSeed, EvNumber) ; }
353 
354 
355  if (counter[kNSeeds] >= m_maxNumberSeeds) {
356  ERR = true;
357  ++m_problemsTotal;
358  break;
359  }
360  }
361 
366  if(not m_SpacePointsPixelKey.empty()) {
367  m_seedsmaker->newEvent(ctx, seedEventData, 1);
368  } else {
369  ATH_MSG_WARNING("SpacePointsPixelKey is empty. Skipping the second seeding pass that uses pixel seeds.");
370  }
371 
373  std::pair<double,double> zBoundaries;
374  if (not m_ITKGeometry) {
376  findZvertex(vertexList, zBoundaries, numberHistogram, zWeightedHistogram, ptWeightedHistogram);
379  m_seedsmaker->find3Sp(ctx, seedEventData, vertexList, &(zBoundaries.first));
380  } else {
381  m_seedsmaker->find3Sp(ctx, seedEventData, vertexList);
382  }
383 
385  while ((seed = m_seedsmaker->next(ctx, seedEventData))) {
386 
387  ++counter[kNSeeds];
388 
389  std::list<Trk::Track*> trackList = m_trackmaker->getTracks(ctx, trackEventData, seed->spacePoints());
390 
391  for (Trk::Track* t: trackList) {
392  qualitySortedTrackCandidates.insert(std::make_pair(-trackQuality(t), t));
393  }
394 
395  if(doWriteNtuple) { m_seedsmaker->writeNtuple(seed, !trackList.empty() ? trackList.front() : nullptr, ISiSpacePointsSeedMaker::PixelSeed, EvNumber); }
396 
397  if (counter[kNSeeds] >= m_maxNumberSeeds) {
398  ERR = true;
399  ++m_problemsTotal;
400  break;
401  }
402  }
403 
404  m_trackmaker->endEvent(trackEventData);
405 
407  filterSharedTracks(qualitySortedTrackCandidates);
408 
410  for (const std::pair<const double, Trk::Track*> & qualityAndTrack: qualitySortedTrackCandidates) {
411  ++counter[kNTracks];
412  if (m_trackSummaryTool.isEnabled()) {
415  m_trackSummaryTool->computeAndReplaceTrackSummary(*qualityAndTrack.second,
416  false /* DO NOT suppress hole search*/);
419  if (m_writeHolesFromPattern && trackEventData.combinatorialData().findPatternHoleSearchOutcome(qualityAndTrack.second,theOutcome)){
421  qualityAndTrack.second->trackSummary()->update(Trk::numberOfPixelHoles, theOutcome.nPixelHoles);
422  qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTHoles, theOutcome.nSCTHoles);
423  qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTDoubleHoles, theOutcome.nSCTDoubleHoles);
424  qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTDeadSensors, theOutcome.nSCTDeads);
425  qualityAndTrack.second->trackSummary()->update(Trk::numberOfPixelDeadSensors, theOutcome.nPixelDeads);
426  }
427  }
428  outputTracks->push_back(qualityAndTrack.second);
430  collectGBTSTrainingData(qualityAndTrack.second);
431  }
432  }
433 
434  m_counterTotal[kNSeeds] += counter[kNSeeds] ;
435 
436  ++m_neventsTotal;
437 
438  if (ERR) {
439  outputTracks->clear();
440  } else {
441  m_counterTotal[kNTracks] += counter[kNTracks];
442  }
443 
444  // Print common event information
445  //
446  if (msgLvl(MSG::DEBUG)) {
448  }
449  return StatusCode::SUCCESS;
450 }
451 
452 
453 
455 // ITk fast tracking strategy
457 
459 {
461  ATH_CHECK(outputTracks.record(std::make_unique<TrackCollection>()));
462 
463  const bool PIX = true ;
464  const bool STRIP = true ;
467  m_trackmaker->newTrigEvent(ctx, trackEventData, PIX, STRIP);
468 
469  SiSpacePointsSeedMakerEventData seedEventData;
470 
480  m_seedsmaker->newEvent(ctx, seedEventData, 0);
482  std::list<Trk::Vertex> vertexList;
484  m_seedsmaker->find3Sp(ctx, seedEventData, vertexList);
485 
486  bool ERR = false;
487  Counter_t counter{};
488  const InDet::SiSpacePointsSeed* seed = nullptr;
489 
491  std::multimap<double, Trk::Track*> qualitySortedTrackCandidates;
492 
494  bool doWriteNtuple = m_seedsmaker->getWriteNtupleBoolProperty();
495  long EvNumber = 0.; //Event number variable to be used for the validation ntuple
496 
497  if (doWriteNtuple) {
499  if(!eventInfo.isValid()) {EvNumber = -1.0;} else {EvNumber = eventInfo->eventNumber();}
500  }
501 
503  while ((seed = m_seedsmaker->next(ctx, seedEventData))) {
504 
505  ++counter[kNSeeds];
506 
508  std::list<Trk::Track*> trackList = m_trackmaker->getTracks(ctx, trackEventData, seed->spacePoints());
510  for (Trk::Track* t: trackList) {
511 
512  qualitySortedTrackCandidates.insert(std::make_pair(-trackQuality(t), t));
513 
514  }
516  if(doWriteNtuple) { m_seedsmaker->writeNtuple(seed, !trackList.empty() ? trackList.front() : nullptr, ISiSpacePointsSeedMaker::PixelSeed, EvNumber) ; }
517 
518  if (counter[kNSeeds] >= m_maxNumberSeeds) {
519  ERR = true;
520  ++m_problemsTotal;
521  break;
522  }
523  }
524 
525  m_trackmaker->endEvent(trackEventData);
526 
528  filterSharedTracksFast(qualitySortedTrackCandidates);
529 
531  for (const std::pair<const double, Trk::Track*> & qualityAndTrack: qualitySortedTrackCandidates) {
532  ++counter[kNTracks];
533 
534  if (m_trackSummaryTool.isEnabled()) {
535  m_trackSummaryTool->computeAndReplaceTrackSummary(*qualityAndTrack.second);
538  if (m_writeHolesFromPattern && trackEventData.combinatorialData().findPatternHoleSearchOutcome(qualityAndTrack.second,theOutcome)){
540  qualityAndTrack.second->trackSummary()->update(Trk::numberOfPixelHoles, theOutcome.nPixelHoles);
541  qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTHoles, theOutcome.nSCTHoles);
542  qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTDoubleHoles, theOutcome.nSCTDoubleHoles);
543  qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTDeadSensors, theOutcome.nSCTDeads);
544  qualityAndTrack.second->trackSummary()->update(Trk::numberOfPixelDeadSensors, theOutcome.nPixelDeads);
545  }
546  }
547 
548  outputTracks->push_back(qualityAndTrack.second);
549  }
550 
551  m_counterTotal[kNSeeds] += counter[kNSeeds] ;
552 
553  ++m_neventsTotal;
554 
555  if (ERR) {
556  outputTracks->clear();
557  } else {
558  m_counterTotal[kNTracks] += counter[kNTracks];
559  }
560 
561  // Print common event information
562  //
563  if (msgLvl(MSG::DEBUG)) {
565  }
566  return StatusCode::SUCCESS;
567 }
568 
569 
571 // Conversion Strategy for ITk
573 
575 {
576  ATH_MSG_DEBUG("Executing " << name() << "::itkConvStrategy");
577 
579  ATH_CHECK(outputTracks.record(std::make_unique<TrackCollection>()));
581  if (not isGoodEvent(ctx)) {
582  return StatusCode::SUCCESS;
583  }
584 
585  SiSpacePointsSeedMakerEventData seedEventData;
586 
588  std::unique_ptr<RoiDescriptor> roiComp = std::make_unique<RoiDescriptor>(true);
589 
590  if(calo_rois.isValid()) {
591  RoiDescriptor * roi =nullptr;
593  double beamZ = beamSpotHandle->beamVtx().position().z();
594  roiComp->clear();
595  roiComp->setComposite();
596 
597  const ROIPhiRZContainer &calo_rois_ref=*calo_rois;
598  for (const ROIPhiRZ &calo_roi : calo_rois_ref) {
599  double phi = calo_roi.phi();
600  if (std::abs(phi)>=M_PI && phi!=-M_PI) continue; // skip duplicates < -pi and >pi
601  double eta = calo_roi.eta();
602  double z = beamZ;
603  double roiPhiMin = phi - m_deltaPhi;
604  double roiPhiMax = phi + m_deltaPhi;
605  double roiEtaMin = eta - m_deltaEta;
606  double roiEtaMax = eta + m_deltaEta;
607  double roiZMin = beamZ - m_deltaZ;
608  double roiZMax = beamZ + m_deltaZ;
609  roi = new RoiDescriptor( eta, roiEtaMin, roiEtaMax,phi, roiPhiMin ,roiPhiMax,z,roiZMin,roiZMax);
610  roiComp->push_back(roi);
611  }
612  }
613  else {
614  ATH_MSG_ERROR("Calo RoI is not valid: " << m_caloClusterROIKey.key());
615  return StatusCode::FAILURE;
616  }
617 
618  std::vector<IdentifierHash> listOfStripIds;
619  std::vector<IdentifierHash> listOfPixIds;
620 
621  m_regsel_strip->lookup(ctx)->HashIDList( *roiComp, listOfStripIds );
622 
624  m_seedsmaker->newRegion(ctx, seedEventData, listOfPixIds, listOfStripIds);
625  std::list<Trk::Vertex> vertexList;
627  m_seedsmaker->find3Sp(ctx, seedEventData, vertexList);
628 
629  const bool PIX = true ;
630  const bool STRIP = true ;
633  m_trackmaker->newEvent(ctx, trackEventData, PIX, STRIP);
634 
635  bool ERR = false;
636  Counter_t counter{};
637  const InDet::SiSpacePointsSeed* seed = nullptr;
638 
640  std::multimap<double, Trk::Track*> qualitySortedTrackCandidates;
641 
643  bool doWriteNtuple = m_seedsmaker->getWriteNtupleBoolProperty();
644  long EvNumber = 0.; //Event number variable to be used for the validation ntuple
645 
646  if (doWriteNtuple) {
648  if(!eventInfo.isValid()) {EvNumber = -1.0;} else {EvNumber = eventInfo->eventNumber();}
649  }
650 
652  while ((seed = m_seedsmaker->next(ctx, seedEventData))) {
653 
654  ++counter[kNSeeds];
655 
657  std::list<Trk::Track*> trackList = m_trackmaker->getTracks(ctx, trackEventData, seed->spacePoints());
659  for (Trk::Track* t: trackList) {
660  qualitySortedTrackCandidates.insert(std::make_pair(-trackQuality(t), t));
661  }
662 
664  if(doWriteNtuple) { m_seedsmaker->writeNtuple(seed, !trackList.empty() ? trackList.front() : nullptr, ISiSpacePointsSeedMaker::StripSeed, EvNumber) ; }
665 
666  if (counter[kNSeeds] >= m_maxNumberSeeds) {
667  ERR = true;
668  ++m_problemsTotal;
669  break;
670  }
671  }
672 
673  m_trackmaker->endEvent(trackEventData);
674 
676  filterSharedTracks(qualitySortedTrackCandidates);
677 
679  for (const std::pair<const double, Trk::Track*> & qualityAndTrack: qualitySortedTrackCandidates) {
680  ++counter[kNTracks];
681  if (m_trackSummaryTool.isEnabled()) {
684  m_trackSummaryTool->computeAndReplaceTrackSummary(*qualityAndTrack.second,
685  false /* DO NOT suppress hole search*/);
688  if (m_writeHolesFromPattern && trackEventData.combinatorialData().findPatternHoleSearchOutcome(qualityAndTrack.second,theOutcome)){
690  qualityAndTrack.second->trackSummary()->update(Trk::numberOfPixelHoles, theOutcome.nPixelHoles);
691  qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTHoles, theOutcome.nSCTHoles);
692  qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTDoubleHoles, theOutcome.nSCTDoubleHoles);
693  qualityAndTrack.second->trackSummary()->update(Trk::numberOfSCTDeadSensors, theOutcome.nSCTDeads);
694  qualityAndTrack.second->trackSummary()->update(Trk::numberOfPixelDeadSensors, theOutcome.nPixelDeads);
695  }
696  }
697  outputTracks->push_back(qualityAndTrack.second);
698  }
699 
700  m_counterTotal[kNSeeds] += counter[kNSeeds] ;
701 
702  ++m_neventsTotal;
703 
704  if (ERR) {
705  outputTracks->clear();
706  } else {
707  m_counterTotal[kNTracks] += counter[kNTracks];
708  }
709 
710  // Print common event information
711  //
712  if (msgLvl(MSG::DEBUG)) {
714  }
715  return StatusCode::SUCCESS;
716 }
717 
718 
719 
721 // Finalize
723 
725 {
726 
727  dump(MSG::INFO, &m_counterTotal);
728 
731  }
732  return StatusCode::SUCCESS;
733 }
734 
736 // Dumps relevant information into the MsgStream
738 
740 {
741  msg(assign_level) <<std::endl;
742  MsgStream& out_msg=msg();
743  if (counter) dumpevent(out_msg ,*counter);
744  else dumptools(out_msg);
745  out_msg << endmsg;
746  return out_msg;
747 }
748 
750 // Dumps conditions information into the MsgStream
752 
753 MsgStream& InDet::SiSPSeededTrackFinder::dumptools(MsgStream& out) const
754 {
755  int n = 65-m_zvertexmaker.type().size();
756  std::string s1; for (int i=0; i<n; ++i) s1.append(" "); s1.append("|");
757  n = 65-m_seedsmaker.type().size();
758  std::string s2; for (int i=0; i<n; ++i) s2.append(" "); s2.append("|");
759  n = 65-m_trackmaker.type().size();
760  std::string s3; for (int i=0; i<n; ++i) s3.append(" "); s3.append("|");
761  n = 65-m_outputTracksKey.key().size();
762  std::string s4; for (int i=0; i<n; ++i) s4.append(" "); s4.append("|");
763 
764  std::string s5;
765  if (m_useZvertexTool) s5= "Yes"; else s5 = "No";
766  n = 65-s5.size(); for (int i=0; i<n; ++i) s5.append(" "); s5.append("|");
767 
768  out<<"|----------------------------------------------------------------"
769  <<"----------------------------------------------------|"
770  <<std::endl;
771  out<<"| Use primary vertices z-coordinates finding?| "<<s5
772  <<std::endl;
773  if (m_useZvertexTool) {
774  out<<"| Tool for primary vertices z-coordinates finding | "<<m_zvertexmaker.type()<<s1
775  <<std::endl;
776  }
777  out<<"| Tool for space points seeds finding | "<<m_seedsmaker.type()<<s2
778  <<std::endl;
779  out<<"| Tool for space points seeded track finding | "<<m_trackmaker.type()<<s3
780  <<std::endl;
781  out<<"| Location of output tracks | "<<m_outputTracksKey.key()<<s4
782  <<std::endl;
783  out<<"|----------------------------------------------------------------"
784  <<"----------------------------------------------------|"
785  <<std::endl;
786  return out;
787 }
788 
790 // Dumps event information into the ostream
792 
794 {
795  out<<"|-------------------------------------------------------------------";
796  out<<"---------------------------------|"
797  <<std::endl;
798  out<<"| Investigated "
799  <<std::setw(9)<<counter[kNSeeds]<<" space points seeds and found ";
800  out<<std::setw(9)<<counter[kNTracks];
801  if (m_ITKGeometry ) out<<" tracks using new strategy for ITK |"<<std::endl;
802  else if (m_useNewStrategy ) out<<" tracks using new strategy ("<<std::setw(2)<< m_nvertex <<") |"<<std::endl;
803  else if (m_useZBoundaryFinding) out<<" tracks using old strategy with Zb |"<<std::endl;
804  else out<<" tracks using old strategy |"<<std::endl;
805 
806  out<<"|-------------------------------------------------------------------";
807  out<<"---------------------------------|"
808  <<std::endl;
810  out<<"| Events "
811  <<std::setw(7)<<m_neventsTotal <<" without Z-vertz "
812  <<std::setw(7)<<m_neventsTotalV <<" with Z-vertex |"
813  <<std::endl;
814  out<<"| Problems "
815  <<std::setw(7)<<m_problemsTotal <<" without Z-vertz "
816  <<std::setw(7)<<m_problemsTotalV <<" with Z-vertex |"
817  <<std::endl;
818  out<<"|-------------------------------------------------------------------";
819  out<<"-----------------------------|"
820  <<std::endl;
821  }
822  return out;
823 }
824 
826 // Test is it good event for reconstruction (mainly for HI events)
828 
829 bool InDet::SiSPSeededTrackFinder::isGoodEvent(const EventContext& ctx) const {
830 
831  if ( not m_alwaysProtectAgainstBusyEvent ) { // if not enabled the protection is only applied to specific events
832  // Test MBTS information from calorimeter
833  //
834  if (not m_useMBTS) return true;
835 
837  if (not eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background, xAOD::EventInfo::MBTSTimeDiffHalo) ) {
838  return true;
839  }
840  }
841 
842  // Test total number pixels space points
843  //
844  unsigned int nsp = 0;
845  if (not m_SpacePointsPixelKey.empty()) {
847  if (spacePointsPixel.isValid()) {
848  for (const SpacePointCollection* spc: *spacePointsPixel) {
849  nsp += spc->size();
850  }
851  if (static_cast<int>(nsp) > m_maxPIXsp) {
852  ATH_MSG_WARNING("Found more than "<<m_maxPIXsp<<" pixels space points in background event. Skip track finding");
853  return false;
854  }
855  }
856  }
857  // Test total number sct space points
858  //
859  nsp = 0;
860  if (not m_SpacePointsSCTKey.empty()) {
862  if (spacePointsSCT.isValid()) {
863  for (const SpacePointCollection* spc: *spacePointsSCT) {
864  nsp += spc->size();
865  }
866  if (static_cast<int>(nsp) > m_maxSCTsp) {
867  ATH_MSG_WARNING("Found more than "<<m_maxSCTsp<<" sct space points in background event. Skip track finding");
868  return false;
869  }
870  }
871  }
872 
873  return true;
874 }
875 
877 // Filer shared tracks
879 
880 void InDet::SiSPSeededTrackFinder::filterSharedTracks(std::multimap<double, Trk::Track*>& qualitySortedTracks) const
881 {
882  std::set<const Trk::PrepRawData*> clusters;
883 
884  std::vector<const Trk::PrepRawData*> freeClusters;
885  freeClusters.reserve(15);
886 
887  std::multimap<double, Trk::Track*>::iterator it_qualityAndTrack = qualitySortedTracks.begin();
888 
890  while (it_qualityAndTrack!=qualitySortedTracks.end()) {
891  freeClusters.clear();
892 
894 
895  int nClusters = 0;
897  for (const Trk::MeasurementBase* m: *((*it_qualityAndTrack).second->measurementsOnTrack())) {
898 
900  const Trk::PrepRawData* pr = (static_cast<const Trk::RIO_OnTrack*>(m))->prepRawData();
901  if (pr) {
903  ++nClusters;
905  if (clusters.find(pr)==it_clustersEnd) {
907  freeClusters.push_back(pr);
908  }
909  }
910  }
911 
913  int nFreeClusters = static_cast<int>(freeClusters.size());
914  if (nFreeClusters >= m_nfreeCut || nFreeClusters==nClusters) {
917  clusters.insert(freeClusters.begin(), freeClusters.end());
918  ++it_qualityAndTrack;
919  } else {
921  delete (*it_qualityAndTrack).second;
922  qualitySortedTracks.erase(it_qualityAndTrack++);
923  }
924  }
925 }
926 
927 
928 void InDet::SiSPSeededTrackFinder::filterSharedTracksFast(std::multimap<double, Trk::Track*>& qualitySortedTracks) const
929 {
930  std::set<const Trk::PrepRawData*> clusters;
931 
932  std::vector<const Trk::PrepRawData*> freeClusters;
933  freeClusters.reserve(15);
934 
935  std::multimap<double, Trk::Track*>::iterator it_qualityAndTrack = qualitySortedTracks.begin();
936 
938  while (it_qualityAndTrack!=qualitySortedTracks.end()) {
939  freeClusters.clear();
940 
942 
943  int nClusters = 0;
944  int nPixels = 0;
946  for (const Trk::TrackStateOnSurface* tsos: *((*it_qualityAndTrack).second->trackStateOnSurfaces())) {
947 
948  if(!tsos->type(Trk::TrackStateOnSurface::Measurement)) continue;
949  const Trk::FitQualityOnSurface fq = tsos->fitQualityOnSurface();
950  if(!fq) continue;
951  if(fq.numberDoF() == 2) ++nPixels;
952 
954  const Trk::MeasurementBase* mb = tsos->measurementOnTrack();
955  const Trk::RIO_OnTrack* ri = dynamic_cast<const Trk::RIO_OnTrack*>(mb);
956  if(!ri) continue;
957  const Trk::PrepRawData* pr = ri->prepRawData();
958  if (pr) {
960  ++nClusters;
962  if (clusters.find(pr)==it_clustersEnd) {
964  freeClusters.push_back(pr);
965  }
966  }
967  }
968 
970  clusters.insert(freeClusters.begin(), freeClusters.end());
971 
972  int nFreeClusters = static_cast<int>(freeClusters.size());
973  if( passEtaDepCuts( (*it_qualityAndTrack).second, nClusters, nFreeClusters, nPixels) ){
975  ++it_qualityAndTrack;
976  } else {
978  delete (*it_qualityAndTrack).second;
979  qualitySortedTracks.erase(it_qualityAndTrack++);
980  }
981  }
982 }
983 
985 // Fill z coordinate histogram
987 
989  const Trk::PerigeeSurface& beamPosPerigee,
990  std::vector<int>& numberHistogram,
991  std::vector<double>& zWeightedHistogram,
992  std::vector<double>& ptWeightedHistogram) const
993 {
994 
995  if (Tr->measurementsOnTrack()->size() < 10) return;
996 
997  const Trk::TrackParameters* paramsAtFirstSurface = Tr->trackStateOnSurfaces()->front()->trackParameters();
998  Amg::Vector3D position = paramsAtFirstSurface->position() ;
999  Amg::Vector3D momentum = paramsAtFirstSurface->momentum() ;
1000 
1002  constexpr double rSquare_max_forZHisto = 60.*60.;
1003  if (position.x()*position.x()+position.y()*position.y() >= rSquare_max_forZHisto) return;
1004 
1005  double pT = sqrt(momentum.x()*momentum.x()+momentum.y()*momentum.y());
1006  if (pT < m_pTcut) return;
1007 
1009  if (not TP.production(paramsAtFirstSurface)) return;
1010 
1011  double step;
1013  if (not m_proptool->propagate(Gaudi::Hive::currentContext(),
1014  TP, beamPosPerigee, TP, Trk::anyDirection, m_fieldprop, step, Trk::pion)) return;
1015 
1016  const AmgVector(5)& parsAtBeamSpot = TP.parameters();
1017  if (std::abs(parsAtBeamSpot[0]) > m_imcut) return;
1019  int z = static_cast<int>((parsAtBeamSpot[1]+m_zcut)*m_zstep);
1021  if (z >=0 and z < m_histsize) {
1023  ++numberHistogram[z];
1025  zWeightedHistogram[z] += parsAtBeamSpot[1];
1027  ptWeightedHistogram[z] += pT;
1028  }
1029 
1030 }
1031 
1033 // Find verteex z coordinates
1035 
1036 void InDet::SiSPSeededTrackFinder::findZvertex(std::list<Trk::Vertex>& vertexZList,
1037  std::pair<double, double> & zBoundaries,
1038  const std::vector<int>& numberHistogram,
1039  const std::vector<double>& zWeightedHistogram,
1040  const std::vector<double>& ptWeightedHistogram) const
1041 {
1042  zBoundaries = {1000., -1000};
1043 
1044  std::multimap<int ,double> vertexZ_sortedByNtracks;
1045  std::multimap<double,double> vertexZ_sortedBySumPt;
1046 
1047  int lastBin = m_histsize-1;
1048  int minBinContentSum = 3;
1049 
1051  for (int binIndex=1; binIndex<lastBin; ++binIndex) {
1052 
1054  int vertexNtracks = numberHistogram.at(binIndex-1)+numberHistogram.at(binIndex)+numberHistogram.at(binIndex+1);
1055 
1058  if (vertexNtracks>=minBinContentSum and (numberHistogram.at(binIndex) >= numberHistogram.at(binIndex-1) and numberHistogram.at(binIndex) >= numberHistogram.at(binIndex+1))) {
1060  double vertexZestimate = (zWeightedHistogram.at(binIndex-1)+zWeightedHistogram.at(binIndex)+zWeightedHistogram.at(binIndex+1))/static_cast<double>(vertexNtracks);
1061 
1064  if (vertexZestimate < zBoundaries.first) zBoundaries.first = vertexZestimate;
1065  if (vertexZestimate > zBoundaries.second) zBoundaries.second = vertexZestimate;
1066 
1067  if (m_useNewStrategy) {
1069  double vertexSumPt = ptWeightedHistogram.at(binIndex-1)+ptWeightedHistogram.at(binIndex)+ptWeightedHistogram.at(binIndex+1);
1070  vertexZ_sortedByNtracks.insert(std::make_pair(-vertexNtracks, vertexZestimate));
1071  vertexZ_sortedBySumPt.insert(std::make_pair(-vertexSumPt, vertexZestimate));
1072  }
1073  }
1074  }
1075 
1076  if (m_useNewStrategy) {
1077 
1078  std::set<double> leadingVertices;
1079  int n = 0;
1080  std::multimap<double, double>::iterator vertex_pt_and_z = vertexZ_sortedBySumPt.begin();
1081  for (std::pair<int, double> nTrackAndZ: vertexZ_sortedByNtracks) {
1083  if (n++ >= m_nvertex) break;
1086  leadingVertices.insert(nTrackAndZ.second);
1087  leadingVertices.insert((*vertex_pt_and_z++).second);
1088  }
1089 
1090  for (double v: leadingVertices) {
1091  vertexZList.emplace_back(Amg::Vector3D{0.,0.,v});
1092  }
1093  }
1095  if (zBoundaries.first > zBoundaries.second) {
1096  zBoundaries.first = -1000.;
1097  zBoundaries.second = +1000.;
1098  } else {
1100  zBoundaries.first -= 20.;
1101  zBoundaries.second += 20.;
1102  }
1103 }
1104 
1105 
1107 // Callback function - get the magnetic field /
1109 
1111 {
1112  // Build MagneticFieldProperties
1113  //
1114  if(m_fieldmode == "NoField") {
1116  } else {
1118  }
1119 }
1120 
1121 
1123 // Check if track passes eta-dependent cuts for fast tracking
1125 
1127  int nClusters,
1128  int nFreeClusters,
1129  int nPixels) const
1130 {
1131  Trk::TrackStates::const_iterator m = track->trackStateOnSurfaces()->begin();
1132  const Trk::TrackParameters* par = (*m)->trackParameters();
1133  if(!par) return false;
1134 
1135  double eta = std::abs(par->eta());
1136  if(nClusters < m_etaDependentCutsSvc->getMinSiHitsAtEta(eta)) return false;
1137  if(nFreeClusters < m_etaDependentCutsSvc->getMinSiNotSharedAtEta(eta)) return false;
1138  if(nClusters-nFreeClusters > m_etaDependentCutsSvc->getMaxSharedAtEta(eta)) return false;
1139  if(nPixels < m_etaDependentCutsSvc->getMinPixelHitsAtEta(eta)) return false;
1140 
1141  if(par->pT() < m_etaDependentCutsSvc->getMinPtAtEta(eta)) return false;
1142  if(!(*m)->type(Trk::TrackStateOnSurface::Perigee)) return true ;
1143  if(std::abs(par->localPosition()[0]) > m_etaDependentCutsSvc->getMaxPrimaryImpactAtEta(eta)) return false;
1144  return true;
1145 }
1146 
1148 
1149  struct VLM_Data {
1150  int vol_id, lay_id, mod_id;
1151  float m_x, m_y, m_z;
1152  };
1153 
1154  const PixelID* IDp = 0;
1155  const SCT_ID* IDs = 0;
1156 
1157  if (detStore()->retrieve(IDp, "PixelID").isFailure()) {
1158  ATH_MSG_FATAL("Could not get Pixel ID helper");
1159  }
1160 
1161  if (detStore()->retrieve(IDs, "SCT_ID").isFailure()) {
1162  ATH_MSG_FATAL("Could not get SCT ID helper");
1163  }
1164 
1165  if (!IDs && !IDp) return;
1166 
1168 
1169  std::vector<VLM_Data> vlm;
1170 
1171  for (const auto* s : *track->trackStateOnSurfaces()) {
1172  if (!s->type(Trk::TrackStateOnSurface::Measurement)) continue;
1173 
1174  const Trk::MeasurementBase* mb = s->measurementOnTrack();
1175  if (!mb) continue;
1176 
1177  const Trk::RIO_OnTrack* ri = dynamic_cast<const Trk::RIO_OnTrack*>(mb);
1178  if (!ri) continue;
1179 
1180  const Trk::PrepRawData* rd = ri->prepRawData();
1181  if (!rd) continue;
1182 
1183  const InDet::SiCluster* si = dynamic_cast<const InDet::SiCluster*>(rd);
1184  if (!si) continue;
1185 
1186  const Amg::Vector3D& pos = s->trackParameters()->position();
1187 
1188  if (dynamic_cast<const InDet::PixelCluster*>(si)) { // Pixel
1189 
1190  Identifier id = si->identify();
1191 
1192  int bec = IDp->barrel_ec(id);
1193 
1194  int vol_id = 8;
1195 
1196  if (bec == -2) vol_id = 7;
1197  if (bec == 2) vol_id = 9;
1198 
1199  if (bec < -2 || bec > 2) continue;
1200 
1201  int lay_id = IDp->layer_disk(id);
1202  int eta_mod = IDp->eta_module(id);
1203  int phi_mod = IDp->phi_module(id);
1204 
1205  Identifier wafer_id = IDp->wafer_id(bec, lay_id, phi_mod, eta_mod);
1206 
1207  int mod_id = IDp->wafer_hash(wafer_id);
1208 
1209  int new_vol = 0, new_lay = 0;
1210 
1211  if (vol_id == 7 || vol_id == 9) {
1212  new_vol = 10 * vol_id + lay_id;
1213  new_lay = eta_mod;
1214  } else if (vol_id == 8) {
1215  new_lay = 0;
1216  new_vol = 10 * vol_id + lay_id;
1217  }
1218  if (vol_id != 0)
1219  vlm.emplace_back(new_vol, new_lay, mod_id, pos.x(), pos.y(), pos.z());
1220  }
1221 
1222  if (dynamic_cast<const InDet::SCT_Cluster*>(si)) { // SCT
1223 
1224  Identifier id = si->identify();
1225 
1226  int bec = IDs->barrel_ec(id);
1227 
1228  int vol_id = 13;
1229 
1230  if (bec < 0) vol_id = 12;
1231  if (bec > 0) vol_id = 14;
1232 
1233  int lay_id = IDs->layer_disk(id);
1234  int eta_mod = IDs->eta_module(id);
1235  int phi_mod = IDs->phi_module(id);
1236  int side = IDs->side(id);
1237 
1238  Identifier wafer_id = IDs->wafer_id(bec, lay_id, phi_mod, eta_mod, side);
1239 
1240  int mod_id = IDs->wafer_hash(wafer_id);
1241 
1242  vlm.emplace_back(vol_id, lay_id, mod_id, pos.x(), pos.y(), pos.z());
1243  }
1244  }
1245 
1246  // remove single-strip cases where no spacepoint exists
1247 
1248  std::vector<VLM_Data> vlm2;
1249 
1250  for (std::size_t it1 = 0; it1 < vlm.size() - 1; it1++) {
1251  if (vlm.at(it1).vol_id > 14) { // Pixels
1252  vlm2.push_back(vlm.at(it1));
1253  continue;
1254  }
1255 
1256  std::size_t it2 = it1 + 1;
1257 
1258  int src = vlm.at(it1).vol_id * 1000 + vlm.at(it1).lay_id;
1259  int dst = vlm.at(it2).vol_id * 1000 + vlm.at(it2).lay_id;
1260 
1261  if (src == dst) { // a spacepoint can be formed
1262  vlm2.push_back(vlm.at(it1));
1263  vlm2.push_back(vlm.at(it2));
1264  it1 = it2;
1265  continue;
1266  }
1267  }
1268 
1269  // remove track segments which are too short
1270  if (m_removeShortSegments) {
1271 
1272  constexpr float minDist = 20.0;
1273 
1274  for (auto it = std::next(vlm2.begin()); it != vlm2.end(); ) {
1275  auto jt = std::prev(it);
1276  float dx = it->m_x - jt->m_x;
1277  float dy = it->m_y - jt->m_y;
1278  float dz = it->m_z - jt->m_z;
1279 
1280  float dist = std::sqrt(dx*dx + dy*dy + dz*dz);
1281 
1282  if (dist < minDist) it = vlm2.erase(it);
1283  else ++it;
1284  }
1285  }
1286 
1287  std::scoped_lock trainingDataLock(m_GBTSTrainingDataMutex);
1288 
1289  for (std::size_t it1 = 0; it1 < vlm2.size() - 1; ++it1) {
1290  std::size_t it2 = it1 + 1;
1291 
1292  int src = vlm2.at(it1).vol_id * 1000 + vlm2.at(it1).lay_id;
1293  int dst = vlm2.at(it2).vol_id * 1000 + vlm2.at(it2).lay_id;
1294 
1295  if (src != dst) { // skip the same layer
1296  auto [im1, new1] = m_GBTSTrainingData.insert({src, {}});
1297  auto [im2, new2] = im1->second.insert({dst, 1ul});
1298  if (!new2) im2->second++;
1299  }
1300  }
1301 }
1302 
1304  std::ofstream tableFile(m_GBTSTrainingDataFileName);
1305  tableFile << "from,to,probability,flow\n";
1306 
1307  unsigned long nTotal = 0;
1308  for (const auto& [src, conns] : m_GBTSTrainingData) {
1309  unsigned long nTotalDst = 0;
1310  for (const auto& [dst, n] : conns) {
1311  nTotalDst += n;
1312  }
1313  nTotal += nTotalDst;
1314  for (const auto& [dst, n] : conns) {
1315  double prob = double(n) / double(nTotalDst);
1316  tableFile << src << ", " << dst << ", " << std::fixed << std::setprecision(6) << prob << ", " << prob << '\n';
1317  }
1318  }
1319  ATH_MSG_INFO("GBTS training data from " << m_numGBTSTrainingData << " tracks with " << nTotal << " pairs written to " << m_GBTSTrainingDataFileName.value());
1320 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
PixelID.h
This is an Identifier helper class for the Pixel subdetector. This class is a factory for creating co...
Trk::anyDirection
@ anyDirection
Definition: PropDirection.h:22
SiSpacePointsSeedMakerEventData.h
Trk::TrackStateOnSurface::trackParameters
const TrackParameters * trackParameters() const
return ptr to trackparameters const overload
InDet::SiSPSeededTrackFinder::m_evtKey
SG::ReadHandleKey< xAOD::EventInfo > m_evtKey
Definition: SiSPSeededTrackFinder.h:131
InDet::SiSPSeededTrackFinder::kNTracks
@ kNTracks
Definition: SiSPSeededTrackFinder.h:79
CalculateHighPtTerm.pT
pT
Definition: ICHEP2016/CalculateHighPtTerm.py:57
PESA::vertexSumPt
double vertexSumPt(const TrackCollection &tracks)
Definition: T2Vertex.cxx:71
InDet::SiSPSeededTrackFinder::dumpevent
MsgStream & dumpevent(MsgStream &out, const SiSPSeededTrackFinder::Counter_t &counter) const
Definition: SiSPSeededTrackFinder.cxx:793
Trk::TrackStateOnSurface::Perigee
@ Perigee
This represents a perigee, and so will contain a Perigee object only.
Definition: TrackStateOnSurface.h:117
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
SCT_ID.h
This is an Identifier helper class for the SCT subdetector. This class is a factory for creating comp...
InDet::SiSPSeededTrackFinder::m_outputTracksKey
SG::WriteHandleKey< TrackCollection > m_outputTracksKey
Definition: SiSPSeededTrackFinder.h:141
InDet::SiSPSeededTrackFinder::kNSeeds
@ kNSeeds
Definition: SiSPSeededTrackFinder.h:79
InDet::ISiSpacePointsSeedMaker::PixelSeed
@ PixelSeed
Definition: ISiSpacePointsSeedMaker.h:136
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
Trk::MagneticFieldProperties
Definition: MagneticFieldProperties.h:31
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
InDet::SiSpacePointsSeedMakerEventData
Definition: SiSpacePointsSeedMakerEventData.h:49
xAOD::EventInfo_v1::eventNumber
uint64_t eventNumber() const
The current event's event number.
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
ParticleGun_SamplingFraction.bec
int bec
Definition: ParticleGun_SamplingFraction.py:89
InDet::SiSPSeededTrackFinder::m_seedsmaker
ToolHandle< ISiSpacePointsSeedMaker > m_seedsmaker
Definition: SiSPSeededTrackFinder.h:146
WriteCellNoiseToCool.src
src
Definition: WriteCellNoiseToCool.py:513
Trk::PerigeeSurface
Definition: PerigeeSurface.h:43
PixelID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: PixelID.h:615
Trk::ParametersBase::position
const Amg::Vector3D & position() const
Access method for the position.
SG::ReadHandle< Trk::PRDtoTrackMap >
Trk::numberOfSCTDeadSensors
@ numberOfSCTDeadSensors
number of TRT hits
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:76
ROIPhiRZContainer
container for phi sorted ROIs defined by phi, r and z.
Definition: ROIPhiRZContainer.h:50
Trk::Track::trackStateOnSurfaces
const Trk::TrackStates * trackStateOnSurfaces() const
return a pointer to a const DataVector of const TrackStateOnSurfaces.
InDet::SiSPSeededTrackFinder::m_alwaysProtectAgainstBusyEvent
BooleanProperty m_alwaysProtectAgainstBusyEvent
Definition: SiSPSeededTrackFinder.h:105
InDet::SiSPSeededTrackFinder::m_histsize
IntegerProperty m_histsize
Definition: SiSPSeededTrackFinder.h:109
Trk::Track::info
const TrackInfo & info() const
Returns a const ref to info of a const tracks.
InDet
Primary Vertex Finder.
Definition: VP1ErrorUtils.h:36
InDet::SiSPSeededTrackFinder::dump
MsgStream & dump(MSG::Level lvl, const SiSPSeededTrackFinder::Counter_t *) const
Definition: SiSPSeededTrackFinder.cxx:739
InDet::SiSPSeededTrackFinder::collectGBTSTrainingData
void collectGBTSTrainingData(const Trk::Track *) const
Definition: SiSPSeededTrackFinder.cxx:1147
plotBeamSpotCompare.x2
x2
Definition: plotBeamSpotCompare.py:217
InDet::SiSPSeededTrackFinder::m_ITKGeometry
BooleanProperty m_ITKGeometry
Definition: SiSPSeededTrackFinder.h:101
InDet::PatternHoleSearchOutcome::nPixelDeads
int nPixelDeads
Definition: SiTrajectory_xk.h:37
InDet::SiSPSeededTrackFinder::m_useZvertexTool
BooleanProperty m_useZvertexTool
Definition: SiSPSeededTrackFinder.h:96
InDet::SiSPSeededTrackFinder::m_pTcut
double m_pTcut
Definition: SiSPSeededTrackFinder.h:124
skel.it
it
Definition: skel.GENtoEVGEN.py:407
InDet::SiSPSeededTrackFinder::m_nfreeCut
IntegerProperty m_nfreeCut
Definition: SiSPSeededTrackFinder.h:108
InDet::SiSPSeededTrackFinder::m_etaDependentCutsSvc
ServiceHandle< IInDetEtaDependentCutsSvc > m_etaDependentCutsSvc
service to get cut values depending on different variable
Definition: SiSPSeededTrackFinder.h:162
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:70
InDet::SiSPSeededTrackFinder::m_removeShortSegments
BooleanProperty m_removeShortSegments
Definition: SiSPSeededTrackFinder.h:118
M_PI
#define M_PI
Definition: ActiveFraction.h:11
AthCommonMsg< Gaudi::Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
Trk::RIO_OnTrack
Definition: RIO_OnTrack.h:70
ReadCellNoiseFromCoolCompare.s4
s4
Definition: ReadCellNoiseFromCoolCompare.py:381
SCT_ID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: SCT_ID.h:728
SCT_ID::phi_module
int phi_module(const Identifier &id) const
Definition: SCT_ID.h:740
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
InDet::SiSPSeededTrackFinder::m_trackSummaryTool
ToolHandle< Trk::IExtendedTrackSummaryTool > m_trackSummaryTool
Definition: SiSPSeededTrackFinder.h:150
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
SG::ReadHandleKey< Trk::PRDtoTrackMap >
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
InDet::SiSPSeededTrackFinder::filterSharedTracksFast
void filterSharedTracksFast(std::multimap< double, Trk::Track * > &scoredTracks) const
Definition: SiSPSeededTrackFinder.cxx:928
xAOD::EventInfo_v1::Background
@ Background
The beam background detectors.
Definition: EventInfo_v1.h:340
covarianceTool.prob
prob
Definition: covarianceTool.py:678
InDet::SiSPSeededTrackFinder::m_maxNumberSeeds
IntegerProperty m_maxNumberSeeds
Definition: SiSPSeededTrackFinder.h:104
InDet::SiSPSeededTrackFinder::m_imcut
double m_imcut
Definition: SiSPSeededTrackFinder.h:125
InDet::PatternHoleSearchOutcome::nSCTDeads
int nSCTDeads
Definition: SiTrajectory_xk.h:38
Trk::numberOfSCTHoles
@ numberOfSCTHoles
number of Holes in both sides of a SCT module
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:73
PixelID::wafer_id
Identifier wafer_id(int barrel_ec, int layer_disk, int phi_module, int eta_module) const
For a single crystal.
Definition: PixelID.h:360
InDet::SiSPSeededTrackFinder::m_useITkConvSeeded
BooleanProperty m_useITkConvSeeded
Definition: SiSPSeededTrackFinder.h:102
InDet::SiSPSeededTrackFinder::m_useMBTS
BooleanProperty m_useMBTS
Definition: SiSPSeededTrackFinder.h:98
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
InDet::SiSPSeededTrackFinder::m_useZBoundaryFinding
BooleanProperty m_useZBoundaryFinding
Definition: SiSPSeededTrackFinder.h:100
InDet::SiSPSeededTrackFinder::m_prdToTrackMap
SG::ReadHandleKey< Trk::PRDtoTrackMap > m_prdToTrackMap
Definition: SiSPSeededTrackFinder.h:134
AthReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition: AthReentrantAlgorithm.h:74
InDet::SiSPSeededTrackFinder::execute
virtual StatusCode execute(const EventContext &ctx) const override
Execute.
Definition: SiSPSeededTrackFinder.cxx:146
TRT::Hit::side
@ side
Definition: HitInfo.h:83
InDet::SiSPSeededTrackFinder::m_trackmaker
ToolHandle< ISiTrackMaker > m_trackmaker
Definition: SiSPSeededTrackFinder.h:148
InDet::SiSPSeededTrackFinder::SiSPSeededTrackFinder
SiSPSeededTrackFinder(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Definition: SiSPSeededTrackFinder.cxx:70
Trk::FastField
@ FastField
call the fast field access method of the FieldSvc
Definition: MagneticFieldMode.h:20
InDet::SiSPSeededTrackFinder::m_nvertex
IntegerProperty m_nvertex
Definition: SiSPSeededTrackFinder.h:110
Trk::FitQualityOnSurface
Definition: FitQualityOnSurface.h:19
InDet::SiSPSeededTrackFinder::m_deltaEta
DoubleProperty m_deltaEta
Definition: SiSPSeededTrackFinder.h:112
InDet::SiSPSeededTrackFinder::m_fieldmode
StringProperty m_fieldmode
Definition: SiSPSeededTrackFinder.h:115
InDet::SiSPSeededTrackFinder::m_problemsTotal
std::atomic_int m_problemsTotal
Number events with number seeds > maxNumber.
Definition: SiSPSeededTrackFinder.h:171
InDet::SiSPSeededTrackFinder::dumpGBTSTrainingData
void dumpGBTSTrainingData() const
Definition: SiSPSeededTrackFinder.cxx:1303
InDet::SiSPSeededTrackFinder::m_SpacePointsSCTKey
SG::ReadHandleKey< SpacePointContainer > m_SpacePointsSCTKey
Definition: SiSPSeededTrackFinder.h:132
PixelID::wafer_hash
IdentifierHash wafer_hash(Identifier wafer_id) const
wafer hash from id
Definition: PixelID.h:383
TrigConf::MSGTC::Level
Level
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStream.h:21
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
RoiDescriptor::push_back
void push_back(const IRoiDescriptor *roi)
add a RoiDescriptor
Definition: RoiDescriptor.h:157
InDet::SiSPSeededTrackFinder::m_beamSpotKey
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey
Definition: SiSPSeededTrackFinder.h:137
ParticleGun_EoverP_Config.momentum
momentum
Definition: ParticleGun_EoverP_Config.py:63
InDet::SiSpacePointsSeed
Definition: SiSpacePointsSeed.h:30
fillPileUpNoiseLumi.next
next
Definition: fillPileUpNoiseLumi.py:52
lumiFormat.i
int i
Definition: lumiFormat.py:85
z
#define z
InDet::SiSPSeededTrackFinder::m_maxSCTsp
IntegerProperty m_maxSCTsp
Definition: SiSPSeededTrackFinder.h:107
InDet::SiSPSeededTrackFinder::magneticFieldInit
void magneticFieldInit()
Definition: SiSPSeededTrackFinder.cxx:1110
InDet::SiTrackMakerEventData_xk::setPRDtoTrackMap
void setPRDtoTrackMap(const Trk::PRDtoTrackMap *prd_to_track_map)
Definition: SiTrackMakerEventData_xk.h:75
beamspotman.n
n
Definition: beamspotman.py:729
DetDescrDictionaryDict::it1
std::vector< HWIdentifier >::iterator it1
Definition: DetDescrDictionaryDict.h:17
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
AmgVector
AmgVector(4) T2BSTrackFilterTool
Definition: T2BSTrackFilterTool.cxx:114
InDet::SiSPSeededTrackFinder::m_neventsTotalV
std::atomic_int m_neventsTotalV
Number events.
Definition: SiSPSeededTrackFinder.h:170
InDet::SiSPSeededTrackFinder::m_proptool
PublicToolHandle< Trk::IPatternParametersPropagator > m_proptool
Definition: SiSPSeededTrackFinder.h:149
Trk::numberOfPixelDeadSensors
@ numberOfPixelDeadSensors
number of pixel hits with broad errors (width/sqrt(12))
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:65
InDet::SiSPSeededTrackFinder::oldStrategy
StatusCode oldStrategy(const EventContext &ctx) const
this method performs the track finding using the old strategy
Definition: SiSPSeededTrackFinder.cxx:180
Trk::pion
@ pion
Definition: ParticleHypothesis.h:32
TileDCSDataPlotter.pr
pr
Definition: TileDCSDataPlotter.py:924
RoiDescriptor.h
InDet::PatternHoleSearchOutcome::nSCTDoubleHoles
int nSCTDoubleHoles
Definition: SiTrajectory_xk.h:36
DataVector::front
const T * front() const
Access the first element in the collection as an rvalue.
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
RoiDescriptor::clear
void clear()
clear the vector
Definition: RoiDescriptor.h:151
InDet::SiSPSeededTrackFinder::dumptools
MsgStream & dumptools(MsgStream &out) const
Definition: SiSPSeededTrackFinder.cxx:753
RoiDescriptor
Describes the Region of Ineterest geometry It has basically 9 parameters.
Definition: RoiDescriptor.h:40
InDet::ISiSpacePointsSeedMaker::StripSeed
@ StripSeed
Definition: ISiSpacePointsSeedMaker.h:136
SCT_ID::wafer_hash
IdentifierHash wafer_hash(const Identifier &wafer_id) const
wafer hash from id - optimized
Definition: SCT_ID.h:492
IDPVM::binIndex
unsigned int binIndex(const T &val, const std::vector< T > &partitions)
general utility function to return bin index given a value and the upper endpoints of each bin
Definition: InDetPhysValMonitoringUtilities.h:43
TrackSummary.h
detail::ul
unsigned long ul
Definition: PrimitiveHelpers.h:46
Trk::TrackInfo::BremFit
@ BremFit
A brem fit was performed on this track.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/TrackInfo.h:78
Trk::ParametersBase
Definition: ParametersBase.h:55
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
xAOD::double
double
Definition: CompositeParticle_v1.cxx:159
Trk::FitQualityOnSurface::numberDoF
int numberDoF() const
returns the number of degrees of freedom of the overall track or vertex fit as integer
Definition: FitQuality.h:60
InDet::SCT_Cluster
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/SCT_Cluster.h:34
InDet::PatternHoleSearchOutcome::nSCTHoles
int nSCTHoles
Definition: SiTrajectory_xk.h:35
InDet::PatternHoleSearchOutcome::nPixelHoles
int nPixelHoles
Definition: SiTrajectory_xk.h:34
InDet::SiSPSeededTrackFinder::m_deltaZ
DoubleProperty m_deltaZ
Definition: SiSPSeededTrackFinder.h:114
columnar::final
CM final
Definition: ColumnAccessor.h:106
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
SiTrackMakerEventData_xk.h
InDet::SiSPSeededTrackFinder::filterSharedTracks
void filterSharedTracks(std::multimap< double, Trk::Track * > &scoredTracks) const
cleans up the collection of quality filtered tracks.
Definition: SiSPSeededTrackFinder.cxx:880
SCT
Definition: SCT_ChipUtils.h:14
Trk::numberOfPixelHoles
@ numberOfPixelHoles
number of pixels which have a ganged ambiguity.
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:59
xAOD::EventInfo_v1::MBTSTimeDiffHalo
@ MBTSTimeDiffHalo
Definition: EventInfo_v1.h:354
InDet::ExtendedSiTrackMakerEventData_xk
Definition: SiSPSeededTrackFinder.cxx:166
Trk::PrepRawData
Definition: PrepRawData.h:62
InDet::SiSPSeededTrackFinder::finalize
virtual StatusCode finalize() override
Definition: SiSPSeededTrackFinder.cxx:724
Trk::MeasurementBase
Definition: MeasurementBase.h:58
Trk::PrepRawData::identify
Identifier identify() const
return the identifier
InDet::SiSPSeededTrackFinder::passEtaDepCuts
bool passEtaDepCuts(const Trk::Track *track, int nClusters, int nFreeClusters, int nPixels) const
Definition: SiSPSeededTrackFinder.cxx:1126
PixelID::layer_disk
int layer_disk(const Identifier &id) const
Definition: PixelID.h:622
Trk::NoField
@ NoField
Field is set to 0., 0., 0.,.
Definition: MagneticFieldMode.h:18
InDet::PatternHoleSearchOutcome
Helper struct for hole search results from the pattern recognition.
Definition: SiTrajectory_xk.h:33
InDet::SiSPSeededTrackFinder::m_SpacePointsPixelKey
SG::ReadHandleKey< SpacePointContainer > m_SpacePointsPixelKey
Definition: SiSPSeededTrackFinder.h:133
PixelID::eta_module
int eta_module(const Identifier &id) const
Definition: PixelID.h:647
InDet::SiSPSeededTrackFinder::m_deltaPhi
DoubleProperty m_deltaPhi
Definition: SiSPSeededTrackFinder.h:113
ReadCellNoiseFromCoolCompare.s3
s3
Definition: ReadCellNoiseFromCoolCompare.py:380
Trk::TrackStateOnSurface
represents the track state (measurement, material, fit parameters and quality) at a surface.
Definition: TrackStateOnSurface.h:71
InDet::SiSPSeededTrackFinder::m_zcut
DoubleProperty m_zcut
Definition: SiSPSeededTrackFinder.h:111
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
createCoolChannelIdFile.par
par
Definition: createCoolChannelIdFile.py:28
RIO_OnTrack.h
InDet::SiSPSeededTrackFinder::isGoodEvent
bool isGoodEvent(const EventContext &ctx) const
EventContext is used to specify which event.
Definition: SiSPSeededTrackFinder.cxx:829
InDet::SiSPSeededTrackFinder::initialize
virtual StatusCode initialize() override
Initialisation.
Definition: SiSPSeededTrackFinder.cxx:78
InDet::SiSPSeededTrackFinder::m_zvertexmaker
ToolHandle< ISiZvertexMaker > m_zvertexmaker
Definition: SiSPSeededTrackFinder.h:147
SCT_ID::layer_disk
int layer_disk(const Identifier &id) const
Definition: SCT_ID.h:734
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
SiSPSeededTrackFinder.h
InDet::SiSPSeededTrackFinder::m_maxPIXsp
IntegerProperty m_maxPIXsp
Definition: SiSPSeededTrackFinder.h:106
InDet::SiSPSeededTrackFinder::m_writeHolesFromPattern
BooleanProperty m_writeHolesFromPattern
Definition: SiSPSeededTrackFinder.h:97
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
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.
InDet::ExtendedSiTrackMakerEventData_xk::m_prdToTrackMap
SG::ReadHandle< Trk::PRDtoTrackMap > m_prdToTrackMap
Definition: SiSPSeededTrackFinder.cxx:175
InDet::SiSPSeededTrackFinder::m_mbtsKey
SG::ReadDecorHandleKey< xAOD::EventInfo > m_mbtsKey
Definition: SiSPSeededTrackFinder.h:139
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:16
InDet::SiSPSeededTrackFinder::itkFastTrackingStrategy
StatusCode itkFastTrackingStrategy(const EventContext &ctx) const
EventContext is used to specify which event.
Definition: SiSPSeededTrackFinder.cxx:458
InDet::SiSPSeededTrackFinder::m_fieldprop
Trk::MagneticFieldProperties m_fieldprop
Definition: SiSPSeededTrackFinder.h:156
InDet::PixelCluster
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/PixelCluster.h:49
InDet::SiSPSeededTrackFinder::m_regsel_strip
ToolHandle< IRegSelTool > m_regsel_strip
Definition: SiSPSeededTrackFinder.h:151
Trk::Track::measurementsOnTrack
const DataVector< const MeasurementBase > * measurementsOnTrack() const
return a pointer to a vector of MeasurementBase (NOT including any that come from outliers).
Definition: Tracking/TrkEvent/TrkTrack/src/Track.cxx:178
python.PyAthena.v
v
Definition: PyAthena.py:154
makeTRTBarrelCans.dy
tuple dy
Definition: makeTRTBarrelCans.py:21
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
Trk::ParametersBase::momentum
const Amg::Vector3D & momentum() const
Access method for the momentum.
InDet::SiSPSeededTrackFinder::m_useNewStrategy
BooleanProperty m_useNewStrategy
Definition: SiSPSeededTrackFinder.h:99
InDet::SiCombinatorialTrackFinderData_xk::findPatternHoleSearchOutcome
bool findPatternHoleSearchOutcome(Trk::Track *theTrack, InDet::PatternHoleSearchOutcome &outcome) const
Methods used to associate the hole search outcome to tracks without having to modify the EDM.
Definition: SiCombinatorialTrackFinderData_xk.cxx:67
SCT_ID
Definition: SCT_ID.h:68
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.Constants.INFO
int INFO
Definition: Control/AthenaCommon/python/Constants.py:15
TRT_PAI_physicsConstants::mb
const double mb
1mb to cm2
Definition: TRT_PAI_physicsConstants.h:17
Trk::PatternTrackParameters
Definition: PatternTrackParameters.h:32
InDet::SiSPSeededTrackFinder::m_GBTSTrainingDataFileName
StringProperty m_GBTSTrainingDataFileName
Definition: SiSPSeededTrackFinder.h:119
InDet::SiSPSeededTrackFinder::itkConvStrategy
StatusCode itkConvStrategy(const EventContext &ctx) const
EventContext is used to specify which event.
Definition: SiSPSeededTrackFinder.cxx:574
SpacePointCollection
Definition: SpacePointCollection.h:40
LVL1TGCTrigger::STRIP
@ STRIP
Definition: TGCNumbering.h:52
DEBUG
#define DEBUG
Definition: page_access.h:11
ReadCellNoiseFromCoolCompare.s2
s2
Definition: ReadCellNoiseFromCoolCompare.py:379
SCT_ID::eta_module
int eta_module(const Identifier &id) const
Definition: SCT_ID.h:746
makeTRTBarrelCans.dx
tuple dx
Definition: makeTRTBarrelCans.py:20
python.TrackLeptonConfig.quality
quality
Definition: TrackLeptonConfig.py:16
InDet::SiSPSeededTrackFinder::newStrategy
StatusCode newStrategy(const EventContext &ctx) const
this method performs the track finding using the new strategy
Definition: SiSPSeededTrackFinder.cxx:265
AthCommonMsg< Gaudi::Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
InDet::ExtendedSiTrackMakerEventData_xk::ExtendedSiTrackMakerEventData_xk
ExtendedSiTrackMakerEventData_xk(const SG::ReadHandleKey< Trk::PRDtoTrackMap > &key)
Definition: SiSPSeededTrackFinder.cxx:168
InDet::SiSPSeededTrackFinder::fillZHistogram
void fillZHistogram(const Trk::Track *Tr, const Trk::PerigeeSurface &beamlinePerigee, std::vector< int > &numberWeightedhistogram, std::vector< double > &zWeightedHistogram, std::vector< double > &ptWeightedHistogram) const
fills three z0 histograms (non-weighted, weighted by z, and weighted by pt) with the track z at the b...
Definition: SiSPSeededTrackFinder.cxx:988
RunTileMonitoring.clusters
clusters
Definition: RunTileMonitoring.py:133
InDet::SiSPSeededTrackFinder::m_GBTSTrainingDataMutex
std::mutex m_GBTSTrainingDataMutex
Definition: SiSPSeededTrackFinder.h:175
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:147
InDet::SiSPSeededTrackFinder::m_doDumpGBTSTrainingData
BooleanProperty m_doDumpGBTSTrainingData
Definition: SiSPSeededTrackFinder.h:116
LArCellBinning.step
step
Definition: LArCellBinning.py:158
RoiDescriptor::setComposite
void setComposite(bool b=true)
Definition: RoiDescriptor.h:138
SCT_ID::side
int side(const Identifier &id) const
Definition: SCT_ID.h:752
InDet::SiTrackMakerEventData_xk
Definition: SiTrackMakerEventData_xk.h:43
PatternTrackParameters.h
Trk::PatternTrackParameters::production
bool production(const TrackParameters *)
Definition: PatternTrackParameters.cxx:42
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
InDet::SiSPSeededTrackFinder::m_caloClusterROIKey
SG::ReadHandleKey< ROIPhiRZContainer > m_caloClusterROIKey
Definition: SiSPSeededTrackFinder.h:135
SCT_ID::wafer_id
Identifier wafer_id(int barrel_ec, int layer_disk, int phi_module, int eta_module, int side) const
For a single side of module.
Definition: SCT_ID.h:464
InDet::SiSPSeededTrackFinder::Counter_t
Definition: SiSPSeededTrackFinder.h:84
InDet::SiSPSeededTrackFinder::m_zstep
double m_zstep
Definition: SiSPSeededTrackFinder.h:126
InDet::SiSPSeededTrackFinder::m_neventsTotal
std::atomic_int m_neventsTotal
Number events.
Definition: SiSPSeededTrackFinder.h:169
InDet::SiSPSeededTrackFinder::m_doFastTracking
BooleanProperty m_doFastTracking
Definition: SiSPSeededTrackFinder.h:103
PixelID::phi_module
int phi_module(const Identifier &id) const
Definition: PixelID.h:640
InDet::SiSPSeededTrackFinder::m_numGBTSTrainingData
std::atomic_ulong m_numGBTSTrainingData
Definition: SiSPSeededTrackFinder.h:177
test_pyathena.counter
counter
Definition: test_pyathena.py:15
InDet::SiSPSeededTrackFinder::m_problemsTotalV
std::atomic_int m_problemsTotalV
Number events with number seeds > maxNumber.
Definition: SiSPSeededTrackFinder.h:172
PixelID
Definition: PixelID.h:67
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
Trk::numberOfSCTDoubleHoles
@ numberOfSCTDoubleHoles
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:75
Trk::TrackInfo::trackProperties
bool trackProperties(const TrackProperties &property) const
Access methods for track properties.
InDet::SiSPSeededTrackFinder::findZvertex
void findZvertex(std::list< Trk::Vertex > &vertexList, std::pair< double, double > &zBoundaries, const std::vector< int > &numberWeightedhistogram, const std::vector< double > &zWeightedHistogram, const std::vector< double > &ptWeightedHistogram) const
estimates a set of vertex positions and a z interval for the second track finding pass using the inpu...
Definition: SiSPSeededTrackFinder.cxx:1036
InDet::SiCluster
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/SiCluster.h:40
Trk::FitQualityOnSurface::chiSquared
double chiSquared() const
returns the of the overall track fit
Definition: FitQuality.h:56
Trk::TrackStateOnSurface::Measurement
@ Measurement
This is a measurement, and will at least contain a Trk::MeasurementBase.
Definition: TrackStateOnSurface.h:101
ROIPhiRZ
Definition: ROIPhiRZContainer.h:19
python.SystemOfUnits.m
float m
Definition: SystemOfUnits.py:106
InDet::SiSPSeededTrackFinder::m_doDumpGBTSTrainingDataLRT
BooleanProperty m_doDumpGBTSTrainingDataLRT
Definition: SiSPSeededTrackFinder.h:117
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
InDet::SiTrackMakerEventData_xk::combinatorialData
SiCombinatorialTrackFinderData_xk & combinatorialData()
Definition: SiTrackMakerEventData_xk.cxx:76
Identifier
Definition: IdentifierFieldParser.cxx:14