ATLAS Offline Software
TRT_Monitoring_Tool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "TRT_Monitoring_Tool.h"
6 
7 #include "AthContainers/DataVector.h"
8 #include "TRT_ReadoutGeometry/TRT_DetectorManager.h"
9 #include "InDetRIO_OnTrack/TRT_DriftCircleOnTrack.h"
10 #include "TrkTrackSummary/TrackSummary.h"
11 #include "AtlasDetDescr/AtlasDetectorID.h"
12 #include "Identifier/Identifier.h"//may be obsolete, TRT_ID includes this
13 #include "InDetIdentifier/TRT_ID.h"
14 #include "InDetRawData/InDetRawDataContainer.h"
15 #include "TrkTrack/Track.h"
16 #include "TrkTrack/TrackCollection.h"
17 #include "TRT_ConditionsServices/ITRT_CalDbTool.h"
18 #include "TRT_ConditionsServices/ITRT_ConditionsSvc.h"
19 #include "TRT_ConditionsServices/ITRT_StrawStatusSummaryTool.h"
20 #include "TRT_ConditionsServices/ITRT_DAQ_ConditionsSvc.h"
21 #include "TRT_ConditionsServices/ITRT_StrawNeighbourSvc.h"
22 #include "InDetConditionsSummaryService/IInDetConditionsSvc.h"
23 #include "xAODTrigger/TrigDecision.h"
24 
25 #include "EventPrimitives/EventPrimitivesHelpers.h"
26 
27 #include "StoreGate/ReadHandle.h"
28 
29 #include "TProfile.h"
30 #include "LWHists/TH1F_LW.h"
31 #include "LWHists/TH2F_LW.h"
32 #include "LWHists/TProfile_LW.h"
33 #include "LWHists/TH1D_LW.h"
34 #include "LWHists/LWHist1D.h"
35 
36 #include <sstream>
37 #include <iomanip>
38 #include <memory>
39 
40 using namespace std;
41 //Private Static Const data member initialization
42 const int TRT_Monitoring_Tool::s_numberOfBarrelStacks = 32;
43 const int TRT_Monitoring_Tool::s_numberOfEndCapStacks = 32;
44 const int TRT_Monitoring_Tool::s_Straw_max[2] = {1642, 3840};
45 const int TRT_Monitoring_Tool::s_iStack_max[2] = {32, 64};
46 const int TRT_Monitoring_Tool::s_iChip_max[2] = {104, 240};
47 const int TRT_Monitoring_Tool::s_numberOfStacks[2] = {32, 32};
48 const int TRT_Monitoring_Tool::s_moduleNum[2] = {96, 64};
49 
50 
51 // TODO: Clean up the rest of the package
52 // TODO: Fix naming conventions
53 
54 //------------------------------------------------------------------------------------------------//
55 TRT_Monitoring_Tool::TRT_Monitoring_Tool(const std::string &type, const std::string &name, const IInterface *parent) :
56  ManagedMonitorToolBase(type, name, parent),
57  m_lastTRTLumiBlock(-99),
58  m_evtLumiBlock(0),
59  m_good_bcid(0),
60  m_nTotalTracks(0),
61  m_passEventBurst(),
62  m_idHelper(nullptr),
63  p_toolSvc("IToolSvc", name),
64  m_sumTool("TRT_StrawStatusSummaryTool", this),
65  m_DAQSvc("TRT_DAQ_ConditionsSvc", name), // NOTE: not used anywhere?
66  m_condSvc_BS("TRT_ByteStream_ConditionsSvc", name), // NOTE: not used anywhere?
67  m_TRTStrawNeighbourSvc("TRT_StrawNeighbourSvc", name),
68  m_TRTCalDbTool("TRT_CalDbTool", this),
69  m_drifttool("TRT_DriftFunctionTool"),
70  m_pTRTHelper(nullptr),
71  m_mgr(nullptr),
72  m_HTfraconTrack_B(),
73  m_LonTrack_B(),
74  m_nTrack_B(),
75  m_HTfraconTrack_E(),
76  m_LonTrack_E(),
77  m_nTrack_E(),
78  m_nTRTHits(),
79  m_doDCS(false),
80  m_EventPhaseScale(1.0),
81  m_nStrawHits_B(),
82  m_nStrawHits_E(),
83  m_DriftTimeonTrkDistScale_B(),
84  m_HLhitOnTrackScale_B(),
85  m_HtoLRatioOnTrackScale_B(),
86  m_HtoLRatioOnTrackScale_B_Ar(),
87  m_HtoLRatioOnTrackScale_B_Xe(),
88  m_NumSwLLWoTScale_B(),
89  m_WireToTrkPositionScale_B(),
90  m_WireToTrkPositionScale_B_Ar(),
91  m_TronTDistScale_B(),
92  m_ResidualScale_B(),
93  m_ResidualScale_B_20GeV(),
94  m_TimeResidualScale_B(),
95  m_DriftTimeonTrkDistScale_B_Ar(),
96  m_TronTDistScale_B_Ar(),
97  m_ResidualScale_B_Ar(),
98  m_ResidualScale_B_Ar_20GeV(),
99  m_TimeResidualScale_B_Ar(),
100  m_DriftTimeonTrkDistScale_E(),
101  m_HLhitOnTrackScale_E(),
102  m_HtoLRatioOnTrackScale_E(),
103  m_HtoLRatioOnTrackScale_E_Ar(),
104  m_HtoLRatioOnTrackScale_E_Xe(),
105  m_NumSwLLWoTScale_E(),
106  m_WireToTrkPositionScale_E(),
107  m_WireToTrkPositionScale_E_Ar(),
108  m_TronTDistScale_E(),
109  m_ResidualScale_E(),
110  m_ResidualScale_E_20GeV(),
111  m_TimeResidualScale_E(),
112  m_DriftTimeonTrkDistScale_E_Ar(),
113  m_ResidualScale_E_Ar(),
114  m_ResidualScale_E_Ar_20GeV(),
115  m_TimeResidualScale_E_Ar(),
116  m_DEBUG(false),
117  m_longToTCut(9.375),
118  m_EventBurstCut(200),
119  m_lumiBlocksToResetOcc(20),
120  m_isCosmics(false),
121  m_minTRThits(10),
122  m_minP(0),
123  m_track_pt(0),
124  m_track_eta(0),
125  m_track_phi(0),
126  m_track_d0(0),
127  m_track_z0(0),
128  m_min_tracks_straw(10)
129 //-----------------------------------------------------------------------------------------------//
130 // NOTE: check up on obsolete properties
131 {
132  declareProperty("ToolSvc", p_toolSvc);
133  declareProperty("InDetTRTStrawStatusSummaryTool", m_sumTool);
134  declareProperty("InDetTRT_DAQ_ConditionsSvc", m_DAQSvc);
135  declareProperty("TRT_StrawNeighbourSvc", m_TRTStrawNeighbourSvc);
136  declareProperty("DriftFunctionTool", m_drifttool);
137  declareProperty("DoTRT_DCS", m_doDCS);
138  declareProperty("DoRDOsMon", m_doRDOsMon = true);
139  declareProperty("DoGeoMon", m_doGeoMon = false);//obsolete
140  declareProperty("NumberOfEvents", m_usedEvents = -1);
141  declareProperty("DoTracksMon", m_doTracksMon = true);
142  declareProperty("doAside", m_doASide = true);//obsolete
143  declareProperty("doCside", m_doCSide = true);//obsolete
144  declareProperty("doStraws", m_doStraws = true);
145  declareProperty("doChips", m_doChips = false);
146  declareProperty("doExpert", m_doExpert = false);
147  declareProperty("doEfficiency", m_doEfficiency = true);
148  declareProperty("doMaskStraws", m_doMaskStraws = true);
149  declareProperty("doShift", m_doShift = true);
150  declareProperty("doDiagnostic", m_doDiagnostic = false);//obsolete
151  declareProperty("DistanceToStraw", m_DistToStraw = 0.4);
152  declareProperty("Geo_Summary_Provider", m_geo_summary_provider);//probably obsolete
153  declareProperty("Map_Path", m_mapPath); // obsolete
154  declareProperty("maxDistToStraw", m_maxDistToStraw = 2.0);//obsolete
155  declareProperty("is_TRT_only_tracks", m_trt_only_trks = true);//obsolete
156  declareProperty("is_zero_mag_field", m_zero_field = true);//obsolete
157  //
158  // Tunable parameters for TRT monitoring histograms
159  //
160  declareProperty("LE_TimeWindow_MIN", m_LE_timeWindow_MIN = 0);//obsolete
161  declareProperty("LE_TimeWindow_MAX", m_LE_timeWindow_MAX = 24);//obsolete
162  declareProperty("LL_TimeWindow_MIN", m_LL_timeWindow_MIN = 0);//obsolete
163  declareProperty("LL_TimeWindow_MAX", m_LL_timeWindow_MAX = 24);//obsolete
164  declareProperty("HL_TimeWindow_MIN", m_HL_timeWindow_MIN = 0);//obsolete
165  declareProperty("HL_TimeWindow_MAX", m_HL_timeWindow_MAX = 3);//obsolete
166  declareProperty("MIN_N_LL_Hits", m_MIN_N_LL_Hits = 10);//obsolete
167  declareProperty("MIN_TOT_Hits", m_MIN_TOT_Hits = 2);//obsolete
168  declareProperty("NoiseSuppressionLevel_30pc", m_NoiseSuppressionLevel_30pc = false);//obsolete
169  declareProperty("NoiseSuppressionMap", m_NoiseSuppressionMap = false);//obsolete
170  declareProperty("Debug", m_DEBUG);//obsolete
171  declareProperty("PrintEventInfo", m_printEventInfo);//obsolete
172  declareProperty("ITRT_CalDbTool", m_TRTCalDbTool);
173  declareProperty("LongToTCut", m_longToTCut);
174  declareProperty("NPhiBins", m_nphi_bins = 360);
175  declareProperty("EventBurstCut", m_EventBurstCut = 200);
176  declareProperty("LumiBlocksToResetOcc", m_lumiBlocksToResetOcc = 20);
177  declareProperty("IsCosmics", m_isCosmics = false);
178  declareProperty("MinTRTHitCut", m_minTRThits = 10);
179  declareProperty("useHoleFinder", m_useHoleFinder = true);
180  declareProperty("max_abs_d0", m_max_abs_d0 = 10 * CLHEP::mm);
181  declareProperty("max_abs_z0", m_max_abs_z0 = 300 * CLHEP::mm);
182  declareProperty("max_abs_eta", m_max_abs_eta = 2.5);
183  declareProperty("MinTrackP", m_minP = 0.0 * CLHEP::GeV);
184  declareProperty("min_pT", m_min_pT = 0.5 * CLHEP::GeV);
185  declareProperty("min_si_hits", m_min_si_hits = 1);
186  declareProperty("min_pixel_hits", m_min_pixel_hits = 0);
187  declareProperty("min_sct_hits", m_min_sct_hits = 0);
188  declareProperty("min_trt_hits", m_min_trt_hits = 10);
189  declareProperty("min_tracks_straw", m_min_tracks_straw = 10);
190  declareProperty("every_xth_track", m_every_xth_track = 25);
191  declareProperty("whatdatatype", m_datatype);//obsolete
192  declareProperty("doArgonXenonSeparation", m_ArgonXenonSplitter = true); // Argon Histograms won't be created if this is set to false.
193  m_flagforscale = 1; //Added for a fix
194  m_totalEvents = 0;
195  m_hSummary = nullptr;
196  m_IntLum = nullptr;//
197  m_LBvsLum = nullptr; // coverity 25098
198  m_LBvsTime = nullptr; //
199  m_hEvtPhaseDetPhi_B = nullptr;
200  m_hEvtPhase = nullptr;
201  m_hEvtPhaseVsTrig = nullptr;
202  m_hOccAll = nullptr;
203  m_hefficiency_eta = nullptr;
204  m_hefficiency_phi = nullptr;
205  m_hefficiency_pt = nullptr;
206  m_hefficiency_z0 = nullptr;
207 
208  for (int iside = 0; iside < 2; iside++) { // A-side(iside=0), C-side(iside=1)
209  m_nTracksB[iside] = 0;
210  m_nTracksEC[iside] = 0;
211  m_nTracksEC_B[iside] = 0;
212  }
213 
214  for (int ibe = 0; ibe < 2; ibe++) {
215  m_hBCIDvsOcc[ibe] = nullptr;
216  m_hHitsOnTrack_Scatter[ibe] = nullptr;
217  m_hLLOcc_Scatter[ibe] = nullptr;
218  m_hHightoLowRatioOnTrack_Scatter[ibe] = nullptr;
219  m_hefficiencyMap[ibe] = nullptr;
220 
221  for (int iside = 0; iside < 2; iside++) {
222  m_hChipBSErrorsVsLB[ibe][iside] = nullptr;
223  m_hRobBSErrorsVsLB[ibe][iside] = nullptr;
224  m_hAvgHLOcc_side[ibe][iside] = nullptr;
225  m_hAvgLLOcc_side[ibe][iside] = nullptr;
226  m_hAvgLLOccMod_side[ibe][iside] = nullptr;
227  m_hAvgHLOccMod_side[ibe][iside] = nullptr;
228  m_hefficiency[ibe][iside] = nullptr;
229  m_hefficiencyIntegral[ibe][iside] = nullptr;
230  }// for (int iside=0; iside<2; iside++)
231 
232  for (int i = 0; i < 64; i++) {
233  m_hChipOcc[ibe][i] = nullptr;
234  m_hStrawOcc[ibe][i] = nullptr;
235  m_hStrawsEff[ibe][i] = nullptr;
236  m_hChipsEff[ibe][i] = nullptr;
237  m_hHitOnTrackVsAllS[ibe][i] = nullptr;
238  m_hHitOnTrackVsAllC[ibe][i] = nullptr;
239  m_hHitWMapS[ibe][i] = nullptr;
240  m_hHitTrWMapS[ibe][i] = nullptr;
241  m_hHitTrMapS[ibe][i] = nullptr;
242  m_hHitAMapS[ibe][i] = nullptr;
243  m_hHitAWMapS[ibe][i] = nullptr;
244  m_hHtoLMapS[ibe][i] = nullptr;
245  m_hHitToTMapS[ibe][i] = nullptr;
246  m_hHitToTLongMapS[ibe][i] = nullptr;
247  m_hHitToTLongTrMapS[ibe][i] = nullptr;
248  m_hHitHMapS[ibe][i] = nullptr;
249  m_hHitHWMapS[ibe][i] = nullptr;
250  m_hHitWonTMapS[ibe][i] = nullptr;
251  m_hHitTronTMapS[ibe][i] = nullptr;
252  m_hHitAonTMapS[ibe][i] = nullptr;
253  m_hHitAWonTMapS[ibe][i] = nullptr;
254  m_hHitHonTMapS[ibe][i] = nullptr;
255  m_hHitHWonTMapS[ibe][i] = nullptr;
256  m_hHtoLonTMapS[ibe][i] = nullptr;
257  m_hHtoLWonTMapS[ibe][i] = nullptr;
258  m_hHitToTonTMapS[ibe][i] = nullptr;
259  m_hHitTronTwEPCMapS[ibe][i] = nullptr;
260  m_hValidRawDriftTimeonTrk[ibe][i] = nullptr;
261  m_hValidRawDriftTimeonTrkC[ibe][i] = nullptr;
262  m_hHitWMapC[ibe][i] = nullptr;
263  m_hHitTrMapC[ibe][i] = nullptr;
264  m_hHitTrWMapC[ibe][i] = nullptr;
265  m_hHitAMapC[ibe][i] = nullptr;
266  m_hHitAWMapC[ibe][i] = nullptr;
267  m_hHtoLMapC[ibe][i] = nullptr;
268  m_hHtoBCMapC[ibe][i] = nullptr;
269  m_hHtoBCMapB[ibe][i] = nullptr;
270  m_hHitToTMapC[ibe][i] = nullptr;
271  m_hHitHMapC[ibe][i] = nullptr;
272  m_hHitHWMapC[ibe][i] = nullptr;
273  m_hHitWonTMapC[ibe][i] = nullptr;
274  m_hHitTronTMapC[ibe][i] = nullptr;
275  m_hHitAonTMapC[ibe][i] = nullptr;
276  m_hHitAWonTMapC[ibe][i] = nullptr;
277  m_hHitHonTMapC[ibe][i] = nullptr;
278  m_hHitHWonTMapC[ibe][i] = nullptr;
279  m_hHtoLonTMapC[ibe][i] = nullptr;
280  m_hHtoLWonTMapC[ibe][i] = nullptr;
281  m_hHitToTonTMapC[ibe][i] = nullptr;
282  m_hHitTronTwEPCMapC[ibe][i] = nullptr;
283  m_hefficiencyS[ibe][i] = nullptr;
284  m_hefficiencyC[ibe][i] = nullptr;
285 
286  if (ibe == 1) m_hHitToTrkDistanceMapS_E[i] = nullptr;
287  } //for (int i = 0; i < 64; i++)
288  } // for (int ibe=0; ibe<2; ibe++)
289 
290  m_nTrksperLB_B = 0;
291  m_nHitsperLB_B = 0;
292  m_nHLHitsperLB_B = 0;
293  m_hNumTrksDetPhi_B = nullptr;
294  m_hNumHoTDetPhi_B = nullptr;
295  m_hAvgTroTDetPhi_B = nullptr;
296  m_hAvgTroTDetPhi_B_Ar = nullptr;
297  m_hStrawEffDetPhi_B = nullptr;
298  m_hNumSwLLWoT_B = nullptr;
299  m_hHitWMap_B = nullptr;
300  m_hHitWonTMap_B = nullptr;
301  m_Pull_Biased_Barrel = nullptr;
302  m_hResidual_B = nullptr;
303  m_hResidual_B_20GeV = nullptr;
304  m_hTimeResidual_B = nullptr;
305  m_hDriftTimeonTrkDist_B = nullptr;
306  m_hTronTDist_B = nullptr;
307  m_hrtRelation_B = nullptr;
308  m_hHLhitOnTrack_B = nullptr;
309  m_hHtoLRatioOnTrack_B = nullptr;
310  m_hWireToTrkPosition_B = nullptr;
311  m_hWireToTrkPosition_B_Ar = nullptr;
312  m_hHtoLRatioOnTrack_B_Ar = nullptr;
313  m_hHtoLRatioOnTrack_B_Xe = nullptr;
314  m_hResVsDetPhi_B = nullptr;
315  m_hNHitsperLB_B = nullptr;
316  m_hNTrksperLB_B = nullptr;
317  m_hNHLHitsperLB_B = nullptr;
318  m_hefficiencyBarrel_locR = nullptr;
319  m_hefficiencyBarrel_locR_Ar = nullptr;
320  m_hHitWMap_B_Ar = nullptr;
321  m_hResidual_B_Ar = nullptr;
322  m_hResidual_B_Ar_20GeV = nullptr;
323  m_hTimeResidual_B_Ar = nullptr;
324  m_hrtRelation_B_Ar = nullptr;
325  m_hDriftTimeonTrkDist_B_Ar = nullptr;
326  m_hTronTDist_B_Ar = nullptr;
327  m_Pull_Biased_EndCap = nullptr;
328 
329  for (int iside = 0; iside < 2; iside++) {
330  m_nTrksperLB_E[iside] = 0;
331  m_nHitsperLB_E[iside] = 0;
332  m_nHLHitsperLB_E[iside] = 0;
333  m_hNumTrksDetPhi_E[iside] = nullptr;
334  m_hNumHoTDetPhi_E[iside] = nullptr;
335  m_hAvgTroTDetPhi_E[iside] = nullptr;
336  m_hAvgTroTDetPhi_E_Ar[iside] = nullptr;
337  m_hStrawEffDetPhi_E[iside] = nullptr;
338  m_hNumSwLLWoT_E[iside] = nullptr;
339  m_hEvtPhaseDetPhi_E[iside] = nullptr;
340  m_hHitWMap_E[iside] = nullptr;
341  m_hHitWonTMap_E[iside] = nullptr;
342  m_hResidual_E[iside] = nullptr;
343  m_hResidual_E_20GeV[iside] = nullptr;
344  m_hTimeResidual_E[iside] = nullptr;
345  m_hDriftTimeonTrkDist_E[iside] = nullptr;
346  m_hTronTDist_E[iside] = nullptr;
347  m_hrtRelation_E[iside] = nullptr;
348  m_hHLhitOnTrack_E[iside] = nullptr;
349  m_hHtoLRatioOnTrack_E[iside] = nullptr;
350  m_hHtoLRatioOnTrack_E_Ar[iside] = nullptr;
351  m_hHtoLRatioOnTrack_E_Xe[iside] = nullptr;
352  m_hWireToTrkPosition_E[iside] = nullptr;
353  m_hWireToTrkPosition_E_Ar[iside] = nullptr;
354  m_hResVsDetPhi_E[iside] = nullptr;
355  m_hNHitsperLB_E[iside] = nullptr;
356  m_hNTrksperLB_E[iside] = nullptr;
357  m_hNHLHitsperLB_E[iside] = nullptr;
358  m_hefficiencyEndCap_locR[iside] = nullptr;
359  m_hefficiencyEndCap_locR_Ar[iside] = nullptr;
360  m_hHitWMap_E_Ar[iside] = nullptr;
361  m_hResidual_E_Ar[iside] = nullptr;
362  m_hResidual_E_Ar_20GeV[iside] = nullptr;
363  m_hTimeResidual_E_Ar[iside] = nullptr;
364  m_hrtRelation_E_Ar[iside] = nullptr;
365  m_hTronTDist_E_Ar[iside] = nullptr;
366  m_hDriftTimeonTrkDist_E_Ar[iside] = nullptr;
367  }
368 }
369 
370 //-------------------------------------------------------------------------//
371 TRT_Monitoring_Tool::~TRT_Monitoring_Tool() {}
372 //-------------------------------------------------------------------------//
373 
374 //------------------------------------------------------------------------------------//
375 StatusCode TRT_Monitoring_Tool::initialize() {
376 //------------------------------------------------------------------------------------//
377  ATH_MSG_VERBOSE("Initializing TRT Monitoring");
378 
379  ATH_CHECK( ManagedMonitorToolBase::initialize() );
380  ATH_CHECK( ManagedMonitorToolBase::initialize() );
381 
382  IToolSvc *p_toolSvc; // NOTE: recreation of ToolSvc
383 
384  ATH_CHECK( service("ToolSvc", p_toolSvc) );
385  // Retrieve detector manager.
386  ATH_CHECK( detStore()->retrieve(m_mgr, "TRT") );
387  // Get ID helper for TRT to access various detector components like straw, straw_layer, layer_or_wheel, phi_module, etc...
388  ATH_CHECK( detStore()->retrieve(m_pTRTHelper, "TRT_ID") );
389  ATH_CHECK( detStore()->retrieve(m_idHelper, "AtlasID") );
390 
391  if (m_doExpert) {
392  // Retrieve the TRT_Straw Status Service.
393  if (m_sumTool.name().empty()) {
394  ATH_MSG_WARNING("TRT_StrawStatusTool not given.");
395  } else {
396  ATH_CHECK( m_sumTool.retrieve() );
397  }
398 
399 
400  // NOTE: is this used anywhere?
401  // NOTE: This is the same of m_BSSvc
402  // Retrieve the TRT_Conditions Service.
403  if (m_condSvc_BS.name().empty()) {
404  ATH_MSG_WARNING("TRT_ConditionsSvc not given.");
405  } else {
406  ATH_CHECK( m_condSvc_BS.retrieve() );
407  }
408 
409  // NOTE: is this used anywhere?
410  // Retrieve the TRT_DAQConditions Service.
411  if (m_DAQSvc.name().empty()) {
412  ATH_MSG_WARNING("TRT_DAQConditionsSvc not given.");
413  } else {
414  ATH_CHECK( m_DAQSvc.retrieve() );
415  }
416 
417  // Test out the TRT_ConditionsSummaryTool.
418  //Identifier ident = m_trtid->straw_id(1,1,1,1,1);
419  Identifier ident;
420 
421  if (!m_sumTool.name().empty()) {
422  ATH_MSG_VERBOSE("Trying " << m_sumTool << " isGood");
423  ATH_MSG_VERBOSE("TRT_StrawStatusTool reports status = " << m_sumTool->getStatus(ident));
424  }
425  }//If do expert
426 
427  //Retrieve TRT_StrawNeighbourService.
428  if (m_TRTStrawNeighbourSvc.name().empty()) {
429  ATH_MSG_WARNING("TRT_StrawNeighbourSvc not given.");
430  } else {
431  if (m_TRTStrawNeighbourSvc.retrieve().isFailure()) {
432  ATH_MSG_FATAL("Could not get StrawNeighbourSvc.");
433  }
434  }
435 
436  // Get Track summary tool
437  if (m_TrackSummaryTool.retrieve().isFailure())
438  ATH_MSG_ERROR("Cannot get TrackSummaryTool");
439  else
440  ATH_MSG_DEBUG("Retrieved succesfully the track summary tool" << m_TrackSummaryTool);
441 
442  //Get TRTCalDbTool
443  if (m_TRTCalDbTool.name().empty()) {
444  ATH_MSG_WARNING("TRT_CalDbTool not given.");
445  } else {
446  if (m_TRTCalDbTool.retrieve().isFailure()) {
447  ATH_MSG_ERROR("Cannot get TRTCalDBTool.");
448  }
449  }
450 
451  // retrieve TRTTrackHoleSearchTool
452  if (m_doEfficiency || m_doExpert) {
453  ATH_CHECK( m_trt_hole_finder.retrieve() );
454  }
455  else {
456  m_trt_hole_finder.disable();
457  }
458 
459  ATH_CHECK(m_drifttool.retrieve());
460 
461  // Initialize arrays
462  // These arrays store information about each entry to the HitMap histograms
463 
464  // if (m_environment==AthenaMonManager::online)
465  if (true) {
466  //loop over straw hash index to create straw number mapping for TRTViewer
467  unsigned int maxHash = m_pTRTHelper->straw_layer_hash_max();
468 
469  for (int ibe = 0; ibe < 2; ibe++) { // ibe=0(barrel), ibe=1(endcap)
470  for (unsigned int index = 0; index < maxHash; index++) {
471  IdentifierHash idHash = index;
472  Identifier id = m_pTRTHelper->layer_id(idHash);
473  int idBarrelEndcap = m_pTRTHelper->barrel_ec(id);
474  int idLayerWheel = m_pTRTHelper->layer_or_wheel(id);
475  int idPhiModule = m_pTRTHelper->phi_module(id);
476  int idStrawLayer = m_pTRTHelper->straw_layer(id);
477  bool isBarrel = m_pTRTHelper->is_barrel(id);
478  int idSide;
479  int sectorflag = 0;
480  const InDetDD::TRT_BaseElement *element = nullptr;
481 
482  if (ibe == 0) { // barrel
483  idSide = idBarrelEndcap ? 1 : -1;
484 
485  if (isBarrel && (idBarrelEndcap == -1)) {
486  sectorflag = 1;
487  element = m_mgr->getBarrelElement(idSide, idLayerWheel, idPhiModule, idStrawLayer);
488  }
489  } else if (ibe == 1) { // endcap
490  idSide = idBarrelEndcap ? 1 : 0;
491 
492  if (!isBarrel && ((idBarrelEndcap == -2) || (idBarrelEndcap == 2))) {
493  sectorflag = 1;
494  element = m_mgr->getEndcapElement(idSide, idLayerWheel, idStrawLayer, idPhiModule);//, idStrawLayer_ec);
495  }
496  }
497 
498  if (sectorflag == 1) {
499  if (!element) continue;
500 
501  for (unsigned int istraw = 0; istraw < element->nStraws(); istraw++) {
502  std::vector<Identifier> neighbourIDs;
503  Identifier strawID = m_pTRTHelper->straw_id(id, int(istraw));
504  int i_chip, i_pad;
505  m_TRTStrawNeighbourSvc->getChip(strawID, i_chip);
506  m_TRTStrawNeighbourSvc->getPad(id, i_pad);
507 
508  if (ibe == 0) { //barrel
509  if (idLayerWheel == 1) i_chip += 21;
510 
511  if (idLayerWheel == 2) i_chip += 54;
512 
513  int tempStrawNumber = strawNumber(istraw, idStrawLayer, idLayerWheel);
514 
515  if (tempStrawNumber < 0 || tempStrawNumber > (s_Straw_max[ibe] - 1)) {
516  ATH_MSG_WARNING("Found tempStrawNumber = " << tempStrawNumber << " out of range.");
517  } else {
518  m_mat_chip_B[idPhiModule][tempStrawNumber] = i_chip;
519  m_mat_chip_B[idPhiModule + 32][tempStrawNumber] = i_chip;
520  }
521  } else if (ibe == 1) { //endcap
522  // i_chip -= 104;
523  ++i_chip -= 104;
524  int tempStrawNumber = strawNumberEndCap(istraw, idStrawLayer, idLayerWheel, idPhiModule, idSide);
525 
526  if (tempStrawNumber < 0 || tempStrawNumber > (s_Straw_max[ibe] - 1)) {
527  ATH_MSG_WARNING("Found tempStrawNumber = " << tempStrawNumber << " out of range.");
528  } else {
529  m_mat_chip_E[idPhiModule][tempStrawNumber] = i_chip;
530  m_mat_chip_E[idPhiModule + 32][tempStrawNumber] = i_chip;
531  }
532  }
533  }
534  }
535  }//for (unsigned int index = 0; index < maxHash; index++)
536  } //for (int ibe=0; ibe<2; ibe++)
537  }
538 
539  // some initializaton
540  // TODO: ugly way of doing this, so we probably want to clean it up a bit.
541  if (m_doShift) {
542  // Barrel
543  int ibe = 0;
544 
545  for (int iStack = 0; iStack < s_iStack_max[ibe]; iStack++) {
546  m_LLOcc[ibe][iStack] = 0;
547  m_LLOcc[ibe][iStack + 32] = 0;
548  m_HTfraconTrack_B[iStack] = 0;
549  m_LonTrack_B[iStack] = 0;
550  m_nTrack_B[iStack] = 0;
551  }
552 
553  for (int i = 0; i < s_Straw_max[ibe]; i++) {
554  m_nStrawHits_B[i] = 0;
555  }
556 
557  // Endcap
558  ibe = 1;
559 
560  for (int iStack = 0; iStack < s_iStack_max[ibe]; iStack++) {
561  m_LLOcc[ibe][iStack] = 0;
562  m_HTfraconTrack_E[iStack] = 0;
563  m_LonTrack_E[iStack] = 0;
564  m_nTrack_E[iStack] = 0;
565  }
566 
567  for (int i = 0; i < s_Straw_max[ibe]; i++) {
568  m_nStrawHits_E[0][i] = 0; // A-side
569  m_nStrawHits_E[1][i] = 0; // C-side
570  }
571  } // doshift for phi bin init
572 
573  // Initialization of VarHandleKeys
574  ATH_CHECK( m_rdoContainerKey.initialize() );
575  ATH_CHECK( m_trackCollectionKey.initialize() );
576  ATH_CHECK( m_combTrackCollectionKey.initialize() );
577  ATH_CHECK( m_xAODEventInfoKey.initialize() );
578  ATH_CHECK( m_TRT_BCIDCollectionKey.initialize() );
579  ATH_CHECK( m_comTimeObjectKey.initialize() );
580  ATH_CHECK( m_bsErrContKey.initialize(SG::AllowEmpty) );
581  ATH_CHECK( m_trigDecisionKey.initialize(!m_trigDecisionKey.empty()) );
582 
583  ATH_MSG_INFO("My TRT_DAQ_ConditionsSvc is " << m_DAQSvc);
584 
585  return StatusCode::SUCCESS;
586 }
587 
588 
589 //------------------------------------------------------------------------------------//
590 StatusCode TRT_Monitoring_Tool::bookHistogramsRecurrent() {
591 //------------------------------------------------------------------------------------//
592  ATH_MSG_VERBOSE("Booking TRT histograms");
593 
594  if (newLumiBlockFlag()) ATH_MSG_VERBOSE("newLumiBlock");
595 
596  if (newRunFlag()) ATH_MSG_VERBOSE("newRun");
597 
598  StatusCode sc = StatusCode::SUCCESS;
599 
600  //If it is a new run check rdo and track containers.
601  if (newRunFlag()) {
602  SG::ReadHandle<TRT_RDO_Container> rdoContainer(m_rdoContainerKey);
603  SG::ReadHandle<TrackCollection> trackCollection(m_trackCollectionKey);
604 
605  if (!rdoContainer.isValid()) {
606  ATH_MSG_WARNING("No TRT_RDO_Container by the name of " <<
607  m_rdoContainerKey.key() << " in StoreGate. Skipping TRT RDO Monitoring.");
608  m_doRDOsMon = false;
609  }
610 
611  if (!trackCollection.isValid()) {
612  ATH_MSG_WARNING("No TrackCollection by the name of " <<
613  m_trackCollectionKey.key() << " in StoreGate. Skipping TRT Track Monitoring.");
614  m_doTracksMon = false;
615  }
616  }
617 
618  //Book_TRT_RDOs registers all raw data histograms
619  if (m_doRDOsMon) {
620  ATH_CHECK( bookTRTRDOs(newLumiBlockFlag(), newRunFlag()) );
621  }
622 
623  //Book_TRT_Tracks registers all tracking histograms
624  if (m_doTracksMon) {
625  sc = bookTRTTracks(newLumiBlockFlag(), newRunFlag());
626 
627  if (m_doShift) {
628  sc = bookTRTShiftTracks(newLumiBlockFlag(), newRunFlag());
629 
630  if (sc == StatusCode::FAILURE) {
631  ATH_MSG_ERROR("Unable to book trt shift tracks histograms");
632  }
633  }
634  }
635 
636  if (m_doEfficiency) {
637  sc = bookTRTEfficiency (newLumiBlockFlag(), newRunFlag());
638 
639  if (sc == StatusCode::FAILURE) {
640  ATH_MSG_ERROR("Unable to book trt efficiency");
641  }
642  }
643 
644  if (newRunFlag()) {
645  ATH_MSG_DEBUG("Begin of run");
646  }
647 
648  if (sc == StatusCode::FAILURE) {
649  ATH_MSG_ERROR("No histograms booked");
650  }
651 
652  return StatusCode::SUCCESS;
653 }
654 
655 //Book TRT Raw Data Object info (all TRT Hits).
656 //----------------------------------------------------------------------------------//
657 StatusCode TRT_Monitoring_Tool::bookTRTRDOs(bool newLumiBlock, bool newRun) {
658 //----------------------------------------------------------------------------------//
659  ATH_MSG_VERBOSE("Booking TRT RDO Histograms");
660 
661  if (newLumiBlock) ATH_MSG_VERBOSE("newLumiBlock");
662 
663  if (newRun) ATH_MSG_VERBOSE("newRun");
664 
665  StatusCode scode = StatusCode::SUCCESS;
666  std::string hName, hTitle;
667  const std::string barrel_or_endcap[2] = { "Barrel", "EndCap" };
668  const std::string be_id[2] = { "B", "E" };
669  const std::string side_id[2] = { "A", "C" };
670 
671  //Booking of some expert monitoring histograms
672  // ibe = 0 (Barrel), ibe = 1 (Endcap)
673  for (int ibe = 0; ibe < 2; ibe++) {
674  for (int i = 0; i < s_numberOfStacks[ibe] * 2; i++) {
675  std::ostringstream oss;
676 
677  if (ibe == 0) {
678  if (i < s_numberOfStacks[ibe]) {
679  oss << "TRT/Barrel/Stack" << i + 1 << "A";
680  } else if (i >= s_numberOfStacks[ibe]) {
681  oss << "TRT/Barrel/Stack" << i + 1 - 32 << "C";
682  }
683  } else if (ibe == 1) {
684  if (i < s_numberOfStacks[ibe]) {
685  oss << "TRT/EndcapA/Sector" << i + 1;
686  } else if (i >= s_numberOfStacks[ibe]) {
687  oss << "TRT/EndcapC/Sector" << i + 1 - 32;
688  }
689  }
690 
691  const std::string hPath = oss.str();
692  MonGroup rdoStackWeighted(this, hPath, run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED, "", "weightedEff");
693 
694  if (newRun && m_doExpert && m_doStraws) {
695  m_hHitWMapS[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHitWMapS", "Leading Edge in Time Window: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability per Event", scode);
696  m_hHitTrWMapS[ibe][i] = bookTProfile_LW(rdoStackWeighted, "hHitTrWMapS", "Mean Trailing Edge in Time Window: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], 0, 75, "Straw Number in Stack", "Time (ns)", scode);
697  m_hHitTrMapS[ibe][i] = bookTProfile_LW(rdoStackWeighted, "hHitTrMapS", "Mean Trailing Edge: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], 0, 75, "Straw Number in Stack", "Time (ns)", scode);
698  m_hHitAWMapS[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHitAWMapS", "LL in Time Window: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
699  m_hHitAMapS[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHitAMapS", "Any LL Bit: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
700  m_hStrawOcc[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hOccupancyS", "Straw Occupancy Distribution: Straws", 201, 0, 1.005, "Occupancy", "Number of Straws", scode);
701  m_hHitToTMapS[ibe][i] = bookTProfile_LW(rdoStackWeighted, "hHitToTMapS", "Mean ToT: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], 0, 75, "Straw Number in Stack", "Time (ns)", scode);
702  m_hHitToTLongMapS[ibe][i] = bookTProfile_LW(rdoStackWeighted, "hHitToTLongMapS", "Mean ToT for Straws with ToT > LongToTCut: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], 0, 75, "Straw Number in Stack", "Time (ns)", scode);
703  m_hHitToTLongTrMapS[ibe][i] = bookTProfile_LW(rdoStackWeighted, "hHitToTLongTrMapS", "Mean Trailing Edge for Straws with ToT > LongToTCut: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], 0, 75, "Straw Number in Stack", "Time (ns)", scode);
704  m_hHitHMapS[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHitHMapS", "Any HL Bit: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
705  m_hHitHWMapS[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHitHWMapS", "HL in Time Window: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
706  m_hHtoLMapS[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHtoLMapS", "HL/LL Ratio: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
707  }
708 
709  if (newRun && m_doExpert && m_doChips) {
710  m_hHitWMapC[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHitWMapC", "Leading Edge in Time Window: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
711  m_hHitTrMapC[ibe][i] = bookTProfile_LW(rdoStackWeighted, "hHitTrMapC", "Mean Trailing Edge: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], 0, 75, "Chip Number in Stack", "Time (ns)", scode);
712  m_hHitTrWMapC[ibe][i] = bookTProfile_LW(rdoStackWeighted, "hHitTrWMapC", "Mean Trailing Edge in Time Window: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], 0, 75, "Chip Number in Stack", "Time (ns)", scode);
713  m_hHitAWMapC[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHitAWMapC", "LL in Time Window: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
714  m_hHitAMapC[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHitAMapC", "Any LL Bit: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
715  m_hChipOcc[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hOccupancyC", "Chip Occupancy Distribution", 201, 0, 1.005, "Occupancy", "Number of Chips", scode);
716  m_hHitToTMapC[ibe][i] = bookTProfile_LW(rdoStackWeighted, "hHitToTMapC", "Mean ToT: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], 0, 75, "Chip Number in Stack", "Time (ns)", scode);
717  m_hHitHMapC[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHitHMapC", "Any HL Bit: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
718  m_hHitHWMapC[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHitHWMapC", "HL in Time Window: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
719  m_hHtoLMapC[ibe][i] = bookTH1F_LW(rdoStackWeighted, "hHtoLMapC", "HL/LL Ratio: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
720  m_hHtoBCMapC[ibe][i] = bookTH2F_LW(rdoStackWeighted, "hHtoBCMapC", "HL in BC: Chips", 3, 0, 3, s_iChip_max[ibe], 0, s_iChip_max[ibe], "Bunch Crossing ID", "Chip Number in Stack", scode);
721 
722  if (ibe == 0) {
723  m_hHtoBCMapB[ibe][i] = bookTH2F_LW(rdoStackWeighted, "hHtoBCMapB", "HL in BC: Boards", 3, 0, 3, 9, 0, 9, "Bunch Crossing ID", "Board Number in Stack", scode);
724  } else if (ibe == 1) {
725  m_hHtoBCMapB[ibe][i] = bookTH2F_LW(rdoStackWeighted, "hHtoBCMapB", "HL in BC: Boards", 3, 0, 3, 20, -0.5, 19.5, "Bunch Crossing ID", "Board Number in Stack", scode);
726  }
727  }
728  }
729  }
730 
731  //Registering Collisions Histograms
732  if (m_doShift) {
733  MonGroup rdoShiftSmry (this, "TRT/Shift/Summary", run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED);
734  MonGroup rdoShiftSmryRebinned (this, "TRT/Shift/Summary", run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED, "", "mergeRebinned");
735 
736  if (newRun) {
737  m_hSummary = bookTH1F_LW(rdoShiftSmry, "hSummary", "Run Summary", 8, 0, 8, "", "Entries", scode);
738  m_hSummary->GetXaxis()->SetBinLabel(1, "Events");
739  m_hSummary->GetXaxis()->SetBinLabel(2, "Tracks Total");
740  m_hSummary->GetXaxis()->SetBinLabel(3, "Tracks BA");
741  m_hSummary->GetXaxis()->SetBinLabel(4, "Tracks BC");
742  m_hSummary->GetXaxis()->SetBinLabel(5, "Tracks EA");
743  m_hSummary->GetXaxis()->SetBinLabel(6, "Tracks EC");
744  m_hSummary->GetXaxis()->SetBinLabel(7, "Transition Side A");
745  m_hSummary->GetXaxis()->SetBinLabel(8, "Transition Side C");
746  //lumi summary histograms
747  m_IntLum = bookTH1F_LW(rdoShiftSmry, "hIntLum", "Luminosity", 1, 0., 1., " ", "Luminosity [#mub^{1}]", scode);
748  m_LBvsLum = bookTH1F_LW(rdoShiftSmry, "hLBvsLum", "Luminosity", 2000, 0., 2000., "Luminosity Bin", "Luminosity [#mub^{1}]", scode);
749  m_LBvsTime = bookTH1F_LW(rdoShiftSmry, "hLBvsTime", "Time", 2000, 0., 2000., " Luminosity Bin", "Time [s]", scode);
750  const unsigned int maxLumiBlock = 200;
751 
752  // ibe = 0 (Barrel), ibe = 1 (Endcap)
753  // iside = 0 (A-side), iside = 1 (C-side)
754  for (int ibe = 0; ibe < 2; ibe++) {
755  for (int iside = 0; iside < 2; iside++) {
756  const std::string regionTag = " (" + be_id[ibe] + side_id[iside] + ")";
757  m_hChipBSErrorsVsLB[ibe][iside] = bookTProfile(rdoShiftSmryRebinned, "hChipBSErrorsVsLB_" + be_id[ibe] + side_id[iside], "Chip Bytestream Errors vs LB" + regionTag, maxLumiBlock + 1, -0.5, maxLumiBlock + 0.5, 0, 150.0, "Luminosity Block", "Fraction of Chips with Errors", scode);
758  m_hChipBSErrorsVsLB[ibe][iside]->SetCanExtend(TH1::kAllAxes);
759  m_hRobBSErrorsVsLB[ibe][iside] = bookTProfile(rdoShiftSmryRebinned, "hRobBSErrorsVsLB_" + be_id[ibe] + side_id[iside], "Rob Bytestream Errors vs LB" + regionTag, maxLumiBlock + 1, -0.5, maxLumiBlock + 0.5, 0, 150.0, "Luminosity Block", "Fraction of RODs with Errors", scode);
760  m_hRobBSErrorsVsLB[ibe][iside]->SetCanExtend(TH1::kAllAxes);
761  }
762  }
763 
764  // Barrel/Endcap Histograms
765  const std::string module_or_wheel[2] = { "Module", "Wheel" };
766  const std::string stack_or_sector[2] = { "Barrel Stack", "Endcap Sector" };
767  const std::string modulenum_assign2[2] = { "Modules Type 1 (1-32), Type 2 (33-64), Type 3 (65-96)", "Wheels A (1-32), B (33-64)" };
768 
769  for (int ibe = 0; ibe < 2; ibe++) {
770  const std::string regionTag = " (" + barrel_or_endcap[ibe] + ")";
771  MonGroup rdo(this, "TRT/" + barrel_or_endcap[ibe] + "/Expert", run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED);
772  MonGroup rdoShift (this, "TRT/Shift/" + barrel_or_endcap[ibe], run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED);
773  MonGroup rdoShiftTH1(this, "TRT/Shift/" + barrel_or_endcap[ibe], run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED, "", "weightedEff");
774 
775  if (ibe == 0) {
776  m_hHitWMap_B = bookTH1F_LW(rdoShiftTH1, "hHitWMap", "Leading Edge in Time Window: Xenon Straws" " (Barrel)", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
777 
778  if (m_ArgonXenonSplitter) {
779  m_hHitWMap_B_Ar = bookTH1F_LW(rdoShiftTH1, "hHitWMap_Ar", "Leading Edge in Time Window: Argon Straws (Barrel)", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
780  }
781 
782  m_hOccAll = bookTH1F_LW(rdoShift, "hOccAll", "Occupancy per Event", 400, 0.0, 1.0, "Occupancy", "Events", scode);
783  } else if (ibe == 1) {
784  m_hHitWMap_E[0] = bookTH1F_LW(rdoShiftTH1, "hHitWMap_A", "Leading Edge in Time Window: Xenon Straws" " (EA)", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
785  m_hHitWMap_E[1] = bookTH1F_LW(rdoShiftTH1, "hHitWMap_C", "Leading Edge in Time Window: Xenon Straws" " (EC)", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
786 
787  if (m_ArgonXenonSplitter) {
788  m_hHitWMap_E_Ar[0] = bookTH1F_LW(rdoShiftTH1, "hHitWMap_Ar_A", "Leading Edge in Time Window: Argon Straws" " (EA)", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
789  m_hHitWMap_E_Ar[1] = bookTH1F_LW(rdoShiftTH1, "hHitWMap_Ar_C", "Leading Edge in Time Window: Argon Straws" " (EC)", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
790  }
791  }
792 
793  m_hBCIDvsOcc[ibe] = bookTProfile_LW(rdo, "hBCIDvsOcc", "Avg. Occupancy vs BCID" + regionTag, 3565, 0, 3564, 0, 1, "Bunch Crossing ID", "Occupancy", scode);
794 
795  for (int iside = 0; iside < 2; iside++) {
796  const std::string regionTag = " (" + be_id[ibe] + side_id[iside] + ")";
797  const std::string regionMarker = (m_environment == AthenaMonManager::online) ? (be_id[ibe] + side_id[iside]) : (side_id[iside]); // for historical reasons ...
798  m_hAvgHLOcc_side[ibe][iside] = bookTProfile_LW(rdoShift, "hAvgHLOcc_" + regionMarker, "Avg. HL Occupancy" + regionTag, 32, 1, 33, 0, 1, stack_or_sector[ibe], "Occupancy", scode);
799  m_hAvgLLOcc_side[ibe][iside] = bookTProfile_LW(rdoShift, "hAvgLLOcc_" + regionMarker, "Avg. LL Occupancy" + regionTag, 32, 1, 33, 0, 1, stack_or_sector[ibe], "Occupancy", scode);
800  m_hAvgLLOccMod_side[ibe][iside] = bookTProfile_LW(rdo, "hAvgLLOccMod_" + regionMarker, "Avg. LL Occupancy: " + module_or_wheel[ibe] + "s" + regionTag, s_moduleNum[ibe], 0, s_moduleNum[ibe], 0, 1, modulenum_assign2[ibe], "Occupancy", scode);
801  m_hAvgHLOccMod_side[ibe][iside] = bookTProfile_LW(rdo, "hAvgHLOccMod_" + regionMarker, "Avg. HL Occupancy: " + module_or_wheel[ibe] + "s" + regionTag, s_moduleNum[ibe], 0, s_moduleNum[ibe], 0, 1, modulenum_assign2[ibe], "Occupancy", scode);
802  }
803  }
804  }
805  }
806 
807  ATH_MSG_VERBOSE("Finished Booking TRT RDO Histograms");
808  return scode;
809 }
810 
811 
812 //----------------------------------------------------------------------------------//
813 StatusCode TRT_Monitoring_Tool::bookTRTTracks(bool newLumiBlock, bool newRun) {
814 //----------------------------------------------------------------------------------//
815  ATH_MSG_VERBOSE("Booking TRT Track Histograms");
816 
817  if (newLumiBlock) ATH_MSG_VERBOSE("newLumiBlock");
818 
819  if (newRun) ATH_MSG_VERBOSE("newRun");
820 
821  StatusCode scode = StatusCode::SUCCESS;
822  std::string hName, hTitle;
823  const std::string barrel_or_endcap[2] = { "Barrel", "EndCap" };
824 
825  for (int ibe = 0; ibe < 2; ibe++) {
826  std::ostringstream oss_distance;
827  oss_distance << std::setprecision(3) << std::fixed << m_DistToStraw;
828  const std::string distance = oss_distance.str();
829  const std::string hPathGen = "TRT/" + barrel_or_endcap[ibe] + "/Expert";
830  const std::string regionTag = " (" + barrel_or_endcap[ibe] + ")";
831 
832  for (int i = 0; i < s_numberOfStacks[ibe] * 2; i++) {
833  std::ostringstream oss;
834 
835  if (ibe == 0) {
836  if (i < s_numberOfStacks[ibe]) {
837  oss << "TRT/Barrel/Stack" << i + 1 << "A";
838  } else if (i >= s_numberOfStacks[ibe]) {
839  oss << "TRT/Barrel/Stack" << i + 1 - 32 << "C";
840  }
841  } else if (ibe == 1) {
842  if (i < s_numberOfStacks[ibe]) {
843  oss << "TRT/EndcapA/Sector" << i + 1;
844  } else if (i >= s_numberOfStacks[ibe]) {
845  oss << "TRT/EndcapC/Sector" << i + 1 - 32;
846  }
847  }
848 
849  const std::string hPath = oss.str();
850  MonGroup trackStackWeighted(this, hPath, run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED, "", "weightedEff");
851 
852  if (newRun && m_doExpert && m_doStraws) {
853  m_hHitWonTMapS[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitWonTMapS", "Leading Edge on Track in Time Window: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
854  m_hHitTronTMapS[ibe][i] = bookTProfile_LW(trackStackWeighted, "hHitTronTMapS", "Mean Trailing Edge on Track: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], 0, 75.0, "Straw Number in Stack", "Time (ns)", scode);
855  m_hHitAonTMapS[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitAonTMapS", "Any LL Bit on Track: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
856  m_hStrawsEff[ibe][i] = bookTProfile_LW(trackStackWeighted, "hEfficiencyS", "Straw Efficiency with " + distance + " mm Cut", s_Straw_max[ibe], 0, s_Straw_max[ibe], 0.0, 1.0, "Straw Number in Stack", "Efficiency", scode);
857  m_hHitAWonTMapS[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitAWonTMapS", "Any LL Bit on Track in Time Window: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
858  m_hHitHonTMapS[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitHonTMapS", "HL Hit on Track: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
859  m_hHitHWonTMapS[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitHWonTMapS", "HL Hit(In Time Window) on Track: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
860  m_hHitAWonTMapS[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitAWonTMapS", "Any LL Bit on Track in Time Window: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
861  m_hHitToTonTMapS[ibe][i] = bookTProfile_LW(trackStackWeighted, "hHitToTonTMapS", "Mean ToT on Track: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], 0, 75, "Straw Number in Stack", "Time (ns)", scode);
862  m_hValidRawDriftTimeonTrk[ibe][i] = bookTProfile_LW(trackStackWeighted, "hValidRawDriftTimeonTrkS", "Valid Raw Drift Time on Track: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], 0, 75, "Straw Number in Stack", "Time (ns)", scode);
863  m_hHtoLonTMapS[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHtoLonTMapS", "HL/LL Ratio on Track: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
864  m_hHtoLWonTMapS[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHtoLWonTMapS", "HL/LL (In Time Window) Ratio on Track: Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Probability", scode);
865  m_hHitTronTwEPCMapS[ibe][i] = bookTProfile_LW(trackStackWeighted, "hHitTronTwEPCMapS", "Mean Trailing Edge on Track (with Event Phase Correction): Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], -50, 75, "Straw Number in Stack", "Time (ns)", scode);
866  m_hHitOnTrackVsAllS[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitonTrackVAllS", "(Hit on Track) / (Any LL Bit): Straws", s_Straw_max[ibe], 0, s_Straw_max[ibe], "Straw Number in Stack", "Ratio", scode);
867  }
868 
869  if (newRun && m_doExpert && m_doChips) {
870  m_hHitWonTMapC[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitWonTMapC", "Leading Edge on Track in Time Window: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
871  m_hHitTronTMapC[ibe][i] = bookTProfile_LW(trackStackWeighted, "hHitTronTMapC", "Mean Trailing Edge on Track: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], 0, 75, "Chip Number in Stack", "Time (ns)", scode);
872  m_hHitAonTMapC[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitAonTMapC", "Any LL Bit on Track: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
873  m_hChipsEff[ibe][i] = bookTProfile_LW(trackStackWeighted, "hEfficiencyC", "Chip Efficiency with " + distance + " mm Cut", s_iChip_max[ibe], 0, s_iChip_max[ibe], 0.0, 1.0, "Chip Number in Stack", "Efficiency", scode);
874  m_hHitAWonTMapC[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitAWonTMapC", "Any LL Bit on Track in Time Window: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
875  m_hHitHonTMapC[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitHonTMapC", "HL Hit on Track: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
876  m_hHitHWonTMapC[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitHWonTMapC", "HL Hit(In time Window) on Track: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
877  m_hHitToTonTMapC[ibe][i] = bookTProfile_LW(trackStackWeighted, "hHitToTonTMapC", "Mean ToT on Track: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], 0, 75, "Chip Number in Stack", "Time (ns)", scode);
878  m_hValidRawDriftTimeonTrkC[ibe][i] = bookTProfile_LW(trackStackWeighted, "hValidRawDriftTimeonTrkC", "Valid Raw Drift Time on Track: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], 0, 75, "Chip Number in Stack", "Time (ns)", scode);
879  m_hHtoLonTMapC[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHtoLonTMapC", "HL/LL Ratio on Track: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
880  m_hHtoLWonTMapC[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHtoLWonTMapC", "HL/LL(In Time Window) Ratio on Track: Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Probability", scode);
881  m_hHitTronTwEPCMapC[ibe][i] = bookTProfile_LW(trackStackWeighted, "hHitTronTwEPCMapC", "Mean Trailing Edge on Track (with Event Phase Correction): Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], -50, 75, "Chip Number in Stack", "Time (ns)", scode);
882  m_hHitOnTrackVsAllC[ibe][i] = bookTH1F_LW(trackStackWeighted, "hHitonTrackVAllC", "(Hit on Track) / (Any LL Bit): Chips", s_iChip_max[ibe], 0, s_iChip_max[ibe], "Chip Number in Stack", "Ratio", scode);
883  }
884  }
885  }
886 
887  ATH_MSG_VERBOSE("Booked TRT Track Histograms successfully");
888  return scode;
889 }
890 
891 
892 //----------------------------------------------------------------------------------//
893 StatusCode TRT_Monitoring_Tool::bookTRTEfficiency(bool newLumiBlock, bool newRun) {
894 //----------------------------------------------------------------------------------//
895  StatusCode scode = StatusCode::SUCCESS;
896 
897  if (newLumiBlock) {}
898 
899  if (newRun) {
900  std::string hName, hTitle;
901  const std::string barrel_or_endcap[2] = { "Barrel", "EndCap" };
902  const std::string be_id[2] = { "B", "E" };
903  const std::string side_id[2] = { "A", "C" };
904  MonGroup trackShiftEff(this, "TRT/Efficiency", run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED);
905  m_hefficiency_eta = bookTProfile_LW(trackShiftEff, "hEfficiency_eta", "Efficiency vs #eta", 50, -2.8, 2.8, 0, 1, "#eta", "Efficiency", scode);
906  m_hefficiency_phi = bookTProfile_LW(trackShiftEff, "hEfficiency_phi", "Efficiency vs #phi", 50, -3.2, 3.2, 0, 1, "#phi (deg)", "Efficiency", scode);
907  m_hefficiency_pt = bookTProfile_LW(trackShiftEff, "hEfficiency_pt", "Efficiency vs pT", 50, 0, 10, 0, 1, "pT (GeV)", "Efficiency", scode);
908  m_hefficiency_z0 = bookTProfile_LW(trackShiftEff, "hEfficiency_z0", "Efficiency vs z0", 50, -200, 200, 0, 1, "z0", "Efficiency", scode);
909  m_hefficiencyBarrel_locR = bookTProfile_LW(trackShiftEff, "hEfficiencyBarrel_locR", "Efficiency vs Track-to-Wire Distance for Xenon Straws" " (Barrel)", 50, -2.5, 2.5, 0, 1, "Track-to-Wire Distance (mm)", "Efficiency", scode);
910  m_hefficiencyBarrel_locR_Ar = bookTProfile_LW(trackShiftEff, "hEfficiencyBarrel_locR_Ar", "Efficiency vs Track-to-Wire Distance for Argon Straws" " (Barrel)", 50, -2.5, 2.5, 0, 1, "Track-to-Wire Distance (mm)", "Efficiency", scode);
911  m_hefficiencyMap[0] = bookTProfile_LW(trackShiftEff, "hEfficiencyBarrelMap", "Straw Efficiency Map" " (Barrel)", s_Straw_max[0], 0, s_Straw_max[0], 0, 1, "Straw Number", "Efficiency", scode);
912  m_hefficiencyMap[1] = bookTProfile_LW(trackShiftEff, "hEfficiencyEndCapMap", "Straw Efficiency Map" " (Endcap)", s_Straw_max[1], 0, s_Straw_max[1], 0, 1, "Straw Number", "Efficiency", scode);
913 
914  for (int iside = 0; iside < 2; iside++) {
915  const std::string regionTag = " (" + be_id[1] + side_id[iside] + ")";
916  m_hefficiencyEndCap_locR[iside] = bookTProfile_LW(trackShiftEff, "hEfficiencyEndCap" + side_id[iside] + "_locR", "Efficiency vs Track-to-Wire Distance for Xenon Straws" + regionTag, 50, -2.5, 2.5, 0, 1, "Track-to-Wire Distance (mm)", "Efficiency", scode);
917  m_hefficiencyEndCap_locR_Ar[iside] = bookTProfile_LW(trackShiftEff, "hEfficiencyEndCap" + side_id[iside] + "_locR_Ar", "Efficiency vs Track-to-Wire Distance for Argon Straws" + regionTag, 50, -2.5, 2.5, 0, 1, "Track-to-Wire Distance (mm)", "Efficiency", scode);
918  }
919 
920  for (int ibe = 0; ibe < 2; ibe++) {
921  for (int iside = 0; iside < 2; iside++) {
922  const std::string regionTag = " (" + be_id[ibe] + side_id[iside] + ")";
923  MonGroup trackShiftEffWeighted(this, "TRT/Efficiency", run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED, "", "weightedEff");
924  m_hefficiency[ibe][iside] = bookTH1F_LW(trackShiftEffWeighted, "hEfficiency" + barrel_or_endcap[ibe] + side_id[iside], "Straw Efficiency" + regionTag, 500, -0.01, 1.01, "Efficiency", "Number of Straws", scode);
925  m_hefficiencyIntegral[ibe][iside] = bookTH1F_LW(trackShiftEffWeighted, "hEfficiencyIntegral" + barrel_or_endcap[ibe] + side_id[iside], "Straw Efficiency Integral" + regionTag, 500, -0.01, 1.01, "Efficiency", "Fraction of Straws", scode);
926 
927  if (m_doExpert) {
928  int imintmp = s_numberOfBarrelStacks * iside;
929  int imaxtmp = s_numberOfBarrelStacks * (iside + 1);
930 
931  for (int i = imintmp; i < imaxtmp; i++) {
932  std::ostringstream oss;
933 
934  if (ibe == 0) {
935  oss << "TRT/Barrel/Stack" << (i + 1 - 32 * iside) << side_id[iside];
936  } else if (ibe == 1) {
937  oss << "TRT/Endcap" << side_id[iside] << "/Sector" << (i + 1 - 32 * iside);
938  }
939 
940  const std::string hPath = oss.str();
941  MonGroup trackStack(this, hPath, run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED);
942  m_hefficiencyS[ibe][i] = bookTProfile_LW(trackStack, "hHitEfficiencyS", "Straw Efficiency Map", s_Straw_max[ibe], 0.5, s_Straw_max[ibe] + 0.5, 0, 1, "Straw Number", "Efficiency", scode);
943  m_hefficiencyC[ibe][i] = bookTProfile_LW(trackStack, "hHitEfficiencyC", "Chip Efficiency Map", s_iChip_max[ibe], 0.5, s_iChip_max[ibe] + 0.5, 0, 1, "Chip Number", "Efficiency", scode);
944  }
945  }
946  }
947  }
948  }
949 
950  return scode;
951 }
952 
953 //----------------------------------------------------------------------------------//
954 StatusCode TRT_Monitoring_Tool::bookTRTShiftTracks(bool newLumiBlock, bool newRun) {
955 //----------------------------------------------------------------------------------//
956  ATH_MSG_VERBOSE("Booking TRT Track Histograms");
957 
958  if (newLumiBlock) ATH_MSG_VERBOSE("newLumiBlock");
959 
960  if (newRun) ATH_MSG_VERBOSE("newRun");
961 
962  std::string hName, hTitle;
963  std::ostringstream oss_distance;
964  oss_distance << std::setprecision(3) << std::fixed << m_DistToStraw;
965  const std::string distance = oss_distance.str();
966  StatusCode scode = StatusCode::SUCCESS;
967  //create several histogram directories.
968  MonGroup trackBarrelShiftTProf(this, "TRT/Shift/Barrel", run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED);
969  MonGroup trackBarrelDiag(this, "TRT/Barrel/Diagnostics", run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED);
970  const std::string barrel_or_endcap[2] = { "Barrel", "EndCap" };
971  const std::string be_id[2] = { "B", "E" };
972  const std::string side_id[2] = { "A", "C" };
973  const int maxLumiblock = 720;
974  //Arrays for Aging
975  const std::string gas[4] = { "in_A", "in_B", "out_A", "out_B"};
976  const std::string Mod[5] = {"1", "2", "3", "shortP", "shortN"};
977 
978  for (int ibe = 0; ibe < 2; ibe++) {
979  const std::string regionTag = " (" + barrel_or_endcap[ibe] + ")";
980  MonGroup trackShift(this, "TRT/Shift/" + barrel_or_endcap[ibe], run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED);
981  MonGroup trackShiftRebinned(this, "TRT/Shift/" + barrel_or_endcap[ibe], run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED, "", "mergeRebinned");
982  MonGroup trackShiftTH1(this, "TRT/Shift/" + barrel_or_endcap[ibe], run, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED, "", "weightedEff");
983  MonGroup trackShiftTH1_lowStat(this, "TRT/Shift/" + barrel_or_endcap[ibe], lowStat, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED, "", "weightedEff");
984  MonGroup trackAging(this, "TRT/Aging/" + barrel_or_endcap[ibe], lowStat, ManagedMonitorToolBase::MgmtAttr_t::ATTRIB_UNMANAGED);
985 
986  if (newRun && m_doShift) {
987  if (ibe == 0) {
988  m_hEvtPhase = bookTH1F_LW(trackShift, "hEvtPhase", "Event Phase Correction Factor", 200, -50, 50, "Event Phase (ns)", "Entries", scode);
989  m_hEvtPhaseVsTrig = bookTH2F_LW(trackShift, "hEvtPhaseVsTrig", "Event Phase vs L1 Trigger Item", 300, -200, 100, 256, -0.5, 255.5, "Event Phase (ns)", "L1 Trigger Item", scode);
990  m_hEvtPhaseDetPhi_B = bookTProfile_LW(trackShift, "hEvtPhaseDetPhi", "Event Phase vs #phi (2D)" + regionTag, m_nphi_bins, 0, 360, -50, 100., "#phi (deg)", "Event Phase from Tracks per Event", scode);
991  m_hrtRelation_B = bookTH2F_LW(trackShift, "hrtRelation", "R(t) Relation for Xenon Straws" + regionTag, 30, -12.5, 81.25, 50, 0, 2.5, "Measured Leading Edge (ns)", "Track-to-Wire Distance (mm)", scode);
992  m_hNumHoTDetPhi_B = bookTProfile_LW(trackShift, "hNumHoTDetPhi", "Number of Hits per Track with " + distance + " mm Cut vs #phi" + regionTag, m_nphi_bins, 0., 360, 0, 150, "#phi (deg)", Form("Hits per Track, TRT Hits >= %d", m_minTRThits), scode);
993  m_hTronTDist_B = bookTH1F_LW(trackShiftTH1, "hTronTDist", "Trailing Edge Distribution on Track for Xenon Straws" + regionTag, 26, -0.5, 80.75, "Trailing Edge (ns)", "Norm. Entries", scode);
994  m_hDriftTimeonTrkDist_B = bookTH1F_LW(trackShiftTH1, "hDriftTimeonTrkDist", "Drift Time Distribution on Track for Xenon Straws" + regionTag, 32, 0, 100., "Drift Time (ns)", "Norm. Entries", scode);
995  m_hNumTrksDetPhi_B = bookTH1F_LW(trackShift, "hNumTrksDetPhi", "Number of Reconstructed Tracks vs #phi (2D)" + regionTag, 60, 0, 360, "#phi (deg)", "Number of Tracks", scode);
996 
997  if (m_ArgonXenonSplitter) {
998  m_hDriftTimeonTrkDist_B_Ar = bookTH1F_LW(trackShiftTH1, "hDriftTimeonTrkDist_Ar", "Drift Time Distribution on Track for Argon Straws" + regionTag, 32, 0, 100., "Drift Time (ns)", "Norm. Entries", scode);
999  m_hTronTDist_B_Ar = bookTH1F_LW(trackShiftTH1, "hTronTDist_Ar", "Trailing Edge Distribution on Track for Argon Straws" + regionTag, 26, -0.5, 80.75, "Trailing Edge (ns)", "Norm. Entries", scode);
1000  m_hrtRelation_B_Ar = bookTH2F_LW(trackShift, "hrtRelation_Ar", "R(t) Relation for Argon Straws" + regionTag, 30, -12.5, 81.25, 50, 0, 2.5, "Measured Leading Edge (ns)", "Track-to-Wire Distance (mm)", scode);
1001  m_Pull_Biased_Barrel = bookTH1F_LW(trackShift, "hPull_Biased_Barrel", "Biased Track Pulls for Barrel Hits", 200, -2.5, 2.5, "Pulls", "Entries", scode);
1002  m_hResidual_B_Ar = bookTH1F_LW(trackShiftTH1_lowStat, "hResidual_Ar", "Residuals for Argon Straws" + regionTag, 200, -2.5, 2.5, "Hit-to-Track Distance (mm)", "Norm. Entries", scode);
1003  m_hResidual_B_Ar_20GeV = bookTH1F_LW(trackShiftTH1, "hResidual_Ar_20GeV", "Residuals for Argon Straws" + regionTag + "(After 20GeV pT cut)", 200, -2.5, 2.5, "Hit-to-Track Distance (mm)", "Norm. Entries", scode);
1004  m_hAvgTroTDetPhi_B_Ar = bookTProfile_LW(trackShift, "hAvgTroTDetPhi_Ar", "Avg. Trailing Edge on Track vs #phi (2D) for Argon" + regionTag, m_nphi_bins, 0, 360, 0, 75., "#phi (deg)", "Trailing Edge (ns)", scode);
1005  m_hTimeResidual_B_Ar = bookTH1F_LW(trackShiftTH1, "hTimeResidual_Ar", "Time Residuals for Argon Straws" + regionTag, 200, -20, 20, "Time Residual (ns)", "Norm. Entries", scode);
1006  m_hWireToTrkPosition_B_Ar = bookTH1F_LW(trackShiftTH1, "hWireToTrkPosition_Ar", "Track-to-Wire Distance for Argon" + regionTag, 100, -5., 5, "Track-to-Wire Distance (mm)", "Norm. Entries", scode);
1007  m_hHtoLRatioOnTrack_B_Ar = bookTH1F_LW(trackShiftTH1, "hHtoLRatioOnTrack_Ar", "HL/LL Ratio per Reconstructed Track for Argon" + regionTag, 50, 0, 1, "HL/LL Ratio", "Norm. Entries", scode); //for argon
1008  }
1009 
1010  m_hHtoLRatioOnTrack_B_Xe = bookTH1F_LW(trackShiftTH1, "hHtoLRatioOnTrack_Xe", "HL/LL Ratio per Reconstructed Track for Xenon" + regionTag, 50, 0, 1, "HL/LL Ratio", "Norm. Entries", scode); //for xenon
1011  m_hResidual_B = bookTH1F_LW(trackShiftTH1_lowStat, "hResidual", "Residuals for Xenon Straws" + regionTag, 200, -2.5, 2.5, "Hit-to-Track Distance (mm)", "Norm. Entries", scode);
1012  m_hResidual_B_20GeV = bookTH1F_LW(trackShiftTH1, "hResidual_20GeV", "Residuals for Xenon Straws" + regionTag + "(After 20GeV pT cut)", 200, -2.5, 2.5, "Hit-to-Track Distance (mm)", "Norm. Entries", scode);
1013  m_hTimeResidual_B = bookTH1F_LW(trackShiftTH1, "hTimeResidual", "Time Residuals for Xenon Straws" + regionTag, 200, -20, 20, "Time Residual (ns)", "Norm. Entries", scode);
1014  m_hWireToTrkPosition_B = bookTH1F_LW(trackShiftTH1, "hWireToTrkPosition", "Track-to-Wire Distance for Xenon" + regionTag, 100, -5., 5, "Track-to-Wire Distance (mm)", "Norm. Entries", scode);
1015  m_hNumSwLLWoT_B = bookTH1F_LW(trackShiftTH1, "hNumSwLLWoT", "Number of Straws with Hits on Track in Time Window" + regionTag, 150, 0, 150, "Number of LL Hits per Track", "Norm. Entries", scode);
1016  m_hAvgTroTDetPhi_B = bookTProfile_LW(trackShift, "hAvgTroTDetPhi", "Avg. Trailing Edge on Track vs #phi (2D) for Xenon" + regionTag, m_nphi_bins, 0, 360, 0, 75., "#phi (deg)", "Trailing Edge (ns)", scode);
1017  m_hNTrksperLB_B = bookTProfile(trackShiftRebinned, "hNTrksperLB", "Avg. Number of Reconstructed Tracks per Event" + regionTag, maxLumiblock, -0.5, maxLumiblock - 0.5, 0, 150.0, "Luminosity Block", "Number of Tracks", scode);
1018  m_hNTrksperLB_B->SetCanExtend(TH1::kAllAxes);
1019  m_hNHitsperLB_B = bookTProfile(trackShiftRebinned, "hNHitsperLB", "Avg. Occupancy" + regionTag, maxLumiblock, -0.5, maxLumiblock - 0.5, 0, 150.0, "Luminosity Block", "Occupancy", scode);
1020  m_hNHitsperLB_B->SetCanExtend(TH1::kAllAxes);
1021  m_hNHLHitsperLB_B = bookTProfile(trackShiftRebinned, "hNHLHitsperLB", "Avg. HL Occupancy" + regionTag, maxLumiblock, -0.5, maxLumiblock - 0.5, 0, 150.0, "Luminosity Block", "Occupancy", scode);
1022  m_hNHLHitsperLB_B->SetCanExtend(TH1::kAllAxes);
1023  m_hHLhitOnTrack_B = bookTH1F_LW(trackShiftTH1, "hHLhitOnTrack", "Number of HL Hits per Reconstructed Track" + regionTag, 50, 0, 50, "Number of HL Hits per Track", "Norm. Entries", scode);
1024  m_hHtoLRatioOnTrack_B = bookTH1F_LW(trackShiftTH1, "hHtoLRatioOnTrack", "HL/LL Ratio per Reconstructed Track for All" + regionTag, 50, 0, 1, "HL/LL Ratio", "Norm. Entries", scode);
1025  m_hHitWonTMap_B = bookTH1F_LW(trackShiftTH1, "hHitWonTMap", "Leading Edge in Time Window per Reconstructed Track" + regionTag, s_Straw_max[0], 0, s_Straw_max[0], "Straw Number", "Norm. Entries", scode);
1026  m_hStrawEffDetPhi_B = bookTProfile_LW(trackShift, "hStrawEffDetPhi", "Straw Efficiency on Track with " + distance + " mm Cut vs #phi(2D)" + regionTag, 32, 0, 32, 0, 1.2, "Stack", "Avg. Straw Efficiency", scode);
1027  } else if (ibe == 1) {
1028  m_Pull_Biased_EndCap = bookTH1F_LW(trackShift, "hPull_Biased_EndCap", "Biased Track Pulls for EndCap Hits", 200, -2.5, 2.5, "Pulls", "Entries", scode);
1029 
1030  for (int iside = 0; iside < 2; iside++) {
1031  const std::string regionTag = " (" + be_id[ibe] + side_id[iside] + ")";
1032  m_hEvtPhaseDetPhi_E[iside] = bookTProfile_LW(trackShift, "hEvtPhaseDetPhi_" + side_id[iside], "Event Phase vs #phi (2D)" + regionTag, m_nphi_bins, 0, 360, -50, 100, "#phi (deg)", "Event Phase from Tracks per Event", scode);
1033  m_hrtRelation_E[iside] = bookTH2F_LW(trackShift, "hrtRelation_" + side_id[iside], "R(t) Relation for Xenon Straws" + regionTag, 30, -12.5, 81.25, 50, 0, 2.5, "Measured Leading Edge (ns)", "Track-to-Wire Distance (mm)", scode);
1034  m_hNumHoTDetPhi_E[iside] = bookTProfile_LW(trackShift, "hNumHoTDetPhi_" + side_id[iside], "Number of Hits per Track with " + distance + " mm Cut vs #phi" + regionTag, m_nphi_bins, 0., 360, 0, 150, "#phi (deg)", Form("Hits per Track, TRT Hits> = %d", m_minTRThits), scode);
1035  m_hTronTDist_E[iside] = bookTH1F_LW(trackShiftTH1, "hTronTDist_" + side_id[iside], "Trailing Edge Distribution on Track for Xenon Straws" + regionTag, 26, -0.5, 80.75, "Trailing Edge (ns)", "Norm. Entries", scode);
1036  m_hDriftTimeonTrkDist_E[iside] = bookTH1F_LW(trackShiftTH1, "hDriftTimeonTrkDist_" + side_id[iside], "Drift Time Distribution on Track for Xenon Straws" + regionTag, 32, 0, 100, "Drift Time (ns)", "Norm. Entries", scode);
1037  m_hNumTrksDetPhi_E[iside] = bookTH1F_LW(trackShift, "hNumTrksDetPhi_" + side_id[iside], "Number of Reconstructed Tracks vs #phi (2D)" + regionTag, 60, 0, 360, "#phi (deg)", "Number of Tracks", scode);
1038  m_hResidual_E[iside] = bookTH1F_LW(trackShiftTH1_lowStat, "hResidual_" + side_id[iside], "Residuals for Xenon Straws" + regionTag, 200, -2.5, 2.5, "Hit-to-Track Distance (mm)", "Norm. Entries", scode);
1039  m_hResidual_E_20GeV[iside] = bookTH1F_LW(trackShiftTH1, "hResidual_" + side_id[iside] + "_20GeV", "Residuals for Xenon Straws" + regionTag + "(After 20GeV pT cut)", 200, -2.5, 2.5, "Hit-to-Track Distance (mm)", "Norm. Entries", scode);
1040  m_hTimeResidual_E[iside] = bookTH1F_LW(trackShiftTH1, "hTimeResidual_" + side_id[iside], "Time Residuals for Xenon Straws" + regionTag, 200, -20, 20, "Time Residual (ns)", "Norm. Entries", scode);
1041 
1042  if (m_ArgonXenonSplitter) {
1043  m_hTronTDist_E_Ar[iside] = bookTH1F_LW(trackShiftTH1, "hTronTDist_Ar_" + side_id[iside], "Trailing Edge Distribution on Track for Argon Straws" + regionTag, 26, -0.5, 80.75, "Trailing Edge (ns)", "Norm. Entries", scode);
1044  m_hAvgTroTDetPhi_E_Ar[iside] = bookTProfile_LW(trackShift, "hAvgTroTDetPhi_Ar_" + side_id[iside], "Avg. Trailing Edge on Track vs #phi (2D) for Argon" + regionTag, m_nphi_bins, 0, 360, 0, 75., "#phi (deg)", "Trailing Edge (ns)", scode);
1045  m_hrtRelation_E_Ar[iside] = bookTH2F_LW(trackShift, "hrtRelation_Ar_" + side_id[iside], "R(t) Relation for Argon Straws" + regionTag, 30, -12.5, 81.25, 50, 0, 2.5, "Measured Leading Edge (ns)", "Track-to-Wire Distance (mm)", scode);
1046  m_hDriftTimeonTrkDist_E_Ar[iside] = bookTH1F_LW(trackShiftTH1, "hDriftTimeonTrkDist_Ar_" + side_id[iside], "Drift Time Distribution on Track for Argon Straws" + regionTag, 32, 0, 100, "Drift Time (ns)", "Norm. Entries", scode);
1047  m_hResidual_E_Ar[iside] = bookTH1F_LW(trackShiftTH1_lowStat, "hResidual_Ar_" + side_id[iside], "Residuals for Argon Straws" + regionTag, 200, -2.5, 2.5, "Hit-to-Track Distance (mm)", "Norm. Entries", scode);
1048  m_hResidual_E_Ar_20GeV[iside] = bookTH1F_LW(trackShiftTH1, "hResidual_Ar_" + side_id[iside] + "_20GeV", "Residuals for Argon Straws" + regionTag + "(After 20GeV pT cut)", 200, -2.5, 2.5, "Hit-to-Track Distance (mm)", "Norm. Entries", scode);
1049  m_hTimeResidual_E_Ar[iside] = bookTH1F_LW(trackShiftTH1, "hTimeResidual_Ar_" + side_id[iside], "Time Residuals for Argon Straws" + regionTag, 200, -20, 20, "Time Residual (ns)", "Norm. Entries", scode);
1050  m_hWireToTrkPosition_E_Ar[iside] = bookTH1F_LW(trackShiftTH1, "hWireToTrkPosition_Ar_" + side_id[iside], "Track-to-Wire Distance for Argon" + regionTag, 100, -5., 5, "Track-to-Wire Distance (mm)", "Norm. Entries", scode);
1051  m_hHtoLRatioOnTrack_E_Ar[iside] = bookTH1F_LW(trackShiftTH1, "hHtoLRatioOnTrack_Ar_" + side_id[iside], "HL/LL Ratio per Reconstructed Track for Argon" + regionTag, 50, 0, 1.0, "HL/LL Ratio", "Norm. Entries", scode);
1052  }
1053 
1054  m_hHtoLRatioOnTrack_E_Xe[iside] = bookTH1F_LW(trackShiftTH1, "hHtoLRatioOnTrack_Xe_" + side_id[iside], "HL/LL Ratio per Reconstructed Track for Xenon" + regionTag, 50, 0, 1.0, "HL/LL Ratio", "Norm. Entries", scode);
1055  m_hWireToTrkPosition_E[iside] = bookTH1F_LW(trackShiftTH1, "hWireToTrkPosition_" + side_id[iside], "Track-to-Wire Distance for Xenon" + regionTag, 100, -5., 5, "Track-to-Wire Distance (mm)", "Norm. Entries", scode);
1056  m_hNumSwLLWoT_E[iside] = bookTH1F_LW(trackShiftTH1, "hNumSwLLWoT_" + side_id[iside], "Number of Straws with Hits on Track in Time Window" + regionTag, 150, 0, 150, "Number of LL Hits per Track", "Norm. Entries", scode);
1057  m_hAvgTroTDetPhi_E[iside] = bookTProfile_LW(trackShift, "hAvgTroTDetPhi_" + side_id[iside], "Avg. Trailing Edge on Track vs #phi (2D) for Xenon" + regionTag, m_nphi_bins, 0, 360, 0, 75., "#phi (deg)", "Trailing Edge (ns)", scode);
1058  m_hNTrksperLB_E[iside] = bookTProfile(trackShiftRebinned, "hNTrksperLB_" + side_id[iside], "Avg. Number of Reconstructed Tracks per Event" + regionTag, maxLumiblock, -0.5, maxLumiblock - 0.5, 0, 150.0, "Luminosity Block", "Number of Tracks", scode);
1059  m_hNTrksperLB_E[iside]->SetCanExtend(TH1::kAllAxes);
1060  m_hNHitsperLB_E[iside] = bookTProfile(trackShiftRebinned, "hNHitsperLB_" + side_id[iside], "Avg. Occupancy" + regionTag, maxLumiblock, -0.5, maxLumiblock - 0.5, 0, 150.0, "Luminosity Block", "Occupancy", scode);
1061  m_hNHitsperLB_E[iside]->SetCanExtend(TH1::kAllAxes);
1062  m_hNHLHitsperLB_E[iside] = bookTProfile(trackShiftRebinned, "hNHLHitsperLB_" + side_id[iside], "Avg. HL Occupancy" + regionTag, maxLumiblock, -0.5, maxLumiblock - 0.5, 0, 150.0, "Luminosity Block", "Occupancy", scode);
1063  m_hNHLHitsperLB_E[iside]->SetCanExtend(TH1::kAllAxes);
1064  m_hHLhitOnTrack_E[iside] = bookTH1F_LW(trackShiftTH1, "hHLhitOnTrack_" + side_id[iside], "Number of HL Hits per Reconstructed Track" + regionTag, 50, 0, 50, "Number of HL Hits per Track", "Norm. Entries", scode);
1065  m_hHtoLRatioOnTrack_E[iside] = bookTH1F_LW(trackShiftTH1, "hHtoLRatioOnTrack_" + side_id[iside], "HL/LL Ratio per Reconstructed Track for All" + regionTag, 50, 0, 1.0, "HL/LL Ratio", "Norm. Entries", scode);
1066  m_hHitWonTMap_E[iside] = bookTH1F_LW(trackShiftTH1, "hHitWonTMap_" + side_id[iside], "Leading Edge in Time Window per Reconstructed Track" + regionTag, s_Straw_max[1], 0, s_Straw_max[1], "Straw Number", "Norm. Entries", scode);
1067  m_hStrawEffDetPhi_E[iside] = bookTProfile_LW(trackShift, "hStrawEffDetPhi_" + side_id[iside], "Straw Efficiency on Track with " + distance + " mm Cut vs #phi(2D)" + regionTag, 32, 0, 32, 0, 1.2, "Stack", "Avg. Straw Efficiency", scode);
1068  }
1069  }
1070 
1071  m_hHitsOnTrack_Scatter[ibe] = bookTH2F_LW(trackShift, "m_hHitsOnTrack_Scatter", "Hits per Track in Time Window in Stacks" + regionTag, 1440, -0.5, 1440 - 0.5, 80, 0, 80, "Luminosity Block (mod 1440)", "Number of Hits per Track in Stacks", scode);
1072  m_hLLOcc_Scatter[ibe] = bookTH2F_LW(trackShift, "m_hLLOcc_Scatter", "LL Occupancy in Stacks" + regionTag, 1440, -0.5, 1440 - 0.5, 400, 0.0, 1.0, "Luminosity Block (mod 1440)", "LL Occupancy in Stacks", scode);
1073  m_hHightoLowRatioOnTrack_Scatter[ibe] = bookTH2F_LW(trackShift, "m_hHightoLowRatioOnTrack_Scatter", "HL/LL Ratio on Track in Stacks" + regionTag, 1440, -0.5, 1440 - 0.5, 40, 0.0, 0.5, "Luminosity Block (mod 1440)", "HL/LL Ratio in Stacks", scode);
1074  }
1075 
1076  //Initialize Aging plots
1077  if (newLumiBlock && m_doShift) {
1078  for (int iL = 0; iL < 5; iL++) {
1079  for (int iSide = 0; iSide < 2; iSide++) {
1080  if (ibe == 0) {
1081  if (iL < 3) {
1082  m_trackz_All[iL][iSide] = bookTH1F_LW(trackAging, "trackz_m" + Mod[iL] + "_" + side_id[iSide] + "_All", "Number All Hits side " + side_id[iSide] + " Layer " + Mod[iL], 30, -750., 750., "z [mm]", "Number of Hits", scode);
1083  m_trackz_HT[iL][iSide] = bookTH1F_LW(trackAging, "trackz_m" + Mod[iL] + "_" + side_id[iSide] + "_HT", "Number HT Hits side " + side_id[iSide] + " Layer " + Mod[iL], 30, -750., 750., "z [mm]", "Number of HT Hits", scode);
1084  }
1085 
1086  if (iL == 3) {
1087  m_trackz_All[iL][iSide] = bookTH1F_LW(trackAging, "trackz_m1_" + side_id[iSide] + "_All_" + Mod[iL], "Number All Hits side " + side_id[iSide] + " Layer 1 " + Mod[iL], 30, 0., 725., "z [mm]", "Number of Hits", scode);
1088  m_trackz_HT[iL][iSide] = bookTH1F_LW(trackAging, "trackz_m1_" + side_id[iSide] + "_HT_" + Mod[iL], "Number HT Hits side " + side_id[iSide] + " Layer 1 " + Mod[iL], 30, 0., 725., "z [mm]", "Number of HT Hits", scode);
1089  }
1090 
1091  if (iL == 4) {
1092  m_trackz_All[iL][iSide] = bookTH1F_LW(trackAging, "trackz_m1_" + side_id[iSide] + "_All_" + Mod[iL], "Number All Hits side " + side_id[iSide] + " Layer 1 " + Mod[iL], 30, -725., 0., "z [mm]", "Number of Hits", scode);
1093  m_trackz_HT[iL][iSide] = bookTH1F_LW(trackAging, "trackz_m1_" + side_id[iSide] + "_HT_" + Mod[iL], "Number HT Hits side " + side_id[iSide] + " Layer 1 " + Mod[iL], 30, -725., 0., "z [mm]", "Number of HT Hits", scode);
1094  }
1095  } else if (ibe == 1) {
1096  // prevent double booking of histograms here
1097  if (iL < 4) {
1098  m_trackr_All[iL][iSide] = bookTH1F_LW(trackAging, "trackr_E" + side_id[iSide] + "_" + gas[iL] + "_All", "Number All Hits E" + side_id[iSide] + " " + gas[iL], 30, 644., 1004., "r [mm]", "Number of Hits", scode);
1099  m_trackr_HT[iL][iSide] = bookTH1F_LW(trackAging, "trackr_E" + side_id[iSide] + "_" + gas[iL] + "_HT", "Number HT Hits E" + side_id[iSide] + " " + gas[iL], 30, 644., 1004., "r [mm]", "Number of HT Hits", scode);
1100  }
1101  }
1102  }
1103  }
1104  }
1105  }
1106 
1107  return scode;
1108 }
1109 
1110 //----------------------------------------------------------------------------------//
1111 StatusCode TRT_Monitoring_Tool::fillHistograms() {
1112 //----------------------------------------------------------------------------------//
1113  ATH_MSG_VERBOSE("Monitoring Histograms being filled");
1114 
1115  // Retrieve containers/objects only once per event
1116  // Dereference handles to pass them to methods
1117  SG::ReadHandle<TRT_RDO_Container> rdoContainer(m_rdoContainerKey);
1118  SG::ReadHandle<TrackCollection> trackCollection(m_trackCollectionKey);
1119  SG::ReadHandle<TrackCollection> combTrackCollection(m_combTrackCollectionKey);
1120  SG::ReadHandle<xAOD::EventInfo> xAODEventInfo(m_xAODEventInfoKey);
1121  SG::ReadHandle<InDetTimeCollection> trtBCIDCollection(m_TRT_BCIDCollectionKey);
1122  SG::ReadHandle<ComTime> comTimeObject(m_comTimeObjectKey);
1123  const xAOD::TrigDecision* trigDecision(nullptr);
1124  if (!m_trigDecisionKey.empty()) {
1125  SG::ReadHandle<xAOD::TrigDecision> htrigDecision{m_trigDecisionKey};
1126  if (htrigDecision.isValid()) {
1127  trigDecision = htrigDecision.get();
1128  }
1129  }
1130 
1131  if (!xAODEventInfo.isValid()) {
1132  ATH_MSG_ERROR("Could not find event info object " << m_xAODEventInfoKey.key() <<
1133  " in store");
1134  return StatusCode::FAILURE;
1135  }
1136 
1137  if (m_doRDOsMon) {
1138  if (!rdoContainer.isValid()) {
1139  ATH_MSG_ERROR("Could not find TRT Raw Data Object " << m_rdoContainerKey.key() <<
1140  " in store");
1141  return StatusCode::FAILURE;
1142  }
1143 
1144  ATH_CHECK( checkEventBurst(*rdoContainer) );
1145 
1146  if (m_passEventBurst) {
1147  m_totalEvents++;
1148  m_evtLumiBlock++;
1149  if (!trtBCIDCollection.isValid()) {
1150  ATH_MSG_INFO("Could not find BCID collection " << m_TRT_BCIDCollectionKey.key() <<
1151  " in store");
1152  }
1153 
1154  ATH_CHECK( fillTRTRDOs(*rdoContainer, *xAODEventInfo, trtBCIDCollection.ptr()) );
1155  }
1156  } else {
1157  m_totalEvents++;
1158  m_passEventBurst = true;
1159  m_evtLumiBlock++;
1160  }
1161 
1162  if (m_doTracksMon) {
1163  if (!trackCollection.isValid()) {
1164  ATH_MSG_ERROR("Could not find track collection " << m_trackCollectionKey.key() <<
1165  " in store");
1166  return StatusCode::FAILURE;
1167  }
1168  if (!m_trigDecisionKey.empty() && !trigDecision) {
1169  ATH_MSG_INFO("Could not find trigger decision object " << m_trigDecisionKey.key() <<
1170  " in store");
1171  }
1172  // NOTE: failing to retrieve ComTime from store for some reason
1173  if (!comTimeObject.isValid()) {
1174  ATH_MSG_DEBUG("Could not find com time object " << m_comTimeObjectKey.key() <<
1175  " in store");
1176  }
1177  if (m_passEventBurst) {
1178  ATH_CHECK( fillTRTTracks(*trackCollection, trigDecision, comTimeObject.isValid() ? comTimeObject.cptr() : nullptr) );
1179  }
1180  }
1181 
1182  if (m_doEfficiency) {
1183  if (!combTrackCollection.isValid()) {
1184  ATH_MSG_ERROR("Could not find track collection " << m_combTrackCollectionKey.key() <<
1185  " in store");
1186  return StatusCode::FAILURE;
1187  }
1188 
1189  ATH_CHECK( fillTRTEfficiency(*combTrackCollection) );
1190  }
1191 
1192  if (!m_doTracksMon) {
1193  if (!trackCollection.isValid()) {
1194  ATH_MSG_ERROR("Could not find track collection " << m_trackCollectionKey.key() <<
1195  " in store");
1196  return StatusCode::FAILURE;
1197  }
1198  }
1199 
1200  if (m_passEventBurst) {
1201  ATH_CHECK( fillTRTHighThreshold(*trackCollection, *xAODEventInfo) );
1202  }
1203 
1204  return StatusCode::SUCCESS;
1205 }
1206 
1207 // Process all of the Histrograms. ie divide, multiply..etc and write them to file.
1208 //----------------------------------------------------------------------------------//
1209 StatusCode TRT_Monitoring_Tool::procHistograms() {
1210 //----------------------------------------------------------------------------------//
1211  double n_BorE[2][2], total_BorE[2][2];
1212  double nfill[2] = {3.0, 2.0}; // [0]:barrel, [1]:endcap
1213 
1214  //proccesing of online histograms
1215  if (m_environment != AthenaMonManager::online) {
1216  if (m_doShift && m_doRDOsMon) {
1217  m_hSummary->SetBinContent(1, m_totalEvents);
1218 
1219  if (m_doTracksMon) {
1220  m_hSummary->SetBinContent(2, m_nTotalTracks);
1221  m_hSummary->SetBinContent(3, m_nTracksB[0]);
1222  m_hSummary->SetBinContent(4, m_nTracksB[1]);
1223  m_hSummary->SetBinContent(5, m_nTracksEC[0]);
1224  m_hSummary->SetBinContent(6, m_nTracksEC[1]);
1225  m_hSummary->SetBinContent(7, m_nTracksEC_B[0]);
1226  m_hSummary->SetBinContent(8, m_nTracksEC_B[1]);
1227  }
1228  }
1229 
1230  if (m_totalEvents < m_usedEvents || m_usedEvents < 0) {
1231  m_usedEvents = m_totalEvents;
1232  }
1233 
1234  // ibe = 0 (Barrel), ibe = 1 (Endcap)
1235  for (int ibe = 0; ibe < 2; ibe++) {
1236  //Loop over stack histograms and normalize to number of events processed.
1237  if (m_doChips && m_doExpert && endOfRunFlag()) {
1238  for (int i = 0; i < 64; i++) {
1239  if (m_doTracksMon && m_doExpert) {
1240  divide_LWHist(m_hHitOnTrackVsAllC[ibe][i], m_hHitAonTMapC[ibe][i], m_hHitAMapC[ibe][i]);
1241  }
1242 
1243  if (m_doRDOsMon) {
1244  float scale = (float)m_usedEvents * 16;
1245 
1246  if (scale > 0) {
1247  scale = 1. / scale;
1248  scale_LWHist(m_hHitHWMapC[ibe][i], scale);
1249  scale_LWHist(m_hHitWMapC[ibe][i], scale);
1250  scale_LWHist(m_hHitAMapC[ibe][i], scale);
1251  scale_LWHist(m_hHitAWMapC[ibe][i], scale);
1252  scale_LWHist(m_hHitHMapC[ibe][i], scale);
1253  }
1254  }
1255 
1256  for (int j = 0; j < s_iChip_max[ibe]; j++) {
1257  if (m_doRDOsMon) m_hChipOcc[ibe][i]->Fill(m_hHitAMapC[ibe][i]->GetBinContent(j + 1));
1258 
1259  if (m_doTracksMon) {
1260  float scale = m_hChipsEff[ibe][i]->GetBinEntries(j + 1);
1261 
1262  if (scale > 0) {
1263  scale = 1. / scale;
1264  m_hHitAonTMapC[ibe][i]->SetBinContent(j + 1, m_hHitAonTMapC[ibe][i]->GetBinContent(j + 1) * scale);
1265  m_hHitWonTMapC[ibe][i]->SetBinContent(j + 1, m_hHitWonTMapC[ibe][i]->GetBinContent(j + 1) * scale);
1266  m_hHitAWonTMapC[ibe][i]->SetBinContent(j + 1, m_hHitAWonTMapC[ibe][i]->GetBinContent(j + 1) * scale);
1267  m_hHitHonTMapC[ibe][i]->SetBinContent(j + 1, m_hHitHonTMapC[ibe][i]->GetBinContent(j + 1) * scale);
1268  m_hHitHWonTMapC[ibe][i]->SetBinContent(j + 1, m_hHitHWonTMapC[ibe][i]->GetBinContent(j + 1) * scale);
1269  } else {
1270  m_hHitAonTMapC[ibe][i]->SetBinContent(j + 1, 0);
1271  m_hHitWonTMapC[ibe][i]->SetBinContent(j + 1, 0);
1272  m_hHitAWonTMapC[ibe][i]->SetBinContent(j + 1, 0);
1273  m_hHitHonTMapC[ibe][i]->SetBinContent(j + 1, 0);
1274  m_hHitHWonTMapC[ibe][i]->SetBinContent(j + 1, 0);
1275  }
1276  }
1277  }
1278 
1279  if (m_doRDOsMon && m_doExpert) {
1280  divide_LWHist(m_hHtoLMapC[ibe][i], m_hHitHMapC[ibe][i], m_hHitAMapC[ibe][i]);
1281  }
1282 
1283  if (m_doTracksMon && m_doExpert) {
1284  divide_LWHist(m_hHtoLonTMapC[ibe][i], m_hHitHonTMapC[ibe][i], m_hHitAonTMapC[ibe][i]);
1285  divide_LWHist(m_hHtoLWonTMapC[ibe][i], m_hHitHWonTMapC[ibe][i], m_hHitAWonTMapC[ibe][i]);
1286  }
1287  }
1288  }
1289 
1290  if (m_doStraws && endOfRunFlag()) {
1291  if (m_doRDOsMon && m_usedEvents > 0) {
1292  if (ibe == 0) {
1293  //fix for leading edge in time window probability vs straw number(Barrel) histograms
1294  initScaleVectors();
1295  vector<float> scalevector;
1296  vector<float> scalevector_Ar;
1297 
1298  for (int k = 0; k < s_Straw_max[0]; k++) {
1299  try {
1300  if (m_scale_hHitWMap_B.at(k) == 0.) {
1301  scalevector.push_back(0.);
1302  } else {
1303  scalevector.push_back(1. / (m_usedEvents * m_scale_hHitWMap_B.at(k)));
1304  }
1305 
1306  if (m_scale_hHitWMap_B_Ar.at(k) == 0.) {
1307  scalevector_Ar.push_back(0.);
1308  } else {
1309  scalevector_Ar.push_back(1. / (m_usedEvents * m_scale_hHitWMap_B_Ar.at(k)));
1310  }
1311  } catch (out_of_range &e) {
1312  ATH_MSG_ERROR("Index " << k << " out of range in scaling for hHitWMap");
1313  }
1314  }
1315 
1316  scale_LWHistWithScaleVector(m_hHitWMap_B, scalevector);
1317 
1318  if (m_ArgonXenonSplitter) {
1319  scale_LWHistWithScaleVector(m_hHitWMap_B_Ar, scalevector_Ar);
1320  }
1321  } else if (ibe == 1) {
1322  float eventScale = 1. / (m_usedEvents * 32);
1323  scale_LWHist(m_hHitWMap_E[0], eventScale);
1324  scale_LWHist(m_hHitWMap_E[1], eventScale);
1325 
1326  if (m_ArgonXenonSplitter) {
1327  scale_LWHist(m_hHitWMap_E_Ar[0], eventScale);
1328  scale_LWHist(m_hHitWMap_E_Ar[1], eventScale);
1329  }
1330  }
1331  }
1332 
1333  for (int i = 0; i < 64; i++) {
1334  if (m_doTracksMon && m_doExpert) {
1335  divide_LWHist(m_hHitOnTrackVsAllS[ibe][i], m_hHitAonTMapS[ibe][i], m_hHitAMapS[ibe][i]);
1336  }
1337 
1338  if (m_doRDOsMon && m_doExpert && m_usedEvents > 0) {
1339  float scale = 1. / m_usedEvents;
1340  scale_LWHist(m_hHitHWMapS[ibe][i], scale);
1341  scale_LWHist(m_hHitWMapS[ibe][i], scale);
1342  scale_LWHist(m_hHitAMapS[ibe][i], scale);
1343  scale_LWHist(m_hHitAWMapS[ibe][i], scale);
1344  scale_LWHist(m_hHitHMapS[ibe][i], scale);
1345  }
1346 
1347  for (int j = 0; j < s_Straw_max[ibe]; j++) {
1348  if (m_doRDOsMon) {
1349  if (m_doExpert) {
1350  m_hStrawOcc[ibe][i]->Fill(m_hHitAMapS[ibe][i]->GetBinContent(j + 1));
1351  }
1352  }
1353 
1354  if (m_doTracksMon) {
1355  if (i == 0) {
1356  if (ibe == 0) {
1357  if (m_nStrawHits_B[j] > 0) {
1358  m_hHitWonTMap_B->SetBinContent(j + 1, m_hHitWonTMap_B->GetBinContent(j + 1) / ((Float_t)m_nStrawHits_B[j]));
1359  }
1360  } else if (ibe == 1) {
1361  if (m_nStrawHits_E[0][j] > 0) {
1362  m_hHitWonTMap_E[0]->SetBinContent(j + 1, (float)m_hHitWonTMap_E[0]->GetBinContent(j + 1) / (m_nStrawHits_E[0][j]));
1363  }
1364 
1365  if (m_nStrawHits_E[1][j] > 0) {
1366  m_hHitWonTMap_E[1]->SetBinContent(j + 1, (float)m_hHitWonTMap_E[1]->GetBinContent(j + 1) / (m_nStrawHits_E[1][j]));
1367  }
1368  }
1369  }
1370 
1371  if (m_doExpert) {
1372  float scale = m_hStrawsEff[ibe][i]->GetBinEntries(j + 1);
1373 
1374  if (scale > 0 && m_hStrawsEff[ibe][i]->GetBinEntries(j + 1) > 0) {
1375  scale = 1. / scale;
1376  m_hHitAWonTMapS[ibe][i]->SetBinContent(j + 1, m_hHitAWonTMapS[ibe][i]->GetBinContent(j + 1) * scale);
1377  m_hHitAonTMapS[ibe][i]->SetBinContent(j + 1, m_hHitAonTMapS[ibe][i]->GetBinContent(j + 1) * scale);
1378  m_hHitHonTMapS[ibe][i]->SetBinContent(j + 1, m_hHitHonTMapS[ibe][i]->GetBinContent(j + 1) * scale);
1379  m_hHitWonTMapS[ibe][i]->SetBinContent(j + 1, m_hHitWonTMapS[ibe][i]->GetBinContent(j + 1) * scale);
1380  } else {
1381  m_hHitAWonTMapS[ibe][i]->SetBinContent(j + 1, 0);
1382  m_hHitAonTMapS[ibe][i]->SetBinContent(j + 1, 0);
1383  m_hHitHonTMapS[ibe][i]->SetBinContent(j + 1, 0);
1384  m_hHitWonTMapS[ibe][i]->SetBinContent(j + 1, 0);
1385  }
1386  }
1387  }
1388  }
1389 
1390  if (m_doRDOsMon && m_doExpert) divide_LWHist(m_hHtoLMapS[ibe][i], m_hHitHMapS[ibe][i], m_hHitAMapS[ibe][i]);
1391 
1392  if (m_doTracksMon && m_doExpert) {
1393  divide_LWHist(m_hHtoLonTMapS[ibe][i], m_hHitHonTMapS[ibe][i], m_hHitAonTMapS[ibe][i]);
1394  divide_LWHist(m_hHtoLWonTMapS[ibe][i], m_hHitHWonTMapS[ibe][i], m_hHitAWonTMapS[ibe][i]);
1395  }
1396  }
1397  }
1398 
1399  if (m_doShift && endOfRunFlag()) {
1400  if (m_doTracksMon) {
1401  if (ibe == 0) {
1402  m_EventPhaseScale = m_hEvtPhase->GetEntries() * 3.125;
1403 
1404  if (m_EventPhaseScale > 0) {
1405  scale_LWHist(m_hEvtPhase, 1. / m_EventPhaseScale);
1406  }
1407 
1408  m_DriftTimeonTrkDistScale_B = m_hDriftTimeonTrkDist_B->GetEntries() * 3.125;
1409 
1410  if (m_DriftTimeonTrkDistScale_B > 0) {
1411  scale_LWHist(m_hDriftTimeonTrkDist_B, 1. / m_DriftTimeonTrkDistScale_B);
1412  }
1413 
1414  m_HLhitOnTrackScale_B = m_hHLhitOnTrack_B->GetEntries();
1415 
1416  if (m_HLhitOnTrackScale_B > 0) {
1417  scale_LWHist(m_hHLhitOnTrack_B, 1. / m_HLhitOnTrackScale_B);
1418  }
1419 
1420  m_HtoLRatioOnTrackScale_B = m_hHtoLRatioOnTrack_B->GetEntries() * 0.02;
1421 
1422  if (m_HtoLRatioOnTrackScale_B > 0) {
1423  scale_LWHist(m_hHtoLRatioOnTrack_B, 1. / m_HtoLRatioOnTrackScale_B);
1424  }
1425 
1426  m_NumSwLLWoTScale_B = m_hNumSwLLWoT_B->GetEntries();
1427 
1428  if (m_NumSwLLWoTScale_B > 0) {
1429  scale_LWHist(m_hNumSwLLWoT_B, 1. / m_NumSwLLWoTScale_B);
1430  }
1431 
1432  m_WireToTrkPositionScale_B = m_hWireToTrkPosition_B->GetEntries() * 0.1;
1433 
1434  if (m_WireToTrkPositionScale_B > 0) {
1435  scale_LWHist(m_hWireToTrkPosition_B, 1. / m_WireToTrkPositionScale_B);
1436  }
1437 
1438  m_TronTDistScale_B = m_hTronTDist_B->GetEntries() * 3.125;
1439 
1440  if (m_TronTDistScale_B > 0) {
1441  scale_LWHist(m_hTronTDist_B, 1. / m_TronTDistScale_B);
1442  }
1443 
1444  m_ResidualScale_B = m_hResidual_B->GetEntries() * 0.025;
1445 
1446  if (m_ResidualScale_B > 0) {
1447  scale_LWHist(m_hResidual_B, 1. / m_ResidualScale_B);
1448  }
1449 
1450  m_ResidualScale_B_20GeV = m_hResidual_B_20GeV->GetEntries() * 0.025;
1451 
1452  if (m_ResidualScale_B_20GeV > 0) {
1453  scale_LWHist(m_hResidual_B_20GeV, 1. / m_ResidualScale_B_20GeV);
1454  }
1455 
1456  m_TimeResidualScale_B = m_hTimeResidual_B->GetEntries() * 0.2;
1457 
1458  if (m_TimeResidualScale_B > 0) {
1459  scale_LWHist(m_hTimeResidual_B, 1. / m_TimeResidualScale_B);
1460  }
1461 
1462  if (m_ArgonXenonSplitter) {
1463  m_DriftTimeonTrkDistScale_B_Ar = m_hDriftTimeonTrkDist_B_Ar->GetEntries() * 3.125;
1464 
1465  if (m_DriftTimeonTrkDistScale_B_Ar > 0) {
1466  scale_LWHist(m_hDriftTimeonTrkDist_B_Ar, 1. / m_DriftTimeonTrkDistScale_B_Ar);
1467  }
1468 
1469  m_WireToTrkPositionScale_B_Ar = m_hWireToTrkPosition_B_Ar->GetEntries() * 0.1;
1470 
1471  if (m_WireToTrkPositionScale_B_Ar > 0) {
1472  scale_LWHist(m_hWireToTrkPosition_B_Ar, 1. / m_WireToTrkPositionScale_B_Ar);
1473  }
1474 
1475  m_HtoLRatioOnTrackScale_B_Ar = m_hHtoLRatioOnTrack_B_Ar->GetEntries() * 0.02;
1476 
1477  if (m_HtoLRatioOnTrackScale_B_Ar > 0) {
1478  scale_LWHist(m_hHtoLRatioOnTrack_B_Ar, 1. / m_HtoLRatioOnTrackScale_B_Ar);
1479  }
1480 
1481  m_TronTDistScale_B_Ar = m_hTronTDist_B_Ar->GetEntries() * 3.125;
1482 
1483  if (m_TronTDistScale_B_Ar > 0) {
1484  scale_LWHist(m_hTronTDist_B_Ar, 1. / m_TronTDistScale_B_Ar);
1485  }
1486 
1487  m_ResidualScale_B_Ar = m_hResidual_B_Ar->GetEntries() * 0.025;
1488 
1489  if (m_ResidualScale_B_Ar > 0) {
1490  scale_LWHist(m_hResidual_B_Ar, 1. / m_ResidualScale_B_Ar);
1491  }
1492 
1493  m_ResidualScale_B_Ar_20GeV = m_hResidual_B_Ar_20GeV->GetEntries() * 0.025;
1494 
1495  if (m_ResidualScale_B_Ar_20GeV > 0) {
1496  scale_LWHist(m_hResidual_B_Ar_20GeV, 1. / m_ResidualScale_B_Ar_20GeV);
1497  }
1498 
1499  m_TimeResidualScale_B_Ar = m_hTimeResidual_B_Ar->GetEntries() * 0.2;
1500 
1501  if (m_TimeResidualScale_B_Ar > 0) {
1502  scale_LWHist(m_hTimeResidual_B_Ar, 1. / m_TimeResidualScale_B_Ar);
1503  }
1504  }
1505 
1506  m_HtoLRatioOnTrackScale_B_Xe = m_hHtoLRatioOnTrack_B_Xe->GetEntries() * 0.02;
1507 
1508  if (m_HtoLRatioOnTrackScale_B_Xe > 0) {
1509  scale_LWHist(m_hHtoLRatioOnTrack_B_Xe, 1. / m_HtoLRatioOnTrackScale_B_Xe);
1510  }
1511  } else if (ibe == 1) {
1512  for (int iside = 0; iside < 2; iside++) {
1513  m_DriftTimeonTrkDistScale_E[iside] = m_hDriftTimeonTrkDist_E[iside]->GetEntries() * 3.125;
1514 
1515  if (m_DriftTimeonTrkDistScale_E[iside] > 0) {
1516  scale_LWHist(m_hDriftTimeonTrkDist_E[iside], 1. / m_DriftTimeonTrkDistScale_E[iside]);
1517  }
1518 
1519  m_HLhitOnTrackScale_E[iside] = m_hHLhitOnTrack_E[iside]->GetEntries();
1520 
1521  if (m_HLhitOnTrackScale_E[iside] > 0) {
1522  scale_LWHist(m_hHLhitOnTrack_E[iside], 1. / m_HLhitOnTrackScale_E[iside]);
1523  }
1524 
1525  m_HtoLRatioOnTrackScale_E[iside] = m_hHtoLRatioOnTrack_E[iside]->GetEntries() * 0.02;
1526 
1527  if (m_HtoLRatioOnTrackScale_E[iside] > 0) {
1528  scale_LWHist(m_hHtoLRatioOnTrack_E[iside], 1. / m_HtoLRatioOnTrackScale_E[iside]);
1529  }
1530 
1531  m_NumSwLLWoTScale_E[iside] = m_hNumSwLLWoT_E[iside]->GetEntries();
1532 
1533  if (m_NumSwLLWoTScale_E[iside] > 0) {
1534  scale_LWHist(m_hNumSwLLWoT_E[iside], 1. / m_NumSwLLWoTScale_E[iside]);
1535  }
1536 
1537  m_WireToTrkPositionScale_E[iside] = m_hWireToTrkPosition_E[iside]->GetEntries() * 0.1;
1538 
1539  if (m_WireToTrkPositionScale_E[iside] > 0) {
1540  scale_LWHist(m_hWireToTrkPosition_E[iside], 1. / m_WireToTrkPositionScale_E[iside]);
1541  }
1542 
1543  m_TronTDistScale_E[iside] = m_hTronTDist_E[iside]->GetEntries() * 3.125;
1544 
1545  if (m_TronTDistScale_E[iside] > 0) {
1546  scale_LWHist(m_hTronTDist_E[iside], 1. / m_TronTDistScale_E[iside]);
1547  }
1548 
1549  m_ResidualScale_E[iside] = m_hResidual_E[iside]->GetEntries() * 0.025;
1550 
1551  if (m_ResidualScale_E[iside] > 0) {
1552  scale_LWHist(m_hResidual_E[iside], 1. / m_ResidualScale_E[iside]);
1553  }
1554 
1555  m_ResidualScale_E_20GeV[iside] = m_hResidual_E_20GeV[iside]->GetEntries() * 0.025;
1556 
1557  if (m_ResidualScale_E_20GeV[iside] > 0) {
1558  scale_LWHist(m_hResidual_E_20GeV[iside], 1. / m_ResidualScale_E_20GeV[iside]);
1559  }
1560 
1561  m_TimeResidualScale_E[iside] = m_hTimeResidual_E[iside]->GetEntries() * 0.2;
1562 
1563  if (m_TimeResidualScale_E[iside] > 0) {
1564  scale_LWHist(m_hTimeResidual_E[iside], 1. / m_TimeResidualScale_E[iside]);
1565  }
1566 
1567  m_HtoLRatioOnTrackScale_E_Xe[iside] = m_hHtoLRatioOnTrack_E_Xe[iside]->GetEntries() * 0.02;
1568 
1569  if (m_HtoLRatioOnTrackScale_E_Xe[iside] > 0) {
1570  scale_LWHist(m_hHtoLRatioOnTrack_E_Xe[iside], 1. / m_HtoLRatioOnTrackScale_E_Xe[iside]);
1571  }
1572 
1573  if (m_ArgonXenonSplitter) {
1574  m_DriftTimeonTrkDistScale_E_Ar[iside] = m_hDriftTimeonTrkDist_E_Ar[iside]->GetEntries() * 3.125;
1575 
1576  if (m_DriftTimeonTrkDistScale_E_Ar[iside] > 0) {
1577  scale_LWHist(m_hDriftTimeonTrkDist_E_Ar[iside], 1. / m_DriftTimeonTrkDistScale_E_Ar[iside]);
1578  }
1579 
1580  m_WireToTrkPositionScale_E_Ar[iside] = m_hWireToTrkPosition_E_Ar[iside]->GetEntries() * 0.1;
1581 
1582  if (m_WireToTrkPositionScale_E_Ar[iside] > 0) {
1583  scale_LWHist(m_hWireToTrkPosition_E_Ar[iside], 1. / m_WireToTrkPositionScale_E_Ar[iside]);
1584  }
1585 
1586  m_HtoLRatioOnTrackScale_E_Ar[iside] = m_hHtoLRatioOnTrack_E_Ar[iside]->GetEntries() * 0.02;
1587 
1588  if (m_HtoLRatioOnTrackScale_E_Ar[iside] > 0) {
1589  scale_LWHist(m_hHtoLRatioOnTrack_E_Ar[iside], 1. / m_HtoLRatioOnTrackScale_E_Ar[iside]);
1590  }
1591 
1592  m_TronTDistScale_E_Ar[iside] = m_hTronTDist_E_Ar[iside]->GetEntries() * 3.125;
1593 
1594  if (m_TronTDistScale_E_Ar[iside] > 0) {
1595  scale_LWHist(m_hTronTDist_E_Ar[iside], 1. / m_TronTDistScale_E_Ar[iside]);
1596  }
1597 
1598  m_ResidualScale_E_Ar[iside] = m_hResidual_E_Ar[iside]->GetEntries() * 0.025;
1599 
1600  if (m_ResidualScale_E_Ar[iside] > 0) {
1601  scale_LWHist(m_hResidual_E_Ar[iside], 1. / m_ResidualScale_E_Ar[iside]);
1602  }
1603 
1604  m_ResidualScale_E_Ar_20GeV[iside] = m_hResidual_E_Ar_20GeV[iside]->GetEntries() * 0.025;
1605 
1606  if (m_ResidualScale_E_Ar_20GeV[iside] > 0) {
1607  scale_LWHist(m_hResidual_E_Ar_20GeV[iside], 1. / m_ResidualScale_E_Ar_20GeV[iside]);
1608  }
1609 
1610  m_TimeResidualScale_E_Ar[iside] = m_hTimeResidual_E_Ar[iside]->GetEntries() * 0.2;
1611 
1612  if (m_TimeResidualScale_E_Ar[iside] > 0) {
1613  scale_LWHist(m_hTimeResidual_E_Ar[iside], 1. / m_TimeResidualScale_E_Ar[iside]);
1614  }
1615  }
1616  }
1617  }
1618  }
1619  }
1620 
1621  if (m_doEfficiency && endOfRunFlag()) {
1622  for (int iside = 0; iside < 2; iside++) {
1623  for (int i = 0; i < 32; i++) {
1624  for (int ibin = 0; ibin <= s_Straw_max[ibe]; ibin++) {
1625  if (m_doExpert) {
1626  if (m_hefficiencyS[ibe][i + (32 * iside)]->GetBinEntries(ibin) > m_min_tracks_straw) {
1627  m_hefficiency[ibe][iside]->Fill(m_hefficiencyS[ibe][i + (32 * iside)]->GetBinContent(ibin));
1628  }
1629  }
1630  }
1631  }
1632 
1633  n_BorE[ibe][iside] = m_hefficiency[ibe][iside]->GetEntries();
1634  total_BorE[ibe][iside] = 0.0;
1635 
1636  for (unsigned int ibin = 0; ibin <= m_hefficiency[ibe][iside]->GetXaxis()->GetNbins(); ibin++) {
1637  total_BorE[ibe][iside] += m_hefficiency[ibe][iside]->GetBinContent(ibin);
1638  m_hefficiencyIntegral[ibe][iside]->SetBinContent(ibin, n_BorE[ibe][iside] != 0.0 ? total_BorE[ibe][iside] / n_BorE[ibe][iside] : 0);
1639  }
1640  }
1641  }
1642  }
1643  }
1644 
1645  if (endOfLumiBlockFlag() || endOfRunFlag()) {
1646  if (m_doShift) {
1647  Int_t lumiblock1440 = m_lastTRTLumiBlock % 1440;
1648  float lumiBlockScale = (m_evtLumiBlock > 0) ? (1. / m_evtLumiBlock) : 0;
1649  const float barrelConst = 1. / 105088;
1650  const float endcapConst = 1. / 122880;
1651 
1652  if (m_doTracksMon && m_evtLumiBlock > 0) {
1653  m_hNHitsperLB_B->Fill(m_lastTRTLumiBlock, (float)m_nHitsperLB_B * lumiBlockScale * barrelConst);
1654  m_hNTrksperLB_B->Fill(m_lastTRTLumiBlock, (float)m_nTrksperLB_B * lumiBlockScale);
1655  m_hNHLHitsperLB_B->Fill(m_lastTRTLumiBlock, (float)m_nHLHitsperLB_B * lumiBlockScale * barrelConst);
1656 
1657  for (int iside = 0; iside < 2; iside++) {
1658  m_hNHitsperLB_E[iside]->Fill(m_lastTRTLumiBlock, (float)m_nHitsperLB_E[iside] * lumiBlockScale * endcapConst);
1659  m_hNTrksperLB_E[iside]->Fill(m_lastTRTLumiBlock, (float)m_nTrksperLB_E[iside] * lumiBlockScale);
1660  m_hNHLHitsperLB_E[iside]->Fill(m_lastTRTLumiBlock, (float)m_nHLHitsperLB_E[iside] * lumiBlockScale * endcapConst);
1661  }
1662 
1663  m_nTrksperLB_B = 0;
1664  m_nHitsperLB_B = 0;
1665  m_nHLHitsperLB_B = 0;
1666 
1667  for (int iside = 0; iside < 2; iside++) {
1668  m_nTrksperLB_E[iside] = 0;
1669  m_nHitsperLB_E[iside] = 0;
1670  m_nHLHitsperLB_E[iside] = 0;
1671  }
1672 
1673  // ibe = 0 (Barrel), ibe = 1 (Endcap)
1674  for (int ibe = 0; ibe < 2; ibe++) {
1675  for (int i = 0; i < s_iStack_max[ibe]; i++) {
1676  if (ibe == 0) {
1677  if (m_evtLumiBlock > 0) {
1678  float occ = (m_LLOcc[ibe][i] * lumiBlockScale) / nfill[ibe];
1679  m_hLLOcc_Scatter[ibe]->Fill(lumiblock1440, occ);
1680  occ = (m_LLOcc[ibe][i + 32] * lumiBlockScale) / nfill[ibe];
1681  m_hLLOcc_Scatter[ibe]->Fill(lumiblock1440, occ);
1682  }
1683 
1684  m_LLOcc[ibe][i] = 0;
1685  m_LLOcc[ibe][i + 32] = 0;
1686 
1687  if (m_nTrack_B[i]) {
1688  float ratio = m_HTfraconTrack_B[i] / m_nTrack_B[i];
1689  m_hHightoLowRatioOnTrack_Scatter[ibe]->Fill(lumiblock1440, ratio);
1690  m_hHitsOnTrack_Scatter[ibe]->Fill(lumiblock1440, m_LonTrack_B[i] / m_nTrack_B[i]);
1691  }
1692 
1693  m_LonTrack_B[i] = 0;
1694  m_HTfraconTrack_B[i] = 0;
1695  m_nTrack_B[i] = 0;
1696  } else if (ibe == 1) {
1697  if (m_evtLumiBlock > 0) {
1698  float occ = (m_LLOcc[ibe][i] * lumiBlockScale) / nfill[ibe];
1699  m_hLLOcc_Scatter[ibe]->Fill(lumiblock1440, occ);
1700  }
1701 
1702  m_LLOcc[ibe][i] = 0;
1703 
1704  if (m_nTrack_E[i]) {
1705  float ratio = m_HTfraconTrack_E[i] / m_nTrack_E[i];
1706  m_hHightoLowRatioOnTrack_Scatter[ibe]->Fill(lumiblock1440, ratio);
1707  m_hHitsOnTrack_Scatter[ibe]->Fill(lumiblock1440, m_LonTrack_E[i] / m_nTrack_E[i]);
1708  }
1709 
1710  m_LonTrack_E[i] = 0;
1711  m_HTfraconTrack_E[i] = 0;
1712  m_nTrack_E[i] = 0;
1713  }
1714  }
1715  }
1716  }
1717  }
1718 
1719  //Resetting Occupuncy histograms for online environment
1720  if (m_doShift && m_environment == AthenaMonManager::online &&
1721  (m_lastTRTLumiBlock % m_lumiBlocksToResetOcc) == 0) {
1722  for (int ibe = 0; ibe < 2; ibe++) {
1723  for (int iside = 0; iside < 2; iside++) {
1724  m_hAvgHLOcc_side[ibe][iside]->Reset();
1725  m_hAvgLLOcc_side[ibe][iside]->Reset();
1726  m_hAvgHLOccMod_side[ibe][iside]->Reset();
1727  m_hAvgLLOccMod_side[ibe][iside]->Reset();
1728  }
1729  }
1730  }
1731 
1732  ATH_MSG_DEBUG("end of event and lumi block");
1733  //number of events in lumiblock counter setted to zero since it is end of the run or the lumiblock
1734  m_evtLumiBlock = 0;
1735  }
1736 
1737  if (endOfRunFlag()) {
1738  ATH_MSG_DEBUG("end of run");
1739  }
1740 
1741  return StatusCode::SUCCESS;
1742 }
1743 
1744 //Check for EventBurst: Counts highlevelhits and returns m_passEventBurst flag true if the count is less than m_m_passEventBurstCut,returns allways succes
1745 //----------------------------------------------------------------------------------//
1746 StatusCode TRT_Monitoring_Tool::checkEventBurst(const TRT_RDO_Container& rdoContainer) {
1747 //----------------------------------------------------------------------------------//
1748  m_passEventBurst = true;
1749 
1750  if (m_EventBurstCut <= 0) return StatusCode::SUCCESS;
1751 
1752  int nHLHits = 0;
1753  TRT_RDO_Container::const_iterator RDO_CollectionBegin = rdoContainer.begin();
1754  TRT_RDO_Container::const_iterator RDO_CollectionEnd = rdoContainer.end();
1755 
1756  for (; RDO_CollectionBegin != RDO_CollectionEnd; ++RDO_CollectionBegin) {
1757  const InDetRawDataCollection<TRT_RDORawData> *TRT_Collection(*RDO_CollectionBegin);
1758 
1759  if (!TRT_Collection) continue;
1760  else {
1761  DataVector<TRT_RDORawData>::const_iterator p_rdo = TRT_Collection->begin();
1762 
1763  for (; p_rdo != TRT_Collection->end(); ++p_rdo) {
1764  const TRT_LoLumRawData *p_lolum = dynamic_cast<const TRT_LoLumRawData *>(*p_rdo);
1765 
1766  if (!p_lolum) continue;
1767 
1768  if (p_lolum->highLevel()) nHLHits++;
1769  }
1770  }
1771  }
1772 
1773  if (nHLHits > m_EventBurstCut) m_passEventBurst = false;
1774 
1775  return StatusCode::SUCCESS;
1776 }
1777 
1778 //Now Fill the TRT RDO Histograms
1779 //----------------------------------------------------------------------------------//
1780 StatusCode TRT_Monitoring_Tool::fillTRTRDOs(const TRT_RDO_Container& rdoContainer,
1781  const xAOD::EventInfo& eventInfo,
1782  const InDetTimeCollection* trtBCIDCollection) {
1783 //----------------------------------------------------------------------------------//
1784  ATH_MSG_DEBUG("Filling TRT RDO Histograms");
1785  TRT_RDO_Container::const_iterator RDO_CollectionBegin = rdoContainer.begin();
1786  TRT_RDO_Container::const_iterator RDO_CollectionEnd = rdoContainer.end();
1787  //Check readout Integrity of TRT
1788  ATH_CHECK( checkTRTReadoutIntegrity(eventInfo) );
1789  int numberOfStacks_b[2]; //Total stack number of barrel and endcap
1790  numberOfStacks_b[0] = s_numberOfBarrelStacks * 3;
1791  numberOfStacks_b[1] = s_numberOfEndCapStacks * 2;
1792  Identifier TRT_Identifier;
1793  int numberOfStrawsMod[3]; // For barrel(number if straw in module)
1794  numberOfStrawsMod[0] = 329;
1795  numberOfStrawsMod[1] = 520;
1796  numberOfStrawsMod[2] = 793;
1797  int numberOfStrawsWheel[2]; // For endcap
1798  numberOfStrawsWheel[0] = 2304; //6 layers (6*16=96) 96*24=2304 straws in wheel type A
1799  numberOfStrawsWheel[1] = 1536; //8 layers (8*8=64) 64*24=1536 straws in wheel type B
1800  int moduleHits_B[192];
1801  int moduleHits_E[128];
1802  int HLmoduleHits_B[192];
1803  int HLmoduleHits_E[128];
1804 
1805  for (int i = 0; i < 192; i++) {
1806  moduleHits_B[i] = 0;
1807  HLmoduleHits_B[i] = 0;
1808  }
1809 
1810  for (int i = 0; i < 128; i++) {
1811  moduleHits_E[i] = 0;
1812  HLmoduleHits_E[i] = 0;
1813  }
1814 
1815  int goodid_status = 0;
1816  int prev_bcid = 0;
1817 
1818  if (trtBCIDCollection) {
1819  InDetTimeCollection::const_iterator itrt_bcid = trtBCIDCollection->begin();
1820 
1821  while (goodid_status == 0 && itrt_bcid != trtBCIDCollection->end()) {
1822  const unsigned int trt_bcid = (*itrt_bcid).second;
1823 
1824  if (itrt_bcid > trtBCIDCollection->begin() && prev_bcid - trt_bcid == 0) {
1825  goodid_status = 1;
1826  } else if (itrt_bcid > trtBCIDCollection->begin() && prev_bcid - trt_bcid != 0) {
1827  ATH_MSG_WARNING("TRT BCID is not consistent. TRT RODID is " <<
1828  std::hex << (*itrt_bcid).first << " trt bcid from ROD is " <<
1829  std::hex << trt_bcid);
1830  }
1831 
1832  prev_bcid = trt_bcid;
1833  ++itrt_bcid;
1834  }
1835  }
1836 
1837  // Test out the TRT_StrawStatusSummarySvc.
1838  if (!m_sumTool.name().empty() && m_doExpert) {
1839  ATH_MSG_VERBOSE("Trying " << m_sumTool << " isGood");
1840  ATH_MSG_VERBOSE("TRT_StrawStatusTool reports status = " << m_sumTool->getStatus(TRT_Identifier));
1841  }
1842 
1843  // ibe = 0 (Barrel), ibe = 1 (Endcap)
1844  for (int ibe = 0; ibe < 2; ibe++) {
1845  m_nTRTHits[ibe] = 0;
1846 
1847  //Take out normalization from previous event for online environment
1848  //Explanation: While online monitoring running we need to present out histograms repeatedly so we need to pay attention to normalization.
1849  //before adding any information from new event to normalized histograms we need to take out the normalization of the previous event by scaling histograms back.
1850  //After we are done with filling those histograms we will normalize them again
1851  if (m_environment == AthenaMonManager::online && m_totalEvents > 0) {
1852  //Loop over stack histograms and normalize to number of events processed.
1853  if (m_doChips && m_doExpert) {
1854  for (int i = 0; i < 64; i++) {
1855  float scale = (m_totalEvents - 1) * 16;
1856  scale_LWHist(m_hHitHWMapC[ibe][i], scale);
1857  scale_LWHist(m_hHitWMapC[ibe][i], scale);
1858  scale_LWHist(m_hHitAMapC[ibe][i], scale);
1859  scale_LWHist(m_hHitAWMapC[ibe][i], scale);
1860  scale_LWHist(m_hHitHMapC[ibe][i], scale);
1861  }
1862  }
1863 
1864  if (m_doStraws) {
1865  if (ibe == 0) {
1866  initScaleVectors();
1867  vector<float> scalevector;
1868  vector<float> scalevector_Ar;
1869 
1870  for (int k = 0; k < s_Straw_max[0]; k++) {
1871  try {
1872  if (m_scale_hHitWMap_B.at(k) == 0.) {
1873  scalevector.push_back(0.);
1874  } else {
1875  scalevector.push_back((m_totalEvents - 1) * m_scale_hHitWMap_B.at(k));
1876  }
1877  if (m_scale_hHitWMap_B_Ar.at(k) == 0.) {
1878  scalevector_Ar.push_back(0.);
1879  } else {
1880  scalevector_Ar.push_back((m_totalEvents - 1) * m_scale_hHitWMap_B_Ar.at(k));
1881  }
1882  } catch (out_of_range &e) {
1883  ATH_MSG_ERROR("Index " << k << " out of range in scaling for hHitWMap");
1884  }
1885  }
1886 
1887  scale_LWHistWithScaleVector(m_hHitWMap_B, scalevector);
1888 
1889  if (m_ArgonXenonSplitter) {
1890  scale_LWHistWithScaleVector(m_hHitWMap_B_Ar, scalevector_Ar);
1891  }
1892  } else if (ibe == 1) {
1893  float scale = (m_totalEvents - 1) * 32;
1894  scale_LWHist(m_hHitWMap_E[0], scale);
1895  scale_LWHist(m_hHitWMap_E[1], scale);
1896 
1897  if (m_ArgonXenonSplitter) {
1898  scale_LWHist(m_hHitWMap_E_Ar[0], scale);
1899  scale_LWHist(m_hHitWMap_E_Ar[1], scale);
1900  }
1901  }
1902 
1903  if (m_doExpert) {
1904  for (int i = 0; i < 64; i++) {
1905  float scale = m_totalEvents - 1;
1906  scale_LWHist(m_hHitHWMapS[ibe][i], scale);
1907  scale_LWHist(m_hHitWMapS[ibe][i], scale);
1908  scale_LWHist(m_hHitAMapS[ibe][i], scale);
1909  scale_LWHist(m_hHitAWMapS[ibe][i], scale);
1910  scale_LWHist(m_hHitHMapS[ibe][i], scale);
1911  }
1912  }
1913  }
1914  }
1915  }
1916 
1917  int nhitsall = 0;
1918 
1919  for (; RDO_CollectionBegin != RDO_CollectionEnd; ++RDO_CollectionBegin) {
1920  const InDetRawDataCollection<TRT_RDORawData> *TRT_Collection(*RDO_CollectionBegin);
1921 
1922  if (!TRT_Collection) continue;
1923 
1924  DataVector<TRT_RDORawData>::const_iterator p_rdo = TRT_Collection->begin();
1925 
1926  for (; p_rdo != TRT_Collection->end(); ++p_rdo) {
1927  int middleHTbit = (*p_rdo)->getWord() & 0x00020000;
1928  //0x00020000 = 0000 0000 0000 0000 0000 0010 0000 0000 0000 0000
1929  int hitinvaliditygate = (*p_rdo)->getWord() & 0x000DFE80;
1930  //0x000DFE80 = 0000 0000 0000 0000 0000 1101 1111 1110 1000 0000 //
1931  bool is_middleHTbit_high = (middleHTbit != 0);
1932  bool is_anybininVgate_high = (hitinvaliditygate != 0);
1933  TRT_Identifier = (*p_rdo)->identify();
1934 
1935  if (m_doMaskStraws && m_sumTool->get_status(TRT_Identifier)) continue;
1936 
1937  int barrel_ec = m_pTRTHelper->barrel_ec(TRT_Identifier);
1938  //ToDo: Check TRT_LoLumRawData object
1939  const TRT_LoLumRawData *p_lolum = dynamic_cast<const TRT_LoLumRawData *>(*p_rdo);
1940 
1941  if (!p_lolum) continue;
1942 
1943  nhitsall++;
1944  int ibe = abs(barrel_ec) - 1;
1945  int iside = barrel_ec > 0 ? 0 : 1;
1946 
1947  //if barrel_ec is outof range go to next measurement in rdo_collection
1948  if (ibe != 1 && ibe != 0) {
1949  ATH_MSG_DEBUG("TRT part retrieved from TRT Identifier is not a barrel or an endcap");
1950  continue;
1951  }
1952 
1953  int moduleNumber_barrel1[2];
1954  int moduleNumber_barrel2[2];
1955  int moduleNumber_barrel3[2];
1956  int moduleNumber_endcapA[2];
1957  int moduleNumber_endcapB[2];
1958  // Get TRT Identifier
1959  // Need to know phi module, module layer, straw layer, and straw # within the layer
1960  // To get proper straw numbering
1961  TRT_Identifier = p_lolum->identify();
1962  //inline function checks m_ArgonXenonSplitter
1963  const bool isArgonStraw = (Straw_Gastype( m_sumTool->getStatusHT(TRT_Identifier) ) == GasType::Ar);
1964  int phi_module = m_pTRTHelper->phi_module(TRT_Identifier);
1965  int layer_or_wheel = m_pTRTHelper->layer_or_wheel(TRT_Identifier);
1966  int straw_layer = m_pTRTHelper->straw_layer(TRT_Identifier);
1967  int straw = m_pTRTHelper->straw(TRT_Identifier);
1968  int thisStrawNumber;
1969  int chip = 0;
1970  int board = -1;
1971  //ToDo: Check if that is really neccessary
1972  bool is_barrel = m_pTRTHelper->is_barrel(TRT_Identifier);
1973 
1974  //check straw number and find the correct chip and m_ board values
1975  if ( is_barrel && ibe == 0 ) {
1976  thisStrawNumber = strawNumber(straw, straw_layer, layer_or_wheel);
1977 
1978  if (thisStrawNumber >= 0 && thisStrawNumber < s_Straw_max[ibe]) {
1979  chip = m_mat_chip_B[phi_module][thisStrawNumber];
1980  }
1981 
1982  board = chipToBoard(chip);
1983  } else if ( !is_barrel && ibe == 1 ) {
1984  thisStrawNumber = strawNumberEndCap(straw, straw_layer, layer_or_wheel, phi_module, barrel_ec);
1985 
1986  if (thisStrawNumber >= 0 && thisStrawNumber < s_Straw_max[ibe]) {
1987  chip = m_mat_chip_E[phi_module][thisStrawNumber];
1988  }
1989 
1990  board = chipToBoard_EndCap(chip);
1991  } else {
1992  thisStrawNumber = -1;
1993  }
1994 
1995  if (thisStrawNumber < 0 || thisStrawNumber >= s_Straw_max[ibe]) {
1996  ATH_MSG_WARNING("Found m_strawNumber = " << thisStrawNumber << " out of range.");
1997  continue;
1998  }
1999 
2000  const int driftTimeBin = p_lolum->driftTimeBin();
2001  const int trailingEdge = p_lolum->trailingEdge();
2002  const bool highlevel = is_middleHTbit_high;//Hardcoded Middle Bit
2003  const bool firstBinHigh = p_lolum->firstBinHigh(); // if the first time bin is up then the hit is out of time window
2004  const bool lastBinHigh = p_lolum->lastBinHigh(); // if the last bin is up then the hit is out of time window.
2005  const float timeOverThreshold = p_lolum->timeOverThreshold();
2006  moduleNumber_barrel1[0] = phi_module;
2007  moduleNumber_barrel1[1] = phi_module + 96;
2008  moduleNumber_barrel2[0] = phi_module + s_numberOfBarrelStacks;
2009  moduleNumber_barrel2[1] = phi_module + s_numberOfBarrelStacks + 96;
2010  moduleNumber_barrel3[0] = phi_module + 2 * s_numberOfBarrelStacks;
2011  moduleNumber_barrel3[1] = phi_module + 2 * s_numberOfBarrelStacks + 96;
2012  moduleNumber_endcapA[0] = phi_module;
2013  moduleNumber_endcapA[1] = phi_module + 64;
2014  moduleNumber_endcapB[0] = phi_module + s_numberOfEndCapStacks;
2015  moduleNumber_endcapB[1] = phi_module + s_numberOfEndCapStacks + 64;
2016  int iphi_module = -999;
2017 
2018  if (iside == 0) {
2019  iphi_module = phi_module;
2020  } else if (iside == 1) {
2021  iphi_module = phi_module + 32;
2022  }
2023 
2024  if (ibe == 0) {
2025  m_nTRTHits[ibe]++;
2026 
2027  if (m_doStraws) {
2028  if (isArgonStraw) {
2029  m_hHitWMap_B_Ar->Fill(thisStrawNumber);
2030  } else {
2031  m_hHitWMap_B->Fill(thisStrawNumber);
2032  }
2033  }
2034 
2035  if (m_doShift) {
2036  m_nHitsperLB_B++;
2037 
2038  if (highlevel) {
2039  m_nHLHitsperLB_B++;
2040  }
2041  }
2042  } else if (ibe == 1) {
2043  m_nTRTHits[ibe]++;
2044 
2045  if (m_doStraws) {
2046  if (isArgonStraw) {
2047  m_hHitWMap_E_Ar[iside]->Fill(thisStrawNumber);
2048  } else {
2049  m_hHitWMap_E[iside]->Fill(thisStrawNumber);
2050  }
2051  }
2052 
2053  if (m_doShift) {
2054  m_nHitsperLB_E[iside]++;
2055 
2056  if (highlevel) {
2057  m_nHLHitsperLB_E[iside]++;
2058  }
2059  }
2060  }
2061 
2062  if (m_doExpert) {
2063  if ( (driftTimeBin > 2) && (driftTimeBin < 17) ) {
2064  if (m_doStraws) m_hHitWMapS[ibe][iphi_module]->Fill(thisStrawNumber);
2065 
2066  if (m_doChips) m_hHitWMapC[ibe][iphi_module]->Fill(chip - 1);
2067  }
2068 
2069  float trailingEdgeScaled = (trailingEdge + 1) * 3.125;
2070 
2071  if ((trailingEdge < 23) && !lastBinHigh && !firstBinHigh) {
2072  if (m_doStraws) m_hHitTrWMapS[ibe][iphi_module]->Fill(thisStrawNumber, trailingEdgeScaled);
2073 
2074  if (m_doChips) m_hHitTrWMapC[ibe][iphi_module]->Fill((chip - 1), trailingEdgeScaled);
2075  }
2076 
2077  if (m_doStraws) m_hHitTrMapS[ibe][iphi_module]->Fill(thisStrawNumber, trailingEdgeScaled);
2078 
2079  if (m_doChips) m_hHitTrMapC[ibe][iphi_module]->Fill((chip - 1), trailingEdgeScaled);
2080 
2081  if (highlevel) {
2082  if (m_doStraws) m_hHitHMapS[ibe][iphi_module]->Fill(thisStrawNumber);
2083 
2084  if (m_doChips) m_hHitHMapC[ibe][iphi_module]->Fill(chip - 1);
2085 
2086 
2087  if (m_doStraws) m_hHitHWMapS[ibe][iphi_module]->Fill(thisStrawNumber);
2088 
2089  if (m_doChips) m_hHitHWMapC[ibe][iphi_module]->Fill(chip - 1);
2090 
2091  }
2092 
2093  if (firstBinHigh || lastBinHigh || driftTimeBin > 0 || trailingEdge < 23) {
2094  if (m_doStraws) m_hHitAMapS[ibe][iphi_module]->Fill(thisStrawNumber);
2095 
2096  if (m_doChips) m_hHitAMapC[ibe][iphi_module]->Fill(chip - 1);
2097  }
2098 
2099  if ( is_anybininVgate_high) {
2100  if (m_doStraws) m_hHitAWMapS[ibe][iphi_module]->Fill(thisStrawNumber);
2101 
2102  if (m_doChips) m_hHitAWMapC[ibe][iphi_module]->Fill(chip - 1);
2103  }
2104 
2105  if (m_doStraws) {
2106  m_hHitToTMapS[ibe][iphi_module]->Fill(thisStrawNumber, timeOverThreshold);
2107 
2108  if (timeOverThreshold > m_longToTCut) {
2109  m_hHitToTLongMapS[ibe][iphi_module]->Fill(thisStrawNumber, timeOverThreshold);
2110  m_hHitToTLongTrMapS[ibe][iphi_module]->Fill(thisStrawNumber, trailingEdgeScaled);
2111  }
2112  }
2113 
2114  if (m_doChips) m_hHitToTMapC[ibe][iphi_module]->Fill((chip - 1), timeOverThreshold);
2115 
2116  if (m_doChips) {
2117  if (p_lolum->highLevel(1)) {
2118  m_hHtoBCMapC[ibe][iphi_module]->Fill(0., chip - 1);
2119  m_hHtoBCMapB[ibe][iphi_module]->Fill(0., board - 1);
2120  }
2121 
2122  if (p_lolum->highLevel(2)) {
2123  m_hHtoBCMapC[ibe][iphi_module]->Fill(1., chip - 1);
2124  m_hHtoBCMapB[ibe][iphi_module]->Fill(1., board - 1);
2125  }
2126 
2127  if (p_lolum->highLevel(3)) {
2128  m_hHtoBCMapC[ibe][iphi_module]->Fill(2., chip - 1);
2129  m_hHtoBCMapB[ibe][iphi_module]->Fill(2., board - 1);
2130  }
2131  }
2132  }
2133 
2134  //Set Module Numbers.
2135  int moduleNumber = -1;
2136 
2137  if (ibe == 0) {
2138  if (layer_or_wheel == 0) {
2139  moduleNumber = moduleNumber_barrel1[iside];
2140  moduleHits_B[moduleNumber]++;
2141  } else if (layer_or_wheel == 1) {
2142  moduleNumber = moduleNumber_barrel2[iside];
2143  moduleHits_B[moduleNumber]++;
2144  } else if (layer_or_wheel == 2) {
2145  moduleNumber = moduleNumber_barrel3[iside];
2146  moduleHits_B[moduleNumber]++;
2147  }
2148 
2149  if (highlevel) {
2150  if (layer_or_wheel == 0) {
2151  moduleNumber = moduleNumber_barrel1[iside];
2152  HLmoduleHits_B[moduleNumber]++;
2153  } else if (layer_or_wheel == 1) {
2154  moduleNumber = moduleNumber_barrel2[iside];
2155  HLmoduleHits_B[moduleNumber]++;
2156  } else if (layer_or_wheel == 2) {
2157  moduleNumber = moduleNumber_barrel3[iside];
2158  HLmoduleHits_B[moduleNumber]++;
2159  }
2160  }
2161  } else if (ibe == 1) {
2162  if (layer_or_wheel < 6) {
2163  moduleNumber = moduleNumber_endcapA[iside];
2164  moduleHits_E[moduleNumber]++;
2165  } else if (layer_or_wheel > 5) {
2166  moduleNumber = moduleNumber_endcapB[iside];
2167  moduleHits_E[moduleNumber]++;
2168  }
2169 
2170  if (highlevel) {
2171  if (layer_or_wheel < 6) {
2172  moduleNumber = moduleNumber_endcapA[iside];
2173  HLmoduleHits_E[moduleNumber]++;
2174  } else if (layer_or_wheel > 5) {
2175  moduleNumber = moduleNumber_endcapB[iside];
2176  HLmoduleHits_E[moduleNumber]++;
2177  }
2178  }
2179  }
2180  }
2181  }
2182 
2183  m_hOccAll->Fill(nhitsall / 350848.);
2184 
2185  //ToDo Explain this
2186  for (int ibe = 0; ibe < 2; ibe++) {
2187  if (m_doShift) {
2188  if (ibe == 0) {
2189  m_hBCIDvsOcc[ibe]->Fill(m_good_bcid, m_nTRTHits[ibe] / 105088.0);
2190  } else if (ibe == 1) {
2191  m_hBCIDvsOcc[ibe]->Fill(m_good_bcid, m_nTRTHits[ibe] / 245760.0);
2192  }
2193 
2194  for (int iside = 0; iside < 2; iside++) {
2195  for (int i = 1; i <= numberOfStacks_b[ibe]; i++) {
2196  int index_tmp, modulenum_tmp;
2197 
2198  if (iside == 0) {
2199  index_tmp = i - 1;
2200  modulenum_tmp = i - 1;
2201  } else {
2202  index_tmp = i + 31;
2203 
2204  if (ibe == 0) modulenum_tmp = (i - 1) + 96;
2205  else if (ibe == 1) modulenum_tmp = (i - 1) + 64;
2206  }
2207 
2208  int nclass = -1;
2209 
2210  if (i <= s_numberOfBarrelStacks) {
2211  nclass = 0;
2212  } else if (i <= 2 * s_numberOfBarrelStacks && i > s_numberOfBarrelStacks) {
2213  nclass = 1;
2214  } else if (i > 2 * s_numberOfBarrelStacks) {
2215  nclass = 2;
2216  }
2217 
2218  int LLocc_index = index_tmp - 32 * nclass;
2219 
2220  if (nclass >= 0) {
2221  if (ibe == 0) {
2222  float occLL = float(moduleHits_B[modulenum_tmp]) / float(numberOfStrawsMod[nclass]);
2223  float occHL = float(HLmoduleHits_B[modulenum_tmp]) / float(numberOfStrawsMod[nclass]);
2224  m_LLOcc[ibe][LLocc_index] += occLL;
2225  m_hAvgLLOcc_side[ibe][iside]->Fill(i - (32 * nclass), occLL);
2226  m_hAvgHLOcc_side[ibe][iside]->Fill(i - (32 * nclass), occHL);
2227  m_hAvgLLOccMod_side[ibe][iside]->Fill(i, occLL);
2228  m_hAvgHLOccMod_side[ibe][iside]->Fill(i, occHL);
2229  } else if (ibe == 1) {
2230  float occLL = float(moduleHits_E[modulenum_tmp]) / float(numberOfStrawsWheel[nclass]);
2231  float occHL = float(HLmoduleHits_E[modulenum_tmp]) / float(numberOfStrawsWheel[nclass]);
2232 
2233  if (LLocc_index < 64) {
2234  m_LLOcc[ibe][LLocc_index] += occLL;
2235  } else {
2236  ATH_MSG_WARNING("m_LLOcc index out of bounds!"); // To satisfy Coverity defect CID 16514 which we believe is a false report.
2237  }
2238 
2239  m_hAvgLLOcc_side[ibe][iside]->Fill(i - (32 * nclass), occLL);
2240  m_hAvgHLOcc_side[ibe][iside]->Fill(i - (32 * nclass), occHL);
2241  m_hAvgLLOccMod_side[ibe][iside]->Fill(i, occLL);
2242  m_hAvgHLOccMod_side[ibe][iside]->Fill(i, occHL);
2243  }
2244  }
2245  }
2246  }
2247  }
2248 
2249  //Normalization for online environmenmet
2250  if (m_environment == AthenaMonManager::online) {
2251  //Loop over stack histograms and normalize to number of events processed.
2252  if (m_doChips && m_doExpert) {
2253  for (int i = 0; i < 64; i++) {
2254  for (int j = 0; j < s_iChip_max[ibe]; j++) {
2255  m_hChipOcc[ibe][i]->Fill(m_hHitAMapC[ibe][i]->GetBinContent(j + 1));
2256  }
2257 
2258  if (m_totalEvents > 0) {
2259  const float scale = 1. / (16 * m_totalEvents);
2260  scale_LWHist(m_hHitHWMapC[ibe][i], scale);
2261  scale_LWHist(m_hHitWMapC[ibe][i], scale);
2262  scale_LWHist(m_hHitAMapC[ibe][i], scale);
2263  scale_LWHist(m_hHitAWMapC[ibe][i], scale);
2264  scale_LWHist(m_hHitHMapC[ibe][i], scale);
2265  }
2266  }
2267  }
2268 
2269  if (m_doStraws && m_doShift && m_totalEvents > 0) {
2270  if (ibe == 0) {
2271  initScaleVectors();
2272  vector<float> scalevector;
2273  vector<float> scalevector_Ar;
2274 
2275  for (int k = 0; k < s_Straw_max[0]; k++) {
2276  try {
2277  if (m_scale_hHitWMap_B.at(k) == 0.) {
2278  scalevector.push_back(0.);
2279  } else {
2280  scalevector.push_back(1. / (m_totalEvents * m_scale_hHitWMap_B.at(k)));
2281  }
2282 
2283  if (m_scale_hHitWMap_B_Ar.at(k) == 0.) {
2284  scalevector_Ar.push_back(0.);
2285  } else {
2286  scalevector_Ar.push_back(1. / (m_totalEvents * m_scale_hHitWMap_B_Ar.at(k)));
2287  }
2288  } catch (out_of_range &e) {
2289  ATH_MSG_ERROR("Index " << k << " out of range in scaling for hHitWMap");
2290  }
2291  }
2292 
2293  scale_LWHistWithScaleVector(m_hHitWMap_B, scalevector);
2294 
2295  if (m_ArgonXenonSplitter) {
2296  scale_LWHistWithScaleVector(m_hHitWMap_B_Ar, scalevector_Ar);
2297  }
2298  } else if (ibe == 1) {
2299  float eventScale = 1. / (32 * m_totalEvents);
2300  scale_LWHist(m_hHitWMap_E[0], eventScale);
2301  scale_LWHist(m_hHitWMap_E[1], eventScale);
2302 
2303  if (m_ArgonXenonSplitter) {
2304  scale_LWHist(m_hHitWMap_E_Ar[0], eventScale);
2305  scale_LWHist(m_hHitWMap_E_Ar[1], eventScale);
2306  }
2307  }
2308  }
2309 
2310  if (m_doStraws) {
2311  for (int i = 0; i < 64; i++) {
2312  if (m_doExpert && m_totalEvents > 0) {
2313  const float scale = 1. / m_totalEvents;
2314  scale_LWHist(m_hHitHWMapS[ibe][i], scale);
2315  scale_LWHist(m_hHitWMapS[ibe][i], scale);
2316  scale_LWHist(m_hHitAMapS[ibe][i], scale);
2317  scale_LWHist(m_hHitAWMapS[ibe][i], scale);
2318  scale_LWHist(m_hHitHMapS[ibe][i], scale);
2319  }
2320 
2321  for (int j = 0; j < s_iChip_max[ibe]; j++) {
2322  if (m_doExpert) {
2323  m_hStrawOcc[ibe][i]->Fill(m_hHitAMapS[ibe][i]->GetBinContent(j + 1));
2324  }
2325  }
2326  }
2327  }
2328  }
2329  }
2330 
2331  if (m_environment == AthenaMonManager::online) {
2332  if (m_doShift) m_hSummary->SetBinContent(1, m_totalEvents);
2333  }
2334 
2335  ATH_MSG_VERBOSE("Leaving Fill TRT RDO Histograms");
2336  return StatusCode::SUCCESS;
2337 }
2338 
2339 //Fill the TRT Track level histograms
2340 //----------------------------------------------------------------------------------//
2341 StatusCode TRT_Monitoring_Tool::fillTRTTracks(const TrackCollection& trackCollection,
2342  const xAOD::TrigDecision* trigDecision,
2343  const ComTime* comTimeObject) {
2344 //----------------------------------------------------------------------------------//
2345  ATH_MSG_VERBOSE("Filling TRT Tracks Histos");
2346  //Initialize a bunch of stuff before looping over the track collection. Fill some basic histograms.
2347  const float timeCor = comTimeObject ? comTimeObject->getTime() : 0;
2348  auto p_trk = trackCollection.begin();
2349  const Trk::Perigee *mPer = nullptr;
2350  const DataVector<const Trk::TrackParameters> *AllTrkPar(nullptr);
2351  DataVector<const Trk::TrackParameters>::const_iterator p_trkpariter;
2352 
2353  //Take out normalization of previous event for online environment
2354  //Explanation: While online monitoring running we need to present out histograms repeatedly so we need to pay attention to normalization.
2355  //before adding any information from new event to normalized histograms we need to take out the normalization of the previous event by scaling histograms back.
2356  //After we are done with filling those histograms we will normalize them again
2357  if (m_environment == AthenaMonManager::online) {
2358  // ibe = 0 (Barrel), ibe = 1 (Endcap)
2359  for (int ibe = 0; ibe < 2; ibe++) {
2360  if (m_doChips && m_doExpert) {
2361  for (int i = 0; i < 64; i++) {
2362  for (int j = 0; j < s_iChip_max[ibe]; j++) {
2363  if (m_hChipsEff[ibe][i]->GetBinEntries(j + 1) > 0) {
2364  m_hHitAonTMapC[ibe][i]->SetBinContent(j + 1, m_hHitAonTMapC[ibe][i]->GetBinContent(j + 1) * m_hChipsEff[ibe][i]->GetBinEntries(j + 1));
2365  m_hHitWonTMapC[ibe][i]->SetBinContent(j + 1, m_hHitWonTMapC[ibe][i]->GetBinContent(j + 1) * m_hChipsEff[ibe][i]->GetBinEntries(j + 1));
2366  m_hHitAWonTMapC[ibe][i]->SetBinContent(j + 1, m_hHitAWonTMapC[ibe][i]->GetBinContent(j + 1) * m_hChipsEff[ibe][i]->GetBinEntries(j + 1));
2367  m_hHitHonTMapC[ibe][i]->SetBinContent(j + 1, m_hHitHonTMapC[ibe][i]->GetBinContent(j + 1) * m_hChipsEff[ibe][i]->GetBinEntries(j + 1));
2368  m_hHitHWonTMapC[ibe][i]->SetBinContent(j + 1, m_hHitHWonTMapC[ibe][i]->GetBinContent(j + 1) * m_hChipsEff[ibe][i]->GetBinEntries(j + 1));
2369  }
2370  }
2371  }
2372  }
2373 
2374  if (m_doStraws) {
2375  for (int i = 0; i < 64; i++) {
2376  for (int j = 0; j < s_Straw_max[ibe]; j++) {
2377  if (ibe == 0) {
2378  if (i == 0 && m_nStrawHits_B[j] > 0) {
2379  m_hHitWonTMap_B->SetBinContent(j + 1, m_hHitWonTMap_B->GetBinContent(j + 1) * m_nStrawHits_B[j]);
2380  }
2381  } else if (ibe == 1) {
2382  for (int iside = 0; iside < 2; iside++) {
2383  if (i == 0 && m_nStrawHits_E[iside][j] > 0) {
2384  m_hHitWonTMap_E[iside]->SetBinContent(j + 1, m_hHitWonTMap_E[iside]->GetBinContent(j + 1) * m_nStrawHits_E[iside][j]);
2385  }
2386  }
2387  }
2388 
2389  if (m_doExpert) {
2390  if (m_hStrawsEff[ibe][i]->GetBinEntries(j + 1) > 0) {
2391  m_hHitAWonTMapS[ibe][i]->SetBinContent(j + 1, m_hHitAWonTMapS[ibe][i]->GetBinContent(j + 1) * m_hStrawsEff[ibe][i]->GetBinEntries(j + 1));
2392  m_hHitAonTMapS[ibe][i]->SetBinContent(j + 1, m_hHitAonTMapS[ibe][i]->GetBinContent(j + 1) * m_hStrawsEff[ibe][i]->GetBinEntries(j + 1));
2393  m_hHitHonTMapS[ibe][i]->SetBinContent(j + 1, m_hHitHonTMapS[ibe][i]->GetBinContent(j + 1) * m_hStrawsEff[ibe][i]->GetBinEntries(j + 1));
2394  m_hHitWonTMapS[ibe][i]->SetBinContent(j + 1, m_hHitWonTMapS[ibe][i]->GetBinContent(j + 1) * m_hStrawsEff[ibe][i]->GetBinEntries(j + 1));
2395  }
2396  }
2397  }
2398  }
2399  }
2400  }
2401 
2402  if (m_doShift) {
2403  scale_LWHist(m_hEvtPhase, m_EventPhaseScale);
2404  scale_LWHist(m_hDriftTimeonTrkDist_B, m_DriftTimeonTrkDistScale_B);
2405  scale_LWHist(m_hHLhitOnTrack_B, m_HLhitOnTrackScale_B);
2406  scale_LWHist(m_hHtoLRatioOnTrack_B, m_HtoLRatioOnTrackScale_B);
2407  scale_LWHist(m_hNumSwLLWoT_B, m_NumSwLLWoTScale_B);
2408  scale_LWHist(m_hWireToTrkPosition_B, m_WireToTrkPositionScale_B);
2409  scale_LWHist(m_hTronTDist_B, m_TronTDistScale_B);
2410  scale_LWHist(m_hResidual_B, m_ResidualScale_B);
2411  scale_LWHist(m_hResidual_B_20GeV, m_ResidualScale_B_20GeV);
2412  scale_LWHist(m_hTimeResidual_B, m_TimeResidualScale_B);
2413 
2414  if (m_ArgonXenonSplitter) {
2415  scale_LWHist(m_hDriftTimeonTrkDist_B_Ar, m_DriftTimeonTrkDistScale_B_Ar);
2416  scale_LWHist(m_hWireToTrkPosition_B_Ar, m_WireToTrkPositionScale_B_Ar);
2417  scale_LWHist(m_hTronTDist_B_Ar, m_TronTDistScale_B_Ar);
2418  scale_LWHist(m_hResidual_B_Ar, m_ResidualScale_B_Ar);
2419  scale_LWHist(m_hResidual_B_Ar_20GeV, m_ResidualScale_B_Ar_20GeV);
2420  scale_LWHist(m_hTimeResidual_B_Ar, m_TimeResidualScale_B_Ar);
2421  }
2422 
2423  for (int iside = 0; iside < 2; iside++) {
2424  scale_LWHist(m_hDriftTimeonTrkDist_E[iside], m_DriftTimeonTrkDistScale_E[iside]);
2425  scale_LWHist(m_hHLhitOnTrack_E[iside], m_HLhitOnTrackScale_E[iside]);
2426  scale_LWHist(m_hHtoLRatioOnTrack_E[iside], m_HtoLRatioOnTrackScale_E[iside]);
2427  scale_LWHist(m_hNumSwLLWoT_E[iside], m_NumSwLLWoTScale_E[iside]);
2428  scale_LWHist(m_hWireToTrkPosition_E[iside], m_WireToTrkPositionScale_E[iside]);
2429  scale_LWHist(m_hTronTDist_E[iside], m_TronTDistScale_E[iside]);
2430  scale_LWHist(m_hResidual_E[iside], m_ResidualScale_E[iside]);
2431  scale_LWHist(m_hResidual_E_20GeV[iside], m_ResidualScale_E_20GeV[iside]);
2432  scale_LWHist(m_hTimeResidual_E[iside], m_TimeResidualScale_E[iside]);
2433 
2434  if (m_ArgonXenonSplitter) {
2435  scale_LWHist(m_hDriftTimeonTrkDist_E_Ar[iside], m_DriftTimeonTrkDistScale_E_Ar[iside]);
2436  scale_LWHist(m_hWireToTrkPosition_E_Ar[iside], m_WireToTrkPositionScale_E_Ar[iside]);
2437  scale_LWHist(m_hTronTDist_E_Ar[iside], m_TronTDistScale_E_Ar[iside]);
2438  scale_LWHist(m_hResidual_E_Ar[iside], m_ResidualScale_E_Ar[iside]);
2439  scale_LWHist(m_hResidual_E_Ar_20GeV[iside], m_ResidualScale_E_Ar_20GeV[iside]);
2440  scale_LWHist(m_hTimeResidual_E_Ar[iside], m_TimeResidualScale_E_Ar[iside]);
2441  }
2442  }
2443  }
2444  }
2445 
2446  int ntrackstack[2][64];
2447 
2448  for (int ibe = 0; ibe < 2; ibe++) {
2449  std::fill(ntrackstack[ibe], ntrackstack[ibe] + 64, 0);
2450  }
2451 
2452  for (; p_trk != trackCollection.end(); ++p_trk) {
2453  std::unique_ptr<const Trk::TrackSummary> summary = m_TrackSummaryTool->summary(*(*p_trk));
2454  int nTRTHits = summary->get(Trk::numberOfTRTHits);
2455 
2456  if (nTRTHits < m_minTRThits) continue;
2457 
2458  AllTrkPar = (*p_trk)->trackParameters();
2459 
2460  // Search of MeasuredPerigee in TrackParameters
2461  // The following algorithm only finds the First perigee measurement.
2462  // As there should be one and only one perigee measurement then this assumption should be valid.
2463  // But no check is done to see if there is more than one perigee measurement.
2464  for (p_trkpariter = AllTrkPar->begin(); p_trkpariter != AllTrkPar->end(); ++p_trkpariter) {
2465  //if track parameter does have a measured perigee then the track parameter is a keeper and break out of the loop
2466  if ((mPer = dynamic_cast<const Trk::Perigee *>(*p_trkpariter))) break;
2467  }
2468 
2469  if (!mPer) continue;
2470 
2471  float theta = mPer->parameters()[Trk::theta];
2472  float p = (mPer->parameters()[Trk::qOverP] != 0.) ? fabs(1. / (mPer->parameters()[Trk::qOverP])) : 10e7;
2473  float pT = (p * sin(theta));
2474  pT = pT * 1e-3; // GeV
2475 
2476  if (p < m_minP) continue;
2477 
2478  const Trk::TrackStates *trackStates = (**p_trk).trackStateOnSurfaces();
2479 
2480  if (trackStates == nullptr) continue;
2481 
2482  Trk::TrackStates::const_iterator TSOSItBegin0 = trackStates->begin();
2483  Trk::TrackStates::const_iterator TSOSItBegin = trackStates->begin();
2484  Trk::TrackStates::const_iterator TSOSItBeginTemp = trackStates->begin();
2485  Trk::TrackStates::const_iterator TSOSItEnd = trackStates->end();
2486  int n_trt_hits = summary->get(Trk::numberOfTRTHits);
2487  int n_sct_hits = summary->get(Trk::numberOfSCTHits);
2488  int n_pixel_hits = summary->get(Trk::numberOfPixelHits);
2489  const int n_si_hits = n_pixel_hits + n_sct_hits;
2490  bool is_pT_over_20GeV = false;
2491 
2492  is_pT_over_20GeV = mPer->pT() > 20 * CLHEP::GeV;
2493 
2494  const bool cnst_is_pT_over_20GeV = is_pT_over_20GeV;
2496  float min_pt_new = m_min_pT;
2497 
2498  if (!m_isCosmics) {
2499  min_pt_new = 2.0 * CLHEP::GeV;
2500  }
2501 
2502  const bool passed_track_preselection =
2503  (mPer->pT() > min_pt_new) &&
2504  (p > m_minP) &&
2505  (n_si_hits >= m_min_si_hits) &&
2506  (n_pixel_hits >= m_min_pixel_hits) &&
2507  (n_sct_hits >= m_min_sct_hits) &&
2508  (n_trt_hits >= m_min_trt_hits);
2509 
2510  if (!passed_track_preselection) continue;
2511 
2512  m_nTotalTracks++;
2513  int checkB[2] = {0, 0};
2514  int checkEC[2] = {0, 0};
2515  int checkEC_B[2] = {0, 0};
2516  int nTRTHitsW[2][2];
2517  int nTRTHitsW_Ar[2][2];
2518  int nTRTHitsW_Xe[2][2];
2519  int nTRTHLHitsW[2][2];
2520  int nTRTHLHitsW_Ar[2][2];
2521  int nTRTHLHitsW_Xe[2][2];
2522  int nTRTHits_side[2][2];
2523  int nTRTHitsW_perwheel[2][18];
2524  int hitontrack[2] = {0, 0};
2525  int hitontrack_E_side[2] = {0, 0};
2526 
2527  for (int ibe = 0; ibe < 2; ibe++) {
2528  for (int iside = 0; iside < 2; iside++) {
2529  nTRTHits_side[ibe][iside] = -1;
2530  nTRTHitsW[ibe][iside] = 0;
2531  nTRTHitsW_Ar[ibe][iside] = 0;
2532  nTRTHitsW_Xe[ibe][iside] = 0;
2533  nTRTHLHitsW[ibe][iside] = 0;
2534  nTRTHLHitsW_Ar[ibe][iside] = 0;
2535  nTRTHLHitsW_Xe[ibe][iside] = 0;
2536  }
2537 
2538  std::fill(nTRTHitsW_perwheel[ibe], nTRTHitsW_perwheel[ibe] + 18, 0);
2539  }
2540 
2541  bool isBarrelOnly = true;
2542  bool ECAhit = false;
2543  bool ECChit = false;
2544  bool Bhit = false;
2545  int barrel_ec = 0;
2546  int layer_or_wheel = 0;
2547  int phi_module = 0;
2548  int straw_layer = 0;
2549  int straw = 0;
2550  int nearest_straw_layer[2] = {100, 100};
2551  int nearest_straw[2] = {0, 0};
2552  int testLayer[2] = {100, 100};
2553  int innerstack[2] = {-999, -999};
2554  float phi2D[2] = {-100, -100};
2555 
2556  for (TSOSItBeginTemp = TSOSItBegin0; TSOSItBeginTemp != TSOSItEnd; ++TSOSItBeginTemp) {
2557  if ((*TSOSItBeginTemp) == nullptr) continue;
2558 
2559  if (! ((*TSOSItBeginTemp)->type(Trk::TrackStateOnSurface::Measurement)) ) continue;
2560 
2561  const InDet::TRT_DriftCircleOnTrack *trtCircle = dynamic_cast<const InDet::TRT_DriftCircleOnTrack *>((*TSOSItBeginTemp)->measurementOnTrack());
2562 
2563  if (!trtCircle) continue;
2564 
2565  const Trk::TrackParameters *aTrackParam = dynamic_cast<const Trk::TrackParameters *>((*TSOSItBeginTemp)->trackParameters());
2566 
2567  if (!aTrackParam) continue;
2568 
2569  Identifier DCoTId = trtCircle->identify();
2570  barrel_ec = m_pTRTHelper->barrel_ec(DCoTId);
2571  int ibe = abs(barrel_ec) - 1;
2572  layer_or_wheel = m_pTRTHelper->layer_or_wheel (DCoTId);
2573  straw_layer = m_pTRTHelper->straw_layer(DCoTId);
2574  straw = m_pTRTHelper->straw(DCoTId);
2575 
2576  //restrict ourselves to the inner most TRT layers To get detector phi.
2577  if (layer_or_wheel >= testLayer[ibe]) continue;
2578 
2579  testLayer[ibe] = layer_or_wheel;
2580 
2581  if (straw_layer < nearest_straw_layer[ibe]) {
2582  nearest_straw_layer[ibe] = straw_layer;
2583  nearest_straw[ibe] = straw;
2584  const InDetDD::TRT_BaseElement *circleElement = nullptr;
2585  circleElement = trtCircle->detectorElement();
2586  phi2D[ibe] = radToDegrees(circleElement->strawCenter(nearest_straw[ibe]).phi());
2587  circleElement = nullptr;
2588  innerstack[ibe] = m_pTRTHelper->phi_module(DCoTId);
2589  }
2590  }
2591 
2592  if (phi2D[0] == -999) {
2593  ATH_MSG_DEBUG("Track did not go through inner layer of Barrel.");
2594  } else {
2595  ATH_MSG_VERBOSE("Track's closest approach is m_layer_or_wheel: " <<
2596  testLayer[0] << " m_straw_layer: " <<
2597  nearest_straw_layer[0] << " (in the Barrel).");
2598  }
2599 
2600  if (phi2D[1] == -999) {
2601  ATH_MSG_DEBUG("Track did not go through any inner layer of EndCap A or C.");
2602  } else {
2603  ATH_MSG_VERBOSE("Track's closest approach is m_layer_or_wheel: " <<
2604  testLayer[1] << " m_straw_layer: " <<
2605  nearest_straw_layer[1] << " (in the EndCaps).");
2606  }
2607 
2608  bool trackfound[2][64];
2609 
2610  for (int i = 0; i < 2; i++) {
2611  std::fill(trackfound[i], trackfound[i] + 64, false);
2612  }
2613 
2614  for (TSOSItBegin = TSOSItBegin0; TSOSItBegin != TSOSItEnd; ++TSOSItBegin) {
2615  //select a TSOS which is non-empty, measurement type and contains both drift circle and track parameters informations
2616  if ((*TSOSItBegin) == nullptr) continue;
2617 
2618  if ( !((*TSOSItBegin)->type(Trk::TrackStateOnSurface::Measurement)) ) continue;
2619 
2620  const InDet::TRT_DriftCircleOnTrack *trtCircle = dynamic_cast<const InDet::TRT_DriftCircleOnTrack *>((*TSOSItBegin)->measurementOnTrack());
2621 
2622  if (!trtCircle) continue;
2623 
2624  const Trk::TrackParameters *aTrackParam = dynamic_cast<const Trk::TrackParameters *>((*TSOSItBegin)->trackParameters());
2625 
2626  if (!aTrackParam) continue;
2627 
2628  Identifier DCoTId = trtCircle->identify();
2629  barrel_ec = m_pTRTHelper->barrel_ec(DCoTId);
2630  layer_or_wheel = m_pTRTHelper->layer_or_wheel(DCoTId);
2631  phi_module = m_pTRTHelper->phi_module(DCoTId);
2632  straw_layer = m_pTRTHelper->straw_layer(DCoTId);
2633  straw = m_pTRTHelper->straw(DCoTId);
2634  // ibe = 0 (Barrel), ibe = 1 (Endcap)
2635  int ibe = abs(barrel_ec) - 1;
2636  // iside = 0 (Side A), iside = 1 (Side C)
2637  int iside = barrel_ec > 0 ? 0 : 1;
2638  int thisStrawNumber[2] = {-1, -1};
2639  int chip[2] = {0, 0};
2640 
2641  if (ibe == 0) {
2642  thisStrawNumber[ibe] = strawNumber(straw, straw_layer, layer_or_wheel);
2643 
2644  if (thisStrawNumber[ibe] >= 0 && thisStrawNumber[ibe] < s_Straw_max[ibe]) {
2645  chip[ibe] = m_mat_chip_B[phi_module][thisStrawNumber[ibe]];
2646  }
2647  } else if (ibe == 1) {
2648  thisStrawNumber[ibe] = strawNumberEndCap(straw, straw_layer, layer_or_wheel, phi_module, barrel_ec);
2649 
2650  if (thisStrawNumber[ibe] >= 0 && thisStrawNumber[ibe] < s_Straw_max[ibe]) {
2651  chip[ibe] = m_mat_chip_E[phi_module][thisStrawNumber[ibe]];
2652  }
2653  } else {
2654  thisStrawNumber[ibe] = -1;
2655  }
2656 
2657  if (thisStrawNumber[ibe] < 0 || thisStrawNumber[ibe] >= s_Straw_max[ibe]) continue;
2658 
2659  if (checkB[iside] == 0 && ibe == 0) {
2660  m_nTracksB[iside]++;
2661  checkB[iside] = 1;
2662  }
2663 
2664  if (checkEC[iside] == 0 && ibe == 1) {
2665  m_nTracksEC[iside]++;
2666  checkEC[iside] = 1;
2667  }
2668 
2669  if (checkEC_B[iside] == 0 && checkB[iside] == 1 && ibe == 1 ) {
2670  m_nTracksEC_B[iside]++;
2671  checkEC_B[iside] = 1;
2672  }//ToDo: be sure about this approach
2673 
2674  if (ibe == 0) {
2675  Bhit = true;
2676  } else if (barrel_ec == 2) {
2677  isBarrelOnly = false;
2678  ECAhit = true;
2679  } else if (barrel_ec == -2) {
2680  isBarrelOnly = false;
2681  ECChit = true;
2682  }
2683 
2684  Identifier surfaceID;
2685  const Trk::MeasurementBase *mesb = (*TSOSItBegin)->measurementOnTrack();
2686  surfaceID = trtCircle->identify();
2687  const bool isArgonStraw = ( Straw_Gastype( m_sumTool->getStatusHT(surfaceID) ) == GasType::Ar );
2688  // assume always Xe if m_ArgonXenonSplitter is not enabled, otherwise check the straw status (good is Xe, non-good is Ar)
2689  float temp_locr = aTrackParam->parameters()[Trk::driftRadius];
2690  TRTCond::RtRelation const *rtr = m_TRTCalDbTool->getRtRelation(surfaceID);
2691  int iphi_module = -9999;
2692 
2693  if (iside == 0) iphi_module = phi_module;
2694  else if (iside == 1) iphi_module = phi_module + 32;
2695 
2696  trackfound[ibe][iphi_module] = true;
2697 
2698  if (((ibe == 0) && (temp_locr < m_DistToStraw)) ||
2699  ((ibe == 1) && ((*TSOSItBegin)->type(Trk::TrackStateOnSurface::Measurement) ||
2700  (*TSOSItBegin)->type(Trk::TrackStateOnSurface::Outlier) ||
2701  (*TSOSItBegin)->type(Trk::TrackStateOnSurface::Hole)) &&
2702  (temp_locr < m_DistToStraw))) {
2703  if (m_idHelper->is_trt(DCoTId)) {
2704  if (ibe == 0) {
2705  hitontrack[ibe]++;
2706 
2707  if (m_doShift) {
2708  m_hStrawEffDetPhi_B->Fill(phi_module, 1.0);
2709  }
2710 
2711  if (m_doStraws && m_doShift) {
2712  m_nStrawHits_B[thisStrawNumber[ibe]]++;
2713  }
2714  } else if (ibe == 1) {
2715  hitontrack[ibe]++;
2716  hitontrack_E_side[iside]++;
2717 
2718  if (m_doShift) {
2719  m_hStrawEffDetPhi_E[iside]->Fill(phi_module, 1.0);
2720  }
2721 
2722  if (m_doStraws && m_doShift) {
2723  m_nStrawHits_E[iside][thisStrawNumber[ibe]]++;
2724  }
2725  }
2726 
2727  if (m_doStraws && m_doExpert) {
2728  m_hStrawsEff[ibe][iphi_module]->Fill(thisStrawNumber[ibe], 1.0);
2729  }
2730 
2731  if (m_doChips && m_doExpert) {
2732  m_hChipsEff[ibe][iphi_module]->Fill((chip[ibe] - 1), 1.0);
2733  }
2734  }
2735  } else {
2736  if (m_idHelper->is_trt(DCoTId)) { //ToDo:Is this really needed
2737  if (ibe == 0) {
2738  if (m_doShift) {
2739  m_hStrawEffDetPhi_B->Fill(phi_module, 0.0);
2740  }
2741 
2742  if (m_doStraws && m_doShift) {
2743  m_nStrawHits_B[thisStrawNumber[ibe]]++;
2744  }
2745  } else if (ibe == 1) {
2746  if (m_doShift) {
2747  m_hStrawEffDetPhi_E[iside]->Fill(phi_module, 0.0);
2748  }
2749 
2750  if (m_doStraws && m_doShift) {
2751  m_nStrawHits_E[iside][thisStrawNumber[ibe]]++;
2752  }
2753  }
2754 
2755  if (m_doStraws && m_doExpert) {
2756  m_hStrawsEff[ibe][iphi_module]->Fill(thisStrawNumber[ibe], 0.0);
2757  }
2758 
2759  if (m_doChips && m_doExpert) {
2760  m_hChipsEff[ibe][iphi_module]->Fill((chip[ibe] - 1), 0.0);
2761  }
2762  }
2763  }
2764 
2765  const InDet::TRT_DriftCircle *RawDriftCircle = dynamic_cast<const InDet::TRT_DriftCircle *>(trtCircle->prepRawData());
2766  bool isTubeHit = (mesb->localCovariance()(Trk::locX, Trk::locX) > 1.0) ? 1 : 0;
2767 
2768  if (RawDriftCircle) {
2769  nTRTHits_side[ibe][iside]++;
2770  int middleHTbit = RawDriftCircle->getWord() & 0x00020000;
2771  //0x00020000 = 0000 0000 0000 0000 0000 0010 0000 0000 0000 0000
2772  int hitinvaliditygate = RawDriftCircle->getWord() & 0x000DFE80;
2773  //0x000DFE80 = 0000 0000 0000 0000 0000 1101 1111 1110 1000 0000 //
2774  bool is_middleHTbit_high = (middleHTbit != 0);
2775  bool is_anybininVgate_high = (hitinvaliditygate != 0);
2776  float timeOverThreshold = RawDriftCircle->timeOverThreshold();
2777  double t0 = m_TRTCalDbTool->getT0(DCoTId, TRTCond::ExpandedIdentifier::STRAW);
2778 
2779 
2780  if (m_doExpert && m_doStraws) {
2781  m_hHitToTonTMapS[ibe][iphi_module]->Fill(thisStrawNumber[ibe], timeOverThreshold);
2782  // NOTE: this looks redundant
2783  m_hHitHonTMapS[ibe][iphi_module]->Fill(thisStrawNumber[ibe], 1.0);
2784 
2785  if (is_middleHTbit_high) {
2786  m_hHitHonTMapS[ibe][iphi_module]->Fill(thisStrawNumber[ibe], 1.0);
2787  m_hHitHWonTMapS[ibe][iphi_module]->Fill(thisStrawNumber[ibe], 1.0);
2788  }
2789  }
2790 
2791  if (m_doExpert && m_doChips) {
2792  m_hHitToTonTMapC[ibe][iphi_module]->Fill((chip[ibe] - 1), timeOverThreshold);
2793 
2794  if (is_middleHTbit_high) {
2795  m_hHitHWonTMapC[ibe][iphi_module]->Fill(chip[ibe] - 1);
2796  m_hHitHonTMapC[ibe][iphi_module]->Fill(chip[ibe] - 1);
2797  }
2798  }
2799 
2800  const bool driftTimeValid = RawDriftCircle->driftTimeValid();
2801 
2802  if (driftTimeValid) {
2803  const float validRawDriftTime = RawDriftCircle->rawDriftTime();
2804 
2805  if (m_doExpert && m_doStraws)
2806  m_hValidRawDriftTimeonTrk[ibe][iphi_module]->Fill(thisStrawNumber[ibe], validRawDriftTime);
2807 
2808  if (m_doExpert && m_doChips)
2809  m_hValidRawDriftTimeonTrkC[ibe][iphi_module]->Fill((chip[ibe] - 1), validRawDriftTime);
2810  }
2811 
2812  if (m_doShift && m_doStraws) {
2813  if (ibe == 0) {
2814  if (isArgonStraw)
2815  m_hDriftTimeonTrkDist_B_Ar->Fill(RawDriftCircle->rawDriftTime());
2816  else
2817  m_hDriftTimeonTrkDist_B->Fill(RawDriftCircle->rawDriftTime());
2818  } else if (ibe == 1) {
2819  if (isArgonStraw)
2820  m_hDriftTimeonTrkDist_E_Ar[iside]->Fill(RawDriftCircle->rawDriftTime());
2821  else
2822  m_hDriftTimeonTrkDist_E[iside]->Fill(RawDriftCircle->rawDriftTime());
2823  }
2824  }
2825 
2826  float locR_err = 0.0;
2827  const AmgSymMatrix(5)* b_err = aTrackParam->covariance();
2828 
2829  if (b_err) {
2830  locR_err = Amg::error(*b_err, Trk::locR);
2831  } else {
2832  ATH_MSG_ERROR("Track parameters have no covariance attached.");
2833  }
2834 
2835  float loc_err = sqrt(Amg::error(trtCircle->localCovariance(), Trk::driftRadius));
2836  float locR = aTrackParam->parameters()[Trk::driftRadius];
2837  float loc = trtCircle->localParameters()[Trk::driftRadius];
2838 
2839  if (isTubeHit) {
2840  bool isOK = false;
2841  loc = m_drifttool->driftRadius(RawDriftCircle->rawDriftTime(), DCoTId, t0, isOK);
2842 
2843  if ((loc * locR) < 0) loc = -loc;
2844  }
2845 
2846  // Calculate Residuals for hit
2847  if (m_doShift && m_doStraws) {
2848  const double pull_b =
2849  ((loc - locR) /
2850  sqrt((loc_err * loc_err * loc_err * loc_err) -
2851  (locR_err * locR_err * locR_err * locR_err)));
2852  const double thist0 = m_TRTCalDbTool->getT0(surfaceID);
2853  const double trkdrifttime = (!rtr) ? 0 : rtr->drifttime(fabs(locR));
2854  const double timeresidual = RawDriftCircle->rawDriftTime() - thist0 - trkdrifttime;
2855 
2856  if (ibe == 0) {
2857  if (!isTubeHit) {
2858  m_Pull_Biased_Barrel->Fill(pull_b);
2859  }
2860 
2861  if (isArgonStraw) {
2862  m_hResidual_B_Ar->Fill(loc - locR);
2863 
2864  if (cnst_is_pT_over_20GeV) {
2865  m_hResidual_B_Ar_20GeV->Fill(loc - locR);
2866  }
2867 
2868  m_hTimeResidual_B_Ar->Fill(timeresidual);
2869  } else {
2870  m_hResidual_B->Fill(loc - locR);
2871  m_hTimeResidual_B->Fill(timeresidual);
2872 
2873  if (cnst_is_pT_over_20GeV) {
2874  m_hResidual_B_20GeV->Fill(loc - locR);
2875  }
2876  }
2877  } else if (ibe == 1) {
2878  if (!isTubeHit) {
2879  m_Pull_Biased_EndCap->Fill(pull_b);
2880  }
2881 
2882  if (isArgonStraw) {
2883  m_hResidual_E_Ar[iside]->Fill(loc - locR);
2884  m_hTimeResidual_E_Ar[iside]->Fill(timeresidual);
2885 
2886  if (cnst_is_pT_over_20GeV) {
2887  m_hResidual_E_Ar_20GeV[iside]->Fill(loc - locR);
2888  }
2889  } else {
2890  m_hResidual_E[iside]->Fill(loc - locR);
2891  m_hTimeResidual_E[iside]->Fill(timeresidual);
2892 
2893  if (cnst_is_pT_over_20GeV) {
2894  m_hResidual_E_20GeV[iside]->Fill(loc - locR);
2895  }
2896  }
2897  }
2898  }
2899 
2900  if (m_doShift) {
2901  if (ibe == 0) {
2902  if (isArgonStraw) {
2903  m_hWireToTrkPosition_B_Ar->Fill(locR);
2904  } else {
2905  m_hWireToTrkPosition_B->Fill(locR);
2906  }
2907  } else if (ibe == 1) {
2908  if (isArgonStraw) {
2909  m_hWireToTrkPosition_E_Ar[iside]->Fill(locR);
2910  } else {
2911  m_hWireToTrkPosition_E[iside]->Fill(locR);
2912  }
2913  }
2914  }
2915 
2916  const float LE = (RawDriftCircle->driftTimeBin()) * 3.125;
2917  const float EP = timeCor;
2918 
2919  if (m_doShift && m_doStraws) {
2920  if (ibe == 0) {
2921  if (isArgonStraw) {
2922  if (m_isCosmics) {
2923  m_hrtRelation_B_Ar->Fill(LE - EP - t0, fabs(locR));
2924  } else {
2925  m_hrtRelation_B_Ar->Fill(LE - t0, fabs(locR));
2926  }
2927  } else {
2928  if (m_isCosmics) {
2929  m_hrtRelation_B->Fill(LE - EP - t0, fabs(locR));
2930  } else {
2931  m_hrtRelation_B->Fill(LE - t0, fabs(locR));
2932  }
2933  }
2934  } else if (ibe == 1) {
2935  if (isArgonStraw) {
2936  if (m_isCosmics) {
2937  m_hrtRelation_E_Ar[iside]->Fill(LE - EP - t0, fabs(locR));
2938  } else {
2939  m_hrtRelation_E_Ar[iside]->Fill(LE - t0, fabs(locR));
2940  }
2941  } else {
2942  if (m_isCosmics) {
2943  m_hrtRelation_E[iside]->Fill(LE - EP - t0, fabs(locR));
2944  } else {
2945  m_hrtRelation_E[iside]->Fill(LE - t0, fabs(locR));
2946  }
2947  }
2948  }
2949  }
2950 
2951  const int driftTimeBin = RawDriftCircle->driftTimeBin();
2952 
2953  if ( (driftTimeBin < 24) &&
2954  !(RawDriftCircle->lastBinHigh()) &&
2955  !(RawDriftCircle->firstBinHigh()) ) {
2956  if (m_doStraws) {
2957  if (ibe == 0) {
2958  m_hHitWonTMap_B->Fill(thisStrawNumber[ibe]);
2959  } else if (ibe == 1) {
2960  m_hHitWonTMap_E[iside]->Fill(thisStrawNumber[ibe]);
2961  }
2962  }
2963  }
2964 
2965  if ((driftTimeBin > 2) && (driftTimeBin < 17)) {
2966  if (m_doExpert && m_doStraws)
2967  m_hHitWonTMapS[ibe][iphi_module]->Fill(thisStrawNumber[ibe], 1.0);
2968 
2969  if (m_doExpert && m_doChips)
2970  m_hHitWonTMapC[ibe][iphi_module]->Fill(chip[ibe] - 1, 1.0);
2971  }
2972 
2973  const int trailingEdge = RawDriftCircle->trailingEdge();
2974  float trailingEdgeScaled = (trailingEdge + 1) * 3.125;
2975 
2976  if ((trailingEdge < 23) &&
2977  !(RawDriftCircle->lastBinHigh()) &&
2978  !(RawDriftCircle->firstBinHigh())) {
2979  if (m_doExpert && m_doStraws)
2980  m_hHitTronTMapS[ibe][iphi_module]->Fill(thisStrawNumber[ibe], trailingEdgeScaled);
2981 
2982  if (m_doExpert && m_doChips)
2983  m_hHitTronTMapC[ibe][iphi_module]->Fill(chip[ibe] - 1, trailingEdgeScaled);
2984 
2985  if (m_doExpert && m_doStraws)
2986  m_hHitTronTwEPCMapS[ibe][iphi_module]->Fill(thisStrawNumber[ibe], trailingEdgeScaled - timeCor);// Mean TE on Track (with Event Phase correction): Straws
2987 
2988  if (m_doExpert && m_doChips)
2989  m_hHitTronTwEPCMapC[ibe][iphi_module]->Fill((chip[ibe] - 1), trailingEdgeScaled - timeCor); // Mean TE on Track (with Event Phase correction): Chips
2990 
2991  if (m_doShift && m_doStraws) {
2992  if (RawDriftCircle->driftTimeValid()) {
2993  if (ibe == 0) {
2994  if (isArgonStraw) {
2995  m_hTronTDist_B_Ar->Fill(trailingEdgeScaled);
2996  m_hAvgTroTDetPhi_B_Ar->Fill(phi2D[ibe], trailingEdgeScaled);
2997  } else {
2998  m_hTronTDist_B->Fill(trailingEdgeScaled);
2999  m_hAvgTroTDetPhi_B->Fill(phi2D[ibe], trailingEdgeScaled);
3000  }
3001  } else if (ibe == 1) {
3002  if (isArgonStraw) {
3003  m_hTronTDist_E_Ar[iside]->Fill(trailingEdgeScaled);
3004  m_hAvgTroTDetPhi_E_Ar[iside]->Fill(phi2D[ibe], trailingEdgeScaled);
3005  } else {
3006  m_hTronTDist_E[iside]->Fill(trailingEdgeScaled);
3007  m_hAvgTroTDetPhi_E[iside]->Fill(phi2D[ibe], trailingEdgeScaled);
3008  }
3009  }
3010  }
3011  }
3012  }
3013 
3014  const bool firstBinHigh = RawDriftCircle->firstBinHigh();
3015  const bool lastBinHigh = RawDriftCircle->lastBinHigh();
3016 
3017  if (firstBinHigh || lastBinHigh || driftTimeBin > 0 || trailingEdge < 23) {
3018  if (m_doExpert && m_doStraws)
3019  m_hHitAonTMapS[ibe][iphi_module]->Fill(thisStrawNumber[ibe]);
3020 
3021  if (m_doExpert && m_doChips)
3022  m_hHitAonTMapC[ibe][iphi_module]->Fill(chip[ibe] - 1);
3023 
3024  nTRTHitsW[ibe][iside]++;
3025 
3026  if (isArgonStraw) {
3027  nTRTHitsW_Ar[ibe][iside]++;
3028  } else {
3029  nTRTHitsW_Xe[ibe][iside]++;
3030  }
3031 
3032  nTRTHitsW_perwheel[iside][layer_or_wheel]++;
3033 
3034  if (is_middleHTbit_high) {
3035  nTRTHLHitsW[ibe][iside]++;
3036 
3037  if (isArgonStraw) {
3038  nTRTHLHitsW_Ar[ibe][iside]++;
3039  } else {
3040  nTRTHLHitsW_Xe[ibe][iside]++;
3041  }
3042  }
3043  }
3044 
3045  if (is_anybininVgate_high) {
3046  if (m_doExpert && m_doStraws)
3047  m_hHitAWonTMapS[ibe][iphi_module]->Fill(thisStrawNumber[ibe]);
3048 
3049  if (m_doExpert && m_doChips)
3050  m_hHitAWonTMapC[ibe][iphi_module]->Fill(chip[ibe] - 1);
3051  }
3052  }
3053  }
3054 
3055  //ToDo: work on the part below
3056  for (int ibe = 0; ibe < 2; ibe++) {
3057  for (int i = 0; i < 64; i++)
3058  if (trackfound[ibe][i])
3059  ntrackstack[ibe][i]++;
3060 
3061  if (m_doShift) {
3062  if (ibe == 0) {
3063  if (hitontrack[ibe] >= m_minTRThits)
3064  m_hNumHoTDetPhi_B->Fill(phi2D[ibe], hitontrack[ibe]);
3065  }
3066 
3067  if (ibe == 1) {
3068  if (hitontrack_E_side[0] >= m_minTRThits)
3069  m_hNumHoTDetPhi_E[0]->Fill(phi2D[ibe], hitontrack_E_side[0]);
3070 
3071  if (hitontrack_E_side[1] >= m_minTRThits)
3072  m_hNumHoTDetPhi_E[1]->Fill(phi2D[ibe], hitontrack_E_side[1]);
3073  }
3074  }
3075 
3076  if (phi2D[ibe] < 0) continue;
3077 
3078  if (m_doShift) {
3079  if (ibe == 0) {
3080  if (nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1] > 0)
3081  m_hNumTrksDetPhi_B->Fill(phi2D[ibe]);
3082  } else if (ibe == 1) {
3083  if (nTRTHitsW[ibe][0] > 0)
3084  m_hNumTrksDetPhi_E[0]->Fill(phi2D[ibe]);
3085 
3086  if (nTRTHitsW[ibe][1] > 0)
3087  m_hNumTrksDetPhi_E[1]->Fill(phi2D[ibe]);
3088  }
3089  }
3090 
3091  if (m_doShift) {
3092  if (innerstack[ibe] >= 0 && innerstack[ibe] < s_iStack_max[ibe]) {
3093  if (ibe == 0) {
3094  m_LonTrack_B[innerstack[ibe]] += nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1];
3095 
3096  if (nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1] > 0) {
3097  m_HTfraconTrack_B[innerstack[ibe]] += (float)(nTRTHLHitsW[ibe][0] + nTRTHLHitsW[ibe][1]) / (nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1]);
3098  m_nTrack_B[innerstack[ibe]] = m_nTrack_B[innerstack[ibe]] + 1;
3099  }
3100  } else if (ibe == 1) {
3101  m_LonTrack_E[innerstack[ibe]] += nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1];
3102 
3103  if ((nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1]) > 0) {
3104  m_HTfraconTrack_E[innerstack[ibe]] += (float)(nTRTHLHitsW[ibe][0] + nTRTHLHitsW[ibe][1]) / (nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1]);
3105  m_nTrack_E[innerstack[ibe]] = m_nTrack_E[innerstack[ibe]] + 1;
3106  }
3107  }
3108  }
3109  }
3110 
3111  if (m_doShift) {
3112  if (ibe == 0) {
3113  if (isBarrelOnly) {
3114  if (nTRTHitsW[ibe][0] > 0) {
3115  if (nTRTHitsW[ibe][1] > 0) m_hNumSwLLWoT_B->Fill(nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1]);
3116  else m_hNumSwLLWoT_B->Fill(nTRTHitsW[ibe][0]);
3117  } else if (nTRTHitsW[ibe][1] > 0) {
3118  m_hNumSwLLWoT_B->Fill(nTRTHitsW[ibe][1]);
3119  }
3120  }
3121 
3122  if (nTRTHLHitsW[ibe][0] > 0) {
3123  if (nTRTHLHitsW[ibe][1] > 0) {
3124  m_hHLhitOnTrack_B->Fill(nTRTHLHitsW[ibe][0] + nTRTHLHitsW[ibe][1]);
3125  } else {
3126  m_hHLhitOnTrack_B->Fill(nTRTHLHitsW[ibe][0]);
3127  }
3128  } else if (nTRTHLHitsW[ibe][1] > 0) {
3129  m_hHLhitOnTrack_B->Fill(nTRTHLHitsW[ibe][1]);
3130  }
3131 
3132  if (nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1] > 0) {
3133  m_hHtoLRatioOnTrack_B->Fill((float)(nTRTHLHitsW[ibe][0] + nTRTHLHitsW[ibe][1]) / (nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1]));
3134  }
3135 
3136  if (nTRTHitsW_Ar[ibe][0] + nTRTHitsW_Ar[ibe][1] > 0) {
3137  m_hHtoLRatioOnTrack_B_Ar->Fill((float)(nTRTHLHitsW_Ar[ibe][0] + nTRTHLHitsW_Ar[ibe][1]) / (nTRTHitsW_Ar[ibe][0] + nTRTHitsW_Ar[ibe][1]));
3138  }
3139 
3140  if (nTRTHitsW_Xe[ibe][0] + nTRTHitsW_Xe[ibe][1] > 0) {
3141  m_hHtoLRatioOnTrack_B_Xe->Fill((float)(nTRTHLHitsW_Xe[ibe][0] + nTRTHLHitsW_Xe[ibe][1]) / (nTRTHitsW_Xe[ibe][0] + nTRTHitsW_Xe[ibe][1]));
3142  }
3143  } else if (ibe == 1) {
3144  if (nTRTHitsW[ibe][0] > 0) {
3145  if (nTRTHitsW[ibe][1] > 0) {
3146  if (ECAhit && !ECChit && !Bhit) {
3147  m_hNumSwLLWoT_E[0]->Fill(nTRTHitsW[ibe][0]);
3148  }
3149 
3150  if (ECChit && !ECAhit && !Bhit) {
3151  m_hNumSwLLWoT_E[1]->Fill(nTRTHitsW[ibe][1]);
3152  }
3153  }
3154 
3155  if (ECAhit && !ECChit && !Bhit) {
3156  m_hNumSwLLWoT_E[0]->Fill(nTRTHitsW[ibe][0]);
3157  }
3158  } else if (nTRTHitsW[ibe][1] > 0) {
3159  if (ECChit && !ECAhit && !Bhit) {
3160  m_hNumSwLLWoT_E[1]->Fill(nTRTHitsW[ibe][1]);
3161  }
3162  }
3163 
3164  for (int iside = 0; iside < 2; iside++) {
3165  if (nTRTHLHitsW[ibe][iside] > 0) {
3166  m_hHLhitOnTrack_E[iside]->Fill(nTRTHLHitsW[ibe][iside]);
3167  }
3168 
3169  if ((nTRTHitsW[ibe][iside]) > 0) {
3170  m_hHtoLRatioOnTrack_E[iside]->Fill((float)(nTRTHLHitsW[ibe][iside]) / nTRTHitsW[ibe][iside]);
3171 
3172  if ((nTRTHitsW_Ar[ibe][iside]) > 0) {
3173  m_hHtoLRatioOnTrack_E_Ar[iside]->Fill((float)(nTRTHLHitsW_Ar[ibe][iside]) / nTRTHitsW_Ar[ibe][iside]);
3174  }
3175 
3176  if ((nTRTHitsW_Xe[ibe][iside]) > 0) {
3177  m_hHtoLRatioOnTrack_E_Xe[iside]->Fill((float)(nTRTHLHitsW_Xe[ibe][iside]) / nTRTHitsW_Xe[ibe][iside]);
3178  }
3179  }
3180  }
3181  }
3182  }
3183 
3184  if (ibe == 0) {
3185  if ((nTRTHitsW[ibe][0] + nTRTHitsW[ibe][1]) > 0) {
3186  m_nTrksperLB_B++;
3187  }
3188  if (comTimeObject) {
3189  if (m_doShift && (phi2D[ibe] > 0) && (std::fabs(timeCor) > 1e-8)) {
3190  m_hEvtPhaseDetPhi_B->Fill(phi2D[ibe], timeCor);
3191  }
3192  }
3193  } else if (ibe == 1) {
3194  for (int iside = 0; iside < 2; iside++) {
3195  if (nTRTHitsW[ibe][iside] > 0) m_nTrksperLB_E[iside]++;
3196  if (comTimeObject) {
3197  if (nTRTHits_side[ibe][iside] > 5 && (std::fabs(timeCor)
3198  > 1e-8)) {
3199  if (m_doShift) m_hEvtPhaseDetPhi_E[iside]->Fill(phi2D[ibe], timeCor);
3200  }
3201  }
3202  }
3203  }
3204  }
3205  }
3206 
3207  if (comTimeObject) {
3208  if (std::fabs(timeCor) > 1e-8) {
3209  if (m_doShift) {
3210  m_hEvtPhase->Fill(timeCor);
3211  }
3212 
3213  if (m_doShift && trigDecision) {
3214  std::vector<int> trigid;
3215  trigid.clear(); // Trigger ID
3216  // get bits for trigger after veto
3217  std::vector<unsigned int> level1TAV = trigDecision->tav();
3218 
3219  for (unsigned int j = 0; j < 8 && j < level1TAV.size(); ++j) {
3220  for (unsigned int i = 0; i < 32; ++i) {
3221  if ((level1TAV[j] >> i) & 0x1) {
3222  trigid.push_back(i + (j % 8) * 32); // Found the ID
3223  }
3224  }
3225  }
3226 
3227  for (unsigned int j = 0; j < trigid.size(); ++j) {
3228  m_hEvtPhaseVsTrig->Fill(timeCor, trigid[j]);// Event Phase vs. Trigger Item
3229  }
3230  }
3231  }
3232  }
3233 
3234  for (int ibe = 0; ibe < 2; ibe++) {
3235  if (m_environment == AthenaMonManager::online && m_totalEvents > 0) {
3236  //Loop over stack histograms and normalize to number of events processed.
3237  if (m_doChips && m_doExpert) {
3238  for (int i = 0; i < 64; i++) {
3239  divide_LWHist(m_hHitOnTrackVsAllC[ibe][i], m_hHitAonTMapC[ibe][i], m_hHitAMapC[ibe][i]);
3240 
3241  for (int j = 0; j < s_iChip_max[ibe]; j++) {
3242  if (m_hChipsEff[ibe][i]->GetBinEntries(j + 1) > 0) {
3243  float effScale = 1. / m_hChipsEff[ibe][i]->GetBinEntries(j + 1);
3244  int binContent = m_hHitAonTMapC[ibe][i]->GetBinContent(j + 1);
3245  m_hHitAonTMapC[ibe][i]->SetBinContent(j + 1, binContent * effScale);
3246  binContent = m_hHitAWonTMapC[ibe][i]->GetBinContent(j + 1);
3247  m_hHitAWonTMapC[ibe][i]->SetBinContent(j + 1, binContent * effScale);
3248  binContent = m_hHitHonTMapC[ibe][i]->GetBinContent(j + 1);
3249  m_hHitHonTMapC[ibe][i]->SetBinContent(j + 1, binContent * effScale);
3250  binContent = m_hHitHWonTMapC[ibe][i]->GetBinContent(j + 1);
3251  m_hHitHWonTMapC[ibe][i]->SetBinContent(j + 1, binContent * effScale);
3252  binContent = m_hHitWonTMapC[ibe][i]->GetBinContent(j + 1);
3253  m_hHitWonTMapC[ibe][i]->SetBinContent(j + 1, binContent * effScale);
3254  } else {
3255  m_hHitAonTMapC[ibe][i]->SetBinContent(j + 1, 0);
3256  m_hHitHonTMapC[ibe][i]->SetBinContent(j + 1, 0);
3257  m_hHitWonTMapC[ibe][i]->SetBinContent(j + 1, 0);
3258  m_hHitAWonTMapC[ibe][i]->SetBinContent(j + 1, 0);
3259  m_hHitHWonTMapC[ibe][i]->SetBinContent(j + 1, 0);
3260  }
3261  }
3262 
3263  divide_LWHist(m_hHtoLMapC[ibe][i], m_hHitHMapC[ibe][i], m_hHitAMapC[ibe][i]);
3264  divide_LWHist(m_hHtoLonTMapC[ibe][i], m_hHitHonTMapC[ibe][i], m_hHitAonTMapC[ibe][i]);
3265  divide_LWHist(m_hHtoLWonTMapC[ibe][i], m_hHitHWonTMapC[ibe][i], m_hHitAWonTMapC[ibe][i]);
3266  }
3267  }
3268 
3269  if (m_doStraws) {
3270  for (int i = 0; i < 64; i++) {
3271  if (m_doExpert) {
3272  divide_LWHist(m_hHitOnTrackVsAllS[ibe][i], m_hHitAonTMapS[ibe][i], m_hHitAMapS[ibe][i]);
3273  }
3274 
3275  for (int j = 0; j < s_Straw_max[ibe]; j++) {
3276  if (i == 0) {
3277  if (ibe == 0) {
3278  if (m_nStrawHits_B[j] > 0) {
3279  m_hHitWonTMap_B->SetBinContent(j + 1, m_hHitWonTMap_B->GetBinContent(j + 1) / m_nStrawHits_B[j]);
3280  }
3281  } else if (ibe == 1) {
3282  if (m_nStrawHits_E[0][j] > 0) {
3283  m_hHitWonTMap_E[0]->SetBinContent(j + 1, m_hHitWonTMap_E[0]->GetBinContent(j + 1) / m_nStrawHits_E[0][j]);
3284  }
3285 
3286  if (m_nStrawHits_E[1][j] > 0) {
3287  m_hHitWonTMap_E[1]->SetBinContent(j + 1, m_hHitWonTMap_E[1]->GetBinContent(j + 1) / m_nStrawHits_E[1][j]);
3288  }
3289  }
3290  }
3291 
3292  if (m_doExpert) {
3293  if (m_hStrawsEff[ibe][i]->GetBinEntries(j + 1) > 0) {
3294  float effScale = 1. / m_hStrawsEff[ibe][i]->GetBinEntries(j + 1);
3295  int binContent = m_hHitAonTMapS[ibe][i]->GetBinContent(j + 1);
3296  m_hHitAonTMapS[ibe][i]->SetBinContent(j + 1, binContent * effScale);
3297  binContent = m_hHitAWonTMapS[ibe][i]->GetBinContent(j + 1);
3298  m_hHitAWonTMapS[ibe][i]->SetBinContent(j + 1, binContent * effScale);
3299  binContent = m_hHitHonTMapS[ibe][i]->GetBinContent(j + 1);
3300  m_hHitHonTMapS[ibe][i]->SetBinContent(j + 1, binContent * effScale);
3301  binContent = m_hHitHWonTMapS[ibe][i]->GetBinContent(j + 1);
3302  m_hHitHWonTMapS[ibe][i]->SetBinContent(j + 1, binContent * effScale);
3303  binContent = m_hHitWonTMapS[ibe][i]->GetBinContent(j + 1);
3304  m_hHitWonTMapS[ibe][i]->SetBinContent(j + 1, binContent * effScale);
3305  } else {
3306  m_hHitAWonTMapS[ibe][i]->SetBinContent(j + 1, 0);
3307  m_hHitAonTMapS[ibe][i]->SetBinContent(j + 1, 0);
3308  m_hHitHonTMapS[ibe][i]->SetBinContent(j + 1, 0);
3309  m_hHitHWonTMapS[ibe][i]->SetBinContent(j + 1, 0);
3310  m_hHitWonTMapS[ibe][i]->SetBinContent(j + 1, 0);
3311  }
3312  }
3313  }
3314 
3315  if (m_doExpert) {
3316  divide_LWHist(m_hHtoLMapS[ibe][i], m_hHitHMapS[ibe][i], m_hHitAMapS[ibe][i]);
3317  divide_LWHist(m_hHtoLonTMapS[ibe][i], m_hHitHonTMapS[ibe][i], m_hHitAonTMapS[ibe][i]);
3318  divide_LWHist(m_hHtoLWonTMapS[ibe][i], m_hHitHWonTMapS[ibe][i], m_hHitAWonTMapS[ibe][i]);
3319  }
3320  }
3321  }
3322 
3323  if (m_doShift) {
3324  if (ibe == 0) {
3325  m_hSummary->SetBinContent(2, m_nTotalTracks);
3326  m_hSummary->SetBinContent(3, m_nTracksB[0]);
3327  m_hSummary->SetBinContent(4, m_nTracksB[1]);
3328  m_hSummary->SetBinContent(5, m_nTracksEC[0]);
3329  m_hSummary->SetBinContent(6, m_nTracksEC[1]);
3330  m_hSummary->SetBinContent(7, m_nTracksEC_B[0]);
3331  m_hSummary->SetBinContent(8, m_nTracksEC_B[1]);
3332  m_EventPhaseScale = m_hEvtPhase->GetEntries() * 3.125;
3333 
3334  if (m_EventPhaseScale > 0) {
3335  scale_LWHist(m_hEvtPhase, 1. / m_EventPhaseScale);
3336  }
3337 
3338  m_DriftTimeonTrkDistScale_B = m_hDriftTimeonTrkDist_B->GetEntries() * 3.125;
3339 
3340  if (m_DriftTimeonTrkDistScale_B > 0) {
3341  scale_LWHist(m_hDriftTimeonTrkDist_B, 1. / m_DriftTimeonTrkDistScale_B);
3342  }
3343 
3344  m_HLhitOnTrackScale_B = m_hHLhitOnTrack_B->GetEntries();
3345 
3346  if (m_HLhitOnTrackScale_B > 0) {
3347  scale_LWHist(m_hHLhitOnTrack_B, 1. / m_HLhitOnTrackScale_B);
3348  }
3349 
3350  m_HtoLRatioOnTrackScale_B = m_hHtoLRatioOnTrack_B->GetEntries() * 0.02;
3351 
3352  if (m_HtoLRatioOnTrackScale_B > 0) {
3353  scale_LWHist(m_hHtoLRatioOnTrack_B, 1. / m_HtoLRatioOnTrackScale_B);
3354  }
3355 
3356  m_NumSwLLWoTScale_B = m_hNumSwLLWoT_B->GetEntries();
3357 
3358  if (m_NumSwLLWoTScale_B > 0) {
3359  scale_LWHist(m_hNumSwLLWoT_B, 1. / m_NumSwLLWoTScale_B);
3360  }
3361 
3362  m_WireToTrkPositionScale_B = m_hWireToTrkPosition_B->GetEntries() * 0.1;
3363 
3364  if (m_WireToTrkPositionScale_B > 0) {
3365  scale_LWHist(m_hWireToTrkPosition_B, 1. / m_WireToTrkPositionScale_B);
3366  }
3367 
3368  m_TronTDistScale_B = m_hTronTDist_B->GetEntries() * 3.125;
3369 
3370  if (m_TronTDistScale_B > 0) {
3371  scale_LWHist(m_hTronTDist_B, 1. / m_TronTDistScale_B);
3372  }
3373 
3374  m_ResidualScale_B = m_hResidual_B->GetEntries() * 0.025;
3375 
3376  if (m_ResidualScale_B > 0) {
3377  scale_LWHist(m_hResidual_B, 1. / m_ResidualScale_B);
3378  }
3379 
3380  m_ResidualScale_B_20GeV = m_hResidual_B_20GeV->GetEntries() * 0.025;
3381 
3382  if (m_ResidualScale_B_20GeV > 0) {
3383  scale_LWHist(m_hResidual_B_20GeV, 1. / m_ResidualScale_B_20GeV);
3384  }
3385 
3386  m_TimeResidualScale_B = m_hTimeResidual_B->GetEntries() * 0.2;
3387 
3388  if (m_TimeResidualScale_B > 0) {
3389  scale_LWHist(m_hTimeResidual_B, 1. / m_TimeResidualScale_B);
3390  }
3391 
3392  if (m_ArgonXenonSplitter) {
3393  m_DriftTimeonTrkDistScale_B_Ar = m_hDriftTimeonTrkDist_B_Ar->GetEntries() * 3.125;
3394 
3395  if (m_DriftTimeonTrkDistScale_B_Ar > 0) {
3396  scale_LWHist(m_hDriftTimeonTrkDist_B_Ar, 1. / m_DriftTimeonTrkDistScale_B_Ar);
3397  }
3398 
3399  m_WireToTrkPositionScale_B_Ar = m_hWireToTrkPosition_B_Ar->GetEntries() * 0.1;
3400 
3401  if (m_WireToTrkPositionScale_B_Ar > 0) {
3402  scale_LWHist(m_hWireToTrkPosition_B_Ar, 1. / m_WireToTrkPositionScale_B_Ar);
3403  }
3404 
3405  m_TronTDistScale_B_Ar = m_hTronTDist_B_Ar->GetEntries() * 3.125;
3406 
3407  if (m_TronTDistScale_B_Ar > 0) {
3408  scale_LWHist(m_hTronTDist_B_Ar, 1. / m_TronTDistScale_B_Ar);
3409  }
3410 
3411  m_ResidualScale_B_Ar = m_hResidual_B_Ar->GetEntries() * 0.025;
3412 
3413  if (m_ResidualScale_B_Ar > 0) {
3414  scale_LWHist(m_hResidual_B_Ar, 1. / m_ResidualScale_B_Ar);
3415  }
3416 
3417  m_ResidualScale_B_Ar_20GeV = m_hResidual_B_Ar_20GeV->GetEntries() * 0.025;
3418 
3419  if (m_ResidualScale_B_Ar_20GeV > 0) {
3420  scale_LWHist(m_hResidual_B_Ar_20GeV, 1. / m_ResidualScale_B_Ar_20GeV);
3421  }
3422 
3423  m_TimeResidualScale_B_Ar = m_hTimeResidual_B_Ar->GetEntries() * 0.2;
3424 
3425  if (m_TimeResidualScale_B_Ar > 0) {
3426  scale_LWHist(m_hTimeResidual_B_Ar, 1. / m_TimeResidualScale_B_Ar);
3427  }
3428  }
3429  } else if (ibe == 1) {
3430  for (int iside = 0; iside < 2; iside++) {
3431  m_DriftTimeonTrkDistScale_E[iside] = m_hDriftTimeonTrkDist_E[iside]->GetEntries() * 3.125;
3432 
3433  if (m_DriftTimeonTrkDistScale_E[iside] > 0) {
3434  scale_LWHist(m_hDriftTimeonTrkDist_E[iside], 1. / m_DriftTimeonTrkDistScale_E[iside]);
3435  }
3436 
3437  m_HLhitOnTrackScale_E[iside] = m_hHLhitOnTrack_E[iside]->GetEntries();
3438 
3439  if (m_HLhitOnTrackScale_E[iside] > 0) {
3440  scale_LWHist(m_hHLhitOnTrack_E[iside], 1. / m_HLhitOnTrackScale_E[iside]);
3441  }
3442 
3443  m_HtoLRatioOnTrackScale_E[iside] = m_hHtoLRatioOnTrack_E[iside]->GetEntries() * 0.02;
3444 
3445  if (m_HtoLRatioOnTrackScale_E[iside] > 0) {
3446  scale_LWHist(m_hHtoLRatioOnTrack_E[iside], 1. / m_HtoLRatioOnTrackScale_E[iside]);
3447  }
3448 
3449  m_NumSwLLWoTScale_E[iside] = m_hNumSwLLWoT_E[iside]->GetEntries();
3450 
3451  if (m_NumSwLLWoTScale_E[iside] > 0) {
3452  scale_LWHist(m_hNumSwLLWoT_E[iside], 1. / m_NumSwLLWoTScale_E[iside]);
3453  }
3454 
3455  m_WireToTrkPositionScale_E[iside] = m_hWireToTrkPosition_E[iside]->GetEntries() * 0.1;
3456 
3457  if (m_WireToTrkPositionScale_E[iside] > 0) {
3458  scale_LWHist(m_hWireToTrkPosition_E[iside], 1. / m_WireToTrkPositionScale_E[iside]);
3459  }
3460 
3461  m_TronTDistScale_E[iside] = m_hTronTDist_E[iside]->GetEntries() * 3.125;
3462 
3463  if (m_TronTDistScale_E[iside] > 0) {
3464  scale_LWHist(m_hTronTDist_E[iside], 1. / m_TronTDistScale_E[iside]);
3465  }
3466 
3467  m_ResidualScale_E[iside] = m_hResidual_E[iside]->GetEntries() * 0.025;
3468 
3469  if (m_ResidualScale_E[iside] > 0) {
3470  scale_LWHist(m_hResidual_E[iside], 1. / m_ResidualScale_E[iside]);
3471  }
3472 
3473  m_ResidualScale_E_20GeV[iside] = m_hResidual_E_20GeV[iside]->GetEntries() * 0.025;
3474 
3475  if (m_ResidualScale_E_20GeV[iside] > 0) {
3476  scale_LWHist(m_hResidual_E_20GeV[iside], 1. / m_ResidualScale_E_20GeV[iside]);
3477  }
3478 
3479  m_TimeResidualScale_E[iside] = m_hTimeResidual_E[iside]->GetEntries() * 0.2;
3480 
3481  if (m_TimeResidualScale_E[iside] > 0) {
3482  scale_LWHist(m_hTimeResidual_E[iside], 1. / m_TimeResidualScale_E[iside]);
3483  }
3484 
3485  if (m_ArgonXenonSplitter) {
3486  m_DriftTimeonTrkDistScale_E_Ar[iside] = m_hDriftTimeonTrkDist_E_Ar[iside]->GetEntries() * 3.125;
3487 
3488  if (m_DriftTimeonTrkDistScale_E_Ar[iside] > 0) {
3489  scale_LWHist(m_hDriftTimeonTrkDist_E_Ar[iside], 1. / m_DriftTimeonTrkDistScale_E_Ar[iside]);
3490  }
3491 
3492  m_WireToTrkPositionScale_E_Ar[iside] = m_hWireToTrkPosition_E_Ar[iside]->GetEntries() * 0.1;
3493 
3494  if (m_WireToTrkPositionScale_E_Ar[iside] > 0) {
3495  scale_LWHist(m_hWireToTrkPosition_E_Ar[iside], 1. / m_WireToTrkPositionScale_E_Ar[iside]);
3496  }
3497 
3498  m_TronTDistScale_E_Ar[iside] = m_hTronTDist_E_Ar[iside]->GetEntries() * 3.125;
3499 
3500  if (m_TronTDistScale_E_Ar[iside] > 0) {
3501  scale_LWHist(m_hTronTDist_E_Ar[iside], 1. / m_TronTDistScale_E_Ar[iside]);
3502  }
3503 
3504  m_ResidualScale_E_Ar[iside] = m_hResidual_E_Ar[iside]->GetEntries() * 0.025;
3505 
3506  if (m_ResidualScale_E_Ar[iside] > 0) {
3507  scale_LWHist(m_hResidual_E_Ar[iside], 1. / m_ResidualScale_E_Ar[iside]);
3508  }
3509 
3510  m_ResidualScale_E_Ar_20GeV[iside] = m_hResidual_E_Ar_20GeV[iside]->GetEntries() * 0.025;
3511 
3512  if (m_ResidualScale_E_Ar_20GeV[iside] > 0) {
3513  scale_LWHist(m_hResidual_E_Ar_20GeV[iside], 1. / m_ResidualScale_E_Ar_20GeV[iside]);
3514  }
3515 
3516  m_TimeResidualScale_E_Ar[iside] = m_hTimeResidual_E_Ar[iside]->GetEntries() * 0.2;
3517 
3518  if (m_TimeResidualScale_E_Ar[iside] > 0) {
3519  scale_LWHist(m_hTimeResidual_E_Ar[iside], 1. / m_TimeResidualScale_E_Ar[iside]);
3520  }
3521  }
3522  }
3523  }
3524  }
3525  }
3526  }
3527 
3528  return StatusCode::SUCCESS;
3529 }
3530 
3531 //Fill the TRT Eff histograms
3532 //----------------------------------------------------------------------------------//
3533 StatusCode TRT_Monitoring_Tool::fillTRTEfficiency(const TrackCollection& combTrackCollection) {
3534 //----------------------------------------------------------------------------------//
3535  ATH_MSG_VERBOSE("Filling TRT Eff Histos");
3536  // reduce unnecessary divisions
3537  const float invGeV = 1. / CLHEP::GeV;
3538  const float invmm = 1. / CLHEP::mm;
3539  int itrack = 0;
3540 
3541  for (auto track = combTrackCollection.begin(); track != combTrackCollection.end(); ++track) {
3542  // online: use all tracks, offline: use only every xth track, skip the rest
3543  if (m_environment != AthenaMonManager::online && (itrack % m_every_xth_track) != 0) continue;
3544 
3545  ++itrack;
3546  // get perigee
3547  const Trk::Perigee *perigee = (*track)->perigeeParameters();
3548 
3549  if (perigee) {
3550  m_track_pt = perigee->pT();
3551  m_track_eta = perigee->eta();
3552  m_track_phi = perigee->parameters()[Trk::phi0];
3553  m_track_d0 = perigee->parameters()[Trk::d0];
3554  m_track_z0 = perigee->parameters()[Trk::z0];
3555  ATH_MSG_DEBUG("This track has perigee parameters:\n"
3556  << " pT = " << m_track_pt * invGeV << " GeV" << "\n"
3557  << " eta = " << m_track_eta << "\n"
3558  << " phi0 = " << m_track_phi << "\n"
3559  << " d0 = " << m_track_d0 * invmm << "\n"
3560  << " z0 = " << m_track_z0 * invmm << "\n"
3561  << " theta = " << perigee->parameters()[Trk::theta] << "\n"
3562  << " qOverP = " << perigee->parameters()[Trk::qOverP]);
3563  } else {
3564  ATH_MSG_DEBUG("This track has null perigeeParameters.");
3565  continue;
3566  }
3567 
3568  const Trk::TrackStates *track_states = (*track)->trackStateOnSurfaces();
3569 
3570  if (track_states) {
3571  ATH_MSG_DEBUG("This track has " << track_states->size() << " track states on surface.");
3572  } else {
3573  ATH_MSG_DEBUG("This track has null track states on surface.");
3574  continue;
3575  }
3576 
3577  std::unique_ptr<const Trk::TrackSummary> summary = m_TrackSummaryTool->summary(*(*track));
3578  int n_trt_hits = summary->get(Trk::numberOfTRTHits);
3579  int n_sct_hits = summary->get(Trk::numberOfSCTHits);
3580  int n_pixel_hits = summary->get(Trk::numberOfPixelHits);
3581  float p = 1.0e+08;
3582 
3583  if (perigee) {
3584  p = (perigee->parameters()[Trk::qOverP] != 0.) ? fabs(1. / (perigee->parameters()[Trk::qOverP])) : 1.0e+08;
3585  }
3586 
3587  float min_pt_new = m_min_pT;
3588 
3589  if (!m_isCosmics) {
3590  min_pt_new = 2.0 * CLHEP::GeV;
3591  }
3592 
3593  // preselect tracks
3594  const bool passed_track_preselection =
3595  (fabs(perigee->parameters()[Trk::d0]) < m_max_abs_d0) &&
3596  (fabs(perigee->parameters()[Trk::z0]) < m_max_abs_z0) &&
3597  (perigee->pT() > min_pt_new) &&
3598  (p > m_minP) &&
3599  (fabs(perigee->eta()) < m_max_abs_eta) &&
3600  (n_pixel_hits >= m_min_pixel_hits) &&
3601  (n_sct_hits >= m_min_sct_hits) &&
3602  (n_trt_hits >= m_min_trt_hits);
3603  ATH_MSG_DEBUG("track has ntrt = " << n_trt_hits
3604  << " and nsct = " << n_sct_hits
3605  << " and npix = " << n_pixel_hits);
3606 
3607  if (!passed_track_preselection) {
3608  ATH_MSG_DEBUG("This track failed preselection.");
3609  continue;
3610  }
3611 
3612  ATH_MSG_DEBUG("This track passed preselection.");
3613 
3614  for (auto it = track_states->begin(); it != track_states->end(); it++) {
3615  if ( !((*it)->type(Trk::TrackStateOnSurface::Measurement)) ) continue;
3616 
3617  const Trk::TrackParameters *track_parameters = (*it)->trackParameters();
3618 
3619  if (!track_parameters) continue;
3620 
3621  Identifier id = track_parameters->associatedSurface().associatedDetectorElementIdentifier();
3622 
3623  if ( !((m_pTRTHelper->is_trt(id)) )) continue;
3624 
3625  float locR = track_parameters->parameters()[Trk::driftRadius];
3626  int barrel_ec = m_pTRTHelper->barrel_ec(id);
3627  int layer_or_wheel = m_pTRTHelper->layer_or_wheel(id);
3628  int phi_module = m_pTRTHelper->phi_module(id);
3629  int straw_layer = m_pTRTHelper->straw_layer(id);
3630  int straw = m_pTRTHelper->straw(id);
3631  const bool isArgonStraw = (Straw_Gastype( m_sumTool->getStatusHT(id) ) == GasType::Ar);
3632  // assume always Xe if m_ArgonXenonSplitter is not enabled, otherwise check the straw status (good is Xe, non-good is Ar)
3633  // ibe = 0 (Barrel), ibe = 1 (Endcap)
3634  int ibe = abs(barrel_ec) - 1;
3635  // iside = 0 (Side A), iside = 1 (Side C)
3636  int iside = barrel_ec > 0 ? 0 : 1;
3637 
3638  if (ibe == 0) {
3639  if (isArgonStraw) {
3640  m_hefficiencyBarrel_locR_Ar->Fill(locR, 1.0);
3641  } else {
3642  m_hefficiencyBarrel_locR->Fill(locR, 1.0);
3643  }
3644  } else if (ibe == 1) {
3645  if (isArgonStraw) {
3646  m_hefficiencyEndCap_locR_Ar[iside]->Fill(locR, 1.0);
3647  } else {
3648  m_hefficiencyEndCap_locR[iside]->Fill(locR, 1.0);
3649  }
3650  }
3651 
3652  if (fabs(locR) >= 1.3) continue;
3653 
3654  int thisStrawNumber = 0;
3655  int chip = 0;
3656 
3657  if (ibe == 0) {
3658  thisStrawNumber = strawNumber(straw, straw_layer, layer_or_wheel);
3659 
3660  if (thisStrawNumber >= 0 && thisStrawNumber < s_Straw_max[ibe])
3661  chip = m_mat_chip_B[phi_module][thisStrawNumber];
3662  } else if (ibe == 1) {
3663  thisStrawNumber = strawNumberEndCap(straw, straw_layer, layer_or_wheel, phi_module, barrel_ec);
3664 
3665  if (thisStrawNumber >= 0 && thisStrawNumber < s_Straw_max[ibe])
3666  chip = m_mat_chip_E[phi_module][thisStrawNumber];
3667  }
3668 
3669  m_hefficiencyMap[ibe]->Fill(thisStrawNumber, 1.0);
3670 
3671  if (m_doExpert) {
3672  if (iside == 0) {
3673  m_hefficiencyS[ibe][phi_module]->Fill(thisStrawNumber, 1.0);
3674  m_hefficiencyC[ibe][phi_module]->Fill(chip, 1.0);
3675  } else if (iside == 1) {
3676  m_hefficiencyS[ibe][phi_module + 32]->Fill(thisStrawNumber, 1.0);
3677  m_hefficiencyC[ibe][phi_module + 32]->Fill(chip, 1.0);
3678  }
3679  }
3680 
3681  m_hefficiency_eta->Fill(m_track_eta, 1.0);
3682  m_hefficiency_phi->Fill(m_track_phi, 1.0);
3683  m_hefficiency_pt->Fill(m_track_pt * invGeV, 1.0);
3684  m_hefficiency_z0->Fill(m_track_z0, 1.0);
3685  }
3686 
3687  //use hole finder to find holes on this track !
3688 
3689  if (m_useHoleFinder) {
3690  std::unique_ptr<const Trk::TrackStates> holes (m_trt_hole_finder->getHolesOnTrack(**track));
3691 
3692  if (!holes) {
3693  ATH_MSG_WARNING("TRTTrackHoleSearchTool returned null results.");
3694  continue;
3695  } else {
3696  for (auto it = holes->begin(); it != holes->end(); ++it) {
3697  if ( !((*it)->type(Trk::TrackStateOnSurface::Hole)) ) continue;
3698 
3699  const Trk::TrackParameters *track_parameters = (*it)->trackParameters();
3700 
3701  if (!track_parameters) continue;
3702 
3703  Identifier id = track_parameters->associatedSurface().associatedDetectorElementIdentifier();
3704 
3705  if ( !(m_pTRTHelper->is_trt(id)) ) continue;
3706 
3707  float locR = track_parameters->parameters()[Trk::driftRadius];
3708  int barrel_ec = m_pTRTHelper->barrel_ec(id);
3709  int layer_or_wheel = m_pTRTHelper->layer_or_wheel(id);
3710  int phi_module = m_pTRTHelper->phi_module(id);
3711  int straw_layer = m_pTRTHelper->straw_layer(id);
3712  int straw = m_pTRTHelper->straw(id);
3713  const bool isArgonStraw = Straw_Gastype( m_sumTool->getStatusHT(id) ) == GasType::Ar;
3714  // assume always Xe if m_ArgonXenonSplitter is not enabled, otherwise check the straw status (good is Xe, non-good is Ar)
3715  // ibe = 0 (Barrel), ibe = 1 (Endcap)
3716  int ibe = abs(barrel_ec) - 1;
3717  // iside = 0 (Side A), iside = 1 (Side C)
3718  int iside = barrel_ec > 0 ? 0 : 1;
3719 
3720  if (ibe == 0) {
3721  if (isArgonStraw) {
3722  m_hefficiencyBarrel_locR_Ar->Fill(locR, 0.0);
3723  } else {
3724  m_hefficiencyBarrel_locR->Fill(locR, 0.0);
3725  }
3726  } else if (ibe == 1) {
3727  if (isArgonStraw) {
3728  m_hefficiencyEndCap_locR_Ar[iside]->Fill(locR, 0.0);
3729  } else {
3730  m_hefficiencyEndCap_locR[iside]->Fill(locR, 0.0);
3731  }
3732  }
3733 
3734  if (fabs(locR) >= 1.3) continue;
3735 
3736  int thisStrawNumber = 0;
3737  int chip = 0;
3738 
3739  if (ibe == 0) {
3740  thisStrawNumber = strawNumber(straw, straw_layer, layer_or_wheel);
3741 
3742  if (thisStrawNumber >= 0 && thisStrawNumber < s_Straw_max[ibe]) {
3743  chip = m_mat_chip_B[phi_module][thisStrawNumber];
3744  }
3745  } else if (ibe == 1) {
3746  thisStrawNumber = strawNumberEndCap(straw, straw_layer, layer_or_wheel, phi_module, barrel_ec);
3747 
3748  if (thisStrawNumber >= 0 && thisStrawNumber < s_Straw_max[ibe]) {
3749  chip = m_mat_chip_E[phi_module][thisStrawNumber];
3750  }
3751  }
3752 
3753  m_hefficiencyMap[ibe]->Fill(thisStrawNumber, 0.0);
3754 
3755  if (m_doExpert) {
3756  if (iside == 0) {
3757  m_hefficiencyS[ibe][phi_module]->Fill(thisStrawNumber, 0.0);
3758  m_hefficiencyC[ibe][phi_module]->Fill(chip, 0.0);
3759  } else if (iside == 1) {
3760  m_hefficiencyS[ibe][phi_module + 32]->Fill(thisStrawNumber, 0.0);
3761  m_hefficiencyC[ibe][phi_module + 32]->Fill(chip, 0.0);
3762  }
3763  }
3764 
3765  m_hefficiency_eta->Fill(m_track_eta, 0.0);
3766  m_hefficiency_phi->Fill(m_track_phi, 0.0);
3767  m_hefficiency_pt->Fill(m_track_pt * invGeV, 0.0);
3768  m_hefficiency_z0->Fill(m_track_z0, 0.0);
3769  }
3770 
3771  }
3772  }
3773  }
3774 
3775  double n_BorE[2][2];
3776  double total_BorE[2][2];
3777 
3778  for (int ibe = 0; ibe < 2; ibe++) {
3779  for (int iside = 0; iside < 2; iside++) {
3780  m_hefficiency[ibe][iside]->Reset();
3781  m_hefficiencyIntegral[ibe][iside]->Reset();
3782 
3783  for (int i = 0; i < 32; i++) {
3784  for (int ibin = 0; ibin <= s_Straw_max[ibe]; ibin++) {
3785  if (m_doExpert) {
3786  if (m_hefficiencyS[ibe][i + (32 * iside)]->GetBinEntries(ibin) > m_min_tracks_straw)
3787  m_hefficiency[ibe][iside]->Fill(m_hefficiencyS[ibe][i + (32 * iside)]->GetBinContent(ibin));
3788  }
3789  }
3790  }
3791 
3792  n_BorE[ibe][iside] = m_hefficiency[ibe][iside]->GetEntries();
3793  total_BorE[ibe][iside] = 0.0;
3794 
3795  for (UInt_t ibin = 0; ibin <= m_hefficiency[ibe][iside]->GetXaxis()->GetNbins(); ibin++) {
3796  total_BorE[ibe][iside] += m_hefficiency[ibe][iside]->GetBinContent(ibin);
3797  m_hefficiencyIntegral[ibe][iside]->SetBinContent(ibin, n_BorE[ibe][iside] != 0.0 ? total_BorE[ibe][iside] / n_BorE[ibe][iside] : 0.0);
3798  }
3799  }
3800  }
3801 
3802  return StatusCode::SUCCESS;
3803 }
3804 
3805 
3806 //----------------------------------------------------------------------------------//
3807 StatusCode TRT_Monitoring_Tool::fillTRTHighThreshold(const TrackCollection& trackCollection,
3808  const xAOD::EventInfo& eventInfo) {
3809 //----------------------------------------------------------------------------------//
3810  ATH_MSG_VERBOSE("");
3811  DataVector<Trk::Track>::const_iterator p_trk;
3812  const Trk::Perigee *perigee = nullptr;
3813  const DataVector<const Trk::TrackParameters> *AllTrkPar(nullptr);
3814  DataVector<const Trk::TrackParameters>::const_iterator p_trkpariter;
3815  int lumiBlockNumber;
3816  int timeStamp;
3817  lumiBlockNumber = eventInfo.lumiBlock();
3818  timeStamp = eventInfo.timeStamp();
3819 
3820  if (timeStamp > m_maxtimestamp) {
3821  m_maxtimestamp = timeStamp;
3822  }
3823 
3824  int runNumber;
3825  runNumber = eventInfo.runNumber();
3826  // get Online Luminosity
3827  double intLum = (this->lbDuration() * this->lbAverageLuminosity());
3828  double timeStampAverage = (m_maxtimestamp - 0.5 * this->lbDuration());
3829  m_IntLum->SetBinContent(1, intLum);
3830  m_LBvsLum->SetBinContent(lumiBlockNumber, intLum);
3831  m_LBvsTime->SetBinContent(lumiBlockNumber, timeStampAverage);
3832 
3833  for (p_trk = trackCollection.begin(); p_trk != trackCollection.end(); ++p_trk) {
3834  AllTrkPar = (*p_trk)->trackParameters();
3835 
3836  for (p_trkpariter = AllTrkPar->begin(); p_trkpariter != AllTrkPar->end(); ++p_trkpariter) {
3837  if ((perigee = dynamic_cast<const Trk::Perigee *>(*p_trkpariter))) break;
3838  }
3839 
3840  //if you went through all of the track parameters and found no perigee mearsurement
3841  //then something is wrong with the track and so don't use the track.
3842  //i.e. continue to the next track.
3843  if (!perigee) continue;
3844 
3845  float track_eta = perigee->eta();
3846  float track_p = (perigee->parameters()[Trk::qOverP] != 0.) ? fabs(1. / (perigee->parameters()[Trk::qOverP])) : 10e7;
3847  const Trk::TrackStates *trackStates = (**p_trk).trackStateOnSurfaces();
3848 
3849  if (trackStates == nullptr) continue;
3850 
3851  Trk::TrackStates::const_iterator TSOSItBegin = trackStates->begin();
3852  Trk::TrackStates::const_iterator TSOSItEnd = trackStates->end();
3853  std::unique_ptr<const Trk::TrackSummary> summary = m_TrackSummaryTool->summary(*(*p_trk));
3854  int trt_hits = summary->get(Trk::numberOfTRTHits);
3855  int sct_hits = summary->get(Trk::numberOfSCTHits);
3856  int pixel_hits = summary->get(Trk::numberOfPixelHits);
3857 
3858  if (fabs(track_eta) > 2.5) continue;
3859  if (fabs(track_p) < 5000.) continue;
3860  if (pixel_hits < 1.) continue;
3861  if (sct_hits < 6.) continue;
3862  if (trt_hits < 6.) continue;
3863 
3864  //Now we have hit informations
3865  const Trk::TrackStates *track_states = (*p_trk)->trackStateOnSurfaces();
3866 
3867  if (track_states) {
3868  ATH_MSG_DEBUG("This track has " << track_states->size() << " track states on surface.");
3869  } else {
3870  ATH_MSG_DEBUG("This track has null track states on surface.");
3871  continue;
3872  }
3873 
3874  int barrel_ec_side = 0;
3875  int layer_or_wheel = 0;
3876  int phi_module = 0;
3877  int straw_layer = 0;
3878 
3879  for (; TSOSItBegin != TSOSItEnd; ++TSOSItBegin) {
3880  if ((*TSOSItBegin) == nullptr) continue;
3881  if ( !((*TSOSItBegin)->type(Trk::TrackStateOnSurface::Measurement)) ) continue;
3882 
3883  const InDet::TRT_DriftCircleOnTrack *trtCircle = dynamic_cast<const InDet::TRT_DriftCircleOnTrack *>((*TSOSItBegin)->measurementOnTrack());
3884  const Trk::TrackParameters *aTrackParam = dynamic_cast<const Trk::TrackParameters *>((*TSOSItBegin)->trackParameters());
3885 
3886  if (!trtCircle) continue;
3887  if (!aTrackParam) continue;
3888 
3889  Identifier DCoTId = trtCircle->identify();
3890  barrel_ec_side = m_pTRTHelper->barrel_ec(DCoTId);
3891  layer_or_wheel = m_pTRTHelper->layer_or_wheel(DCoTId);
3892  phi_module = m_pTRTHelper->phi_module(DCoTId);
3893  straw_layer = m_pTRTHelper->straw_layer(DCoTId);
3894  //Ba_Ec: 0 is barrel 1 is Endcap
3895  //Side : 0 is side_A 1 is side_C
3896  int Ba_Ec = abs(barrel_ec_side) - 1;
3897  int Side = barrel_ec_side > 0 ? 0 : 1;
3898  double xPos = trtCircle->globalPosition().x(); // global x coordinate
3899  double yPos = trtCircle->globalPosition().y(); // global y coordinate
3900  double zPos = trtCircle->globalPosition().z(); // global z coordinate
3901  double RPos = sqrt(xPos * xPos + yPos * yPos);
3902  Identifier surfaceID;
3903  surfaceID = trtCircle->identify();
3904  // assume always Xe if m_ArgonXenonSplitter is not enabled, otherwise check the straw status (good is Xe, non-good is Ar)
3905  const InDet::TRT_DriftCircle *RawDriftCircle = dynamic_cast<const InDet::TRT_DriftCircle *>(trtCircle->prepRawData());
3906 
3907  if (!RawDriftCircle) { //coverity 25097
3908  //This shouldn't happen in normal conditions because trtCircle is a TRT_DriftCircleOnTrack object
3909  ATH_MSG_WARNING("RawDriftCircle object returned null");
3910  continue;
3911  }
3912 
3913  int middleHTbit = RawDriftCircle->getWord() & 0x00020000;
3914  //0x00020000 = 0000 0000 0000 0000 0000 0010 0000 0000 0000 0000
3915  bool is_middleHTbit_high = (middleHTbit != 0);
3916  //bool isHighLevel= RawDriftCircle->highLevel();
3917  bool isHighLevel = is_middleHTbit_high; //Hardcoded HT Middle Bit
3918  bool shortStraw = false;
3919  int InputBar = 0;
3920 
3921  if (fabs(track_eta) < 2. && Ba_Ec == 0.) {
3922  if ((layer_or_wheel == 0) && (phi_module < 4 || (phi_module > 7 && phi_module < 12) || (phi_module > 15 && phi_module < 20) || (phi_module > 23 && phi_module < 28))) InputBar = 1;
3923  else if ((runNumber >= 296939) && (layer_or_wheel == 0) && (phi_module > 27)) InputBar = 1;
3924  else if (layer_or_wheel == 0)
3925  InputBar = 0;
3926  else if ((layer_or_wheel == 1) && ((phi_module > 1 && phi_module < 6) || (phi_module > 9 && phi_module < 14) || (phi_module > 17 && phi_module < 22) || (phi_module > 25 && phi_module < 30)))
3927  InputBar = 1;
3928  else if (layer_or_wheel == 1)
3929  InputBar = 0;
3930  else if (layer_or_wheel == 2 && phi_module % 2 != 0)
3931  InputBar = 1;
3932  else if (layer_or_wheel == 2)
3933  InputBar = 0;
3934  else {
3935  ATH_MSG_WARNING("Should not pass here");
3936  continue;
3937  }
3938 
3939  if ((layer_or_wheel == 0) && straw_layer < 9.)
3940  shortStraw = true;
3941  }
3942 
3943  //Fill Barrel Plots
3944  if ((!shortStraw) && (Ba_Ec == 0)) {
3945  m_trackz_All[layer_or_wheel][InputBar]->Fill(zPos);
3946  if (isHighLevel)
3947  m_trackz_HT[layer_or_wheel][InputBar]->Fill(zPos);
3948  }
3949 
3950  if (shortStraw) {
3951  if (zPos > 0.) {
3952  m_trackz_All[3][InputBar]->Fill(zPos);
3953  if (isHighLevel)
3954  m_trackz_HT[3][InputBar]->Fill(zPos);
3955  } else {
3956  m_trackz_All[4][InputBar]->Fill(zPos);
3957 
3958  if (isHighLevel)m_trackz_HT[4][InputBar]->Fill(zPos);
3959  }
3960  }
3961 
3962  //End of Barrel Plots, begin EC plots
3963  int WType = -1;
3964 
3965  if ((Ba_Ec == 1) && (layer_or_wheel < 6) &&
3966  ((straw_layer > 3 && straw_layer < 8) ||
3967  (straw_layer > 11))) {
3968  WType = 0;
3969  }
3970  if ((Ba_Ec == 1) && (layer_or_wheel >= 6) &&
3971  (straw_layer > 3)) {
3972  WType = 3;
3973  }
3974  if ((Ba_Ec == 1) && (layer_or_wheel < 6) &&
3975  ((straw_layer > -1 && straw_layer < 4) ||
3976  (straw_layer > 7 && straw_layer < 12))) {
3977  WType = 2;
3978  }
3979  if ((Ba_Ec == 1) && (layer_or_wheel >= 6) &&
3980  ((straw_layer > -1 && straw_layer < 4))) {
3981  WType = 1;
3982  }
3983 
3984  if (WType < 0 && Ba_Ec == 1) { //Coverity CID 25096
3985  ATH_MSG_WARNING("The variable \"WType\" is less than zero!.");
3986  continue;
3987  }
3988 
3989  if (Ba_Ec == 1) {
3990  m_trackr_All[WType][Side]->Fill(RPos);
3991  if (isHighLevel)m_trackr_HT[WType][Side]->Fill(RPos);
3992  }
3993  }
3994  }
3995 
3996  return StatusCode::SUCCESS;
3997 }
3998 
3999 
4000 //-------------------------------------------------------------------------------------------------//
4001 StatusCode TRT_Monitoring_Tool::checkTRTReadoutIntegrity(const xAOD::EventInfo& eventInfo) {
4002 //-------------------------------------------------------------------------------------------------//
4003  StatusCode sc = StatusCode::SUCCESS;
4004 
4005  const TRT_BSErrContainer emptyErrCont;//Empty dummy instance for MC
4006  const TRT_BSErrContainer* bsErrCont=&emptyErrCont;
4007 
4008  if (!m_bsErrContKey.empty()) {
4009  //Regular real-data case, get the byte-stream errors from SG
4010  SG::ReadHandle<TRT_BSErrContainer> bsErrContHdl{m_bsErrContKey};
4011  bsErrCont=bsErrContHdl.cptr();
4012  }
4013  else {
4014  ATH_MSG_DEBUG("MC case, using dummy TRT_BSErrContainer");
4015  }
4016 
4017  const unsigned int lumiBlock = eventInfo.lumiBlock();
4018  ATH_MSG_VERBOSE("This is lumiblock : " << lumiBlock);
4019  m_good_bcid = eventInfo.bcid();
4020 
4021  if ((int)lumiBlock != m_lastTRTLumiBlock) {
4022  m_lastTRTLumiBlock = lumiBlock;
4023  }
4025  //Get BSConversion errors
4026  const std::set<std::pair<uint32_t, uint32_t> > &L1IDErrorSet = bsErrCont->getL1ErrorSet();
4027  const std::set<std::pair<uint32_t, uint32_t> > &BCIDErrorSet = bsErrCont->getBCIDErrorSet();
4028  const std::set<uint32_t> &MissingErrorSet = bsErrCont->getMissingErrorSet();
4029  const std::set<uint32_t> &SidErrorSet = bsErrCont->getSidErrorSet();
4030  const std::set<std::pair<uint32_t, uint32_t> > &RobStatusErrorSet = bsErrCont->getRobErrorSet();
4031 
4032  const unsigned int rod_id_base[2][2] = { { 0x310000, 0x320000 }, { 0x330000, 0x340000 } };
4033  const unsigned int nChipsTotal[2][2] = { { 3328, 3328 }, { 7680, 7680 } };
4034  const unsigned int nRobsTotal[2][2] = { { 32, 32 }, { 64, 64 } };
4035  float nBSErrors[2][2] = { { 0, 0 }, { 0, 0 } };
4036  float nRobErrors[2][2] = { { 0, 0 }, { 0, 0 } };
4037  const std::set<std::pair<uint32_t, uint32_t> > *errorset1[2] = { &BCIDErrorSet, &L1IDErrorSet };
4038 
4039  for (int iset = 0; iset < 2; ++iset) {
4040  for (auto setIt = errorset1[iset]->begin(); setIt != errorset1[iset]->end(); ++setIt) {
4041  for (int ibe = 0; ibe < 2; ++ibe) {
4042  for (int iside = 0; iside < 2; ++iside) {
4043  if (((setIt->first >> 8) & 0xFF0000) == rod_id_base[ibe][iside]) {
4044  nBSErrors[ibe][iside] += 1. / nChipsTotal[ibe][iside];
4045  }
4046  }
4047  }
4048  }
4049  }
4050 
4051  const std::set<uint32_t> *errorset2[2] = { &MissingErrorSet, &SidErrorSet };
4052 
4053  for (int iset = 0; iset < 2; ++iset) {
4054  for (auto setIt = errorset2[iset]->begin(); setIt != errorset2[iset]->end(); ++setIt) {
4055  for (int ibe = 0; ibe < 2; ++ibe) {
4056  for (int iside = 0; iside < 2; ++iside) {
4057  if (((*setIt >> 8) & 0xFF0000) == rod_id_base[ibe][iside]) {
4058  nBSErrors[ibe][iside] += 1. / nChipsTotal[ibe][iside];
4059  }
4060  }
4061  }
4062  }
4063  }
4064 
4065  for (int ibe = 0; ibe < 2; ++ibe) {
4066  for (int iside = 0; iside < 2; ++iside) {
4067  m_hChipBSErrorsVsLB[ibe][iside]->Fill(lumiBlock, nBSErrors[ibe][iside]);
4068  m_hChipBSErrorsVsLB[ibe][iside]->SetEntries(lumiBlock); // we need this so the LastBinThreshold algorithm can find the last bin
4069  }
4070  }
4071 
4072  for (auto setIt = RobStatusErrorSet.begin(); setIt != RobStatusErrorSet.end(); ++setIt) {
4073  for (int ibe = 0; ibe < 2; ++ibe) {
4074  for (int iside = 0; iside < 2; ++iside) {
4075  if (setIt->first % rod_id_base[ibe][iside] < 0xffff) {
4076  nRobErrors[ibe][iside] += 1. / nRobsTotal[ibe][iside];
4077  }
4078  }
4079  }
4080  }
4081 
4082  for (int ibe = 0; ibe < 2; ++ibe) {
4083  for (int iside = 0; iside < 2; ++iside) {
4084  m_hRobBSErrorsVsLB[ibe][iside]->Fill(lumiBlock, nRobErrors[ibe][iside]);
4085  m_hRobBSErrorsVsLB[ibe][iside]->SetEntries(lumiBlock); // we need this so the LastBinThreshold algorithm can find the last bin
4086  }
4087  }
4088 
4089  return sc;
4090 }
4091 
4092 //----------------------------------------------------------------------------------//
4093 int TRT_Monitoring_Tool::strawNumber(int strawNumber, int strawlayerNumber, int LayerNumber) {
4094 //----------------------------------------------------------------------------------//
4095  int addToStrawNumber = 0;
4096  int addToStrawNumberNext = 0;
4097  int i = 0;
4098  const int numberOfStraws[75] = {
4099  0,
4100  15,
4101  16, 16, 16, 16,
4102  17, 17, 17, 17, 17,
4103  18, 18, 18, 18, 18,
4104  19, 19, 19,
4105  18,
4106  19,
4107  20, 20, 20, 20, 20,
4108  21, 21, 21, 21, 21,
4109  22, 22, 22, 22, 22,
4110  23, 23, 23, 23, 23,
4111  24, 24,
4112  23, 23,
4113  24, 24, 24, 24,
4114  25, 25, 25, 25, 25,
4115  26, 26, 26, 26, 26,
4116  27, 27, 27, 27, 27,
4117  28, 28, 28, 28, 28,
4118  29, 29, 29, 29,
4119  28,
4120  0
4121  };
4122 
4123  do {
4124  i++;
4125  addToStrawNumber += numberOfStraws[i - 1];
4126  addToStrawNumberNext = addToStrawNumber + numberOfStraws[i];
4127  } while (strawLayerNumber(strawlayerNumber, LayerNumber) != i - 1);
4128 
4129  strawNumber = addToStrawNumberNext - strawNumber - 1;
4130 
4131  if (strawNumber < 0 || strawNumber > s_Straw_max[0] - 1) {
4132  ATH_MSG_WARNING("strawNumber = " << strawNumber << " out of range. Will set to 0.");
4133  strawNumber = 0;
4134  }
4135 
4136  return strawNumber;
4137 }
4138 
4139 //----------------------------------------------------------------------------------//
4140 int TRT_Monitoring_Tool::strawNumber_reverse (int inp_strawnumber, int *strawNumber, int *strawlayerNumber, int *LayerNumber) {
4141 //----------------------------------------------------------------------------------//
4142  const int numberOfStraws[75] = {
4143  0,
4144  15,
4145  16, 16, 16, 16,
4146  17, 17, 17, 17, 17,
4147  18, 18, 18, 18, 18,
4148  19, 19, 19,
4149  18,
4150  19,
4151  20, 20, 20, 20, 20,
4152  21, 21, 21, 21, 21,
4153  22, 22, 22, 22, 22,
4154  23, 23, 23, 23, 23,
4155  24, 24,
4156  23, 23,
4157  24, 24, 24, 24,
4158  25, 25, 25, 25, 25,
4159  26, 26, 26, 26, 26,
4160  27, 27, 27, 27, 27,
4161  28, 28, 28, 28, 28,
4162  29, 29, 29, 29,
4163  28,
4164  0
4165  };
4166  //ToDo check inp_strawnumber
4167  int i = 1;
4168 
4169  for (i = 1; inp_strawnumber >= 0; i++) {
4170  inp_strawnumber -= numberOfStraws[i];
4171  }
4172 
4173  i -= 2;
4174  strawLayerNumber_reverse(i, strawlayerNumber, LayerNumber);
4175  *strawNumber = -inp_strawnumber - 1;
4176  return 0;
4177 }
4178 
4179 //----------------------------------------------------------------------------------//
4180 int TRT_Monitoring_Tool::strawNumberEndCap(int strawNumber, int strawLayerNumber, int LayerNumber, int phi_stack, int side) {
4181 //----------------------------------------------------------------------------------//
4182  // Before perfoming map, corrections need to be perfomed.
4183  // apply special rotations for endcap mappings
4184  // for eca, rotate triplets by 180 for stacks 9-16, and 25-32.
4185  static const int TripletOrientation[2][32] = {
4186  {
4187  1, 1, 1, 1, 1, 1, 1, 1,
4188  0, 0, 0, 0, 0, 0, 0, 0,
4189  1, 1, 1, 1, 1, 1, 1, 1,
4190  0, 0, 0, 0, 0, 0, 0, 0
4191  },
4192  {
4193  1, 1, 1, 1, 1, 1, 1, 1,
4194  0, 0, 0, 0, 0, 0, 0, 0,
4195  1, 1, 1, 1, 1, 1, 1, 1,
4196  0, 0, 0, 0, 0, 0, 0, 0
4197  }
4198  };
4199  int phi1 = -1;
4200 
4201  if (side == 2) phi1 = phi_stack, side = 1;
4202  else if (side == -2) phi1 = 31 - phi_stack, side = 0;
4203 
4204  if (phi1 > -1) {
4205  if (TripletOrientation[side][phi1]) {
4206  //Change straw number from 0-23 in straw layer to 0-192
4207  if (strawLayerNumber < 8)strawNumber = strawNumber + 24 * strawLayerNumber;
4208 
4209  if (strawLayerNumber > 7)strawNumber = strawNumber + 24 * (strawLayerNumber - 8);
4210 
4211  strawNumber = (192 - 1) * TripletOrientation[side][phi1] + strawNumber * (1 - 2 * TripletOrientation[side][phi1]); //actual rotation
4212 
4213  //take strawNumber back to 0-23
4214  if (strawLayerNumber < 8) strawLayerNumber = int(strawNumber / 24);
4215 
4216  if (strawLayerNumber > 7) strawLayerNumber = int(strawNumber / 24) + 8;
4217 
4218  strawNumber = strawNumber % 24;
4219  }
4220 
4221  //Finish rotation
4222  //Flip straw in layer.
4223 
4224  if (side == 0) strawNumber = 23 - strawNumber;
4225 
4226  //Finish Flipping
4227  }
4228 
4229  // Done with corrections
4230  // Start mapping from athena identifiers to TRTViewer maps
4231  int strawNumberNew = 0;
4232 
4233  if (LayerNumber < 6 && strawLayerNumber > 7) {
4234  strawNumberNew = strawNumberNew + (384 * LayerNumber);
4235  strawNumberNew = strawNumberNew + 192 + (strawLayerNumber % 8) + (strawNumber * 8);
4236  } else if (LayerNumber < 6 && strawLayerNumber < 8) {
4237  strawNumberNew = strawNumberNew + (384 * LayerNumber);
4238  strawNumberNew = strawNumberNew + (strawLayerNumber % 8) + (strawNumber * 8);
4239  } else if (LayerNumber > 5 && strawLayerNumber > 7) {
4240  strawNumberNew = strawNumberNew + 2304 + 192 * (LayerNumber - 6);
4241  strawNumberNew = strawNumberNew + 192 + (strawLayerNumber % 8) + (8 * strawNumber);
4242  } else if (LayerNumber > 5 && strawLayerNumber < 8) {
4243  strawNumberNew = strawNumberNew + 2304 + 192 * (LayerNumber - 6);
4244  strawNumberNew = strawNumberNew + (strawLayerNumber % 8) + (8 * strawNumber);
4245  }
4246 
4247  strawNumber = strawNumberNew;
4248 
4249  if (strawNumber < 0 || strawNumber > s_Straw_max[1] - 1) {
4250  ATH_MSG_WARNING("strawNumber = " << strawNumber << " out of range. Will set to 0.");
4251  strawNumber = 0;
4252  }
4253 
4254  return strawNumber;
4255 }
4256 
4257 //----------------------------------------------------------------------------------//
4258 int TRT_Monitoring_Tool::strawLayerNumber(int strawLayerNumber, int LayerNumber) {
4259 //----------------------------------------------------------------------------------//
4260  switch (LayerNumber) {
4261  case 0:
4262  return strawLayerNumber;
4263 
4264  case 1:
4265  return strawLayerNumber + 19;
4266 
4267  case 2:
4268  return strawLayerNumber + 43;
4269 
4270  default:
4271  return strawLayerNumber;
4272  }
4273 }
4274 
4275 //----------------------------------------------------------------------------------//
4276 int TRT_Monitoring_Tool::strawLayerNumber_reverse(int strawLayerNumInp, int *strawLayerNumber, int *LayerNumber) {
4277 //----------------------------------------------------------------------------------//
4278  //Danger? There are no checks on input
4279  //use with care
4280  if (strawLayerNumInp < 19) {
4281  *strawLayerNumber = strawLayerNumInp;
4282  *LayerNumber = 0;
4283  } else if (strawLayerNumInp < 43) {
4284  *strawLayerNumber = strawLayerNumInp - 19;
4285  *LayerNumber = 1;
4286  } else {
4287  *strawLayerNumber = strawLayerNumInp - 43;
4288  *LayerNumber = 2;
4289  }
4290 
4291  return 0;
4292 }
4293 
4294 //----------------------------------------------------------------------------------//
4295 float TRT_Monitoring_Tool::radToDegrees(float radValue) {
4296 //----------------------------------------------------------------------------------//
4297  float degreeValue = radValue / M_PI * 180;
4298 
4299  if (degreeValue < 0) degreeValue += 360;
4300 
4301  return degreeValue;
4302 }
4303 
4304 //----------------------------------------------------------------------------------//
4305 int TRT_Monitoring_Tool::chipToBoard(int chip) {
4306 //----------------------------------------------------------------------------------//
4307  // return logical board index:
4308  // 0 for Board 1S (has 10 chips) 0 - 9
4309  // 1 for 1L (11) 10 - 20
4310  // 2 for 2S (15) 21 - 35
4311  // 3 for 2L, first 9 chips 36 - 44
4312  // 4 for 2L, second 9 chips 45 - 53
4313  // 5 for 3S, first 11 54 - 64
4314  // 6 for 3S, second 12 65 - 76
4315  // 7 for 3L, first 13 77 - 89
4316  // 8 for 3L, second 14 90 - 103
4317  const int list[] = {10, 11, 15, 9, 9, 11, 12, 13, 14};
4318  int count = 0;
4319  chip--;
4320 
4321  for (int i = 0; i < 9; i++) {
4322  count += list[i];
4323 
4324  if (chip < count) return i + 1;
4325  else if (chip == 104) return 9;
4326  }
4327 
4328  assert(count == 104);
4329  assert(false); // should never come this far
4330  return -1;
4331 }
4332 
4333 //----------------------------------------------------------------------------------//
4334 int TRT_Monitoring_Tool::chipToBoard_EndCap(int chip) {
4335 //----------------------------------------------------------------------------------//
4336  const int remainder = (chip - 1) % 12;
4337  const int Board = int(((chip - 1) - remainder) / 12);
4338  return Board + 1;
4339 }
4340 
4341 // Code to normalize a LW histogram. For now does it only of TH1F_LW.
4342 // Return whether we could do it (ie integral was non-zero)
4343 //----------------------------------------------------------------------------------//
4344 void TRT_Monitoring_Tool::scale_LWHist(LWHist1D *hist, float scale) {
4345 //----------------------------------------------------------------------------------//
4346  if (!hist) return;
4347 
4348  const unsigned int entries = hist->GetEntries();
4349  unsigned int index;
4350  double content, error;
4351  hist->resetActiveBinLoop();
4352 
4353  while (hist->getNextActiveBin(index, content, error)) {
4354  hist->SetBinContentAndError(index, scale * content, scale * error);
4355  }
4356 
4357  hist->SetEntries(entries);
4358 }
4359 
4360 //function for scaling a histogram with an vector
4361 // checks that number of bins matches vector length
4362 //----------------------------------------------------------------------------------//
4363 void TRT_Monitoring_Tool::scale_LWHistWithScaleVector(LWHist1D *hist, const vector<float> &scale) {
4364 //----------------------------------------------------------------------------------//
4365  if (!hist) return;
4366 
4367  if (hist->GetNbinsX() != scale.size()) return; // Could add an error message here
4368 
4369  const unsigned int entries = hist->GetEntries();
4370  unsigned int index;
4371  double content, error;
4372  hist->resetActiveBinLoop();
4373 
4374  while (hist->getNextActiveBin(index, content, error)) {
4375  // histogram bins run from 1 to n while array runs from 0 ro n-1
4376  try {
4377  hist->SetBinContentAndError(index, scale.at(index - 1) * content, scale.at(index - 1) * error);
4378  } catch (out_of_range &e) {
4379  ATH_MSG_ERROR("Index " << index << " out of range in scale_LWHistWithScaleVector");
4380  }
4381  }
4382 
4383  hist->SetEntries(entries);
4384 }
4385 
4386 // code to divide one histogram by another and save result
4387 // we could add coefficients to this, but we're not going to
4388 // we might also want to check that the bin ranges are the same, but for now
4389 // all we check is that we have the same number of bins!
4390 // Also, for now we don't care (I don't think) about the errors, so don't bother with them...
4391 //----------------------------------------------------------------------------------//
4392 void TRT_Monitoring_Tool::divide_LWHist(TH1F_LW *result, TH1F_LW *a, TH1F_LW *b) {
4393 //----------------------------------------------------------------------------------//
4394  if (!result || !a || !b) return;
4395 
4396  if (result->GetXaxis()->GetNbins() != a->GetXaxis()->GetNbins() || b->GetXaxis()->GetNbins() != a->GetXaxis()->GetNbins()) return;
4397 
4398  result->Reset();
4399  unsigned index;
4400  double contentA, errorA;
4401  double contentB, errorB;
4402  a->resetActiveBinLoop();
4403 
4404  while (a->getNextActiveBin(index, contentA, errorA)) {
4405  b->GetBinContentAndError(index, contentB, errorB);
4406 
4407  if (contentB == 0)
4408  result->SetBinContentAndError(index, 0, 0);
4409  else
4410  result->SetBinContentAndError(index, contentA / contentB, 0);
4411  }
4412 
4413  result->SetEntries(a->GetEntries());
4414 }
4415 
4416 //----------------------------------------------------------------------------------//
4417 TH1F_LW *TRT_Monitoring_Tool::bookTH1F_LW(MonGroup &mongroup, const std::string &hName, const std::string &hTitle, int nbins, double firstbin, double lastbin, const std::string &xTitle, const std::string &yTitle, StatusCode &scode) {
4418 //----------------------------------------------------------------------------------//
4419  TH1F_LW *hist = TH1F_LW::create(hName.c_str(), hTitle.c_str(), nbins, firstbin, lastbin);
4420  scode = trtRegHist<TH1F_LW>(hist, mongroup, hName.c_str());
4421  hist->GetXaxis()->SetLabelSize(0.03);
4422  hist->GetYaxis()->SetLabelSize(0.03);
4423  hist->SetXTitle(xTitle.c_str());
4424  hist->SetYTitle(yTitle.c_str());
4425  return hist;
4426 }
4427 
4428 //Bens addition
4429 //----------------------------------------------------------------------------------//
4430 TH1D_LW *TRT_Monitoring_Tool::bookTH1D_LW(MonGroup &mongroup, const std::string &hName, const std::string &hTitle, int nbins, double firstbin, double lastbin, const std::string &xTitle, const std::string &yTitle, StatusCode &scode) {
4431 //----------------------------------------------------------------------------------//
4432  TH1D_LW *hist = TH1D_LW::create(hName.c_str(), hTitle.c_str(), nbins, firstbin, lastbin);
4433  scode = trtRegHist<TH1D_LW>(hist, mongroup, hName.c_str());
4434  hist->GetXaxis()->SetLabelSize(0.03);
4435  hist->GetYaxis()->SetLabelSize(0.03);
4436  hist->SetXTitle(xTitle.c_str());
4437  hist->SetYTitle(yTitle.c_str());
4438  return hist;
4439 }
4440 
4441 //TProfile can be rebinned (unlike TProfile_LW) so we still need it.
4442 //----------------------------------------------------------------------------------//
4443 TProfile *TRT_Monitoring_Tool::bookTProfile(MonGroup &mongroup, const std::string &hName, const std::string &hTitle, int nbins, double firstbin, double lastbin, double ymin, double ymax, const std::string &xTitle, const std::string &yTitle, StatusCode &scode) {
4444 //----------------------------------------------------------------------------------//
4445  TProfile *hist = new TProfile(hName.c_str(), hTitle.c_str(), nbins, firstbin, lastbin, ymin, ymax);
4446  scode = trtRegHist<TProfile>(hist, mongroup, hName.c_str());
4447  hist->SetMarkerSize(0.5);
4448  hist->SetMarkerStyle(2);
4449  hist->SetMarkerColor(2);
4450  hist->GetXaxis()->SetLabelSize(0.03);
4451  hist->GetYaxis()->SetLabelSize(0.03);
4452  hist->GetXaxis()->SetTitle(xTitle.c_str());
4453  hist->GetYaxis()->SetTitle(yTitle.c_str());
4454  return hist;
4455 }
4456 
4457 //----------------------------------------------------------------------------------//
4458 TProfile_LW *TRT_Monitoring_Tool::bookTProfile_LW(MonGroup &mongroup, const std::string &hName, const std::string &hTitle, int nbins, double firstbin, double lastbin, double ymin, double ymax, const std::string &xTitle, const std::string &yTitle, StatusCode &scode) {
4459 //----------------------------------------------------------------------------------//
4460  TProfile_LW *hist = TProfile_LW::create(hName.c_str(), hTitle.c_str(), nbins, firstbin, lastbin, ymin, ymax);
4461  scode = trtRegHist<TProfile_LW>(hist, mongroup, hName.c_str());
4462  hist->SetMarkerSize(0.5);
4463  hist->SetMarkerStyle(2);
4464  hist->SetMarkerColor(2);
4465  hist->GetXaxis()->SetLabelSize(0.03);
4466  hist->GetYaxis()->SetLabelSize(0.03);
4467  hist->GetXaxis()->SetTitle(xTitle.c_str());
4468  hist->GetYaxis()->SetTitle(yTitle.c_str());
4469  return hist;
4470 }
4471 
4472 //----------------------------------------------------------------------------------//
4473 TH2F_LW *TRT_Monitoring_Tool::bookTH2F_LW(MonGroup &mongroup, const std::string &hName, const std::string &hTitle, int xnbins, double xfirstbin, double xlastbin, int ynbins, double yfirstbin, double ylastbin, const std::string &xTitle, const std::string &yTitle, StatusCode &scode) {
4474 //----------------------------------------------------------------------------------//
4475  TH2F_LW *hist = TH2F_LW::create(hName.c_str(), hTitle.c_str(), xnbins, xfirstbin, xlastbin, ynbins, yfirstbin, ylastbin);
4476  scode = trtRegHist<TH2F_LW>(hist, mongroup, hName.c_str());
4477  hist->GetXaxis()->SetLabelSize(0.03);
4478  hist->GetYaxis()->SetLabelSize(0.03);
4479  hist->SetXTitle(xTitle.c_str());
4480  hist->SetYTitle(yTitle.c_str());
4481  return hist;
4482 }
4483 
4484 
4485 //----------------------------------------------------------------------------------//
4486 int TRT_Monitoring_Tool::initScaleVectors() {
4487 //----------------------------------------------------------------------------------//
4488  if (m_flagforscale == 0 ) return 0;
4489 
4490  m_scale_hHitWMap_B.clear();
4491  m_scale_hHitWMap_B_Ar.clear();
4492 
4493  for (int i = 0; i < s_Straw_max[0]; i++) {
4494  float countAr = 0;
4495  float countXe = 0;
4496  int sN, sLN, lN;
4497  strawNumber_reverse(i, &sN, &sLN, &lN);
4498 
4499  for (int side = -1 ; side < 2; side += 2 ) {
4500  for (int j = 0; j < 32; j++ ) {
4501  Identifier Dummy_Identifier;
4502  Dummy_Identifier = m_pTRTHelper->straw_id(side, j, lN, sLN, sN);
4503  bool isArgonStraw = (Straw_Gastype( m_sumTool->getStatusHT(Dummy_Identifier) ) == GasType::Ar);
4504 
4505  if (isArgonStraw)
4506  countAr += 1.0;
4507  else
4508  countXe += 1.0;
4509  }
4510  }
4511 
4512  m_scale_hHitWMap_B.push_back(countXe);
4513  m_scale_hHitWMap_B_Ar.push_back(countAr);
4514  }
4515 
4516  m_flagforscale = 0;
4517  return 0;
4518 }
TRT_Monitoring_Tool::m_usedEvents
int m_usedEvents
Definition: TRT_Monitoring_Tool.h:486
TH2F_LW::Fill
virtual void Fill(const double &x, const double &y) override
Definition: TH2F_LW.cxx:329
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
TRT_Monitoring_Tool::m_ArgonXenonSplitter
bool m_ArgonXenonSplitter
Definition: TRT_Monitoring_Tool.h:84
TRT_Monitoring_Tool::Straw_Gastype
GasType Straw_Gastype(int stat)
Definition: TRT_Monitoring_Tool.h:633
TRT_Monitoring_Tool::m_HL_timeWindow_MIN
int m_HL_timeWindow_MIN
Definition: TRT_Monitoring_Tool.h:508
TRT_Monitoring_Tool::m_HtoLRatioOnTrackScale_E
float m_HtoLRatioOnTrackScale_E[2]
Definition: TRT_Monitoring_Tool.h:548
Trk::numberOfPixelHits
@ numberOfPixelHits
number of pixel layers on track with absence of hits
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:57
TRT_Monitoring_Tool::m_hHtoLRatioOnTrack_B_Xe
TH1F_LW * m_hHtoLRatioOnTrack_B_Xe
Definition: TRT_Monitoring_Tool.h:203
TRT_Monitoring_Tool::bookTProfile
TProfile * bookTProfile(MonGroup &mongroup, const std::string &hName, const std::string &hTitle, int bins, double lowbin, double highbin, double ymin, double ymax, const std::string &xTitle, const std::string &yTitle, StatusCode &scode)
Definition: TRT_Monitoring_Tool.cxx:4443
TRT_Monitoring_Tool::initialize
virtual StatusCode initialize()
Definition: TRT_Monitoring_Tool.cxx:375
TRT_Monitoring_Tool::m_mat_chip_E
unsigned char m_mat_chip_E[64][3840]
Definition: TRT_Monitoring_Tool.h:522
TRT_Monitoring_Tool::m_hTronTDist_B_Ar
TH1F_LW * m_hTronTDist_B_Ar
Definition: TRT_Monitoring_Tool.h:212
TRT_Monitoring_Tool::bookTProfile_LW
TProfile_LW * bookTProfile_LW(MonGroup &mongroup, const std::string &hName, const std::string &hTitle, int bins, double lowbin, double highbin, double ymin, double ymax, const std::string &xTitle, const std::string &yTitle, StatusCode &scode)
Definition: TRT_Monitoring_Tool.cxx:4458
CalculateHighPtTerm.pT
pT
Definition: ICHEP2016/CalculateHighPtTerm.py:57
TRT_Monitoring_Tool::m_ResidualScale_B_20GeV
float m_ResidualScale_B_20GeV
Definition: TRT_Monitoring_Tool.h:535
TRT_Monitoring_Tool::m_hHitHonTMapC
TH1F_LW * m_hHitHonTMapC[2][64]
Definition: TRT_Monitoring_Tool.h:423
TRT_ID::layer_id
Identifier layer_id(int barrel_ec, int phi_module, int layer_or_wheel, int straw_layer) const
For an individual straw layer.
Definition: TRT_ID.h:500
TRT_BSErrContainer::getMissingErrorSet
const std::set< uint32_t > & getMissingErrorSet(void) const
Definition: TRT_BSErrContainer.h:33
lastBinHigh
bool lastBinHigh(unsigned int m_word)
Definition: driftCircle.h:108
TRT_Monitoring_Tool::m_hHitAonTMapS
TH1F_LW * m_hHitAonTMapS[2][64]
Any LL bit on track: Straws Any low level bit is set from hit associated with a track.
Definition: TRT_Monitoring_Tool.h:357
ForwardTracker::Side
Side
Definition: ForwardTrackerConstants.h:13
TH1F_LW.h
TRT_Monitoring_Tool::m_nTRTHits
int m_nTRTHits[2]
Definition: TRT_Monitoring_Tool.h:487
ymin
double ymin
Definition: listroot.cxx:63
TRT_Monitoring_Tool::bookTRTRDOs
StatusCode bookTRTRDOs(bool isNewLumiBlock, bool isNewRun)
Definition: TRT_Monitoring_Tool.cxx:657
TH2F_LW.h
TRT_Monitoring_Tool::m_hHitsOnTrack_Scatter
TH2F_LW * m_hHitsOnTrack_Scatter[2]
Anatoli's "Scatter histograms" ** Monitor quantities as a function of lumi block.
Definition: TRT_Monitoring_Tool.h:450
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
TRT_Monitoring_Tool::m_hHtoLMapC
TH1F_LW * m_hHtoLMapC[2][64]
Definition: TRT_Monitoring_Tool.h:406
TRT_Monitoring_Tool::m_nHLHitsperLB_E
int m_nHLHitsperLB_E[2]
Definition: TRT_Monitoring_Tool.h:565
TRT_Monitoring_Tool::m_trackr_All
TH1F_LW * m_trackr_All[4][2]
Definition: TRT_Monitoring_Tool.h:467
TRT_Monitoring_Tool::m_hAvgTroTDetPhi_E_Ar
TProfile_LW * m_hAvgTroTDetPhi_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:222
TRT::Hit::straw
@ straw
Definition: HitInfo.h:82
InDet::TRT_DriftCircleOnTrack::prepRawData
virtual const TRT_DriftCircle * prepRawData() const override final
returns the PrepRawData - is a TRT_DriftCircle in this scope
Definition: TRT_DriftCircleOnTrack.h:202
TRT_Monitoring_Tool::m_min_trt_hits
int m_min_trt_hits
Definition: TRT_Monitoring_Tool.h:596
TRT_Monitoring_Tool::m_min_si_hits
int m_min_si_hits
Definition: TRT_Monitoring_Tool.h:593
TRT_Monitoring_Tool::m_hHtoLRatioOnTrack_E
TH1F_LW * m_hHtoLRatioOnTrack_E[2]
Definition: TRT_Monitoring_Tool.h:235
TRT_Monitoring_Tool::bookTH2F_LW
TH2F_LW * bookTH2F_LW(MonGroup &mongroup, const std::string &hName, const std::string &hTitle, int xbins, double lowxbins, double highxbins, int ybins, double lowybins, double highybins, const std::string &xTitle, const std::string &yTitle, StatusCode &scode)
Definition: TRT_Monitoring_Tool.cxx:4473
TRT_Monitoring_Tool::fillTRTHighThreshold
StatusCode fillTRTHighThreshold(const TrackCollection &trackCollection, const xAOD::EventInfo &eventInfo)
Definition: TRT_Monitoring_Tool.cxx:3807
TRT_Monitoring_Tool::m_hStrawOcc
TH1F_LW * m_hStrawOcc[2][64]
Definition: TRT_Monitoring_Tool.h:445
TRT_Monitoring_Tool::m_TRTStrawNeighbourSvc
ServiceHandle< ITRT_StrawNeighbourSvc > m_TRTStrawNeighbourSvc
Definition: TRT_Monitoring_Tool.h:151
get_generator_info.result
result
Definition: get_generator_info.py:21
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
TH1D_LW::create
static TH1D_LW * create(const char *name, const char *title, unsigned nbinsx, const double &xlow, const double &xup)
Definition: TH1D_LW.cxx:33
TRT_Monitoring_Tool::m_hHtoLRatioOnTrack_E_Ar
TH1F_LW * m_hHtoLRatioOnTrack_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:236
TRT_Monitoring_Tool::m_hHitTrMapC
TProfile_LW * m_hHitTrMapC[2][64]
Definition: TRT_Monitoring_Tool.h:402
TrigDecision.h
TRT_Monitoring_Tool::m_hHitWMapC
TH1F_LW * m_hHitWMapC[2][64]
Definition: TRT_Monitoring_Tool.h:401
TRT_Monitoring_Tool::m_nTrack_E
int m_nTrack_E[64]
Definition: TRT_Monitoring_Tool.h:481
TRT_Monitoring_Tool::m_isCosmics
bool m_isCosmics
Definition: TRT_Monitoring_Tool.h:577
TH1F_LW::Fill
virtual void Fill(const double &x) override
Definition: TH1F_LW.cxx:246
TRT_Monitoring_Tool::chipToBoard_EndCap
static int chipToBoard_EndCap(int chip)
Definition: TRT_Monitoring_Tool.cxx:4334
TRT_Monitoring_Tool::m_min_tracks_straw
int m_min_tracks_straw
Definition: TRT_Monitoring_Tool.h:603
TRT_Monitoring_Tool::m_hDriftTimeonTrkDist_B_Ar
TH1F_LW * m_hDriftTimeonTrkDist_B_Ar
Definition: TRT_Monitoring_Tool.h:211
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
TRT_Monitoring_Tool::m_hHitWMap_B
TH1F_LW * m_hHitWMap_B
Definition: TRT_Monitoring_Tool.h:191
Trk::locX
@ locX
Definition: ParamDefs.h:43
TRT_Monitoring_Tool::p_toolSvc
ServiceHandle< IToolSvc > p_toolSvc
Definition: TRT_Monitoring_Tool.h:147
TRT_Monitoring_Tool::m_DAQSvc
ServiceHandle< ITRT_DAQ_ConditionsSvc > m_DAQSvc
Definition: TRT_Monitoring_Tool.h:149
ComTime::getTime
double getTime() const
Definition: ComTime.h:44
TRT_Monitoring_Tool::m_hHitTronTMapS
TProfile_LW * m_hHitTronTMapS[2][64]
Mean TE on track: Straws Average Trailing Edge(TE) from a hit associated with a track.
Definition: TRT_Monitoring_Tool.h:351
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
TRT_Monitoring_Tool::m_sumTool
ToolHandle< ITRT_StrawStatusSummaryTool > m_sumTool
Definition: TRT_Monitoring_Tool.h:148
TRT_DetectorManager.h
TRT_Monitoring_Tool::fillTRTEfficiency
StatusCode fillTRTEfficiency(const TrackCollection &combTrackCollection)
Definition: TRT_Monitoring_Tool.cxx:3533
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
TRT_Monitoring_Tool::m_hStrawEffDetPhi_B
TProfile_LW * m_hStrawEffDetPhi_B
Definition: TRT_Monitoring_Tool.h:190
TRT_Monitoring_Tool::m_hHitToTMapS
TProfile_LW * m_hHitToTMapS[2][64]
Mean ToT (ns): Straws.
Definition: TRT_Monitoring_Tool.h:310
TRT_Monitoring_Tool::s_numberOfEndCapStacks
static const int s_numberOfEndCapStacks
Definition: TRT_Monitoring_Tool.h:138
ManagedMonitorToolBase::lumiBlock
@ lumiBlock
Definition: ManagedMonitorToolBase.h:114
TRT_LoLumRawData::highLevel
virtual bool highLevel() const override final
Definition: TRT_LoLumRawData.h:128
TRT_Monitoring_Tool::m_hHitTronTMapC
TProfile_LW * m_hHitTronTMapC[2][64]
Definition: TRT_Monitoring_Tool.h:420
TRT_Monitoring_Tool::m_hefficiencyIntegral
TH1F_LW * m_hefficiencyIntegral[2][2]
Definition: TRT_Monitoring_Tool.h:623
TH1F_LW::create
static TH1F_LW * create(const char *name, const char *title, unsigned nbinsx, const double &xlow, const double &xup)
Definition: TH1F_LW.cxx:33
ManagedMonitorToolBase
Provides functionality for users to implement and save histograms, ntuples, and summary data,...
Definition: ManagedMonitorToolBase.h:74
TRT_Monitoring_Tool::m_doASide
bool m_doASide
Definition: TRT_Monitoring_Tool.h:491
TRT_LoLumRawData::lastBinHigh
bool lastBinHigh() const
Definition: TRT_LoLumRawData.h:165
TRT_Monitoring_Tool::m_minTRThits
int m_minTRThits
Definition: TRT_Monitoring_Tool.h:578
TRT_Monitoring_Tool::m_hNumHoTDetPhi_B
TProfile_LW * m_hNumHoTDetPhi_B
Definition: TRT_Monitoring_Tool.h:186
TRT_Monitoring_Tool::m_nTracksB
int m_nTracksB[2]
Definition: TRT_Monitoring_Tool.h:79
TRT_Monitoring_Tool::chipToBoard
static int chipToBoard(int chip)
Definition: TRT_Monitoring_Tool.cxx:4305
TRT_Monitoring_Tool::m_LL_timeWindow_MIN
int m_LL_timeWindow_MIN
Definition: TRT_Monitoring_Tool.h:505
TH1D_LW.h
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
TRT_LoLumRawData
Definition: TRT_LoLumRawData.h:25
index
Definition: index.py:1
Trk::ParametersBase::associatedSurface
virtual const Surface & associatedSurface() const override=0
Access to the Surface associated to the Parameters.
TRT_Monitoring_Tool::m_doDCS
bool m_doDCS
Definition: TRT_Monitoring_Tool.h:490
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
TRT_Monitoring_Tool::m_nphi_bins
int m_nphi_bins
Definition: TRT_Monitoring_Tool.h:574
TRT_Monitoring_Tool::m_hHitWMap_E
TH1F_LW * m_hHitWMap_E[2]
Definition: TRT_Monitoring_Tool.h:225
InDetDD::holes
@ holes
Definition: InDetDD_Defs.h:17
TRT_Monitoring_Tool::m_hHitTrWMapS
TProfile_LW * m_hHitTrWMapS[2][64]
TE in Time Window: Straws.
Definition: TRT_Monitoring_Tool.h:276
InDetDD::TRT_DetectorManager::getBarrelElement
const TRT_BarrelElement * getBarrelElement(unsigned int positive, unsigned int moduleIndex, unsigned int phiIndex, unsigned int strawLayerIndex) const
Access Barrel Elements:---------------—(Fast)-------------------------—.
Definition: TRT_DetectorManager.cxx:113
TRT_Monitoring_Tool::bookTRTEfficiency
StatusCode bookTRTEfficiency(bool isNewLumiBlock, bool isNewRun)
Definition: TRT_Monitoring_Tool.cxx:893
TRT_Monitoring_Tool::m_ResidualScale_E_Ar_20GeV
float m_ResidualScale_E_Ar_20GeV[2]
Definition: TRT_Monitoring_Tool.h:561
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
ManagedMonitorToolBase::endOfLumiBlockFlag
bool endOfLumiBlockFlag() const
Definition: ManagedMonitorToolBase.h:858
TRT_Monitoring_Tool::m_nTrksperLB_E
int m_nTrksperLB_E[2]
Definition: TRT_Monitoring_Tool.h:563
TRT_Monitoring_Tool::m_DriftTimeonTrkDistScale_B
float m_DriftTimeonTrkDistScale_B
Definition: TRT_Monitoring_Tool.h:525
TRT_Monitoring_Tool::m_drifttool
ToolHandle< ITRT_DriftFunctionTool > m_drifttool
Definition: TRT_Monitoring_Tool.h:170
TRT_ID::straw_layer_hash_max
size_type straw_layer_hash_max(void) const
Definition: TRT_ID.h:920
InDet::TRT_DriftCircle::timeOverThreshold
double timeOverThreshold() const
returns Time over threshold in ns
plotmaker.hist
hist
Definition: plotmaker.py:148
TRT_Monitoring_Tool::s_iStack_max
static const int s_iStack_max[2]
Definition: TRT_Monitoring_Tool.h:141
InDetDD::TRT_BaseElement::nStraws
unsigned int nStraws() const
Number of straws in the element.
TRT_Monitoring_Tool::m_hValidRawDriftTimeonTrk
TProfile_LW * m_hValidRawDriftTimeonTrk[2][64]
Valid Raw Drift Time on Track.
Definition: TRT_Monitoring_Tool.h:399
EventPrimitivesHelpers.h
TRT_Monitoring_Tool::m_good_bcid
int m_good_bcid
Definition: TRT_Monitoring_Tool.h:77
Trk::Surface::associatedDetectorElementIdentifier
Identifier associatedDetectorElementIdentifier() const
return Identifier of the associated Detector Element
TRT_Monitoring_Tool::m_hDriftTimeonTrkDist_E
TH1F_LW * m_hDriftTimeonTrkDist_E[2]
Definition: TRT_Monitoring_Tool.h:231
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:71
TRT_Monitoring_Tool::m_hefficiency_z0
TProfile_LW * m_hefficiency_z0
Definition: TRT_Monitoring_Tool.h:613
TRT_Monitoring_Tool::m_Pull_Biased_Barrel
TH1F_LW * m_Pull_Biased_Barrel
Definition: TRT_Monitoring_Tool.h:193
ALFA_EventTPCnv_Dict::t0
std::vector< ALFA_RawData_p1 > t0
Definition: ALFA_EventTPCnvDict.h:42
TRT_Monitoring_Tool::m_nTracksEC
int m_nTracksEC[2]
Definition: TRT_Monitoring_Tool.h:80
ManagedMonitorToolBase::lbDuration
virtual double lbDuration(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Luminosity block time (in seconds)
Definition: ManagedMonitorToolBase.cxx:2047
TRT_Monitoring_Tool::m_hResidual_E_20GeV
TH1F_LW * m_hResidual_E_20GeV[2]
Definition: TRT_Monitoring_Tool.h:229
TH1F_LW::SetBinContent
virtual void SetBinContent(unsigned bin, const double &) override
Definition: TH1F_LW.cxx:267
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
TRT_Monitoring_Tool::m_TronTDistScale_B
float m_TronTDistScale_B
Definition: TRT_Monitoring_Tool.h:533
TRT_Monitoring_Tool::m_mgr
const InDetDD::TRT_DetectorManager * m_mgr
Definition: TRT_Monitoring_Tool.h:173
skel.it
it
Definition: skel.GENtoEVGEN.py:423
TRT_ID.h
This is an Identifier helper class for the TRT subdetector. This class is a factory for creating comp...
TRT_Monitoring_Tool::m_hHitAMapS
TH1F_LW * m_hHitAMapS[2][64]
Any LL bit on: Straws if any low threshold bit was set.
Definition: TRT_Monitoring_Tool.h:289
M_PI
#define M_PI
Definition: ActiveFraction.h:11
TRT_Monitoring_Tool::m_xAODEventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_xAODEventInfoKey
Definition: TRT_Monitoring_Tool.h:159
TRT_Monitoring_Tool::m_HTfraconTrack_B
float m_HTfraconTrack_B[32]
Definition: TRT_Monitoring_Tool.h:473
TRT_Monitoring_Tool::m_hrtRelation_B
TH2F_LW * m_hrtRelation_B
Definition: TRT_Monitoring_Tool.h:199
TRT_Monitoring_Tool::m_doShift
bool m_doShift
Definition: TRT_Monitoring_Tool.h:495
TRT_Monitoring_Tool::m_TronTDistScale_E_Ar
float m_TronTDistScale_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:559
LWHist1D.h
InDetDD::TRT_BaseElement::strawCenter
const Amg::Vector3D & strawCenter(int straw) const
Straw Surface: Local -> global transform of the straw via integer.
Definition: TRT_BaseElement.cxx:143
TRT_Monitoring_Tool::m_nTracksEC_B
int m_nTracksEC_B[2]
Definition: TRT_Monitoring_Tool.h:81
TRT_Monitoring_Tool::m_ResidualScale_B_Ar
float m_ResidualScale_B_Ar
Definition: TRT_Monitoring_Tool.h:539
Trk::z0
@ z0
Definition: ParamDefs.h:70
xAOD::TrigDecision_v1::tav
const std::vector< uint32_t > & tav() const
Get the Trigger After Veto bits.
TRT_Monitoring_Tool::m_useHoleFinder
bool m_useHoleFinder
Definition: TRT_Monitoring_Tool.h:500
TRT_Monitoring_Tool::m_doDiagnostic
bool m_doDiagnostic
Definition: TRT_Monitoring_Tool.h:499
TRT_Monitoring_Tool::m_TronTDistScale_E
float m_TronTDistScale_E[2]
Definition: TRT_Monitoring_Tool.h:554
TRT_Monitoring_Tool::m_LBvsTime
TH1F_LW * m_LBvsTime
Definition: TRT_Monitoring_Tool.h:471
TRT_Monitoring_Tool::m_hTronTDist_B
TH1F_LW * m_hTronTDist_B
Definition: TRT_Monitoring_Tool.h:198
TRT_Monitoring_Tool::m_hHtoLRatioOnTrack_E_Xe
TH1F_LW * m_hHtoLRatioOnTrack_E_Xe[2]
Definition: TRT_Monitoring_Tool.h:237
TRT_Monitoring_Tool::m_totalEvents
int m_totalEvents
Definition: TRT_Monitoring_Tool.h:488
TH1D_LW
Definition: TH1D_LW.h:23
TProfile_LW.h
TRT_Monitoring_Tool::m_maxtimestamp
std::atomic< int > m_maxtimestamp
Definition: TRT_Monitoring_Tool.h:608
LWHist1D
Definition: LWHist1D.h:23
TRT_Monitoring_Tool::m_HLhitOnTrackScale_E
float m_HLhitOnTrackScale_E[2]
Definition: TRT_Monitoring_Tool.h:547
TRT_Monitoring_Tool::strawLayerNumber
static int strawLayerNumber(int strawLayerNumber, int LayerNumber)
Definition: TRT_Monitoring_Tool.cxx:4258
TRT_Monitoring_Tool::m_hBCIDvsOcc
TProfile_LW * m_hBCIDvsOcc[2]
Definition: TRT_Monitoring_Tool.h:438
TRT_Monitoring_Tool::m_hResVsDetPhi_B
TH1F_LW * m_hResVsDetPhi_B
Definition: TRT_Monitoring_Tool.h:206
TRT_Monitoring_Tool::m_TimeResidualScale_E
float m_TimeResidualScale_E[2]
Definition: TRT_Monitoring_Tool.h:557
TRT_Monitoring_Tool::m_nHitsperLB_E
int m_nHitsperLB_E[2]
Definition: TRT_Monitoring_Tool.h:564
Trk::locR
@ locR
Definition: ParamDefs.h:50
AtlasDetectorID::is_trt
bool is_trt(Identifier id) const
Definition: AtlasDetectorID.h:782
TRT_Monitoring_Tool::scale_LWHistWithScaleVector
void scale_LWHistWithScaleVector(LWHist1D *hist, const std::vector< float > &scale)
Definition: TRT_Monitoring_Tool.cxx:4363
InDetRawDataContainer
Definition: InDetRawDataContainer.h:27
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
TRT_Monitoring_Tool::m_hHtoLWonTMapS
TH1F_LW * m_hHtoLWonTMapS[2][64]
Definition: TRT_Monitoring_Tool.h:381
TRT_Monitoring_Tool::m_WireToTrkPositionScale_E
float m_WireToTrkPositionScale_E[2]
Definition: TRT_Monitoring_Tool.h:552
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
InDetRawDataContainer.h
InDet::TRT_DriftCircle::driftTimeBin
int driftTimeBin() const
returns the leading edge bin defined as in TRT_LoLumRawData to be the first 0-1 transition
yodamerge_tmp.scale
scale
Definition: yodamerge_tmp.py:138
TRT_Monitoring_Tool::m_HTfraconTrack_E
float m_HTfraconTrack_E[64]
Definition: TRT_Monitoring_Tool.h:479
TRT_Monitoring_Tool::m_hResidual_B_20GeV
TH1F_LW * m_hResidual_B_20GeV
Definition: TRT_Monitoring_Tool.h:195
InDet::TRT_DriftCircleOnTrack
Definition: TRT_DriftCircleOnTrack.h:53
TProfile_LW
Definition: TProfile_LW.h:24
ComTime
Definition: ComTime.h:17
TRT_Monitoring_Tool::initScaleVectors
int initScaleVectors()
Definition: TRT_Monitoring_Tool.cxx:4486
InDet::TRT_DriftCircleOnTrack::detectorElement
virtual const InDetDD::TRT_BaseElement * detectorElement() const override final
returns the detector element, assoicated with the PRD of this class
Definition: TRT_DriftCircleOnTrack.h:224
TRT_Monitoring_Tool::m_HtoLRatioOnTrackScale_E_Xe
float m_HtoLRatioOnTrackScale_E_Xe[2]
Definition: TRT_Monitoring_Tool.h:550
TRT_Monitoring_Tool::m_hHitWonTMapC
TH1F_LW * m_hHitWonTMapC[2][64]
LE in time window on track: Chips.
Definition: TRT_Monitoring_Tool.h:419
TRT_Monitoring_Tool::m_LonTrack_B
float m_LonTrack_B[32]
Definition: TRT_Monitoring_Tool.h:474
TRT_Monitoring_Tool::m_maxDistToStraw
float m_maxDistToStraw
Definition: TRT_Monitoring_Tool.h:567
TRT_Monitoring_Tool::m_scale_hHitWMap_B_Ar
std::vector< float > m_scale_hHitWMap_B_Ar
Definition: TRT_Monitoring_Tool.h:456
AmgSymMatrix
#define AmgSymMatrix(dim)
Definition: EventPrimitives.h:52
TRT_Monitoring_Tool::m_scale_hHitWMap_B
std::vector< float > m_scale_hHitWMap_B
Definition: TRT_Monitoring_Tool.h:455
TRT_Monitoring_Tool::m_lumiBlocksToResetOcc
int m_lumiBlocksToResetOcc
Definition: TRT_Monitoring_Tool.h:576
InDet::TRT_DriftCircle
Definition: TRT_DriftCircle.h:32
TRT_Monitoring_Tool::m_hResidual_E
TH1F_LW * m_hResidual_E[2]
Definition: TRT_Monitoring_Tool.h:228
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
TRT_Monitoring_Tool::s_Straw_max
static const int s_Straw_max[2]
Definition: TRT_Monitoring_Tool.h:140
XMLtoHeader.count
count
Definition: XMLtoHeader.py:85
TRT_Monitoring_Tool::s_numberOfStacks
static const int s_numberOfStacks[2]
Definition: TRT_Monitoring_Tool.h:143
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
TRT_Monitoring_Tool::m_hEvtPhase
TH1F_LW * m_hEvtPhase
Definition: TRT_Monitoring_Tool.h:257
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
TRT_Monitoring_Tool::m_hHitToTMapC
TProfile_LW * m_hHitToTMapC[2][64]
Definition: TRT_Monitoring_Tool.h:410
TRT_Monitoring_Tool::m_evtLumiBlock
int m_evtLumiBlock
Definition: TRT_Monitoring_Tool.h:76
TRT_Monitoring_Tool.h
ITRT_ConditionsSvc.h
TRT_BSErrContainer::getRobErrorSet
const std::set< std::pair< uint32_t, uint32_t > > & getRobErrorSet(void) const
Definition: TRT_BSErrContainer.h:31
TRT_Monitoring_Tool::m_NumSwLLWoTScale_B
float m_NumSwLLWoTScale_B
Definition: TRT_Monitoring_Tool.h:530
TRT_Monitoring_Tool::m_ResidualScale_E_Ar
float m_ResidualScale_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:560
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
TRT_Monitoring_Tool::m_hNHLHitsperLB_B
TProfile * m_hNHLHitsperLB_B
Definition: TRT_Monitoring_Tool.h:209
TProfile_LW::Reset
virtual void Reset() override
Definition: TProfile_LW.cxx:182
TRT::Hit::side
@ side
Definition: HitInfo.h:83
Track.h
TRT_Monitoring_Tool::m_hNumHoTDetPhi_E
TProfile_LW * m_hNumHoTDetPhi_E[2]
Definition: TRT_Monitoring_Tool.h:220
TRT_Monitoring_Tool::m_hAvgHLOcc_side
TProfile_LW * m_hAvgHLOcc_side[2][2]
Definition: TRT_Monitoring_Tool.h:182
TRT_Monitoring_Tool::m_nTrksperLB_B
int m_nTrksperLB_B
Definition: TRT_Monitoring_Tool.h:542
LWHist::GetXaxis
LWHistAxis * GetXaxis()
Definition: LWHist.cxx:309
TRT_Monitoring_Tool::m_hResidual_B_Ar_20GeV
TH1F_LW * m_hResidual_B_Ar_20GeV
Definition: TRT_Monitoring_Tool.h:215
TRT_Monitoring_Tool::m_hChipsEff
TProfile_LW * m_hChipsEff[2][64]
Definition: TRT_Monitoring_Tool.h:259
TRT_Monitoring_Tool::m_hNumTrksDetPhi_B
TH1F_LW * m_hNumTrksDetPhi_B
Definition: TRT_Monitoring_Tool.h:185
SCT_CalibAlgs::nbins
@ nbins
Definition: SCT_CalibNumbers.h:10
TRT_LoLumRawData::driftTimeBin
virtual int driftTimeBin() const override final
Definition: TRT_LoLumRawData.h:57
TRT_BSErrContainer
Definition: TRT_BSErrContainer.h:20
TRT_Monitoring_Tool::m_hTimeResidual_B
TH1F_LW * m_hTimeResidual_B
Definition: TRT_Monitoring_Tool.h:196
grepfile.content
string content
Definition: grepfile.py:56
TRT_Monitoring_Tool::m_hResidual_E_Ar_20GeV
TH1F_LW * m_hResidual_E_Ar_20GeV[2]
Definition: TRT_Monitoring_Tool.h:249
TRT_LoLumRawData::firstBinHigh
bool firstBinHigh() const
Definition: TRT_LoLumRawData.h:154
TRT_Monitoring_Tool::m_geo_summary_provider
std::string m_geo_summary_provider
Definition: TRT_Monitoring_Tool.h:175
TRTCond::RtRelation
Definition: RtRelation.h:27
TRT_Monitoring_Tool::m_track_d0
float m_track_d0
Definition: TRT_Monitoring_Tool.h:601
TRT_Monitoring_Tool::bookTRTShiftTracks
StatusCode bookTRTShiftTracks(bool isNewLumiBlock, bool isNewRun)
Definition: TRT_Monitoring_Tool.cxx:954
TRT_Monitoring_Tool::TRT_Monitoring_Tool
TRT_Monitoring_Tool(const std::string &type, const std::string &name, const IInterface *parent)
Definition: TRT_Monitoring_Tool.cxx:55
AtlasDetectorID.h
This class provides an interface to generate or decode an identifier for the upper levels of the dete...
ManagedMonitorToolBase::MonGroup
A container of information describing a monitoring object.
Definition: ManagedMonitorToolBase.h:138
TRT_Monitoring_Tool::m_hHitWMap_E_Ar
TH1F_LW * m_hHitWMap_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:247
TRT_Monitoring_Tool::m_hValidRawDriftTimeonTrkC
TProfile_LW * m_hValidRawDriftTimeonTrkC[2][64]
Definition: TRT_Monitoring_Tool.h:400
TRT_Monitoring_Tool::m_hHitTronTwEPCMapS
TProfile_LW * m_hHitTronTwEPCMapS[2][64]
Mean TE on track (with Event Phase correction): Straws.
Definition: TRT_Monitoring_Tool.h:393
TRT_Monitoring_Tool::m_hefficiencyBarrel_locR
TProfile_LW * m_hefficiencyBarrel_locR
Definition: TRT_Monitoring_Tool.h:614
TRT_Monitoring_Tool::m_hefficiency_phi
TProfile_LW * m_hefficiency_phi
Definition: TRT_Monitoring_Tool.h:611
TRT_Monitoring_Tool::m_condSvc_BS
ServiceHandle< ITRT_ConditionsSvc > m_condSvc_BS
Definition: TRT_Monitoring_Tool.h:150
TRT_Monitoring_Tool::m_track_phi
float m_track_phi
Definition: TRT_Monitoring_Tool.h:600
TRT_Monitoring_Tool::m_hDriftTimeonTrkDist_E_Ar
TH1F_LW * m_hDriftTimeonTrkDist_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:246
TRT_Monitoring_Tool::m_nHitsperLB_B
int m_nHitsperLB_B
Definition: TRT_Monitoring_Tool.h:543
TRT_Monitoring_Tool::m_min_pT
float m_min_pT
Definition: TRT_Monitoring_Tool.h:590
TRT_Monitoring_Tool::s_moduleNum
static const int s_moduleNum[2]
Definition: TRT_Monitoring_Tool.h:144
TRT_ID::straw
int straw(const Identifier &id) const
Definition: TRT_ID.h:902
TRT_Monitoring_Tool::m_trt_hole_finder
ToolHandle< Trk::ITrackHoleSearchTool > m_trt_hole_finder
Definition: TRT_Monitoring_Tool.h:169
TRT_Monitoring_Tool::m_hNHitsperLB_E
TProfile * m_hNHitsperLB_E[2]
Definition: TRT_Monitoring_Tool.h:241
TH1F_LW
Definition: TH1F_LW.h:23
TRT_Monitoring_Tool::m_trackr_HT
TH1F_LW * m_trackr_HT[4][2]
Definition: TRT_Monitoring_Tool.h:468
TRT_Monitoring_Tool::m_WireToTrkPositionScale_E_Ar
float m_WireToTrkPositionScale_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:553
TRT_Monitoring_Tool::m_hAvgLLOccMod_side
TProfile_LW * m_hAvgLLOccMod_side[2][2]
Avg.
Definition: TRT_Monitoring_Tool.h:436
TRT_Monitoring_Tool::m_hHitAWMapC
TH1F_LW * m_hHitAWMapC[2][64]
Definition: TRT_Monitoring_Tool.h:405
TRT_Monitoring_Tool::m_hHitOnTrackVsAllC
TH1F_LW * m_hHitOnTrackVsAllC[2][64]
Definition: TRT_Monitoring_Tool.h:262
TRT_Monitoring_Tool::m_hefficiency
TH1F_LW * m_hefficiency[2][2]
Definition: TRT_Monitoring_Tool.h:622
TRT_Monitoring_Tool::m_hHitHWMapS
TH1F_LW * m_hHitHWMapS[2][64]
HL in time window: Straws If a hit has any of the high threshold time bins up, and is in the time win...
Definition: TRT_Monitoring_Tool.h:339
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TRT_Monitoring_Tool::m_hefficiencyMap
TProfile_LW * m_hefficiencyMap[2]
Definition: TRT_Monitoring_Tool.h:619
TRT_Monitoring_Tool::m_mapPath
std::string m_mapPath
Definition: TRT_Monitoring_Tool.h:176
ITRT_DAQ_ConditionsSvc.h
ITRT_StrawStatusSummaryTool.h
abstract interface to TRT straw status constants
ManagedMonitorToolBase::initialize
virtual StatusCode initialize()
Definition: ManagedMonitorToolBase.cxx:669
TRT_Monitoring_Tool::m_longToTCut
float m_longToTCut
Definition: TRT_Monitoring_Tool.h:573
TRT_Monitoring_Tool::m_hAvgTroTDetPhi_E
TProfile_LW * m_hAvgTroTDetPhi_E[2]
Definition: TRT_Monitoring_Tool.h:221
TRT_Monitoring_Tool::m_doRDOsMon
bool m_doRDOsMon
Definition: TRT_Monitoring_Tool.h:483
TRT_Monitoring_Tool::m_hChipOcc
TH1F_LW * m_hChipOcc[2][64]
Avg.
Definition: TRT_Monitoring_Tool.h:444
TRT_Monitoring_Tool::m_zero_field
bool m_zero_field
Definition: TRT_Monitoring_Tool.h:570
TRT_Monitoring_Tool::m_LBvsLum
TH1F_LW * m_LBvsLum
Definition: TRT_Monitoring_Tool.h:470
TRT_Monitoring_Tool::checkTRTReadoutIntegrity
StatusCode checkTRTReadoutIntegrity(const xAOD::EventInfo &eventInfo)
Definition: TRT_Monitoring_Tool.cxx:4001
TProfile_LW::create
static TProfile_LW * create(const char *name, const char *title, unsigned nbinsx, const double &xlow, const double &xup, const char *option=" ")
Definition: TProfile_LW.cxx:32
TRT_Monitoring_Tool::strawNumberEndCap
int strawNumberEndCap(int strawNumber, int strawLayerNumber, int LayerNumber, int phi_stack, int side)
Definition: TRT_Monitoring_Tool.cxx:4180
Trk::TrackStateOnSurface::Hole
@ Hole
A hole on the track - this is defined in the following way.
Definition: TrackStateOnSurface.h:128
lumiFormat.i
int i
Definition: lumiFormat.py:92
TrackCollection
DataVector< Trk::Track > TrackCollection
This typedef represents a collection of Trk::Track objects.
Definition: TrackCollection.h:19
TRT_Monitoring_Tool::m_nTotalTracks
int m_nTotalTracks
Definition: TRT_Monitoring_Tool.h:78
python.TrigEgammaMonitorHelper.TProfile
def TProfile(*args, **kwargs)
Definition: TrigEgammaMonitorHelper.py:81
TRT_Monitoring_Tool::m_DistToStraw
float m_DistToStraw
Definition: TRT_Monitoring_Tool.h:568
TRT_Monitoring_Tool::s_iChip_max
static const int s_iChip_max[2]
Definition: TRT_Monitoring_Tool.h:142
TRT_Monitoring_Tool::m_hHitTrWMapC
TProfile_LW * m_hHitTrWMapC[2][64]
Definition: TRT_Monitoring_Tool.h:403
TRT_Monitoring_Tool::m_doStraws
bool m_doStraws
Definition: TRT_Monitoring_Tool.h:493
TRT_Monitoring_Tool::m_hHitAWonTMapC
TH1F_LW * m_hHitAWonTMapC[2][64]
Definition: TRT_Monitoring_Tool.h:422
TRTCond::RtRelation::drifttime
virtual float drifttime(float radius) const =0
drifttime for given radius
Trk::theta
@ theta
Definition: ParamDefs.h:72
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
Trk::numberOfSCTHits
@ numberOfSCTHits
number of SCT holes
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:71
TRT_Monitoring_Tool::m_HL_timeWindow_MAX
int m_HL_timeWindow_MAX
Definition: TRT_Monitoring_Tool.h:509
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthenaMonManager::online
@ online
Definition: AthenaMonManager.h:49
TRT_Monitoring_Tool::m_hHitTronTwEPCMapC
TProfile_LW * m_hHitTronTwEPCMapC[2][64]
Definition: TRT_Monitoring_Tool.h:428
TRT_Monitoring_Tool::m_doCSide
bool m_doCSide
Definition: TRT_Monitoring_Tool.h:492
Trk::driftRadius
@ driftRadius
trt, straws
Definition: ParamDefs.h:59
TRT_Monitoring_Tool::m_max_abs_d0
float m_max_abs_d0
Definition: TRT_Monitoring_Tool.h:588
TRT_Monitoring_Tool::m_hResidual_E_Ar
TH1F_LW * m_hResidual_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:248
TRT_Monitoring_Tool::m_hefficiencyEndCap_locR
TProfile_LW * m_hefficiencyEndCap_locR[2]
Definition: TRT_Monitoring_Tool.h:616
TrackCollection.h
TRT_Monitoring_Tool::m_HtoLRatioOnTrackScale_B
float m_HtoLRatioOnTrackScale_B
Definition: TRT_Monitoring_Tool.h:527
SignEnum::LE
@ LE
Definition: SignEnums.h:21
TRT_Monitoring_Tool::m_passEventBurst
bool m_passEventBurst
Definition: TRT_Monitoring_Tool.h:83
TRT_Monitoring_Tool::m_hHitAonTMapC
TH1F_LW * m_hHitAonTMapC[2][64]
Definition: TRT_Monitoring_Tool.h:421
TRT_Monitoring_Tool::m_hWireToTrkPosition_B
TH1F_LW * m_hWireToTrkPosition_B
Definition: TRT_Monitoring_Tool.h:204
InDetRawDataCollection
Definition: InDetRawDataCollection.h:31
Side
Definition: WaferTree.h:36
TRT_Monitoring_Tool::m_LE_timeWindow_MIN
int m_LE_timeWindow_MIN
Definition: TRT_Monitoring_Tool.h:502
TRT_Monitoring_Tool::m_combTrackCollectionKey
SG::ReadHandleKey< TrackCollection > m_combTrackCollectionKey
Definition: TRT_Monitoring_Tool.h:158
TRT_Monitoring_Tool::m_hHLhitOnTrack_E
TH1F_LW * m_hHLhitOnTrack_E[2]
Definition: TRT_Monitoring_Tool.h:234
TRT_Monitoring_Tool::m_hHitHMapC
TH1F_LW * m_hHitHMapC[2][64]
Definition: TRT_Monitoring_Tool.h:411
test_pyathena.parent
parent
Definition: test_pyathena.py:15
TRT_Monitoring_Tool::m_EventPhaseScale
float m_EventPhaseScale
Definition: TRT_Monitoring_Tool.h:516
TRT_Monitoring_Tool::m_hHitHWonTMapC
TH1F_LW * m_hHitHWonTMapC[2][64]
Definition: TRT_Monitoring_Tool.h:424
TRT_Monitoring_Tool::m_hNTrksperLB_B
TProfile * m_hNTrksperLB_B
Definition: TRT_Monitoring_Tool.h:208
TRT_Monitoring_Tool::m_LL_timeWindow_MAX
int m_LL_timeWindow_MAX
Definition: TRT_Monitoring_Tool.h:506
TRT_Monitoring_Tool::m_Pull_Biased_EndCap
TH1F_LW * m_Pull_Biased_EndCap
Definition: TRT_Monitoring_Tool.h:227
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
IdentifiableContainerMT::end
const_iterator end() const
return const_iterator for end of container
Definition: IdentifiableContainerMT.h:242
TRT_Monitoring_Tool::m_trackCollectionKey
SG::ReadHandleKey< TrackCollection > m_trackCollectionKey
Definition: TRT_Monitoring_Tool.h:156
TRT_Monitoring_Tool::m_hHtoLMapS
TH1F_LW * m_hHtoLMapS[2][64]
HL/LL: Straws The ratio of High Level hits to Low Level hits per straw.
Definition: TRT_Monitoring_Tool.h:302
TRT_Monitoring_Tool::m_trt_only_trks
bool m_trt_only_trks
Definition: TRT_Monitoring_Tool.h:569
TRT_Monitoring_Tool::m_lastTRTLumiBlock
int m_lastTRTLumiBlock
Definition: TRT_Monitoring_Tool.h:75
TRT_Monitoring_Tool::m_hWireToTrkPosition_E_Ar
TH1F_LW * m_hWireToTrkPosition_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:239
run
Definition: run.py:1
histSizes.list
def list(name, path='/')
Definition: histSizes.py:38
TRT_Monitoring_Tool::m_hHitToTonTMapC
TProfile_LW * m_hHitToTonTMapC[2][64]
Definition: TRT_Monitoring_Tool.h:427
TRT_Monitoring_Tool::fillHistograms
virtual StatusCode fillHistograms()
An inheriting class should either override this function or fillHists().
Definition: TRT_Monitoring_Tool.cxx:1111
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:82
ITRT_CalDbTool.h
abstract interface to TRT calibration constants
TrackSummary.h
Trk::ParametersBase
Definition: ParametersBase.h:55
IdentifiableContainerMT::begin
const_iterator begin() const
return const_iterator for first entry
Definition: IdentifiableContainerMT.h:236
TRT_DriftCircleOnTrack.h
InDet::TRT_DriftCircle::trailingEdge
int trailingEdge() const
returns the trailing edge bin
TRT_Monitoring_Tool::m_hHitToTLongTrMapS
TProfile_LW * m_hHitToTLongTrMapS[2][64]
Mean Trailing Edge (ns) for straws with ToT > LongToTCut: Straws.
Definition: TRT_Monitoring_Tool.h:326
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
TRT_ID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: TRT_ID.h:866
TRT_Monitoring_Tool::m_hTimeResidual_B_Ar
TH1F_LW * m_hTimeResidual_B_Ar
Definition: TRT_Monitoring_Tool.h:216
TRT_Monitoring_Tool::m_hHitHonTMapS
TH1F_LW * m_hHitHonTMapS[2][64]
Definition: TRT_Monitoring_Tool.h:372
TRT_Monitoring_Tool::m_hEvtPhaseDetPhi_B
TProfile_LW * m_hEvtPhaseDetPhi_B
Definition: TRT_Monitoring_Tool.h:255
TRT_ID::straw_layer
int straw_layer(const Identifier &id) const
Definition: TRT_ID.h:893
TRT_Monitoring_Tool::radToDegrees
static float radToDegrees(float radValue)
Definition: TRT_Monitoring_Tool.cxx:4295
TRT_Monitoring_Tool::strawNumber_reverse
static int strawNumber_reverse(int inp_strawnumber, int *strawNumber, int *strawlayerNumber, int *LayerNumber)
Definition: TRT_Monitoring_Tool.cxx:4140
TRT_Monitoring_Tool::m_hHitWonTMap_E
TH1F_LW * m_hHitWonTMap_E[2]
Definition: TRT_Monitoring_Tool.h:226
TRT_Monitoring_Tool::m_hefficiencyEndCap_locR_Ar
TProfile_LW * m_hefficiencyEndCap_locR_Ar[2]
Definition: TRT_Monitoring_Tool.h:617
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
TRT_ID::layer_or_wheel
int layer_or_wheel(const Identifier &id) const
Definition: TRT_ID.h:884
TRT_Monitoring_Tool::m_hNHLHitsperLB_E
TProfile * m_hNHLHitsperLB_E[2]
Definition: TRT_Monitoring_Tool.h:243
TRT_Monitoring_Tool::m_hRobBSErrorsVsLB
TProfile * m_hRobBSErrorsVsLB[2][2]
Definition: TRT_Monitoring_Tool.h:180
xAOD::EventInfo_v1::lumiBlock
uint32_t lumiBlock() const
The current event's luminosity block number.
TRT_Monitoring_Tool::m_track_pt
float m_track_pt
Definition: TRT_Monitoring_Tool.h:598
TRT_Monitoring_Tool::m_pTRTHelper
const TRT_ID * m_pTRTHelper
Definition: TRT_Monitoring_Tool.h:172
TRT_Monitoring_Tool::m_LE_timeWindow_MAX
int m_LE_timeWindow_MAX
Definition: TRT_Monitoring_Tool.h:503
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
TRT_Monitoring_Tool::m_hResidual_B
TH1F_LW * m_hResidual_B
Definition: TRT_Monitoring_Tool.h:194
TProfile_LW::Fill
void Fill(const double &x, const double &y)
Definition: TProfile_LW.cxx:223
ManagedMonitorToolBase::m_environment
AthenaMonManager::Environment_t m_environment
Definition: ManagedMonitorToolBase.h:902
TRT_Monitoring_Tool::m_hHtoLRatioOnTrack_B_Ar
TH1F_LW * m_hHtoLRatioOnTrack_B_Ar
Definition: TRT_Monitoring_Tool.h:202
Trk::MeasurementBase::localCovariance
const Amg::MatrixX & localCovariance() const
Interface method to get the localError.
Definition: MeasurementBase.h:138
TRT_Monitoring_Tool::fillTRTTracks
StatusCode fillTRTTracks(const TrackCollection &trackCollection, const xAOD::TrigDecision *trigDecision, const ComTime *comTimeObject)
Definition: TRT_Monitoring_Tool.cxx:2341
TRT_Monitoring_Tool::m_hOccAll
TH1F_LW * m_hOccAll
Definition: TRT_Monitoring_Tool.h:453
TRT_Monitoring_Tool::s_numberOfBarrelStacks
static const int s_numberOfBarrelStacks
Definition: TRT_Monitoring_Tool.h:137
TRT_Monitoring_Tool::checkEventBurst
StatusCode checkEventBurst(const TRT_RDO_Container &rdoContainer)
Definition: TRT_Monitoring_Tool.cxx:1746
TRT_Monitoring_Tool::m_hefficiencyBarrel_locR_Ar
TProfile_LW * m_hefficiencyBarrel_locR_Ar
Definition: TRT_Monitoring_Tool.h:615
TRT_Monitoring_Tool::m_hStrawsEff
TProfile_LW * m_hStrawsEff[2][64]
Definition: TRT_Monitoring_Tool.h:253
firstBinHigh
bool firstBinHigh(unsigned int m_word)
Definition: driftCircle.h:104
TRT_Monitoring_Tool::m_DriftTimeonTrkDistScale_E
float m_DriftTimeonTrkDistScale_E[2]
Definition: TRT_Monitoring_Tool.h:546
InDetDD::TRT_DetectorManager::getEndcapElement
const TRT_EndcapElement * getEndcapElement(unsigned int positive, unsigned int wheelIndex, unsigned int strawLayerIndex, unsigned int phiIndex) const
Access Endcap Elements:---------------—(Fast)--------------------------—.
Definition: TRT_DetectorManager.cxx:129
Trk::MeasurementBase
Definition: MeasurementBase.h:58
TRT_Monitoring_Tool::m_hStrawEffDetPhi_E
TProfile_LW * m_hStrawEffDetPhi_E[2]
Definition: TRT_Monitoring_Tool.h:224
TRT_Monitoring_Tool::m_NoiseSuppressionLevel_30pc
bool m_NoiseSuppressionLevel_30pc
Definition: TRT_Monitoring_Tool.h:511
TRT_Monitoring_Tool::m_hHitWMap_B_Ar
TH1F_LW * m_hHitWMap_B_Ar
Definition: TRT_Monitoring_Tool.h:213
TRT_Monitoring_Tool::m_nHLHitsperLB_B
int m_nHLHitsperLB_B
Definition: TRT_Monitoring_Tool.h:544
TRT_Monitoring_Tool::m_hTronTDist_E_Ar
TH1F_LW * m_hTronTDist_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:245
TRT_Monitoring_Tool::m_hNTrksperLB_E
TProfile * m_hNTrksperLB_E[2]
Definition: TRT_Monitoring_Tool.h:242
TRT_Monitoring_Tool::m_nStrawHits_E
int m_nStrawHits_E[2][3840]
Definition: TRT_Monitoring_Tool.h:523
TRT_Monitoring_Tool::m_track_eta
float m_track_eta
Definition: TRT_Monitoring_Tool.h:599
Trk::numberOfTRTHits
@ numberOfTRTHits
number of TRT outliers
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:79
TRT_LoLumRawData::trailingEdge
int trailingEdge() const
Definition: TRT_LoLumRawData.h:66
TRT_Monitoring_Tool::strawNumber
int strawNumber(int strawNumber, int strawlayerNumber, int LayerNumber)
Definition: TRT_Monitoring_Tool.cxx:4093
TRT_Monitoring_Tool::fillTRTRDOs
StatusCode fillTRTRDOs(const TRT_RDO_Container &rdoContainer, const xAOD::EventInfo &eventInfo, const InDetTimeCollection *trtBCIDCollection)
Definition: TRT_Monitoring_Tool.cxx:1780
InDetTimeCollection
std::vector< std::pair< uint32_t, unsigned int > > InDetTimeCollection
Definition: InDetTimeCollection.h:12
TRT_Monitoring_Tool::m_hHitWMapS
TH1F_LW * m_hHitWMapS[2][64]
Leading Edge in time Window: Straws.
Definition: TRT_Monitoring_Tool.h:269
TRT_Monitoring_Tool::m_hHitHMapS
TH1F_LW * m_hHitHMapS[2][64]
High Level: Straws If a hit has any of the high threshold time bins up.
Definition: TRT_Monitoring_Tool.h:333
TH1F_LW::GetBinContent
virtual double GetBinContent(unsigned bin) const override
Definition: TH1F_LW.cxx:265
TRT_Monitoring_Tool::m_TronTDistScale_B_Ar
float m_TronTDistScale_B_Ar
Definition: TRT_Monitoring_Tool.h:538
remainder
std::vector< std::string > remainder(const std::vector< std::string > &v1, const std::vector< std::string > &v2)
list of entries in a vector that are not in another
Definition: compareFlatTrees.cxx:44
TRT_Monitoring_Tool::m_hLLOcc_Scatter
TH2F_LW * m_hLLOcc_Scatter[2]
Definition: TRT_Monitoring_Tool.h:451
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
Trk::d0
@ d0
Definition: ParamDefs.h:69
TRT_Monitoring_Tool::m_hHtoLonTMapC
TH1F_LW * m_hHtoLonTMapC[2][64]
Definition: TRT_Monitoring_Tool.h:425
TRT_LoLumRawData::timeOverThreshold
virtual double timeOverThreshold() const override final
Definition: TRT_LoLumRawData.h:47
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
TRT_Monitoring_Tool::m_hHitTrMapS
TProfile_LW * m_hHitTrMapS[2][64]
Mean TE: Straws.
Definition: TRT_Monitoring_Tool.h:282
Amg::error
double error(const Amg::MatrixX &mat, int index)
return diagonal error of the matrix caller should ensure the matrix is symmetric and the index is in ...
Definition: EventPrimitivesHelpers.h:40
TH2F_LW::create
static TH2F_LW * create(const char *name, const char *title, unsigned nbinsx, const double &xmin, const double &xmax, unsigned nbinsy, const double &ymin, const double &ymax)
Definition: TH2F_LW.cxx:33
TRT_Monitoring_Tool::m_hefficiency_eta
TProfile_LW * m_hefficiency_eta
Definition: TRT_Monitoring_Tool.h:610
LWHist::LWHistAxis::SetBinLabel
void SetBinLabel(unsigned bin, const char *label)
Definition: LWHist.cxx:411
TRT_Monitoring_Tool::m_doExpert
bool m_doExpert
Definition: TRT_Monitoring_Tool.h:496
TRT_Monitoring_Tool::m_NumSwLLWoTScale_E
float m_NumSwLLWoTScale_E[2]
Definition: TRT_Monitoring_Tool.h:551
TRTCond::ExpandedIdentifier::STRAW
@ STRAW
Definition: InnerDetector/InDetConditions/TRT_ConditionsData/TRT_ConditionsData/ExpandedIdentifier.h:37
TRT_Monitoring_Tool::m_ResidualScale_E_20GeV
float m_ResidualScale_E_20GeV[2]
Definition: TRT_Monitoring_Tool.h:556
InDet::TRT_DriftCircle::lastBinHigh
bool lastBinHigh() const
returns true if the last bin is high
TRT_Monitoring_Tool::m_hAvgHLOccMod_side
TProfile_LW * m_hAvgHLOccMod_side[2][2]
Definition: TRT_Monitoring_Tool.h:437
TRT_Monitoring_Tool::bookTH1F_LW
TH1F_LW * bookTH1F_LW(MonGroup &mongroup, const std::string &hName, const std::string &hTitle, int bins, double lowbin, double highbin, const std::string &xTitle, const std::string &yTitle, StatusCode &scode)
Definition: TRT_Monitoring_Tool.cxx:4417
TRT_Monitoring_Tool::m_DriftTimeonTrkDistScale_E_Ar
float m_DriftTimeonTrkDistScale_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:558
TRT_Monitoring_Tool::m_track_z0
float m_track_z0
Definition: TRT_Monitoring_Tool.h:602
TRT_BSErrContainer::getSidErrorSet
const std::set< uint32_t > & getSidErrorSet(void) const
Definition: TRT_BSErrContainer.h:39
TRT_Monitoring_Tool::m_hHitWonTMap_B
TH1F_LW * m_hHitWonTMap_B
Definition: TRT_Monitoring_Tool.h:192
TRT_Monitoring_Tool::m_ResidualScale_B_Ar_20GeV
float m_ResidualScale_B_Ar_20GeV
Definition: TRT_Monitoring_Tool.h:540
TRT::Hit::ident
@ ident
Definition: HitInfo.h:77
TRT_ID::phi_module
int phi_module(const Identifier &id) const
Definition: TRT_ID.h:875
ManagedMonitorToolBase::lowStat
@ lowStat
Definition: ManagedMonitorToolBase.h:115
TRT_Monitoring_Tool::m_hNumTrksDetPhi_E
TH1F_LW * m_hNumTrksDetPhi_E[2]
Definition: TRT_Monitoring_Tool.h:219
TRT_Monitoring_Tool::m_WireToTrkPositionScale_B_Ar
float m_WireToTrkPositionScale_B_Ar
Definition: TRT_Monitoring_Tool.h:532
TRT_Monitoring_Tool::m_hHitWonTMapS
TH1F_LW * m_hHitWonTMapS[2][64]
LE in time window on track: Straws.
Definition: TRT_Monitoring_Tool.h:345
TRT_Monitoring_Tool::m_every_xth_track
int m_every_xth_track
Definition: TRT_Monitoring_Tool.h:605
TRT_Monitoring_Tool::m_IntLum
TH1F_LW * m_IntLum
Definition: TRT_Monitoring_Tool.h:469
TRT_Monitoring_Tool::m_idHelper
const AtlasDetectorID * m_idHelper
Definition: TRT_Monitoring_Tool.h:87
TRT_Monitoring_Tool::m_min_pixel_hits
int m_min_pixel_hits
Definition: TRT_Monitoring_Tool.h:594
TH1F_LW::GetEntries
virtual unsigned GetEntries() const override
Definition: TH1F_LW.cxx:269
TRT_Monitoring_Tool::m_hHitToTLongMapS
TProfile_LW * m_hHitToTLongMapS[2][64]
Mean ToT (ns) for straws with ToT > LongToTCut: Straws.
Definition: TRT_Monitoring_Tool.h:318
TRT_Monitoring_Tool::m_hefficiencyC
TProfile_LW * m_hefficiencyC[2][64]
Definition: TRT_Monitoring_Tool.h:621
xAOD::timeStamp
setEventNumber timeStamp
Definition: EventInfo_v1.cxx:128
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
Trk::MeasurementBase::localParameters
const LocalParameters & localParameters() const
Interface method to get the LocalParameters.
Definition: MeasurementBase.h:132
ITRT_StrawNeighbourSvc.h
Abstract interface to information on straws electronic grouping.
TRT_Monitoring_Tool::m_hAvgTroTDetPhi_B
TProfile_LW * m_hAvgTroTDetPhi_B
Definition: TRT_Monitoring_Tool.h:187
SG::ReadHandle::ptr
const_pointer_type ptr()
Dereference the pointer.
TRT_Monitoring_Tool::m_hHitAWMapS
TH1F_LW * m_hHitAWMapS[2][64]
LL in time window: Straws Any low level hit in time window by straw.
Definition: TRT_Monitoring_Tool.h:296
DataVector< RawDataT >::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
IInDetConditionsSvc.h
TRT_Monitoring_Tool::m_hResidual_B_Ar
TH1F_LW * m_hResidual_B_Ar
Definition: TRT_Monitoring_Tool.h:214
TRT_Monitoring_Tool::m_hNHitsperLB_B
TProfile * m_hNHitsperLB_B
Definition: TRT_Monitoring_Tool.h:207
TRT_Monitoring_Tool::m_max_abs_eta
float m_max_abs_eta
Definition: TRT_Monitoring_Tool.h:591
TRT_Monitoring_Tool::m_EventBurstCut
int m_EventBurstCut
Definition: TRT_Monitoring_Tool.h:575
DeMoAtlasDataLoss.runNumber
string runNumber
Definition: DeMoAtlasDataLoss.py:64
DataVector.h
An STL vector of pointers that by default owns its pointed-to elements.
TRT_Monitoring_Tool::bookTH1D_LW
TH1D_LW * bookTH1D_LW(MonGroup &mongroup, const std::string &hName, const std::string &hTitle, int bins, double lowbin, double highbin, const std::string &xTitle, const std::string &yTitle, StatusCode &scode)
Definition: TRT_Monitoring_Tool.cxx:4430
TRT_Monitoring_Tool::m_hAvgTroTDetPhi_B_Ar
TProfile_LW * m_hAvgTroTDetPhi_B_Ar
Definition: TRT_Monitoring_Tool.h:188
TProfile_LW::GetBinEntries
double GetBinEntries(unsigned bin) const
Definition: TProfile_LW.cxx:242
DeMoScan.index
string index
Definition: DeMoScan.py:362
TRT_Monitoring_Tool::m_hHitAWonTMapS
TH1F_LW * m_hHitAWonTMapS[2][64]
Any LL bit in time window on track: Straws Any low level (LL) bit set and is in time window from hits...
Definition: TRT_Monitoring_Tool.h:363
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
TRT_ID::is_barrel
bool is_barrel(const Identifier &id) const
Test for barrel.
Definition: TRT_ID.h:857
a
TList * a
Definition: liststreamerinfos.cxx:10
python.compareTCTs.ratio
ratio
Definition: compareTCTs.py:295
TRT_Monitoring_Tool::m_hEvtPhaseVsTrig
TH2F_LW * m_hEvtPhaseVsTrig
Definition: TRT_Monitoring_Tool.h:258
TRT_Monitoring_Tool::m_hHitOnTrackVsAllS
TH1F_LW * m_hHitOnTrackVsAllS[2][64]
Definition: TRT_Monitoring_Tool.h:261
TRT_Monitoring_Tool::strawLayerNumber_reverse
static int strawLayerNumber_reverse(int strawLayerNumInp, int *strawLayerNumber, int *LayerNumber)
Definition: TRT_Monitoring_Tool.cxx:4276
TRT_Monitoring_Tool::m_hrtRelation_E_Ar
TH2F_LW * m_hrtRelation_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:251
TRT_Monitoring_Tool::m_nStrawHits_B
int m_nStrawHits_B[1642]
Definition: TRT_Monitoring_Tool.h:520
lumiFormat.fill
fill
Definition: lumiFormat.py:111
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TRT_Monitoring_Tool::m_hrtRelation_E
TH2F_LW * m_hrtRelation_E[2]
Definition: TRT_Monitoring_Tool.h:233
TRT_Monitoring_Tool::m_hDriftTimeonTrkDist_B
TH1F_LW * m_hDriftTimeonTrkDist_B
Definition: TRT_Monitoring_Tool.h:197
TRT_Monitoring_Tool::m_hHtoLRatioOnTrack_B
TH1F_LW * m_hHtoLRatioOnTrack_B
Definition: TRT_Monitoring_Tool.h:201
TRT_Monitoring_Tool::m_TrackSummaryTool
ToolHandle< Trk::ITrackSummaryTool > m_TrackSummaryTool
Definition: TRT_Monitoring_Tool.h:168
TRT_Monitoring_Tool::scale_LWHist
static void scale_LWHist(LWHist1D *hist, float scale)
Definition: TRT_Monitoring_Tool.cxx:4344
TRT_Monitoring_Tool::m_ResidualScale_B
float m_ResidualScale_B
Definition: TRT_Monitoring_Tool.h:534
ManagedMonitorToolBase::endOfRunFlag
bool endOfRunFlag() const
Definition: ManagedMonitorToolBase.h:859
TRT_Monitoring_Tool::m_hEvtPhaseDetPhi_E
TProfile_LW * m_hEvtPhaseDetPhi_E[2]
Definition: TRT_Monitoring_Tool.h:256
TRT_Monitoring_Tool::bookTRTTracks
StatusCode bookTRTTracks(bool isNewLumiBlock, bool isNewRun)
Definition: TRT_Monitoring_Tool.cxx:813
TRT_Monitoring_Tool::m_hHtoBCMapB
TH2F_LW * m_hHtoBCMapB[2][64]
Definition: TRT_Monitoring_Tool.h:409
TRT_Monitoring_Tool::procHistograms
virtual StatusCode procHistograms()
An inheriting class should either override this function or finalHists().
Definition: TRT_Monitoring_Tool.cxx:1209
TRT_Monitoring_Tool::m_trigDecisionKey
SG::ReadHandleKey< xAOD::TrigDecision > m_trigDecisionKey
Definition: TRT_Monitoring_Tool.h:162
TH1F_LW::Reset
virtual void Reset() override
Definition: TH1F_LW.cxx:183
TRT_Monitoring_Tool::m_doEfficiency
bool m_doEfficiency
Definition: TRT_Monitoring_Tool.h:498
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
TRT_Monitoring_Tool::m_hefficiency_pt
TProfile_LW * m_hefficiency_pt
Definition: TRT_Monitoring_Tool.h:612
TRT_Monitoring_Tool::m_hHitToTonTMapS
TProfile_LW * m_hHitToTonTMapS[2][64]
Mean ToT (ns) on Track: Straws Average Time over Threshold (ToT) from a straw hit associated with a t...
Definition: TRT_Monitoring_Tool.h:387
TRT_Monitoring_Tool::m_hHitToTrkDistanceMapS_E
TProfile_LW * m_hHitToTrkDistanceMapS_E[64]
Definition: TRT_Monitoring_Tool.h:430
TRT_Monitoring_Tool::m_TRTCalDbTool
ToolHandle< ITRT_CalDbTool > m_TRTCalDbTool
Definition: TRT_Monitoring_Tool.h:152
TRT_Monitoring_Tool::m_hAvgLLOcc_side
TProfile_LW * m_hAvgLLOcc_side[2][2]
Definition: TRT_Monitoring_Tool.h:183
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:73
TRT_BSErrContainer::getL1ErrorSet
const std::set< std::pair< uint32_t, uint32_t > > & getL1ErrorSet() const
Definition: TRT_BSErrContainer.h:42
Trk::RIO_OnTrack::identify
virtual Identifier identify() const final
return the identifier -extends MeasurementBase
Definition: RIO_OnTrack.h:155
TRT_Monitoring_Tool::m_hTimeResidual_E_Ar
TH1F_LW * m_hTimeResidual_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:250
TRT_Monitoring_Tool::m_ResidualScale_E
float m_ResidualScale_E[2]
Definition: TRT_Monitoring_Tool.h:555
TRT_Monitoring_Tool::m_TimeResidualScale_B_Ar
float m_TimeResidualScale_B_Ar
Definition: TRT_Monitoring_Tool.h:541
python.LArCondContChannels.isBarrel
isBarrel
Definition: LArCondContChannels.py:659
entries
double entries
Definition: listroot.cxx:49
TRT_Monitoring_Tool::m_doMaskStraws
bool m_doMaskStraws
Definition: TRT_Monitoring_Tool.h:497
xAOD::EventInfo_v1::timeStamp
uint32_t timeStamp() const
POSIX time in seconds from 1970. January 1st.
TRT_Monitoring_Tool::m_hHtoLWonTMapC
TH1F_LW * m_hHtoLWonTMapC[2][64]
Definition: TRT_Monitoring_Tool.h:426
InDet::TRT_DriftCircle::driftTimeValid
bool driftTimeValid() const
return true if the corrected drift time is OK
TRT_Monitoring_Tool::m_HtoLRatioOnTrackScale_E_Ar
float m_HtoLRatioOnTrackScale_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:549
TRT_Monitoring_Tool::m_TRT_BCIDCollectionKey
SG::ReadHandleKey< InDetTimeCollection > m_TRT_BCIDCollectionKey
Definition: TRT_Monitoring_Tool.h:160
TRT_Monitoring_Tool::m_NoiseSuppressionMap
bool m_NoiseSuppressionMap
Definition: TRT_Monitoring_Tool.h:514
TRT_Monitoring_Tool::m_hTimeResidual_E
TH1F_LW * m_hTimeResidual_E[2]
Definition: TRT_Monitoring_Tool.h:230
TRT_Monitoring_Tool::m_hResVsDetPhi_E
TH1F_LW * m_hResVsDetPhi_E[2]
Definition: TRT_Monitoring_Tool.h:240
TRT_Monitoring_Tool::bookHistogramsRecurrent
virtual StatusCode bookHistogramsRecurrent()
An inheriting class should either override this function, bookHists() or bookHistograms().
Definition: TRT_Monitoring_Tool.cxx:590
TRT_Monitoring_Tool::m_LLOcc
float m_LLOcc[2][64]
Definition: TRT_Monitoring_Tool.h:458
ManagedMonitorToolBase::lbAverageLuminosity
virtual float lbAverageLuminosity(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1)
Definition: ManagedMonitorToolBase.cxx:1960
timeOverThreshold
double timeOverThreshold(unsigned int m_word)
Definition: driftCircle.h:116
TRT_Monitoring_Tool::m_hSummary
TH1F_LW * m_hSummary
Definition: TRT_Monitoring_Tool.h:178
TRT_Monitoring_Tool::m_LonTrack_E
float m_LonTrack_E[64]
Definition: TRT_Monitoring_Tool.h:480
InDetRawData::identify
virtual Identifier identify() const override final
Definition: InDetRawData.h:41
TRT_Monitoring_Tool::~TRT_Monitoring_Tool
virtual ~TRT_Monitoring_Tool()
Definition: TRT_Monitoring_Tool.cxx:371
TRT_Monitoring_Tool::m_printEventInfo
bool m_printEventInfo
Definition: TRT_Monitoring_Tool.h:572
TRT_Monitoring_Tool::m_flagforscale
int m_flagforscale
Definition: TRT_Monitoring_Tool.h:583
TRT_Monitoring_Tool::m_TimeResidualScale_B
float m_TimeResidualScale_B
Definition: TRT_Monitoring_Tool.h:536
TH2F_LW
Definition: TH2F_LW.h:23
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
TRT_Monitoring_Tool::m_hWireToTrkPosition_E
TH1F_LW * m_hWireToTrkPosition_E[2]
Definition: TRT_Monitoring_Tool.h:238
TRT_Monitoring_Tool::m_TimeResidualScale_E_Ar
float m_TimeResidualScale_E_Ar[2]
Definition: TRT_Monitoring_Tool.h:562
TRT_Monitoring_Tool::m_trackz_All
TH1F_LW * m_trackz_All[5][2]
Initialize Aging plots** HT, All, Barrel, EC, In/A, Out/C, etc...
Definition: TRT_Monitoring_Tool.h:464
TRT_Monitoring_Tool::m_DriftTimeonTrkDistScale_B_Ar
float m_DriftTimeonTrkDistScale_B_Ar
Definition: TRT_Monitoring_Tool.h:537
TRT_Monitoring_Tool::m_hWireToTrkPosition_B_Ar
TH1F_LW * m_hWireToTrkPosition_B_Ar
Definition: TRT_Monitoring_Tool.h:205
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
InDet::TRT_DriftCircle::rawDriftTime
double rawDriftTime() const
returns the raw driftTime
ReadHandle.h
Handle class for reading from StoreGate.
TRT_Monitoring_Tool::m_doTracksMon
bool m_doTracksMon
Definition: TRT_Monitoring_Tool.h:485
InDet::TRT_DriftCircleOnTrack::globalPosition
virtual const Amg::Vector3D & globalPosition() const override final
return the global position of this RIO_OnTrack
Definition: TRT_DriftCircleOnTrack.cxx:160
TRT_Monitoring_Tool::m_hHtoBCMapC
TH2F_LW * m_hHtoBCMapC[2][64]
Definition: TRT_Monitoring_Tool.h:408
TRT_Monitoring_Tool::m_hefficiencyS
TProfile_LW * m_hefficiencyS[2][64]
Definition: TRT_Monitoring_Tool.h:620
TRT_Monitoring_Tool::m_MIN_N_LL_Hits
int m_MIN_N_LL_Hits
Definition: TRT_Monitoring_Tool.h:512
InDet::TRT_DriftCircle::getWord
unsigned int getWord() const
returns the TRT dataword
get_generator_info.error
error
Definition: get_generator_info.py:40
TRT_Monitoring_Tool::m_hHLhitOnTrack_B
TH1F_LW * m_hHLhitOnTrack_B
Definition: TRT_Monitoring_Tool.h:200
ManagedMonitorToolBase::newLumiBlockFlag
bool newLumiBlockFlag() const
Definition: ManagedMonitorToolBase.h:853
TRT_Monitoring_Tool::m_doChips
bool m_doChips
Definition: TRT_Monitoring_Tool.h:494
xAOD::EventInfo_v1::bcid
uint32_t bcid() const
The bunch crossing ID of the event.
TRT_Monitoring_Tool::m_HLhitOnTrackScale_B
float m_HLhitOnTrackScale_B
Definition: TRT_Monitoring_Tool.h:526
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
TRT_Monitoring_Tool::m_hHitHWMapC
TH1F_LW * m_hHitHWMapC[2][64]
Definition: TRT_Monitoring_Tool.h:412
TRT_Monitoring_Tool::m_doGeoMon
bool m_doGeoMon
Definition: TRT_Monitoring_Tool.h:484
error
Definition: IImpactPoint3dEstimator.h:70
GeV
#define GeV
Definition: CaloTransverseBalanceVecMon.cxx:30
trailingEdge
int trailingEdge(unsigned int m_word)
Definition: driftCircle.h:64
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
TRT_Monitoring_Tool::m_comTimeObjectKey
SG::ReadHandleKey< ComTime > m_comTimeObjectKey
Definition: TRT_Monitoring_Tool.h:161
TRT_Monitoring_Tool::m_MIN_TOT_Hits
int m_MIN_TOT_Hits
Definition: TRT_Monitoring_Tool.h:513
TRT_Monitoring_Tool::m_nTrack_B
int m_nTrack_B[32]
Definition: TRT_Monitoring_Tool.h:475
TRT_Monitoring_Tool::m_DEBUG
bool m_DEBUG
Definition: TRT_Monitoring_Tool.h:571
TRT_Monitoring_Tool::m_hrtRelation_B_Ar
TH2F_LW * m_hrtRelation_B_Ar
Definition: TRT_Monitoring_Tool.h:217
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
TRT_Monitoring_Tool::m_hNumSwLLWoT_E
TH1F_LW * m_hNumSwLLWoT_E[2]
Definition: TRT_Monitoring_Tool.h:223
InDet::TRT_DriftCircle::firstBinHigh
bool firstBinHigh() const
returns true if the first bin is high
TRT_Monitoring_Tool::m_trackz_HT
TH1F_LW * m_trackz_HT[5][2]
Definition: TRT_Monitoring_Tool.h:465
readCCLHist.float
float
Definition: readCCLHist.py:83
TRT_Monitoring_Tool::divide_LWHist
static void divide_LWHist(TH1F_LW *result, TH1F_LW *a, TH1F_LW *b)
Definition: TRT_Monitoring_Tool.cxx:4392
TRT_Monitoring_Tool::m_hHitHWonTMapS
TH1F_LW * m_hHitHWonTMapS[2][64]
Any HL hit on track: Straws Any straw with a High Threshold (HL) hit associated with a track.
Definition: TRT_Monitoring_Tool.h:369
TRT_Monitoring_Tool::m_max_abs_z0
float m_max_abs_z0
Definition: TRT_Monitoring_Tool.h:589
TRT_Monitoring_Tool::m_hHitAMapC
TH1F_LW * m_hHitAMapC[2][64]
Definition: TRT_Monitoring_Tool.h:404
xAOD::TrigDecision_v1
Interface to the raw trigger decision information of the event.
Definition: TrigDecision_v1.h:44
TRT_Monitoring_Tool::m_WireToTrkPositionScale_B
float m_WireToTrkPositionScale_B
Definition: TRT_Monitoring_Tool.h:531
TRT_Monitoring_Tool::m_datatype
std::string m_datatype
Definition: TRT_Monitoring_Tool.h:606
TRT_Monitoring_Tool::m_min_sct_hits
int m_min_sct_hits
Definition: TRT_Monitoring_Tool.h:595
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
TRT_BSErrContainer::getBCIDErrorSet
const std::set< std::pair< uint32_t, uint32_t > > & getBCIDErrorSet() const
Definition: TRT_BSErrContainer.h:45
TRT_Monitoring_Tool::m_hHtoLonTMapS
TH1F_LW * m_hHtoLonTMapS[2][64]
HL in time window on track: Straws Straws with a High Threshold hit associated with a track and the h...
Definition: TRT_Monitoring_Tool.h:378
TRT_Monitoring_Tool::m_hHightoLowRatioOnTrack_Scatter
TH2F_LW * m_hHightoLowRatioOnTrack_Scatter[2]
Definition: TRT_Monitoring_Tool.h:452
TRT_Monitoring_Tool::m_rdoContainerKey
SG::ReadHandleKey< TRT_RDO_Container > m_rdoContainerKey
Definition: TRT_Monitoring_Tool.h:155
TRT_Monitoring_Tool::m_hTronTDist_E
TH1F_LW * m_hTronTDist_E[2]
Definition: TRT_Monitoring_Tool.h:232
DataVector< RawDataT >::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
fitman.k
k
Definition: fitman.py:528
InDetDD::TRT_BaseElement
Definition: TRT_BaseElement.h:57
invGeV
constexpr float invGeV
Definition: PFTrackSelector.cxx:10
TRT_Monitoring_Tool::m_minP
float m_minP
Definition: TRT_Monitoring_Tool.h:579
TRT_ID::straw_id
Identifier straw_id(int barrel_ec, int phi_module, int layer_or_wheel, int straw_layer, int straw) const
Three ways of getting id for a single straw:
Definition: TRT_ID.h:581
ymax
double ymax
Definition: listroot.cxx:64
TRT_Monitoring_Tool::m_HtoLRatioOnTrackScale_B_Ar
float m_HtoLRatioOnTrackScale_B_Ar
Definition: TRT_Monitoring_Tool.h:528
TRT_Monitoring_Tool::m_bsErrContKey
SG::ReadHandleKey< TRT_BSErrContainer > m_bsErrContKey
Definition: TRT_Monitoring_Tool.h:164
TRT_Monitoring_Tool::m_HtoLRatioOnTrackScale_B_Xe
float m_HtoLRatioOnTrackScale_B_Xe
Definition: TRT_Monitoring_Tool.h:529
TRT_Monitoring_Tool::m_hNumSwLLWoT_B
TH1F_LW * m_hNumSwLLWoT_B
Definition: TRT_Monitoring_Tool.h:189
driftTimeBin
int driftTimeBin(unsigned int m_word)
Definition: driftCircle.h:50
TRT_Monitoring_Tool::m_mat_chip_B
unsigned char m_mat_chip_B[64][1642]
Definition: TRT_Monitoring_Tool.h:519
TRT_Monitoring_Tool::m_hChipBSErrorsVsLB
TProfile * m_hChipBSErrorsVsLB[2][2]
Definition: TRT_Monitoring_Tool.h:179
ManagedMonitorToolBase::newRunFlag
bool newRunFlag() const
Definition: ManagedMonitorToolBase.h:854
SCT_Monitoring::summary
@ summary
Definition: SCT_MonitoringNumbers.h:65
Generated on Tue Jul 2 2024 21:31:34 for ATLAS Offline Software by   doxygen 1.8.18