ATLAS Offline Software
InDetGlobalTrackMonAlg.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 
17 //main header
18 #include "InDetGlobalTrackMonAlg.h"
19 
20 //Standard c++
21 #include <vector>
22 #include <memory>
23 
24 
25 InDetGlobalTrackMonAlg::InDetGlobalTrackMonAlg( const std::string& name, ISvcLocator* pSvcLocator ) :
26  AthMonitorAlgorithm(name, pSvcLocator) {}
27 
28 
30 
31 
34  ATH_CHECK( m_IBLParameterSvc.retrieve() );
35 
36  m_doIBL = m_IBLParameterSvc->containsIBL();
37 
38  if (!m_trackSelTool.empty() ) ATH_CHECK( m_trackSelTool.retrieve() );
39  if (!m_tight_trackSelTool.empty()) ATH_CHECK( m_tight_trackSelTool.retrieve() );
40  if (!m_loose_trackSelTool.empty()) ATH_CHECK( m_loose_trackSelTool.retrieve() );
41 
43  ATH_CHECK( m_vxContainerName.initialize() );
44  ATH_CHECK( m_jetContainerName.initialize() );
45 
47 }
48 
49 
50 StatusCode InDetGlobalTrackMonAlg::fillHistograms( const EventContext& ctx ) const {
51  using namespace Monitored;
52 
53  //*******************************************************************************
54  //************************** Begin of filling Track Histograms ******************
55  //*******************************************************************************
56 
57  ATH_MSG_DEBUG("Filling InDetGlobalTrackMonAlg");
58 
59  // For histogram naming
60  auto trackGroup = getGroup("Track");
61 
62  // m_manager->lumiBlockNumber() // not used anymore, now use
63  int lb = GetEventInfo(ctx)->lumiBlock();
64  auto lb_m = Monitored::Scalar<int>( "m_lb", lb );
65 
66  // retrieving tracks
67  auto trackParticles = SG::makeHandle(m_trackParticleName, ctx);
68 
69  // check for tracks
70  if ( !(trackParticles.isValid()) ) {
71  ATH_MSG_ERROR("InDetGlobalMonitoringRun3Test: Track container "<< m_trackParticleName.key() << " could not be found.");
72  return StatusCode::RECOVERABLE;
73  } else {
74  ATH_MSG_DEBUG("InDetGlobalMonitoringRun3Test: Track container "<< trackParticles.name() <<" is found.");
75  }
76 
77  // counters
78  int nBase = 0;
79  int nTight = 0;
80  int nNoIBL = 0;
81  int nNoBL = 0;
82  int nNoTRText = 0;
83 
84  uint8_t iSummaryValue(0); // Dummy counter to retrieve summary values
85 
86  for (const auto trackPart: *trackParticles) {
87  const Trk::Track * track = trackPart->track();
88  if ( !track )
89  {
90  ATH_MSG_DEBUG( "InDetGlobalMonitoringRun3Test: NULL track pointer in collection" );
91  continue;
92  }
93 
94  const Trk::Perigee *perigee = track->perigeeParameters();
95  if ( !perigee )
96  {
97  ATH_MSG_DEBUG( "InDetGlobalMonitoringRun3Test: NULL track->perigeeParameters pointer " );
98  continue;
99  }
100 
101  // =================================== //
102  // Fill hits BEGINS
103 
104  float eta_perigee = perigee->eta();
105  float phi_perigee = perigee->parameters()[Trk::phi0];
106 
107  auto eta_perigee_m = Monitored::Scalar<float>( "m_eta_perigee", eta_perigee);
108  auto phi_perigee_m = Monitored::Scalar<float>( "m_phi_perigee", phi_perigee);
109 
110  auto eta_perigee_loose_m = Monitored::Scalar<float>( "m_eta_perigee_loose", eta_perigee);
111  auto phi_perigee_loose_m = Monitored::Scalar<float>( "m_phi_perigee_loose", phi_perigee);
112 
113  // Loose tracks
114  if ( m_loose_trackSelTool->accept(*track) ){
115  fill(trackGroup, eta_perigee_loose_m, phi_perigee_loose_m);
116  }
117 
118  // Base tracks
119  if ( !m_trackSelTool->accept(*track) )
120  continue;
121 
122  nBase++;
123 
124  fill(trackGroup, eta_perigee_m, phi_perigee_m); // Trk_Base_eta_phi
125 
126  if ( m_doIBL )
127  {
128  int numberOfInnermostPixelLayerHits = trackPart->summaryValue(iSummaryValue, xAOD::numberOfInnermostPixelLayerHits) ? iSummaryValue : 0;
129  auto numberOfInnermostPixelLayerHits_m = Monitored::Scalar<int>( "m_numberOfInnermostPixelLayerHits", numberOfInnermostPixelLayerHits);
130  fill(trackGroup, eta_perigee_m, phi_perigee_m, numberOfInnermostPixelLayerHits_m);
131 
132  fill(trackGroup, lb_m, numberOfInnermostPixelLayerHits_m);
133  }
134 
135  int numberOfPixelHits = trackPart->summaryValue(iSummaryValue, xAOD::numberOfPixelHits) ? iSummaryValue : 0;
136  int numberOfPixelDeadSensors = trackPart->summaryValue(iSummaryValue, xAOD::numberOfPixelDeadSensors) ? iSummaryValue : 0;
138  auto pixHits_m = Monitored::Scalar<int>( "m_pixHits", pixHits );
139  fill(trackGroup, eta_perigee_m, phi_perigee_m, pixHits_m);
140  fill(trackGroup, lb_m, pixHits_m);
141 
142  auto numberOfPixelDeadSensors_m = Monitored::Scalar<int>( "m_numberOfPixelDeadSensors", numberOfPixelDeadSensors );
143  fill(trackGroup, eta_perigee_m, phi_perigee_m, numberOfPixelDeadSensors_m);
144 
145  int numberOfPixelSharedHits = trackPart->summaryValue(iSummaryValue, xAOD::numberOfPixelSharedHits) ? iSummaryValue : 0;
146  auto numberOfPixelSharedHits_m = Monitored::Scalar<int>( "m_numberOfPixelSharedHits", numberOfPixelSharedHits);
147  fill(trackGroup, eta_perigee_m, phi_perigee_m, numberOfPixelSharedHits_m);
148 
149  int numberOfPixelHoles = trackPart->summaryValue(iSummaryValue, xAOD::numberOfPixelHoles) ? iSummaryValue : 0;
150  auto numberOfPixelHoles_m = Monitored::Scalar<int>( "m_numberOfPixelHoles", numberOfPixelHoles);
151  fill(trackGroup, eta_perigee_m, phi_perigee_m, numberOfPixelHoles_m);
152 
153  int numberOfPixelSplitHits = trackPart->summaryValue(iSummaryValue, xAOD::numberOfPixelSplitHits) ? iSummaryValue : 0;
154  auto numberOfPixelSplitHits_m = Monitored::Scalar<int>( "m_numberOfPixelSplitHits", numberOfPixelSplitHits);
155  fill(trackGroup, eta_perigee_m, phi_perigee_m, numberOfPixelSplitHits_m);
156 
157  int numberOfSCTHits = trackPart->summaryValue(iSummaryValue, xAOD::numberOfSCTHits) ? iSummaryValue : 0;
158  int numberOfSCTDeadSensors = trackPart->summaryValue(iSummaryValue, xAOD::numberOfSCTDeadSensors) ? iSummaryValue : 0;
159  int sctHits = numberOfSCTHits + numberOfSCTDeadSensors;
160  auto sctHits_m = Monitored::Scalar<int>( "m_sctHits", sctHits );
161  fill(trackGroup, eta_perigee_m, phi_perigee_m, sctHits_m);
162  fill(trackGroup, lb_m, sctHits_m);
163 
164  auto numberOfSCTDeadSensors_m = Monitored::Scalar<int>( "m_numberOfSCTDeadSensors", numberOfSCTDeadSensors );
165  fill(trackGroup, eta_perigee_m, phi_perigee_m, numberOfSCTDeadSensors_m);
166 
167  int numberOfSCTSharedHits = trackPart->summaryValue(iSummaryValue, xAOD::numberOfSCTSharedHits) ? iSummaryValue : 0;
168  auto numberOfSCTSharedHits_m = Monitored::Scalar<int>( "m_numberOfSCTSharedHits", numberOfSCTSharedHits);
169  fill(trackGroup, eta_perigee_m, phi_perigee_m, numberOfSCTSharedHits_m);
170 
171  int numberOfSCTHoles = trackPart->summaryValue(iSummaryValue, xAOD::numberOfSCTHoles) ? iSummaryValue : 0;
172  auto numberOfSCTHoles_m = Monitored::Scalar<int>( "m_numberOfSCTHoles", numberOfSCTHoles);
173  fill(trackGroup, eta_perigee_m, phi_perigee_m, numberOfSCTHoles_m);
174 
175  int numberOfTRTHits = trackPart->summaryValue(iSummaryValue, xAOD::numberOfTRTHits) ? iSummaryValue : 0;
176  int numberOfTRTDeadStraws = trackPart->summaryValue(iSummaryValue, xAOD::numberOfTRTDeadStraws) ? iSummaryValue : 0;
177  int trtHits = numberOfTRTHits + numberOfTRTDeadStraws;
178  auto trtHits_m = Monitored::Scalar<int>( "m_trtHits", trtHits );
179  fill(trackGroup, eta_perigee_m, phi_perigee_m, trtHits_m);
180  fill(trackGroup, lb_m, trtHits_m);
181 
182  auto numberOfTRTDeadStraws_m = Monitored::Scalar<int>( "m_numberOfTRTDeadStraws", numberOfTRTDeadStraws);
183  fill(trackGroup, eta_perigee_m, phi_perigee_m, numberOfTRTDeadStraws_m);
184 
185  // Fill hits ENDS
186  // =================================== //
187 
188  // =================================== //
189  // FillEtaPhi BEGINS
190 
191  int InnermostPixelLayerHit = 0;
192  int NextToInnermostPixelLayerHit = 0;
193 
194  int expInHit = trackPart->summaryValue(iSummaryValue, xAOD::expectInnermostPixelLayerHit) ? iSummaryValue : 0;
195  int nInHits = trackPart->summaryValue(iSummaryValue, xAOD::numberOfInnermostPixelLayerHits) ? iSummaryValue : 0;
196 
199  int expNInHit = trackPart->summaryValue(iSummaryValue, expNInHitField) ? iSummaryValue : 0;
200  int nNInHits = trackPart->summaryValue(iSummaryValue, nNInHitField) ? iSummaryValue : 0;
201 
202  if ( m_doIBL )
203  {
204  // no IBL hit but a hit is expected
205  if ( expInHit==1 && nInHits==0 ) InnermostPixelLayerHit = 1;
206  auto InnermostPixelLayerHit_m = Monitored::Scalar<int>( "m_InnermostPixelLayerHit", InnermostPixelLayerHit);
207  fill(trackGroup, eta_perigee_m, phi_perigee_m, InnermostPixelLayerHit_m);
208  }
209 
210  // no b-layer hit but a hit is expected
211  if ( expNInHit==1 && nNInHits==0 ) NextToInnermostPixelLayerHit = 1 ;
212  auto NextToInnermostPixelLayerHit_m = Monitored::Scalar<int>( "m_NextToInnermostPixelLayerHit", NextToInnermostPixelLayerHit);
213  fill(trackGroup, eta_perigee_m, phi_perigee_m, NextToInnermostPixelLayerHit_m);
214 
215  // No TRT extension
216  int noTRTHits = 0;
217  if ( numberOfTRTHits == 0 ) noTRTHits = 1;
218  auto noTRTHits_m = Monitored::Scalar<int>( "m_noTRTHits", noTRTHits);
219  fill(trackGroup, eta_perigee_m, phi_perigee_m, noTRTHits_m);
220 
221 
222  // Tight track selection
223  int track_pass_tight = 0;
224  if ( m_tight_trackSelTool -> accept(*track) ){
225  track_pass_tight = 1; // tight selection
226  nTight++;
227  }
228  auto track_pass_tight_m = Monitored::Scalar<int>( "m_track_pass_tight", track_pass_tight);
229  fill(trackGroup, eta_perigee_m, phi_perigee_m, track_pass_tight_m);
230 
231  // =================================== //
232  // FillEtaPhi ENDS
233 
234  int NoIBL = 0;
235  if ( m_doIBL )
236  {
237  // no IBL hit but a hit is expected
238  if ( expInHit==1 && nInHits==0 ) NoIBL = 1;
239  if (NoIBL == 1) nNoIBL++;
240  auto NoIBL_m = Monitored::Scalar<int>( "m_NoIBL_LB", NoIBL);
241  fill(trackGroup, lb_m, NoIBL_m);
242  }
243 
244  int NoBL = 0;
245  if ( expNInHit==1 && nNInHits==0 ) NoBL = 1;
246  if (NoBL == 1) nNoBL++;
247  auto NoBL_m = Monitored::Scalar<int>( "m_NoBL_LB", NoBL);
248  fill(trackGroup, lb_m, NoBL_m);
249 
250  int NoTRText = 0;
251  int numberOfTRTOutliers = trackPart->summaryValue(iSummaryValue, xAOD::numberOfTRTOutliers) ? iSummaryValue : 0;
252  if ( numberOfTRTHits + numberOfTRTOutliers == 0 ) NoTRText = 1;
253  if (NoTRText == 1) nNoTRText++;
254  auto NoTRText_m = Monitored::Scalar<int>( "m_NoTRText_LB", NoTRText);
255  fill(trackGroup, lb_m, NoTRText_m);
256 
257  // FillHitMaps is false for now
258  // FillHoles is false for now
259 
260 
261  } // end of track loop
262 
263  // =================================== //
264  // FillTide BEGINS
265  if ( m_doTide )
266  {
267  // retrieving vertices
268  auto handle_vxContainer = SG::makeHandle(m_vxContainerName, ctx);
269  const xAOD::VertexContainer* vertexContainer = nullptr;
270 
271  if (!handle_vxContainer.isPresent()) {
272  ATH_MSG_DEBUG ("InDetGlobalTrackMonAlg: StoreGate doesn't contain primary vertex container with key "+m_vxContainerName.key()+",may not be able to produce TIDE histograms");
273  }
274  if (!handle_vxContainer.isValid()) {
275  ATH_MSG_DEBUG ("InDetGlobalTrackMonAlg: Could not retrieve primary vertex container with key "+m_vxContainerName.key()+",may not be able to produce TIDE histograms");
276  }
277  else {
278  vertexContainer = handle_vxContainer.cptr();
279  }
280 
281  // retrieving jets
282 
283  auto handle_jetContainer = SG::makeHandle(m_jetContainerName, ctx);
284 
285  if (!handle_jetContainer.isPresent()) {
286  ATH_MSG_DEBUG ("InDetGlobalTrackMonAlg: StoreGate doesn't contain jet container with key "+m_jetContainerName.key()+",may not be able to produce TIDE histograms");
287  }
288  if (!handle_jetContainer.isValid()) {
289  ATH_MSG_DEBUG ("InDetGlobalTrackMonAlg: Could not retrieve jet container with key "+m_jetContainerName.key()+",may not be able to produce TIDE histograms");
290  }
291 
292  auto jetContainer = handle_jetContainer.cptr();
293 
294  if ( handle_jetContainer.isValid() ) {
295  for ( auto jetItr = jetContainer->begin(); jetItr != jetContainer->end(); ++jetItr )
296  {
297  if ( (*jetItr)->pt() < 20000. ){
298  continue;
299  }
300  std::vector<const xAOD::IParticle*> trackVector;
301  if ( !(*jetItr)->getAssociatedObjects<xAOD::IParticle>(xAOD::JetAttribute::GhostTrack, trackVector) ){
302  continue;
303  }
304 
305  for ( std::vector<const xAOD::IParticle*>::const_iterator trkItr = trackVector.begin(); trkItr != trackVector.end() ; ++trkItr )
306  {
307  const xAOD::TrackParticle* trackPart = dynamic_cast<const xAOD::TrackParticle*>(*trkItr);
308  if ( !trackPart ){
309  continue;
310  }
311  uint8_t split;
312  uint8_t shared;
313  uint8_t pix;
314  if ( trackPart->summaryValue(pix, xAOD::numberOfPixelHits) && pix )
315  {
316  const Trk::Perigee perigeeTIDE = trackPart->perigeeParameters();
317  const xAOD::Vertex* foundVertex { nullptr };
318  if ( handle_vxContainer.isValid() ){
319  for ( const auto *const vx : *vertexContainer )
320  {
321  for ( const auto& tpLink : vx->trackParticleLinks() )
322  {
323  if ( *tpLink == trackPart )
324  {
325  foundVertex = vx;
326  break;
327  }
328  }
329  if (foundVertex) break;
330  }
331  }
332  if ( foundVertex )
333  {
334  std::unique_ptr<const Trk::ImpactParametersAndSigma>myIPandSigma(m_trackToVertexIPEstimator->estimate(trackPart,foundVertex));
335 
336  if ( myIPandSigma )
337  {
338  float jetassocdR = trackPart->p4().DeltaR( (*jetItr)->p4());
339  float jetassocd0Reso = std::abs( myIPandSigma->IPd0 / std::sqrt( myIPandSigma->sigmad0*myIPandSigma->sigmad0 + myIPandSigma->PVsigmad0*myIPandSigma->PVsigmad0 ) );
340  float jetassocz0Reso = std::abs( myIPandSigma->IPz0 / std::sqrt( myIPandSigma->sigmaz0*myIPandSigma->sigmaz0 + myIPandSigma->PVsigmaz0*myIPandSigma->PVsigmaz0 ) );
341  float jetassocIPReso = std::abs( myIPandSigma->IPd0 / std::sqrt( myIPandSigma->sigmad0*myIPandSigma->sigmad0 + myIPandSigma->PVsigmad0*myIPandSigma->PVsigmad0 ) );
342  auto jetassocdR_m = Monitored::Scalar<float>("m_jetassocdR", jetassocdR);
343  auto jetassocd0Reso_m = Monitored::Scalar<float>("m_jetassocd0Reso", jetassocd0Reso);
344  auto jetassocz0Reso_m = Monitored::Scalar<float>("m_jetassocz0Reso", jetassocz0Reso);
345  auto jetassocIPReso_m = Monitored::Scalar<float>("m_jetassocd0Reso", jetassocIPReso);
346 
347  fill(trackGroup, jetassocdR_m, jetassocd0Reso_m);
348  fill(trackGroup, jetassocdR_m, jetassocz0Reso_m);
349  fill(trackGroup, lb_m, jetassocIPReso_m);
350  }
351 
352  }
353  if ( trackPart->summaryValue( split, xAOD::numberOfPixelSplitHits) ){
354  float frac = (double)split / pix;
355  float pixSplitdR = trackPart->p4().DeltaR( (*jetItr)->p4() );
356  auto pixSplitFrac_m = Monitored::Scalar<float>("m_pixSplitFrac", frac);
357  auto pixSplitdR_m = Monitored::Scalar<float>("m_pixSplitdR", pixSplitdR);
358 
359  fill(trackGroup, pixSplitdR_m, pixSplitFrac_m);
360  fill(trackGroup, lb_m, pixSplitFrac_m);
361  }
362 
363  if ( trackPart->summaryValue( shared, xAOD::numberOfPixelSharedHits) ){
364  float frac = (float)shared / pix;
365  float pixShareddR = trackPart->p4().DeltaR( (*jetItr)->p4() );
366  auto pixSharedFrac_m = Monitored::Scalar<float>("m_pixSharedFrac", frac);
367  auto pixShareddR_m = Monitored::Scalar<float>("m_pixShareddR", pixShareddR);
368 
369  fill(trackGroup, pixShareddR_m, pixSharedFrac_m);
370  fill(trackGroup, lb_m, pixSharedFrac_m);
371  }
372  }
373  }
374  }
375  }
376  }
377 
378  // FillTide ENDS
379  // =================================== //
380 
381  // Filling per-event histograms
382  auto nBase_m = Monitored::Scalar<int>( "m_nBase", nBase);
383  fill(trackGroup, nBase_m);
384 
385  auto nBaseLB_m = Monitored::Scalar<int>( "m_nBase_LB", nBase);
386  fill(trackGroup, lb_m, nBaseLB_m);
387 
388  auto nTight_m = Monitored::Scalar<int>( "m_nTight_LB", nTight);
389  fill(trackGroup, lb_m, nTight_m);
390 
391  if ( m_doIBL ) {
392  auto nNoIBL_m = Monitored::Scalar<int>( "m_nNoIBL_LB", nNoIBL);
393  fill(trackGroup, lb_m, nNoIBL_m);
394  }
395 
396  auto nNoBL_m = Monitored::Scalar<int>( "m_nNoBL_LB", nNoBL);
397  fill(trackGroup, lb_m, nNoBL_m);
398 
399  auto nNoTRText_m = Monitored::Scalar<int>( "m_nNoTRText_LB", nNoTRText);
400  fill(trackGroup, lb_m, nNoTRText_m);
401 
402 
403 
404 
405  //*******************************************************************************
406  //**************************** End of filling Track Histograms ******************
407  //*******************************************************************************
408 
409  return StatusCode::SUCCESS;
410 }
xAOD::numberOfPixelHoles
@ numberOfPixelHoles
number of pixel layers on track with absence of hits [unit8_t].
Definition: TrackingPrimitives.h:261
xAOD::numberOfSCTSharedHits
@ numberOfSCTSharedHits
number of SCT hits shared by several tracks [unit8_t].
Definition: TrackingPrimitives.h:272
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
Trk::ImpactParametersAndSigma::PVsigmaz0
double PVsigmaz0
Definition: ITrackToVertexIPEstimator.h:41
CutsMETMaker::accept
StatusCode accept(const xAOD::Muon *mu)
Definition: CutsMETMaker.cxx:18
xAOD::TrackParticle_v1::summaryValue
bool summaryValue(uint8_t &value, const SummaryType &information) const
Accessor for TrackSummary values.
Definition: TrackParticle_v1.cxx:736
Trk::ImpactParametersAndSigma::IPd0
double IPd0
Definition: ITrackToVertexIPEstimator.h:34
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:259
xAOD::expectInnermostPixelLayerHit
@ expectInnermostPixelLayerHit
Do we expect a 0th-layer barrel hit for this track?
Definition: TrackingPrimitives.h:236
xAOD::numberOfTRTHits
@ numberOfTRTHits
number of TRT hits [unit8_t].
Definition: TrackingPrimitives.h:275
InDetGlobalTrackMonAlg::m_jetContainerName
SG::ReadHandleKey< xAOD::JetContainer > m_jetContainerName
Definition: InDetGlobalTrackMonAlg.h:68
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:41
InDetGlobalTrackMonAlg::m_vxContainerName
SG::ReadHandleKey< xAOD::VertexContainer > m_vxContainerName
Definition: InDetGlobalTrackMonAlg.h:67
InDetGlobalTrackMonAlg::initialize
virtual StatusCode initialize() override
initialize
Definition: InDetGlobalTrackMonAlg.cxx:32
AthMonitorAlgorithm
Base class for Athena Monitoring Algorithms.
Definition: AthMonitorAlgorithm.h:36
InDetGlobalTrackMonAlg::m_loose_trackSelTool
ToolHandle< InDet::IInDetTrackSelectionTool > m_loose_trackSelTool
Definition: InDetGlobalTrackMonAlg.h:63
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:270
xAOD::TrackParticle_v1::p4
virtual FourMom_t p4() const override final
The full 4-momentum of the particle.
Definition: TrackParticle_v1.cxx:129
Trk::ImpactParametersAndSigma::PVsigmad0
double PVsigmad0
Definition: ITrackToVertexIPEstimator.h:40
xAOD::TrackParticle_v1::perigeeParameters
const Trk::Perigee & perigeeParameters() const
Returns the Trk::MeasuredPerigee track parameters.
Definition: TrackParticle_v1.cxx:485
xAOD::numberOfPixelSharedHits
@ numberOfPixelSharedHits
number of Pixel all-layer hits shared by several tracks [unit8_t].
Definition: TrackingPrimitives.h:262
xAOD::SummaryType
SummaryType
Enumerates the different types of information stored in Summary.
Definition: TrackingPrimitives.h:228
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
xAOD::expectNextToInnermostPixelLayerHit
@ expectNextToInnermostPixelLayerHit
Do we expect a 1st-layer barrel hit for this track?
Definition: TrackingPrimitives.h:247
python.BunchSpacingUtils.lb
lb
Definition: BunchSpacingUtils.py:88
Monitored
Generic monitoring tool for athena components.
Definition: GenericMonitoringTool.h:30
InDetGlobalTrackMonAlg::m_tight_trackSelTool
ToolHandle< InDet::IInDetTrackSelectionTool > m_tight_trackSelTool
Definition: InDetGlobalTrackMonAlg.h:62
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
checkxAOD.frac
frac
Definition: Tools/PyUtils/bin/checkxAOD.py:259
InDetGlobalTrackMonAlg::m_doIBL
BooleanProperty m_doIBL
Definition: InDetGlobalTrackMonAlg.h:72
InDetGlobalTrackMonAlg::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const override
adds event to the monitoring histograms
Definition: InDetGlobalTrackMonAlg.cxx:50
Trk::ImpactParametersAndSigma::IPz0
double IPz0
Definition: ITrackToVertexIPEstimator.h:35
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Trk::ImpactParametersAndSigma::sigmad0
double sigmad0
Definition: ITrackToVertexIPEstimator.h:37
AthMonitorAlgorithm::fill
void fill(const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
Fills a vector of variables to a group by reference.
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::numberOfPixelSplitHits
@ numberOfPixelSplitHits
number of Pixel all-layer hits split by cluster splitting [unit8_t].
Definition: TrackingPrimitives.h:263
InDetGlobalTrackMonAlg::~InDetGlobalTrackMonAlg
virtual ~InDetGlobalTrackMonAlg()
Definition: InDetGlobalTrackMonAlg.cxx:29
InDetGlobalTrackMonAlg::m_IBLParameterSvc
ServiceHandle< IIBLParameterSvc > m_IBLParameterSvc
Definition: InDetGlobalTrackMonAlg.h:70
xAOD::double
double
Definition: CompositeParticle_v1.cxx:159
xAOD::numberOfSCTHoles
@ numberOfSCTHoles
number of SCT holes [unit8_t].
Definition: TrackingPrimitives.h:270
AthMonitorAlgorithm::GetEventInfo
SG::ReadHandle< xAOD::EventInfo > GetEventInfo(const EventContext &) const
Return a ReadHandle for an EventInfo object (get run/event numbers, etc.)
Definition: AthMonitorAlgorithm.cxx:107
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
InDetGlobalTrackMonAlg::InDetGlobalTrackMonAlg
InDetGlobalTrackMonAlg(const std::string &name, ISvcLocator *pSvcLocator)
Definition: InDetGlobalTrackMonAlg.cxx:25
xAOD::numberOfNextToInnermostPixelLayerHits
@ numberOfNextToInnermostPixelLayerHits
these are the hits in the 1st pixel barrel layer
Definition: TrackingPrimitives.h:248
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
InDetGlobalTrackMonAlg::m_trackToVertexIPEstimator
ToolHandle< Trk::ITrackToVertexIPEstimator > m_trackToVertexIPEstimator
Definition: InDetGlobalTrackMonAlg.h:64
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
xAOD::numberOfTRTOutliers
@ numberOfTRTOutliers
number of TRT outliers [unit8_t].
Definition: TrackingPrimitives.h:276
InDetGlobalTrackMonAlg.h
InDetGlobalTrackMonAlg::m_doTide
BooleanProperty m_doTide
Definition: InDetGlobalTrackMonAlg.h:73
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
xAOD::numberOfSCTDeadSensors
@ numberOfSCTDeadSensors
number of dead SCT sensors crossed [unit8_t].
Definition: TrackingPrimitives.h:273
InDetGlobalTrackMonAlg::m_trackParticleName
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_trackParticleName
Definition: InDetGlobalTrackMonAlg.h:66
Trk::ImpactParametersAndSigma::sigmaz0
double sigmaz0
Definition: ITrackToVertexIPEstimator.h:38
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:268
xAOD::numberOfPixelDeadSensors
@ numberOfPixelDeadSensors
number of dead pixel sensors crossed [unit8_t].
Definition: TrackingPrimitives.h:266
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
pix
Definition: PixelMapping.cxx:16
xAOD::JetAttribute::GhostTrack
@ GhostTrack
Definition: JetAttributes.h:252
PixelAthClusterMonAlgCfg.trackGroup
trackGroup
Definition: PixelAthClusterMonAlgCfg.py:124
xAOD::numberOfTRTDeadStraws
@ numberOfTRTDeadStraws
number of dead TRT straws crossed [unit8_t].
Definition: TrackingPrimitives.h:282
readCCLHist.float
float
Definition: readCCLHist.py:83
Trk::split
@ split
Definition: LayerMaterialProperties.h:38
Trk::phi0
@ phi0
Definition: ParamDefs.h:65
AthMonitorAlgorithm::getGroup
const ToolHandle< GenericMonitoringTool > & getGroup(const std::string &name) const
Get a specific monitoring tool from the tool handle array.
Definition: AthMonitorAlgorithm.cxx:164
InDetGlobalTrackMonAlg::m_trackSelTool
ToolHandle< InDet::IInDetTrackSelectionTool > m_trackSelTool
Definition: InDetGlobalTrackMonAlg.h:61
xAOD::numberOfInnermostPixelLayerHits
@ numberOfInnermostPixelLayerHits
these are the hits in the 0th pixel barrel layer
Definition: TrackingPrimitives.h:237