ATLAS Offline Software
AFPToFAlgorithm.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 *
4 *
5 * AFPToFAlgorithm
6 *
7 *
8 */
9 
10 #include "Run3AFPMonitoring/AFPToFAlgorithm.h"
11 #include "StoreGate/ReadHandleKey.h"
12 #include "xAODForward/AFPStationID.h"
13 
14 
15 AFPToFAlgorithm::AFPToFAlgorithm( const std::string& name, ISvcLocator* pSvcLocator )
16 :AthMonitorAlgorithm(name,pSvcLocator)
17 , m_afpToFHitContainerKey("AFPToFHitContainer"), m_afpTrackContainerKey( "AFPTrackContainer" )
18 
19 {
20  declareProperty( "AFPToFHitContainer", m_afpToFHitContainerKey );
21  declareProperty( "AFPTrackContainer", m_afpTrackContainerKey );
22 }
23 
24 
25 AFPToFAlgorithm::~AFPToFAlgorithm() {}
26 
27 
28 StatusCode AFPToFAlgorithm::initialize() {
29  using namespace Monitored;
30 
31  m_StationNamesGroup = buildToolMap<int>(m_tools,"AFPToFTool", m_stationNamesToF);
32  m_TrainsToFGroup = buildToolMap<int>(m_tools, "AFPToFTool", m_trainsToF);
33  m_BarsInTrainsA = buildToolMap<std::map<std::string,int>>(m_tools, "AFPToFTool", m_trainsToFA, m_barsToF);
34  m_BarsInTrainsC = buildToolMap<std::map<std::string,int>>(m_tools,"AFPToFTool", m_trainsToFC, m_barsToF);
35  m_GroupChanCombDeltaT = buildToolMap<int>(m_tools, "AFPToFTool", m_chanComb);
36 
37 
38  // We must declare to the framework in initialize what SG objects we are going to use
39  SG::ReadHandleKey<xAOD::AFPToFHitContainer> afpToFHitContainerKey("AFPToFHits");
40  ATH_CHECK(m_afpToFHitContainerKey.initialize());
41  SG::ReadHandleKey<xAOD::AFPTrackContainer> afpTrackContainerKey( "AFPTracks" );
42  ATH_CHECK( m_afpTrackContainerKey.initialize() );
43 
44  ATH_MSG_INFO( "BunchCrossingKey initialization (ToF)" );
45  ATH_CHECK(m_bunchCrossingKeyToF.initialize());
46  ATH_MSG_INFO( "initialization completed (ToF)" );
47 
48  return AthMonitorAlgorithm::initialize();
49 }
50 
51 
52 StatusCode AFPToFAlgorithm::fillHistograms( const EventContext& ctx ) const {
53  using namespace Monitored;
54 
55  const unsigned NTRAINS = 4;
56  enum { FRONT, MIDDLE, END, NPOS } position = NPOS;
57 
58  auto bcidAllToF = Monitored::Scalar<int>("bcidAllToF", 0);
59  Monitored::Scalar<int> bcidToF[NPOS] =
60  { Monitored::Scalar<int>("bcidFrontToF", 0),
61  Monitored::Scalar<int>("bcidMiddleToF", 0),
62  Monitored::Scalar<int>("bcidEndToF", 0) };
63 
64  // Declare the quantities which should be monitored
65  auto lb = Monitored::Scalar<int>("lb", 0);
66  auto nTofHits = Monitored::Scalar<int>("nTofHits", 1);
67  auto numberOfHit_S0 = Monitored::Scalar<int>("numberOfHit_S0", 0);
68  auto numberOfHit_S3 = Monitored::Scalar<int>("numberOfHit_S3", 0);
69  auto trainID = Monitored::Scalar<int>("trainID", 0);
70  auto barInTrainID = Monitored::Scalar<int>("barInTrainID", 0);
71  auto barInTrainAllA = Monitored::Scalar<int>("barInTrainAllA", 0);
72  auto barInTrainIDA = Monitored::Scalar<int>("barInTrainIDA", 0);
73  auto barInTrainAllC = Monitored::Scalar<int>("barInTrainAllC", 0);
74  auto barInTrainIDC = Monitored::Scalar<int>("barInTrainIDC", 0);
75 
76  auto ToFHits_sideA = Monitored::Scalar<int>("ToFHits_sideA", 0);
77  auto ToFHits_sideC = Monitored::Scalar<int>("ToFHits_sideC", 0);
78  auto ToFHits_MU_Weight = Monitored::Scalar<float>("ToFHits_MU_Weight", 0.0);
79  auto muPerBXToF = Monitored::Scalar<float>("muPerBXToF", 0.0);
80 
81  auto lbAToF = Monitored::Scalar<int>("lbAToF", 0);
82  auto lbCToF = Monitored::Scalar<int>("lbCToF", 0);
83  auto lbAToF_Weight = Monitored::Scalar<float>("lbAToF_Weight", 0.0);
84  auto lbCToF_Weight = Monitored::Scalar<float>("lbCToF_Weight", 0.0);
85 
86  auto lbAToFEvents = Monitored::Scalar<int>("lbAToFEvents", 0);
87  auto lbCToFEvents = Monitored::Scalar<int>("lbCToFEvents", 0);
88  auto lbAandCToFEvents = Monitored::Scalar<int>("lbAandCToFEvents", 0);
89 
90  // FME histograms quantites (side A)
91 
92  Monitored::Scalar<int> lbAToF_T[NTRAINS] =
93  { Monitored::Scalar<int>("lbAToF_T0", 0),
94  Monitored::Scalar<int>("lbAToF_T1", 0),
95  Monitored::Scalar<int>("lbAToF_T2", 0),
96  Monitored::Scalar<int>("lbAToF_T3", 0) };
97 
98  auto lbAToF_TAll_Weight = Monitored::Scalar<float>("lbAToF_TAll_Weight", 1);
99 
100  Monitored::Scalar<int> lbAToF_TP[NTRAINS][NPOS] =
101  { { Monitored::Scalar<int>("lbAToF_T0_Front", 0),
102  Monitored::Scalar<int>("lbAToF_T0_Middle", 0),
103  Monitored::Scalar<int>("lbAToF_T0_End", 0) },
104  { Monitored::Scalar<int>("lbAToF_T1_Front", 0),
105  Monitored::Scalar<int>("lbAToF_T1_Middle", 0),
106  Monitored::Scalar<int>("lbAToF_T1_End", 0) },
107  { Monitored::Scalar<int>("lbAToF_T2_Front", 0),
108  Monitored::Scalar<int>("lbAToF_T2_Middle", 0),
109  Monitored::Scalar<int>("lbAToF_T2_End", 0) },
110  { Monitored::Scalar<int>("lbAToF_T3_Front", 0),
111  Monitored::Scalar<int>("lbAToF_T3_Middle", 0),
112  Monitored::Scalar<int>("lbAToF_T3_End", 0) } };
113 
114  Monitored::Scalar<float> lbAToF_TWeight[NPOS] =
115  { Monitored::Scalar<float>("lbAToF_TFront_Weight", 1),
116  Monitored::Scalar<float>("lbAToF_TMiddle_Weight", 1),
117  Monitored::Scalar<float>("lbAToF_TEnd_Weight", 1) };
118 
119  // FME histograms quantites (side C)
120 
121  Monitored::Scalar<int> lbCToF_T[NTRAINS] =
122  { Monitored::Scalar<int>("lbCToF_T0", 0),
123  Monitored::Scalar<int>("lbCToF_T1", 0),
124  Monitored::Scalar<int>("lbCToF_T2", 0),
125  Monitored::Scalar<int>("lbCToF_T3", 0) };
126 
127  auto lbCToF_TAll_Weight = Monitored::Scalar<float>("lbCToF_TAll_Weight", 1);
128 
129  Monitored::Scalar<int> lbCToF_TP[NTRAINS][NPOS] =
130  { { Monitored::Scalar<int>("lbCToF_T0_Front", 0),
131  Monitored::Scalar<int>("lbCToF_T0_Middle", 0),
132  Monitored::Scalar<int>("lbCToF_T0_End", 0) },
133  { Monitored::Scalar<int>("lbCToF_T1_Front", 0),
134  Monitored::Scalar<int>("lbCToF_T1_Middle", 0),
135  Monitored::Scalar<int>("lbCToF_T1_End", 0) },
136  { Monitored::Scalar<int>("lbCToF_T2_Front", 0),
137  Monitored::Scalar<int>("lbCToF_T2_Middle", 0),
138  Monitored::Scalar<int>("lbCToF_T2_End", 0) },
139  { Monitored::Scalar<int>("lbCToF_T3_Front", 0),
140  Monitored::Scalar<int>("lbCToF_T3_Middle", 0),
141  Monitored::Scalar<int>("lbCToF_T3_End", 0) } };
142 
143  Monitored::Scalar<float> lbCToF_TWeight[NPOS] =
144  { Monitored::Scalar<float>("lbCToF_TFront_Weight", 1),
145  Monitored::Scalar<float>("lbCToF_TMiddle_Weight", 1),
146  Monitored::Scalar<float>("lbCToF_TEnd_Weight", 1) };
147 
148  SG::ReadHandle<xAOD::EventInfo> eventInfo = GetEventInfo(ctx);
149  lb = eventInfo->lumiBlock();
150  lbAToF = eventInfo->lumiBlock();
151  lbCToF = eventInfo->lumiBlock();
152  lbAToFEvents = eventInfo->lumiBlock();
153  lbCToFEvents = eventInfo->lumiBlock();
154  lbAandCToFEvents = eventInfo->lumiBlock();
155  muPerBXToF = lbAverageInteractionsPerCrossing(ctx);
156 
157  if (muPerBXToF == 0.0) {
158  ATH_MSG_DEBUG("AverageInteractionsPerCrossing is 0, forcing to 1.0");
159  muPerBXToF=1.0;
160  }
161 
162 
163  ToFHits_MU_Weight = 1/muPerBXToF;
164  lbAToF_Weight = 1/muPerBXToF;
165  lbCToF_Weight = 1/muPerBXToF;
166  lbAToF_TAll_Weight = 1/muPerBXToF;
167  lbCToF_TAll_Weight = 1/muPerBXToF;
168  lbAToF_TWeight[FRONT] = 1/muPerBXToF;
169  lbAToF_TWeight[MIDDLE] = 1/muPerBXToF;
170  lbAToF_TWeight[END] = 1/muPerBXToF;
171  lbCToF_TWeight[FRONT] = 1/muPerBXToF;
172  lbCToF_TWeight[MIDDLE] = 1/muPerBXToF;
173  lbCToF_TWeight[END] = 1/muPerBXToF;
174 
175  fill("AFPToFTool", lb, muPerBXToF);
176 
177  // BCX handler
178  const unsigned int tempBCID = eventInfo->bcid();
179  SG::ReadCondHandle<BunchCrossingCondData> bcidHdlToF(m_bunchCrossingKeyToF,ctx);
180  if (!bcidHdlToF.isValid()) {
181  ATH_MSG_ERROR( "Unable to retrieve BunchCrossing conditions object (ToF)" );
182  }
183  const BunchCrossingCondData* bcDataToF{*bcidHdlToF};
184 
185  // Classifying bunches by position in train (Front, Middle, End)
186  if(bcDataToF->isFilled(tempBCID))
187  {
188  bcidAllToF = tempBCID;
189  fill("AFPToFTool", bcidAllToF);
190  if(!bcDataToF->isFilled(tempBCID-1))
191  {
192  position = FRONT;
193  }
194  else if(bcDataToF->isFilled(tempBCID+1))
195  {
196  position = MIDDLE;
197  }
198  else
199  {
200  position = END;
201  }
202  bcidToF[position] = tempBCID;
203  fill("AFPToFTool", bcidToF[position]);
204  }
205 
206 
207  SG::ReadHandle<xAOD::AFPToFHitContainer> afpToFHitContainer(m_afpToFHitContainerKey, ctx);
208  if(! afpToFHitContainer.isValid())
209  {
210  ATH_MSG_WARNING("evtStore() does not contain hits collection with name " << m_afpToFHitContainerKey);
211  return StatusCode::SUCCESS;
212  }
213 
214  ATH_CHECK( afpToFHitContainer.initialize() );
215 
216  SG::ReadHandle<xAOD::AFPTrackContainer> afpTrackContainer( m_afpTrackContainerKey, ctx );
217  if ( !afpTrackContainer.isValid() ) {
218  ATH_MSG_WARNING( "evtStore() does not contain hits collection with name " << m_afpTrackContainerKey );
219  return StatusCode::SUCCESS;
220  }
221  ATH_CHECK( afpTrackContainer.initialize() );
222 
223  nTofHits = afpToFHitContainer->size();
224  fill("AFPToFTool", lb, nTofHits);
225 
226  int eventsInStations[4] = {};
227 
228  for(const xAOD::AFPToFHit *hitsItr: *afpToFHitContainer)
229  {
230  trainID = hitsItr->trainID();
231  barInTrainID = hitsItr->barInTrainID();
232  ++eventsInStations[hitsItr->stationID()];
233 
234  if(hitsItr->isSideA())
235  {
236  numberOfHit_S0 = hitsItr->trainID();
237  fill("AFPToFTool", numberOfHit_S0);
238 
239  barInTrainIDA = hitsItr->barInTrainID();
240  fill(m_tools[m_TrainsToFGroup.at(m_trainsToF.at(hitsItr->trainID()))], barInTrainIDA);
241  barInTrainAllA = (hitsItr->trainID()*4)+barInTrainIDA;
242  fill("AFPToFTool", barInTrainAllA);
243 
244  ToFHits_sideA = eventInfo->lumiBlock();
245  fill("AFPToFTool", ToFHits_sideA, ToFHits_MU_Weight);
246  }
247  else if(hitsItr->isSideC())
248  {
249  numberOfHit_S3 = hitsItr->trainID();
250  fill("AFPToFTool", numberOfHit_S3);
251 
252  barInTrainIDC = hitsItr->barInTrainID();
253  fill(m_tools[m_TrainsToFGroup.at(m_trainsToF.at(hitsItr->trainID()))], barInTrainIDC);
254  barInTrainAllC = (hitsItr->trainID()*4)+barInTrainIDC;
255  fill("AFPToFTool", barInTrainAllC);
256 
257  ToFHits_sideC = eventInfo->lumiBlock();
258  fill("AFPToFTool", ToFHits_sideC, ToFHits_MU_Weight);
259  }
260 
261  if(hitsItr->isSideA() || hitsItr->isSideC())
262  {
263  auto& lbToF_T = hitsItr->isSideA() ? lbAToF_T : lbCToF_T;
264  auto& lbToF_TP = hitsItr->isSideA() ? lbAToF_TP : lbCToF_TP;
265  auto& lbToF_TAll_Weight = hitsItr->isSideA() ? lbAToF_TAll_Weight : lbCToF_TAll_Weight;
266  auto& lbToF_TWeight = hitsItr->isSideA() ? lbAToF_TWeight : lbCToF_TWeight;
267 
268  unsigned int train = hitsItr->trainID();
269  if(train < NTRAINS)
270  {
271  lbToF_T[train] = eventInfo->lumiBlock();
272  fill("AFPToFTool", lbToF_T[train], lbToF_TAll_Weight);
273 
274  if(position != NPOS)
275  {
276  lbToF_TP[train][position] = eventInfo->lumiBlock();
277  fill("AFPToFTool", lbToF_TP[train][position], lbToF_TWeight[position]);
278  }
279  }
280  }
281 
282  if (hitsItr->stationID() == 0 || hitsItr->stationID() == 3)
283  {
284  fill(m_tools[m_StationNamesGroup.at(m_stationNamesToF.at(hitsItr->stationID()))], barInTrainID, trainID);
285 
286  if(hitsItr->stationID() == 0) // farAside
287  {
288  fill(m_tools[m_BarsInTrainsA.at(m_trainsToFA.at(hitsItr->trainID())).at(m_barsToF.at(hitsItr->barInTrainID()))], lbAToF, lbAToF_Weight);
289  }
290  else // farCside
291  {
292  fill(m_tools[m_BarsInTrainsC.at(m_trainsToFC.at(hitsItr->trainID())).at(m_barsToF.at(hitsItr->barInTrainID()))], lbCToF, lbCToF_Weight);
293  }
294  }
295  }
296 
297  // Events histograms
298  if(eventsInStations[0] > 0 || eventsInStations[3] > 0)
299  {
300  fill("AFPToFTool", lbAandCToFEvents);
301 
302  if(eventsInStations[0] > 0)
303  {
304  fill("AFPToFTool", lbAToFEvents);
305  }
306  if(eventsInStations[3] > 0)
307  {
308  fill("AFPToFTool", lbCToFEvents);
309  }
310  }
311 
312  return fillHistograms_crossBarDeltaT(*afpTrackContainer, *afpToFHitContainer);
313 }
314 
315 StatusCode AFPToFAlgorithm::fillHistograms_crossBarDeltaT(
316  const xAOD::AFPTrackContainer& afpTrackContainer,
317  const xAOD::AFPToFHitContainer& afpToFHitContainer) const {
318  // Initialize monitored variables for histogram filling
319  Monitored::Scalar<float> crossBarDeltaT[2] = {
320  Monitored::Scalar<float>( "crossBarDeltaT_A", 0.0 ),
321  Monitored::Scalar<float>( "crossBarDeltaT_C", 0.0 )
322  };
323 
324  bool channel_present[2][16] = {};
325  bool multihit[2] = {};
326  std::size_t track_count[2] = {};
327  std::size_t train_count[2][4] = {};
328 
329  for (const xAOD::AFPTrack* tracksItr : afpTrackContainer)
330  {
331  const auto side = tracksItr->stationID() == 3;
332  // Ignore tracks that are not from FAR stations
333  if (tracksItr->stationID() != 0 && tracksItr->stationID() != 3)
334  continue;
335  ++track_count[side];
336  }
337 
338  // Load the necessary information
339  auto times = std::vector<std::vector<std::vector<float>>>(2, std::vector<std::vector<float>>(4, std::vector<float>(4, -10000)));
340  for (const xAOD::AFPToFHit* hitsItr : afpToFHitContainer)
341  {
342  const auto side = hitsItr->stationID() == 3;
343  const auto train = hitsItr->trainID();
344  const auto bar = hitsItr->barInTrainID();
345  const auto channel = 4 * train + bar;
346  const auto tof_time = hitsItr->time();
347  const auto TimePs=(tof_time)*1000;
348  //Cut on only 1 SiT track in the monitored station
349  if (track_count[side] != 1) continue;
350  // Ignore hits with an impossible origin
351  if (hitsItr->stationID() != 0 && hitsItr->stationID() != 3)
352  continue;
353  if (channel >= 16) continue;
354  if (channel_present[side][channel])
355  multihit[side] = true;
356  channel_present[side][channel] = true;
357  ++train_count[side][train];
358 
359  times[side][train][bar]=TimePs;
360 
361  }
362 
363  for (uint8_t side : {0, 1})
364  {
365  // Cut on only 1 SiT track in the monitored station
366  if (track_count[side] != 1) continue;
367  // Cut on maximum of 1 hit in each ToF channel
368  if (multihit[side]) continue;
369  //Cut on maximum 1 train per event
370  uint8_t multrain[2] = {};
371  for (uint8_t train = 0; train < 4; ++train) {
372  if (train_count[side][train]>1) {
373  ++multrain[side];
374  }
375  }
376  if (multrain[side]>1) continue;
377  //fill histos
378  for (uint8_t train = 0; train < 4; ++train) {
379  for (uint8_t bar1 = 0; bar1 < 4; ++bar1) {
380  for (uint8_t bar2 = 0; bar2 < 4; ++bar2) {
381  if (bar2>bar1) {
382  int comb = bar1*bar2+bar2-1;
383  if (comb==5) {comb=4;}
384  if (comb==8) {comb=5;}
385  int global_comb = train*6 + comb;
386  if (times[side][train][bar1]>-10000 && times[side][train][bar2]>-10000) {
387  crossBarDeltaT[side] = (times[side][train][bar1] - times[side][train][bar2]);
388  fill(m_tools[m_GroupChanCombDeltaT.at(m_chanComb.at(global_comb))], crossBarDeltaT[side]);
389  }
390  }
391  }
392  }
393  }
394  }
395 
396  return StatusCode::SUCCESS;
397 }
ReadHandleKey.h
Property holding a SG store/key/clid from which a ReadHandle is made.
AFPToFAlgorithm.h
xAOD::AFPTrack_v2
Class representing a track reconstructed in AFP.
Definition: AFPTrack_v2.h:37
BunchCrossingCondData
Definition: BunchCrossingCondData.h:23
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:24
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
AFPToFAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const override
adds event to the monitoring histograms
Definition: AFPToFAlgorithm.cxx:52
AFPToFAlgorithm::m_afpTrackContainerKey
SG::ReadHandleKey< xAOD::AFPTrackContainer > m_afpTrackContainerKey
Definition: AFPToFAlgorithm.h:34
SG::ReadCondHandle::isValid
bool isValid()
Definition: ReadCondHandle.h:206
AFPToFAlgorithm::fillHistograms_crossBarDeltaT
virtual StatusCode fillHistograms_crossBarDeltaT(const xAOD::AFPTrackContainer &, const xAOD::AFPToFHitContainer &) const
Definition: AFPToFAlgorithm.cxx:315
AFPToFAlgorithm::m_BarsInTrainsA
std::map< std::string, std::map< std::string, int > > m_BarsInTrainsA
Definition: AFPToFAlgorithm.h:30
SG::ReadHandleKey
Property holding a SG store/key/clid from which a ReadHandle is made.
Definition: StoreGate/StoreGate/ReadHandleKey.h:39
AFPToFAlgorithm::m_GroupChanCombDeltaT
std::map< std::string, int > m_GroupChanCombDeltaT
Definition: AFPToFAlgorithm.h:32
xAOD::AFPToFHit_v1
Class representing a hit in ToF detector.
Definition: AFPToFHit_v1.h:20
TRT::Hit::side
@ side
Definition: HitInfo.h:83
AthMonitorAlgorithm
Base class for Athena Monitoring Algorithms.
Definition: AthMonitorAlgorithm.h:36
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
python.BunchSpacingUtils.lb
lb
Definition: BunchSpacingUtils.py:88
AFPToFAlgorithm::m_trainsToFC
std::vector< std::string > m_trainsToFC
Definition: AFPToFAlgorithm.h:43
AFPToFAlgorithm::m_trainsToFA
std::vector< std::string > m_trainsToFA
Definition: AFPToFAlgorithm.h:42
Monitored
Generic monitoring tool for athena components.
Definition: GenericMonitoringTool.h:30
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AFPToFAlgorithm::m_stationNamesToF
std::vector< std::string > m_stationNamesToF
Definition: AFPToFAlgorithm.h:39
AFPToFAlgorithm::m_chanComb
std::vector< std::string > m_chanComb
Definition: AFPToFAlgorithm.h:46
internal_poltrig::END
@ END
Definition: PolygonTriangulator.cxx:112
AFPStationID.h
Definitions of AFP stations identification numbers.
AFPToFAlgorithm::AFPToFAlgorithm
AFPToFAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Definition: AFPToFAlgorithm.cxx:15
AFPToFAlgorithm::m_afpToFHitContainerKey
SG::ReadHandleKey< xAOD::AFPToFHitContainer > m_afpToFHitContainerKey
Definition: AFPToFAlgorithm.h:33
AFPToFAlgorithm::m_TrainsToFGroup
std::map< std::string, int > m_TrainsToFGroup
Definition: AFPToFAlgorithm.h:29
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AthMonitorAlgorithm::fill
void fill(const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
Fills a vector of variables to a group by reference.
AthMonitorAlgorithm::GetEventInfo
SG::ReadHandle< xAOD::EventInfo > GetEventInfo(const EventContext &) const
Return a ReadHandle for an EventInfo object (get run/event numbers, etc.)
Definition: AthMonitorAlgorithm.cxx:107
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
xAOD::EventInfo_v1::lumiBlock
uint32_t lumiBlock() const
The current event's luminosity block number.
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition: AthMonitorAlgorithm.h:338
python.SystemOfUnits.bar
int bar
Definition: SystemOfUnits.py:188
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
AthMonitorAlgorithm::lbAverageInteractionsPerCrossing
virtual float lbAverageInteractionsPerCrossing(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Calculate the average mu, i.e.
Definition: AthMonitorAlgorithm.cxx:222
AFPToFAlgorithm::~AFPToFAlgorithm
virtual ~AFPToFAlgorithm()
Definition: AFPToFAlgorithm.cxx:25
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
AFPToFAlgorithm::m_barsToF
std::vector< std::string > m_barsToF
Definition: AFPToFAlgorithm.h:44
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
SG::VarHandleBase::initialize
StatusCode initialize(bool used=true)
Verify that the handle has been configured properly.
Definition: StoreGate/src/VarHandleBase.cxx:452
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
AFPToFAlgorithm::m_StationNamesGroup
std::map< std::string, int > m_StationNamesGroup
Definition: AFPToFAlgorithm.h:28
xAOD::EventInfo_v1::bcid
uint32_t bcid() const
The bunch crossing ID of the event.
AFPToFAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AFPToFAlgorithm.cxx:28
AFPToFAlgorithm::m_bunchCrossingKeyToF
SG::ReadCondHandleKey< BunchCrossingCondData > m_bunchCrossingKeyToF
Definition: AFPToFAlgorithm.h:35
AFPToFAlgorithm::m_BarsInTrainsC
std::map< std::string, std::map< std::string, int > > m_BarsInTrainsC
Definition: AFPToFAlgorithm.h:31
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AFPToFAlgorithm::m_trainsToF
std::vector< std::string > m_trainsToF
Definition: AFPToFAlgorithm.h:40
plot_times.times
def times(fn)
Definition: plot_times.py:11
Generated on Thu Nov 7 2024 21:09:41 for ATLAS Offline Software by   doxygen 1.8.18