ATLAS Offline Software
L1CaloPprPlotManager.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 
6 #include "GaudiKernel/ITHistSvc.h"
7 #include "GaudiKernel/StatusCode.h"
8 #include "GaudiKernel/MsgStream.h"
9 
10 #include "AthenaMonitoring/AthenaMonManager.h"
11 #include "AthenaMonitoring/ManagedMonitorToolBase.h"
12 
13 #include <cmath>
14 #include <utility>
15 
16 #include "TH2F.h"
17 #include "TProfile.h"
18 #include "TProfile2D.h"
19 
20 #include "LWHists/TH2F_LW.h"
21 #include "LWHists/TProfile_LW.h"
22 #include "LWHists/TProfile2D_LW.h"
23 
24 #include "TrigT1CaloCalibTools/L1CaloPprPlotManager.h"
25 #include "TrigT1CaloMonitoringTools/TrigT1CaloLWHistogramTool.h"
26 #include "TrigT1CaloCalibConditions/L1CaloCoolChannelId.h"
27 #include "TrigT1CaloCalibToolInterfaces/IL1CaloOfflineTriggerTowerTools.h"
28 #include "TrigT1CaloToolInterfaces/IL1TriggerTowerTool.h"
29 
30 #include "TrigT1CaloEvent/TriggerTowerCollection.h"
31 #include "xAODTrigL1Calo/TriggerTower.h"
32 #include "xAODTrigL1Calo/TriggerTowerContainer.h"
33 
34 // constructor for offline monitoring
35 L1CaloPprPlotManager::L1CaloPprPlotManager(ITHistSvc* histSvc,
36  ToolHandle<LVL1::IL1CaloOfflineTriggerTowerTools> &ttTool_offline,
37  const int ADC_cut,
38  unsigned int lumiMax,
39  const std::string& pathInRootFile,
40  const std::string& monitoringPath,
41  const std::string& monitoringName,
42  const std::string& monitoringTitle,
43  const std::string& monitoringDimension,
44  bool doRunHistograms):
45  AthMessaging(Form("L1CaloPpr%sPlotManager", monitoringPath.data())),
46  m_histTool("LVL1::TrigT1CaloLWHistogramTool/TrigT1CaloLWHistogramTool"),
47  m_ttToolOffline(ttTool_offline),
48  m_histoSvc(histSvc),
49  m_monObj(0),
50  m_pathInRootFile(pathInRootFile),
51  m_monitoringPath(monitoringPath),
52  m_monitoringName(monitoringName),
53  m_monitoringTitle(monitoringTitle),
54  m_monitoringDimension(monitoringDimension),
55  m_p_online_em_valueVsLumi(0),
56  m_p_online_had_valueVsLumi(0),
57  m_p_online_em_valueVsBCN(0),
58  m_p_online_had_valueVsBCN(0),
59  m_h_ppm_em_2d_value_BCN_Lumi(0),
60  m_h_ppm_had_2d_value_BCN_Lumi(0),
61  m_p_offline_em_valueVsLumi(0),
62  m_p_offline_had_valueVsLumi(0),
63  m_p_online_em_etaPhiValue(0),
64  m_p_online_had_etaPhiValue(0),
65  m_h_online_em_etaPhiValueRMS(0),
66  m_h_online_had_etaPhiValueRMS(0),
67  m_h_offline_em_etaPhiValueRMS(0),
68  m_h_offline_had_etaPhiValueRMS(0),
69  m_p_offline_em_valueVsRunNumber(0),
70  m_p_offline_had_valueVsRunNumber(0),
71  m_isOnline(false),
72  m_firstRun(true),
73  m_doRunHistograms(doRunHistograms),
74  m_ppmAdcMinValue(ADC_cut),
75  m_lumiNo(0),
76  m_bunchCrossing(0),
77  m_lumiMax(lumiMax),
78  m_sampleInterval(25), //25 nano second sampling interval
79  m_currentRunNo(0),
80  m_lastRunNo(0)
81 {
82 }
83 
84 // --------------------------------------------------------------------------
85 
86 // Overloaded constructor for online monitoring
87 L1CaloPprPlotManager::L1CaloPprPlotManager(ManagedMonitorToolBase* aMonObj,
88  ToolHandle<LVL1::IL1TriggerTowerTool>&ttTool_online,
89  int ADC_cut,
90  unsigned int lumiMax,
91  const std::string& pathInRootFile,
92  const std::string& monitoringPath,
93  const std::string& monitoringName,
94  const std::string& monitoringTitle,
95  const std::string& monitoringDimension):
96  AthMessaging(Form("L1CaloPpr%sPlotManager", monitoringPath.data())),
97  m_histTool("LVL1::TrigT1CaloLWHistogramTool/TrigT1CaloLWHistogramTool"),
98  m_ttToolOnline(ttTool_online),
99  m_histoSvc(0),
100  m_monObj(aMonObj),
101  m_pathInRootFile(pathInRootFile),
102  m_monitoringPath(monitoringPath),
103  m_monitoringName(monitoringName),
104  m_monitoringTitle(monitoringTitle),
105  m_monitoringDimension(monitoringDimension),
106  m_p_online_em_valueVsLumi(0),
107  m_p_online_had_valueVsLumi(0),
108  m_p_online_em_valueVsBCN(0),
109  m_p_online_had_valueVsBCN(0),
110  m_h_ppm_em_2d_value_BCN_Lumi(0),
111  m_h_ppm_had_2d_value_BCN_Lumi(0),
112  m_p_offline_em_valueVsLumi(0),
113  m_p_offline_had_valueVsLumi(0),
114  m_p_online_em_etaPhiValue(0),
115  m_p_online_had_etaPhiValue(0),
116  m_h_online_em_etaPhiValueRMS(0),
117  m_h_online_had_etaPhiValueRMS(0),
118  m_h_offline_em_etaPhiValueRMS(0),
119  m_h_offline_had_etaPhiValueRMS(0),
120  m_p_offline_em_valueVsRunNumber(0),
121  m_p_offline_had_valueVsRunNumber(0),
122  m_isOnline(true),
123  m_firstRun(true),
124  m_doRunHistograms(false),
125  m_ppmAdcMinValue(ADC_cut),
126  m_lumiNo(0),
127  m_bunchCrossing(0),
128  m_lumiMax(lumiMax),
129  m_sampleInterval(25), // 25 nano second sampling interval
130  m_currentRunNo(0),
131  m_lastRunNo(0)
132 {
133  TH1::AddDirectory(0);
134 }
135 
136 // --------------------------------------------------------------------------
137 
138 L1CaloPprPlotManager::~L1CaloPprPlotManager()
139 {
140 }
141 
142 // --------------------------------------------------------------------------
143 
144 void L1CaloPprPlotManager::Analyze(const EventContext& ctx, const xAOD::TriggerTower* trigTower, bool channelDisabled)
145 {
146  unsigned int coolID = trigTower->coolId();
147 
148  m_lumiNo = ctx.eventID().lumi_block();
149  m_currentRunNo = ctx.eventID().run_number();
150  m_bunchCrossing = ctx.eventID().bunch_crossing_id();
151 
152  if (!m_isOnline && m_doRunHistograms)
153  {
154  if (m_firstRun)
155  {
156  this->bookRunHistograms().ignore();
157  m_firstRun = false;
158  }
159  if (this->isNewRun())
160  {
161 
162  StatusCode sc = this->MakeSummary();
163  if (sc.isFailure()) {ATH_MSG_FATAL("Could not make Summary");}
164 
165  sc = this->bookRunHistograms();
166  if (sc.isFailure()) {ATH_MSG_FATAL("Could not book Run Histograms");}
167  }
168  }
169  if (m_isOnline && this->isNewRun())
170  {
171  m_p_online_em_valueVsLumi = 0;
172  m_p_online_had_valueVsLumi = 0;
173  m_p_online_em_valueVsBCN = 0;
174  m_p_online_had_valueVsBCN = 0;
175  m_p_online_em_etaPhiValue = 0;
176  m_p_online_had_etaPhiValue = 0;
177  m_h_online_em_etaPhiValueRMS = 0;
178  m_h_online_had_etaPhiValueRMS = 0;
179  m_map_online_partitionProfile_ValueVsLumi.clear();
180  m_map_online_partitionProfile_ValueVsBCN.clear();
181  m_map_online_partitionProfile_ValueVsLumiVsBCN.clear();
182  m_map_online_coolIDProfile_ValueVsLumi.clear();
183  m_map_online_coolIDProfile_ValueVsBCN.clear();
184  }
185  //Check if the TriggerTowers are disabled or not before analysis
186  if (!channelDisabled)
187  {
188  if ( m_isOnline) {
189  if ( trigTower->layer() == 0 ) { this->fillOnlineHistos(trigTower, coolID, Emlayer); }
190  if ( trigTower->layer() == 1 ) { this->fillOnlineHistos(trigTower, coolID, Hadlayer); }
191  }
192  else {
193  if ( trigTower->layer() == 0 ) { this->fillOfflineHistos(trigTower, coolID, Emlayer); }
194  if ( trigTower->layer() == 1 ) { this->fillOfflineHistos(trigTower, coolID, Hadlayer); }
195  }
196  }
197 }
198 
199 // --------------------------------------------------------------------------
200 
201 StatusCode L1CaloPprPlotManager::bookRunHistograms()
202 {
203  StatusCode sc;
204 
205  m_p_offline_em_valueVsRunNumber = new TProfile(Form("ppm_em_1d_profile_adc_%sVsRunNumber", m_monitoringName.data()),
206  Form("%s Vs Run No: Em TriggerTower; Run No; %s %s",
207  m_monitoringTitle.data(),
208  m_monitoringTitle.data(),
209  m_monitoringDimension.data()),
210  100000,
211  150000,
212  200000);
213  m_p_offline_em_valueVsRunNumber->Sumw2();
214  sc = m_histoSvc->regHist(Form("/AANT/ADC/%s/ppm_em_1d_profile_adc_%sVsRunNumber", m_monitoringPath.data(), m_monitoringName.data()),
215  m_p_offline_em_valueVsRunNumber);
216  if (sc.isFailure()) {ATH_MSG_ERROR("could not register histogram: " << m_p_offline_em_valueVsRunNumber->GetName());}
217  else {ATH_MSG_INFO(Form("EM%s VS RUN NO HISTOGRAM booked", m_monitoringName.data()));}
218 
219  m_p_offline_had_valueVsRunNumber = new TProfile(Form("ppm_had_1d_profile_adc_%sVsRunNumber", m_monitoringName.data()),
220  Form("%s Vs Run No: Had TriggerTower; Run No; %s %s",
221  m_monitoringTitle.data(),
222  m_monitoringTitle.data(),
223  m_monitoringDimension.data()),
224  100000,
225  150000,
226  200000);
227  m_p_offline_had_valueVsRunNumber->Sumw2();
228  sc = m_histoSvc->regHist(Form("/AANT/ADC/%s/ppm_had_1d_profile_adc_%sVsRunNumber", m_monitoringPath.data(), m_monitoringName.data()),
229  m_p_offline_had_valueVsRunNumber);
230  if (sc.isFailure()) {ATH_MSG_ERROR("could not register histogram: " << m_p_offline_had_valueVsRunNumber->GetName());}
231  else {ATH_MSG_INFO(Form("HAD%s VS RUN NO HISTOGRAM booked", m_monitoringName.data()));}
232 
233  m_p_offline_em_valueVsLumi = new TProfile(Form("ppm_em_1d_profile_adc_%sVsLumi", m_monitoringName.data()),
234  Form("Profile Histogram of %s vs Luminosity Block: Em TriggerTower; LumiBlock; %s %s",
235  m_monitoringTitle.data(),
236  m_monitoringTitle.data(),
237  m_monitoringDimension.data()),
238  1000,
239  0,
240  m_lumiMax);
241  sc = m_histoSvc->regHist(Form("/AANT/ADC/%s/run#%d/ppm_em_1d_profile_adc_%sVsLumi",
242  m_monitoringPath.data(),
243  m_currentRunNo,
244  m_monitoringName.data()),
245  m_p_offline_em_valueVsLumi);
246  m_p_offline_em_valueVsLumi->Sumw2();
247  if (sc.isFailure()) {ATH_MSG_ERROR("could not register histogram: " << m_p_offline_em_valueVsLumi->GetName());}
248 
249  m_p_offline_had_valueVsLumi = new TProfile(Form("ppm_had_1d_profile_adc_%sVsLumi", m_monitoringName.data()),
250  Form("Profile Histogram of %s vs Luminosity Block: Had TriggerTower; LumiBlock; %s %s",
251  m_monitoringTitle.data(),
252  m_monitoringTitle.data(),
253  m_monitoringDimension.data()),
254  1000,
255  0,
256  m_lumiMax);
257  sc = m_histoSvc->regHist(Form("/AANT/ADC/%s/run#%d/ppm_had_1d_profile_adc_%sVsLumi",
258  m_monitoringPath.data(),
259  m_currentRunNo,
260  m_monitoringName.data()),
261  m_p_offline_had_valueVsLumi);
262  m_p_offline_had_valueVsLumi->Sumw2();
263  if (sc.isFailure()) {ATH_MSG_ERROR("could not register histogram: " << m_p_offline_had_valueVsLumi->GetName());}
264 
265  //Eta Phi Maps
266  m_p_online_em_etaPhiValue = m_histTool->bookProfilePPMEmEtaVsPhi(Form("ppm_em_2d_profile_etaPhi_adc_%s", m_monitoringName.data()),
267  Form("#eta-#phi profile map of %s: Em Trigger Tower", m_monitoringTitle.data()));
268  m_p_online_had_etaPhiValue = m_histTool->bookProfilePPMHadEtaVsPhi(Form("ppm_had_2d_profile_etaPhi_adc_%s", m_monitoringName.data()),
269  Form("#eta-#phi profile map of %s: Had Trigger Tower", m_monitoringTitle.data()));
270 
271  m_h_online_em_etaPhiValueRMS = m_histTool->bookPPMEmEtaVsPhi(Form("ppm_em_2d_etaPhi_adc_%sRMS,", m_monitoringName.data()),
272  Form("#eta-#phi Histogram of %s RMS: Em Trigger Tower", m_monitoringTitle.data()));
273  m_h_online_had_etaPhiValueRMS = m_histTool->bookPPMHadEtaVsPhi(Form("ppm_had_2d_etaPhi_adc_%sRMS", m_monitoringName.data()),
274  Form("#eta-#phi Histogram of %s RMS: Had Trigger Tower", m_monitoringTitle.data()));
275 
276  return sc;
277 
278 }
279 
280 // --------------------------------------------------------------------------
281 
282 /*virtual*/
283 void L1CaloPprPlotManager::fillOnlineHistos(const xAOD::TriggerTower* trigTower, unsigned int &mapCoolid, CalLayerEnum theLayer)
284 {
285  // get value to be filled in histograms
286  double value = this->getMonitoringValue(trigTower, theLayer);
287 
288  if ( doMonitoring(value) )
289  {
290  this->fillPartitionOnlineHistos(trigTower, theLayer, value);
291  if (AthenaMonManager::environment() == AthenaMonManager::online) { // Don't run on Tier0
292  this->fillDifferentialOnlineHistos(trigTower, mapCoolid, theLayer, value);
293  }
294  this->fillGlobalOnlineHistos(trigTower, theLayer, value);
295  }
296 
297 }
298 
299 // --------------------------------------------------------------------------
300 
301 /*virtual*/
302 void L1CaloPprPlotManager::fillGlobalOnlineHistos(const xAOD::TriggerTower* trigTower, CalLayerEnum layer, double &value)
303 {
304  /* Create global partition integrated plots */
305  /********************************************************************************************************/
306  double eta = trigTower->eta();
307  double phi = trigTower->phi();
308 
309  if (!m_p_online_em_valueVsLumi) {
310 
311  std::string mergeMethod("");
312  int nbins = m_lumiMax;
313  double xmin = 0.;
314  double xmax = m_lumiMax;
315  if (AthenaMonManager::environment() != AthenaMonManager::online) {
316  // Tier0 - assumes each job processes only one lumiblock
317  mergeMethod = "mergeRebinned";
318  nbins = 1;
319  xmin = m_lumiNo;
320  xmax = m_lumiNo + 1.;
321  }
322 
323  ManagedMonitorToolBase::MgmtAttr_t attr = ManagedMonitorToolBase::ATTRIB_UNMANAGED;
324  ManagedMonitorToolBase::MonGroup ADC_GlobalMrg(m_monObj, m_pathInRootFile, ManagedMonitorToolBase::run, attr, "", mergeMethod);
325  m_histTool->setMonGroup(&ADC_GlobalMrg);
326 
327  m_p_online_em_valueVsLumi =
328  m_histTool->bookProfile(Form("ppm_em_1d_profile_adc_%s", m_monitoringName.data()),
329  Form("Profile plot of %s Vs Lumi Block: Em TriggerTower; Lumi Block; %s %s",
330  m_monitoringTitle.data(),
331  m_monitoringTitle.data(),
332  m_monitoringDimension.data()),
333  nbins, xmin, xmax);
334  m_p_online_had_valueVsLumi
335  = m_histTool->bookProfile(Form("ppm_had_1d_profile_adc_%s", m_monitoringName.data()),
336  Form("Profile plot of %s Vs Lumi Block: Had TriggerTower; Lumi Block; %s %s",
337  m_monitoringTitle.data(),
338  m_monitoringTitle.data(),
339  m_monitoringDimension.data()),
340  nbins, xmin, xmax);
341 
342  ManagedMonitorToolBase::MonGroup ADC_Global(m_monObj, m_pathInRootFile, ManagedMonitorToolBase::run, attr);
343  m_histTool->setMonGroup(&ADC_Global);
344 
345  m_p_online_em_etaPhiValue
346  = m_histTool->bookProfilePPMEmEtaVsPhi(Form("ppm_em_2d_profile_etaPhi_adc_%s", m_monitoringName.data()),
347  Form("#eta-#phi profile map of %s: Em Trigger Tower", m_monitoringTitle.data()));
348 
349  m_p_online_had_etaPhiValue
350  = m_histTool->bookProfilePPMHadEtaVsPhi(Form("ppm_had_2d_profile_etaPhi_adc_%s", m_monitoringName.data()),
351  Form("#eta-#phi profile map of %s: Had Trigger Tower", m_monitoringTitle.data()));
352 
353  m_h_online_em_etaPhiValueRMS
354  = m_histTool->bookPPMEmEtaVsPhi(Form("ppm_em_2d_etaPhi_adc_%sRMS", m_monitoringName.data()),
355  Form("#eta-#phi map of %s RMS: Em Trigger Tower", m_monitoringTitle.data()));
356 
357  m_h_online_had_etaPhiValueRMS
358  = m_histTool->bookPPMHadEtaVsPhi(Form("ppm_had_2d_etaPhi_adc_%sRMS", m_monitoringName.data()),
359  Form("#eta-#phi map of %s RMS: Had Trigger Tower", m_monitoringTitle.data()));
360  m_histTool->unsetMonGroup();
361  }
362  //Fill Channel and detector partition integrated plots.
363  if ( layer == 0 ) {m_p_online_em_valueVsLumi->Fill(m_lumiNo, value);}
364  else { m_p_online_had_valueVsLumi->Fill(m_lumiNo, value);}
365 
366  //Fill Etaphi Plots
367  int binX(0), binY(0);
368  double entries = 0;
369  double val = 0;
370  double rms = 0;
371 
372  if ( layer == 0 )
373  {
374  m_histTool->fillPPMEmEtaVsPhi(m_p_online_em_etaPhiValue, eta, phi, value, 1);
375  if (AthenaMonManager::environment() == AthenaMonManager::online) { // Needs post-processing algorithm on Tier0
376  m_histTool->findBinPPMEmEtaVsPhi(m_p_online_em_etaPhiValue, eta, phi, binX, binY);
377  m_p_online_em_etaPhiValue->GetBinInfo(binX, binY, entries, val, rms);
378  m_histTool->setBinPPMEmEtaVsPhi(m_h_online_em_etaPhiValueRMS,
379  binX, binY, rms, rms / sqrt(2 * entries));
380  }
381  }
382  else
383  {
384  m_histTool->fillPPMHadEtaVsPhi(m_p_online_had_etaPhiValue, eta, phi, value, 1);
385  if (AthenaMonManager::environment() == AthenaMonManager::online) {
386  m_histTool->findBinPPMHadEtaVsPhi(m_p_online_had_etaPhiValue, eta, phi, binX, binY);
387  m_p_online_had_etaPhiValue->GetBinInfo(binX, binY, entries, val, rms);
388  m_histTool->setBinPPMHadEtaVsPhi(m_h_online_had_etaPhiValueRMS,
389  binX, binY, rms, rms / sqrt(2 * entries));
390  }
391  }
392 
393 }
394 
395 // --------------------------------------------------------------------------
396 
397 /*virtual*/
398 void L1CaloPprPlotManager::fillPartitionOnlineHistos(const xAOD::TriggerTower* trigTower, CalLayerEnum theLayer, double &value)
399 {
400  //Create Channel Integrated, Partition differentiated plots
401  /****************************************************************************************************/
402  double eta = trigTower->eta();
403  CaloDivisionEnum detectorRegion = this->GetDetectorRegion(eta, theLayer);
404 
405  std::map<CaloDivisionEnum, TProfile_LW*>::iterator part_itr = m_map_online_partitionProfile_ValueVsLumi.find(detectorRegion);
406  if (part_itr == m_map_online_partitionProfile_ValueVsLumi.end())
407  {
408  std::string plotType = this->GetDetectorLayerString(theLayer);
409  std::string detectorRegionString = this->GetDetectorRegionString(detectorRegion);
410  std::string mergeMethod("");
411  int nbins = m_lumiMax;
412  double xmin = 0.;
413  double xmax = m_lumiMax;
414  if (AthenaMonManager::environment() != AthenaMonManager::online) {
415  mergeMethod = "mergeRebinned";
416  nbins = 1;
417  xmin = m_lumiNo;
418  xmax = m_lumiNo + 1.;
419  }
420 
421  ManagedMonitorToolBase::MgmtAttr_t attr = ManagedMonitorToolBase::ATTRIB_UNMANAGED;
422  ManagedMonitorToolBase::MonGroup ADC_Partitions(m_monObj, m_pathInRootFile , ManagedMonitorToolBase::run, attr, "", mergeMethod);
423  m_histTool->setMonGroup(&ADC_Partitions);
424 
425  TProfile_LW* anLWProfileHist = m_histTool->bookProfile(Form("ppm_%s_1d_profile_adc_%s_%sVsLumi",
426  plotType.data(),
427  detectorRegionString.data(),
428  m_monitoringName.data()),
429  Form("Run:%d, %s Vs Lumi Profile for partition %s",
430  m_currentRunNo,
431  m_monitoringTitle.data(),
432  detectorRegionString.data()),
433  nbins, xmin, xmax);
434  anLWProfileHist->Fill(m_lumiNo, value);
435 
436  m_map_online_partitionProfile_ValueVsLumi.insert( std::pair<CaloDivisionEnum, TProfile_LW*> (detectorRegion, anLWProfileHist));
437 
438  m_histTool->unsetMonGroup();
439  }
440  else
441  {
442  part_itr->second->Fill(m_lumiNo, value);
443  }
444 }
445 
446 // --------------------------------------------------------------------------
447 
448 /*virtual*/
449 void L1CaloPprPlotManager::fillDifferentialOnlineHistos(const xAOD::TriggerTower* trigTower, unsigned int &coolId, CalLayerEnum theLayer, double &value)
450 {
451  //Create fully differential plots
452  /****************************************************************************************************/
453 
454  std::map<unsigned int, TProfile_LW*>::iterator p_itr;
455  p_itr = m_map_online_coolIDProfile_ValueVsLumi.find(coolId);
456 
457  if (p_itr == m_map_online_coolIDProfile_ValueVsLumi.end())
458  {
459  double eta = trigTower->eta();
460  std::string plotType = this->GetDetectorLayerString(theLayer);
461  CaloDivisionEnum detectorRegion = this->GetDetectorRegion(eta, theLayer);
462  std::string detectorRegionString = this->GetDetectorRegionString(detectorRegion);
463 
464  ManagedMonitorToolBase::MgmtAttr_t attr = ManagedMonitorToolBase::ATTRIB_UNMANAGED;
465  ManagedMonitorToolBase::MonGroup ADC_Channels(m_monObj,
466  m_pathInRootFile + Form("/%s", detectorRegionString.data()),
467  ManagedMonitorToolBase::run,
468  attr);
469  m_histTool->setMonGroup(&ADC_Channels);
470 
471  std::string titles;
472  if ( m_ppmAdcMinValue > 0 ) {
473  titles = Form("Run:%d, %s Vs Lumi Profile for %sFADC >%d, Channel:%08x ;Lumi Block; %s %s",
474  m_currentRunNo,
475  m_monitoringTitle.data(),
476  plotType.data(),
477  m_ppmAdcMinValue,
478  coolId,
479  m_monitoringTitle.data(),
480  m_monitoringDimension.data());
481  }
482  else {
483  titles = Form("Run:%d, %s Vs Lumi Profile, Channel:%08x ;Lumi Block; %s %s",
484  m_currentRunNo,
485  m_monitoringTitle.data(),
486  coolId,
487  m_monitoringTitle.data(),
488  m_monitoringDimension.data());
489  }
490  TProfile_LW* anLWProfileHist = m_histTool->bookProfile(Form("ppm_%s_1d_profile_adc_%08x_%sVsLumi",
491  plotType.data(),
492  coolId,
493  m_monitoringName.data()),
494  titles,
495  m_lumiMax,
496  0,
497  m_lumiMax);
498  anLWProfileHist->Fill(m_lumiNo, value);
499  m_map_online_coolIDProfile_ValueVsLumi.insert ( std::pair<unsigned int, TProfile_LW*>(coolId, anLWProfileHist) );
500 
501  m_histTool->unsetMonGroup();
502 
503  }
504  else
505  {
506  p_itr->second->Fill(m_lumiNo, value);
507  }
508 
509 }
510 
511 
512 // --------------------------------------------------------------------------
513 
514 /*virtual*/
515 void L1CaloPprPlotManager::fillOfflineHistos(const xAOD::TriggerTower* trigTower, unsigned int &mapCoolid, CalLayerEnum theLayer)
516 {
517  // compute value to be monitored
518  double value = this->getMonitoringValue(trigTower, theLayer);
519 
520 
521  // check if histograms need to be filled
522  if ( this->doMonitoring(value) )
523  {
524 
525  double eta = trigTower->eta();
526  double phi = trigTower->phi();
527 
528 
529  if ( m_doRunHistograms ) { this->fillRunHistograms(eta, phi, theLayer, value); }
530  // fill histograms per calorimeter partition and per channel
531  this->fillPartitionOfflineHistos(trigTower, theLayer, value);
532  this->fillDifferentialOfflineHistos(trigTower, mapCoolid, theLayer, value);
533 
534 
535  }
536 }
537 
538 // --------------------------------------------------------------------------
539 
540 void L1CaloPprPlotManager::fillRunHistograms(double &eta, double &phi, CalLayerEnum theLayer, double &value)
541 {
542 
543  if (theLayer == Emlayer)
544  {
545  m_p_offline_em_valueVsRunNumber->Fill(m_currentRunNo, value);
546  m_p_offline_em_valueVsLumi->Fill(m_lumiNo, value);
547  m_histTool->fillPPMEmEtaVsPhi(m_p_online_em_etaPhiValue, eta, phi, value, 1);
548  }
549  else if (theLayer == Hadlayer)
550  {
551  m_p_offline_had_valueVsRunNumber->Fill(m_currentRunNo, value);
552  m_p_offline_had_valueVsLumi->Fill(m_lumiNo, value);
553  m_histTool->fillPPMHadEtaVsPhi(m_p_online_had_etaPhiValue, eta, phi, value);
554  }
555 }
556 
557 // --------------------------------------------------------------------------
558 
559 /*virtual*/
560 void L1CaloPprPlotManager::fillPartitionOfflineHistos(const xAOD::TriggerTower* trigTower,
561  CalLayerEnum theLayer,
562  double &value)
563 {
564  // fill offline histograms for the given calorimeter partition with the given value
565 
566  double eta = trigTower->eta();
567 
568  std::string plotType = this->GetDetectorLayerString(theLayer);
569  CaloDivisionEnum detectorRegion = this->GetDetectorRegion(eta, theLayer);
570  std::string detectorRegionString = this->GetDetectorRegionString(detectorRegion);
571 
572  std::map<CaloDivisionEnum, TProfile*>::iterator part_itr = m_map_offline_partitionProfile_ValueVsLumi.find(detectorRegion);
573  if ( part_itr == m_map_offline_partitionProfile_ValueVsLumi.end() )
574  {
575  // create new histogram for given detector region with one bin per lumi block
576  TProfile* aProfileHist = new TProfile(Form("ppm_%s_1d_profile_adc_%s_%sVsLumi",
577  plotType.data(),
578  detectorRegionString.data(),
579  m_monitoringName.data()),
580  Form("Run:%d, %s Vs Lumi Profile for partition %s;Lumi Block; %s %s",
581  m_currentRunNo,
582  m_monitoringTitle.data(),
583  detectorRegionString.data(),
584  m_monitoringTitle.data(),
585  m_monitoringDimension.data()),
586  m_lumiMax,
587  0,
588  m_lumiMax);
589  aProfileHist->Sumw2();
590  StatusCode sc = m_histoSvc->regHist(Form("/AANT/ADC/%s/run#%d/ppm_%s_1d_profile_adc_%s_%sVsLumi",
591  m_monitoringPath.data(),
592  m_currentRunNo,
593  plotType.data(),
594  detectorRegionString.data(),
595  m_monitoringName.data()),
596  aProfileHist);
597  if ( sc.isFailure() ) { ATH_MSG_ERROR("could not register histogram: " << aProfileHist->GetName()); }
598 
599  aProfileHist->Fill(m_lumiNo, value);
600  m_map_offline_partitionProfile_ValueVsLumi.insert( std::pair<CaloDivisionEnum, TProfile*> (detectorRegion, aProfileHist) );
601  }
602  else
603  {
604  part_itr->second->Fill(m_lumiNo, value);
605  }
606 }
607 
608 // --------------------------------------------------------------------------
609 
610 /*virtual*/
611 void L1CaloPprPlotManager::fillDifferentialOfflineHistos(const xAOD::TriggerTower* trigTower,
612  unsigned int &coolId,
613  CalLayerEnum theLayer,
614  double &value)
615 {
616  // fill offline histograms for the given trigger tower with the given value
617 
618  double eta = trigTower->eta();
619 
620  std::string plotType = this->GetDetectorLayerString(theLayer);
621  CaloDivisionEnum detectorRegion = this->GetDetectorRegion(eta, theLayer);
622  std::string detectorRegionString = this->GetDetectorRegionString(detectorRegion);
623 
624  std::map<unsigned int, TProfile*>::iterator tt_itr = m_map_offline_coolIDProfile_ValueVsLumi.find(coolId);
625  if ( tt_itr == m_map_offline_coolIDProfile_ValueVsLumi.end() )
626  {
627  std::string titles;
628  if ( m_ppmAdcMinValue > 0 ) {
629  titles = Form("Run:%d, %s Vs Lumi Profile for %sFADC >%d, Channel:%08x ;Lumi Block; %s %s",
630  m_currentRunNo,
631  m_monitoringTitle.data(),
632  plotType.data(),
633  m_ppmAdcMinValue,
634  coolId,
635  m_monitoringTitle.data(),
636  m_monitoringDimension.data());
637  }
638  else {
639  titles = Form("Run:%d, %s Vs Lumi Profile, Channel:%08x ;Lumi Block; %s %s",
640  m_currentRunNo,
641  m_monitoringTitle.data(),
642  coolId,
643  m_monitoringTitle.data(),
644  m_monitoringDimension.data());
645  }
646  // create new histogram for given channel with one bin per lumi block
647  TProfile* aProfileHist = new TProfile(Form("ppm_%s_1d_profile_adc_%08x_%sVsLumi",
648  plotType.data(),
649  coolId,
650  m_monitoringName.data()),
651  titles.c_str(),
652  m_lumiMax,
653  0,
654  m_lumiMax);
655  aProfileHist->Sumw2();
656  StatusCode sc = m_histoSvc->regHist(Form("/AANT/ADC/%s/run#%d/%s/ppm_%s_1d_profile_adc_%08x_%sVsLumi",
657  m_monitoringPath.data(),
658  m_currentRunNo,
659  detectorRegionString.data(),
660  plotType.data(),
661  coolId,
662  m_monitoringName.data()),
663  aProfileHist);
664  if ( sc.isFailure() ) { ATH_MSG_ERROR("could not register histogram: " << aProfileHist->GetName()); }
665 
666  aProfileHist->Fill(m_lumiNo, value);
667  m_map_offline_coolIDProfile_ValueVsLumi.insert( std::pair<unsigned int, TProfile*> (coolId, aProfileHist) );
668 
669  }
670  else
671  {
672  tt_itr->second->Fill(m_lumiNo, value);
673  }
674 }
675 
676 // --------------------------------------------------------------------------
677 
678 StatusCode L1CaloPprPlotManager::MakeSummary()
679 {
680  StatusCode sc;
681  if ( !m_isOnline && m_doRunHistograms )
682  {
683  ATH_MSG_INFO("MakeSummary for " << m_monitoringName.data() << " plots");
684  sc = m_histoSvc->regHist(Form("/AANT/ADC/%s/run#%d/ppm_em_2d_profile_etaPhi_adc_%s",
685  m_monitoringPath.data(),
686  m_currentRunNo,
687  m_monitoringName.data()),
688  this->ConvertToOfflineHist(m_p_online_em_etaPhiValue, 20));
689  if (sc.isFailure()) {ATH_MSG_ERROR("could not register histogram: " << m_p_online_em_etaPhiValue->GetName());}
690 
691  sc = m_histoSvc->regHist(Form("/AANT/ADC/%s/run#%d/ppm_had_2d_profile_etaPhi_adc_%s",
692  m_monitoringPath.data(),
693  m_currentRunNo,
694  m_monitoringName.data()),
695  this->ConvertToOfflineHist(m_p_online_had_etaPhiValue, 20));
696  if (sc.isFailure()) {ATH_MSG_ERROR("could not register histogram: " << m_p_online_had_etaPhiValue->GetName());}
697  }
698  return sc;
699 }
700 
701 // --------------------------------------------------------------------------
702 
703 TProfile* L1CaloPprPlotManager::ConvertToOfflineHist(TProfile_LW* hist)
704 {
705  TProfile* temp = hist->getROOTHist();
706  return (TProfile*)temp->Clone();
707 }
708 
709 // --------------------------------------------------------------------------
710 
711 void L1CaloPprPlotManager::SetHistogramLimits( TProfile2D_LW* hist, const int min, const int max)
712 {
713  hist->SetMinimum(min);
714  hist->SetMaximum(max);
715 }
716 
717 // --------------------------------------------------------------------------
718 
719 //Overloaded function to Save offline TProfile.
720 TProfile2D* L1CaloPprPlotManager::ConvertToOfflineHist(TProfile2D_LW* hist, unsigned int binContours)
721 {
722  TProfile2D* temp = hist->getROOTHist();
723  temp->SetMaximum(temp->GetMaximum());
724  temp->SetMinimum(temp->GetMinimum());
725  temp->SetContour(binContours);
726  ATH_MSG_INFO("ConvertToOfflineHist for " << temp->GetName());
727  return (TProfile2D*)temp->Clone();
728 }
729 
730 // --------------------------------------------------------------------------
731 
732 CaloDivisionEnum L1CaloPprPlotManager::GetDetectorRegion(double etaIn, CalLayerEnum layer)
733 {
734  CaloDivisionEnum part = bound;
735 
736  if (layer == Emlayer)
737  {
738  if (etaIn < -3.2 ) { part = LArFCAL1C; }
739  else if (etaIn < -1.5 ) { part = LArEMECC; }
740  else if (etaIn < -1.4 ) { part = LArOverlapC; }
741  else if (etaIn < 0. ) { part = LArEMBC; }
742  else if (etaIn < 1.4 ) { part = LArEMBA; }
743  else if (etaIn < 1.5 ) { part = LArOverlapA; }
744  else if (etaIn < 3.2 ) { part = LArEMECA; }
745  else { part = LArFCAL1A; }
746  }
747  else
748  {
749  if (etaIn < -3.2 ) { part = LArFCAL23C; }
750  else if (etaIn < -1.5 ) { part = LArHECC; }
751  else if (etaIn < -0.9 ) { part = TileEBC; }
752  else if (etaIn < 0. ) { part = TileLBC; }
753  else if (etaIn < 0.9 ) { part = TileLBA; }
754  else if (etaIn < 1.5 ) { part = TileEBA; }
755  else if (etaIn < 3.2 ) { part = LArHECA; }
756  else { part = LArFCAL23A; }
757  }
758  return part;
759 }
760 
761 // --------------------------------------------------------------------------
762 
763 std::string L1CaloPprPlotManager::GetDetectorRegionString(CaloDivisionEnum detRegion)
764 {
765  std::string stringOut;
766  switch (detRegion)
767  {
768  case LArFCAL1C:
769  stringOut = "LArFCAL1C";
770  return stringOut;
771  break;
772  case LArEMECC:
773  stringOut = "LArEMECC";
774  return stringOut;
775  break;
776  case LArOverlapC:
777  stringOut = "LArOverlapC";
778  return stringOut;
779  break;
780  case LArEMBC:
781  stringOut = "LArEMBC";
782  return stringOut;
783  break;
784  case LArEMBA:
785  stringOut = "LArEMBA";
786  return stringOut;
787  break;
788  case LArOverlapA:
789  stringOut = "LArOverlapA";
790  return stringOut;
791  break;
792  case LArEMECA:
793  stringOut = "LArEMECA";
794  return stringOut;
795  break;
796  case LArFCAL1A:
797  stringOut = "LArFCAL1A";
798  return stringOut;
799  break;
800  case LArFCAL23C:
801  stringOut = "LArFCAL23C";
802  return stringOut;
803  break;
804  case LArHECC:
805  stringOut = "LArHECC";
806  return stringOut;
807  break;
808  case TileEBC:
809  stringOut = "TileEBC";
810  return stringOut;
811  break;
812  case TileLBC:
813  stringOut = "TileLBC";
814  return stringOut;
815  break;
816  case TileLBA:
817  stringOut = "TileLBA";
818  return stringOut;
819  break;
820  case TileEBA:
821  stringOut = "TileEBA";
822  return stringOut;
823  break;
824  case LArHECA:
825  stringOut = "LArHECA";
826  return stringOut;
827  break;
828  case LArFCAL23A:
829  stringOut = "LArFCAL23A";
830  return stringOut;
831  break;
832  case bound:
833  stringOut = "NoRegion";
834  return stringOut;
835  break;
836  }
837 
838  return stringOut;
839 }
840 
841 // --------------------------------------------------------------------------
842 
843 std::string L1CaloPprPlotManager::GetDetectorLayerString(CalLayerEnum layer)
844 {
845  std::string stringOut;
846  switch (layer)
847  {
848  case Emlayer:
849  stringOut = "em";
850  return stringOut;
851  break;
852 
853  case Hadlayer:
854  stringOut = "had";
855  return stringOut;
856  break;
857 
858  case undef:
859  stringOut = "NoLayer";
860  return stringOut;
861  break;
862  }
863 
864  return stringOut;
865 }
866 
867 // --------------------------------------------------------------------------
868 
869 bool L1CaloPprPlotManager::isNewRun()
870 {
871  if (m_lastRunNo != m_currentRunNo && m_lastRunNo != 0)
872  {
873  m_lastRunNo = m_currentRunNo;
874  return true;
875  }
876  else
877  {
878  return false;
879  }
880 }
L1CaloPprPlotManager::m_map_online_coolIDProfile_ValueVsBCN
std::map< unsigned int, TProfile_LW * > m_map_online_coolIDProfile_ValueVsBCN
Definition: L1CaloPprPlotManager.h:213
L1CaloPprPlotManager::m_p_online_em_valueVsBCN
TProfile_LW * m_p_online_em_valueVsBCN
Definition: L1CaloPprPlotManager.h:182
LArG4FSStartPointFilter.part
part
Definition: LArG4FSStartPointFilter.py:21
L1CaloPprPlotManager::fillPartitionOfflineHistos
virtual void fillPartitionOfflineHistos(const xAOD::TriggerTower *trigTower, CalLayerEnum theLayer, double &value)
Definition: L1CaloPprPlotManager.cxx:560
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
L1CaloPprPlotManager::m_currentRunNo
unsigned int m_currentRunNo
Definition: L1CaloPprPlotManager.h:225
L1CaloCoolChannelId.h
L1CaloPprPlotManager::m_p_online_had_valueVsBCN
TProfile_LW * m_p_online_had_valueVsBCN
Definition: L1CaloPprPlotManager.h:183
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
LArHECC
@ LArHECC
Definition: L1CaloPprPlotManager.h:67
TH2F_LW.h
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
L1CaloPprPlotManager::L1CaloPprPlotManager
L1CaloPprPlotManager(ITHistSvc *histoSvc, ToolHandle< LVL1::IL1CaloOfflineTriggerTowerTools > &offlineTT_tool, const int ADC_cut, const unsigned int lumimax, const std::string &pathInRootFile, const std::string &monitoringPath, const std::string &monitoringName, const std::string &monitoringTitle, const std::string &monitoringDimension, bool doRunHistograms)
Definition: L1CaloPprPlotManager.cxx:35
L1CaloPprPlotManager::fillOfflineHistos
virtual void fillOfflineHistos(const xAOD::TriggerTower *trigTower, unsigned int &coolID, CalLayerEnum layer)
Definition: L1CaloPprPlotManager.cxx:515
L1CaloPprPlotManager::m_bunchCrossing
unsigned int m_bunchCrossing
Definition: L1CaloPprPlotManager.h:222
L1CaloPprPlotManager::m_p_online_had_etaPhiValue
TProfile2D_LW * m_p_online_had_etaPhiValue
Definition: L1CaloPprPlotManager.h:192
TileLBC
@ TileLBC
Definition: L1CaloPprPlotManager.h:69
max
#define max(a, b)
Definition: cfImp.cxx:41
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::TriggerTower_v2::phi
virtual double phi() const final
The azimuthal angle ( ) of the particle.
Definition: TriggerTower_v2.cxx:222
ManagedMonitorToolBase::MgmtAttr_t
MgmtAttr_t
An enumeration describing how the class handles the histogram.
Definition: ManagedMonitorToolBase.h:131
Hadlayer
@ Hadlayer
Definition: L1CaloPprPlotManager.h:80
ManagedMonitorToolBase
Provides functionality for users to implement and save histograms, ntuples, and summary data,...
Definition: ManagedMonitorToolBase.h:74
L1CaloPprPlotManager::m_lumiMax
unsigned int m_lumiMax
Definition: L1CaloPprPlotManager.h:223
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
L1CaloPprPlotManager::fillOnlineHistos
virtual void fillOnlineHistos(const xAOD::TriggerTower *trigTower, unsigned int &coolID, CalLayerEnum layer)
Definition: L1CaloPprPlotManager.cxx:283
Emlayer
@ Emlayer
Definition: L1CaloPprPlotManager.h:79
L1CaloPprPlotManager::GetDetectorRegion
CaloDivisionEnum GetDetectorRegion(double Eta, CalLayerEnum Layer)
Definition: L1CaloPprPlotManager.cxx:732
plotmaker.hist
hist
Definition: plotmaker.py:148
IL1CaloOfflineTriggerTowerTools.h
L1CaloPprPlotManager::getMonitoringValue
virtual double getMonitoringValue(const xAOD::TriggerTower *trigTower, CalLayerEnum theLayer)=0
TriggerTowerContainer.h
L1CaloPprPlotManager::m_p_offline_em_valueVsRunNumber
TProfile * m_p_offline_em_valueVsRunNumber
Definition: L1CaloPprPlotManager.h:201
TProfile2D
Definition: rootspy.cxx:531
L1CaloPprPlotManager::m_p_offline_em_valueVsLumi
TProfile * m_p_offline_em_valueVsLumi
Definition: L1CaloPprPlotManager.h:188
L1CaloPprPlotManager::m_p_online_em_etaPhiValue
TProfile2D_LW * m_p_online_em_etaPhiValue
Definition: L1CaloPprPlotManager.h:191
LArFCAL23A
@ LArFCAL23A
Definition: L1CaloPprPlotManager.h:73
L1CaloPprPlotManager::fillDifferentialOnlineHistos
virtual void fillDifferentialOnlineHistos(const xAOD::TriggerTower *trigTower, unsigned int &coolId, CalLayerEnum theLayer, double &value)
Definition: L1CaloPprPlotManager.cxx:449
L1CaloPprPlotManager::fillRunHistograms
virtual void fillRunHistograms(double &eta, double &phi, CalLayerEnum theLayer, double &value)
Definition: L1CaloPprPlotManager.cxx:540
L1CaloPprPlotManager::m_p_online_em_valueVsLumi
TProfile_LW * m_p_online_em_valueVsLumi
Definition: L1CaloPprPlotManager.h:179
bound
@ bound
Definition: L1CaloPprPlotManager.h:74
athena.value
value
Definition: athena.py:122
TProfile_LW.h
L1CaloPprPlotManager::GetDetectorLayerString
std::string GetDetectorLayerString(CalLayerEnum layer)
Definition: L1CaloPprPlotManager.cxx:843
TileEBA
@ TileEBA
Definition: L1CaloPprPlotManager.h:71
L1CaloPprPlotManager::m_p_online_had_valueVsLumi
TProfile_LW * m_p_online_had_valueVsLumi
Definition: L1CaloPprPlotManager.h:180
TrigT1CaloLWHistogramTool.h
LArOverlapC
@ LArOverlapC
Definition: L1CaloPprPlotManager.h:60
L1CaloPprPlotManager::m_lastRunNo
unsigned int m_lastRunNo
Definition: L1CaloPprPlotManager.h:226
TProfile_LW
Definition: TProfile_LW.h:24
L1CaloPprPlotManager::m_p_offline_had_valueVsRunNumber
TProfile * m_p_offline_had_valueVsRunNumber
Definition: L1CaloPprPlotManager.h:202
L1CaloPprPlotManager::m_map_offline_partitionProfile_ValueVsLumi
std::map< CaloDivisionEnum, TProfile * > m_map_offline_partitionProfile_ValueVsLumi
Definition: L1CaloPprPlotManager.h:209
LArEMECA
@ LArEMECA
Definition: L1CaloPprPlotManager.h:64
CaloDivisionEnum
CaloDivisionEnum
Definition: L1CaloPprPlotManager.h:57
L1CaloPprPlotManager::m_doRunHistograms
bool m_doRunHistograms
Definition: L1CaloPprPlotManager.h:219
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
LArEMBA
@ LArEMBA
Definition: L1CaloPprPlotManager.h:62
L1CaloPprPlotManager::m_pathInRootFile
std::string m_pathInRootFile
Definition: L1CaloPprPlotManager.h:169
AthenaMonManager::environment
static Environment_t environment()
Returns the running environment of the monitoring application to help ManagedMonitorToolBase objects ...
Definition: AthenaMonManager.cxx:321
L1CaloPprPlotManager::isNewRun
bool isNewRun()
Definition: L1CaloPprPlotManager.cxx:869
L1CaloPprPlotManager::m_map_online_partitionProfile_ValueVsLumiVsBCN
std::map< CaloDivisionEnum, TProfile2D_LW * > m_map_online_partitionProfile_ValueVsLumiVsBCN
Definition: L1CaloPprPlotManager.h:207
SCT_CalibAlgs::nbins
@ nbins
Definition: SCT_CalibNumbers.h:10
Trk::binY
@ binY
Definition: BinningType.h:48
ManagedMonitorToolBase.h
ManagedMonitorToolBase::MonGroup
A container of information describing a monitoring object.
Definition: ManagedMonitorToolBase.h:138
LArFCAL23C
@ LArFCAL23C
Definition: L1CaloPprPlotManager.h:66
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
xmin
double xmin
Definition: listroot.cxx:60
L1CaloPprPlotManager::m_monObj
ManagedMonitorToolBase * m_monObj
Definition: L1CaloPprPlotManager.h:166
python.TrigEgammaMonitorHelper.TProfile
def TProfile(*args, **kwargs)
Definition: TrigEgammaMonitorHelper.py:81
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
AthenaMonManager::online
@ online
Definition: AthenaMonManager.h:49
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
xAOD::TriggerTower_v2::layer
int layer() const
get layer ( 0 = EM, 1 = Had, 2 = FCAL23) - to be confirmed
Definition: TriggerTower_v2.cxx:121
L1CaloPprPlotManager::ConvertToOfflineHist
TProfile * ConvertToOfflineHist(TProfile_LW *hist)
Definition: L1CaloPprPlotManager.cxx:703
xAOD::TriggerTower_v2
Description of TriggerTower_v2.
Definition: TriggerTower_v2.h:49
ManagedMonitorToolBase::ATTRIB_UNMANAGED
@ ATTRIB_UNMANAGED
Definition: ManagedMonitorToolBase.h:131
L1CaloPprPlotManager::m_map_online_partitionProfile_ValueVsLumi
std::map< CaloDivisionEnum, TProfile_LW * > m_map_online_partitionProfile_ValueVsLumi
Definition: L1CaloPprPlotManager.h:205
xAOD::TriggerTower_v2::eta
virtual double eta() const final
The pseudorapidity ( ) of the particle.
Definition: TriggerTower_v2.cxx:210
L1CaloPprPlotManager.h
MuonSegmentReaderConfig.histSvc
histSvc
Definition: MuonSegmentReaderConfig.py:96
AthMessaging
Class to provide easy MsgStream access and capabilities.
Definition: AthMessaging.h:55
LArHECA
@ LArHECA
Definition: L1CaloPprPlotManager.h:72
AthenaMonManager.h
LWHist::GetName
const char * GetName() const
Definition: LWHist.cxx:366
xAOD::TriggerTower_v2::coolId
uint32_t coolId() const
Tower identifiers.
L1CaloPprPlotManager::m_h_online_had_etaPhiValueRMS
TH2F_LW * m_h_online_had_etaPhiValueRMS
Definition: L1CaloPprPlotManager.h:195
LArEMBC
@ LArEMBC
Definition: L1CaloPprPlotManager.h:61
Trk::binX
@ binX
Definition: BinningType.h:47
TileEBC
@ TileEBC
Definition: L1CaloPprPlotManager.h:68
L1CaloPprPlotManager::GetDetectorRegionString
std::string GetDetectorRegionString(CaloDivisionEnum detectorRegion)
Definition: L1CaloPprPlotManager.cxx:763
LArOverlapA
@ LArOverlapA
Definition: L1CaloPprPlotManager.h:63
TProfile_LW::Fill
void Fill(const double &x, const double &y)
Definition: TProfile_LW.cxx:223
min
#define min(a, b)
Definition: cfImp.cxx:40
TileLBA
@ TileLBA
Definition: L1CaloPprPlotManager.h:70
TProfile2D_LW::GetBinInfo
void GetBinInfo(unsigned binx, unsigned biny, double &entries, double &content, double &error) const
Definition: TProfile2D_LW.cxx:329
L1CaloPprPlotManager::m_monitoringPath
std::string m_monitoringPath
Definition: L1CaloPprPlotManager.h:173
LArEMECC
@ LArEMECC
Definition: L1CaloPprPlotManager.h:59
L1CaloPprPlotManager::fillPartitionOnlineHistos
virtual void fillPartitionOnlineHistos(const xAOD::TriggerTower *trigTower, CalLayerEnum theLayer, double &value)
Definition: L1CaloPprPlotManager.cxx:398
undef
@ undef
Definition: L1CaloPprPlotManager.h:81
L1CaloPprPlotManager::m_map_online_coolIDProfile_ValueVsLumi
std::map< unsigned int, TProfile_LW * > m_map_online_coolIDProfile_ValueVsLumi
Definition: L1CaloPprPlotManager.h:212
L1CaloPprPlotManager::~L1CaloPprPlotManager
virtual ~L1CaloPprPlotManager()
Definition: L1CaloPprPlotManager.cxx:138
TProfile2D_LW.h
TProfile
Definition: rootspy.cxx:515
L1CaloPprPlotManager::bookRunHistograms
virtual StatusCode bookRunHistograms()
Definition: L1CaloPprPlotManager.cxx:201
L1CaloPprPlotManager::m_monitoringDimension
std::string m_monitoringDimension
Definition: L1CaloPprPlotManager.h:176
TProfile2D_LW
Definition: TProfile2D_LW.h:24
beamspotnt.plotType
string plotType
Definition: bin/beamspotnt.py:1423
L1CaloPprPlotManager::m_histoSvc
ITHistSvc * m_histoSvc
Definition: L1CaloPprPlotManager.h:165
IL1TriggerTowerTool.h
L1CaloPprPlotManager::fillGlobalOnlineHistos
virtual void fillGlobalOnlineHistos(const xAOD::TriggerTower *trigTower, CalLayerEnum layer, double &value)
Definition: L1CaloPprPlotManager.cxx:302
ManagedMonitorToolBase::run
@ run
Definition: ManagedMonitorToolBase.h:116
LArFCAL1C
@ LArFCAL1C
Definition: L1CaloPprPlotManager.h:58
L1CaloPprPlotManager::SetHistogramLimits
void SetHistogramLimits(TProfile2D_LW *hist, const int min, const int max)
Definition: L1CaloPprPlotManager.cxx:711
TProfile::Fill
int Fill(double, double)
Definition: rootspy.cxx:523
L1CaloPprPlotManager::m_monitoringName
std::string m_monitoringName
Definition: L1CaloPprPlotManager.h:174
TriggerTower.h
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
L1CaloPprPlotManager::m_isOnline
bool m_isOnline
Definition: L1CaloPprPlotManager.h:217
xmax
double xmax
Definition: listroot.cxx:61
beamspotnt.rms
rms
Definition: bin/beamspotnt.py:1266
L1CaloPprPlotManager::m_map_online_partitionProfile_ValueVsBCN
std::map< CaloDivisionEnum, TProfile_LW * > m_map_online_partitionProfile_ValueVsBCN
Definition: L1CaloPprPlotManager.h:206
entries
double entries
Definition: listroot.cxx:49
TriggerTowerCollection.h
L1CaloPprPlotManager::m_histTool
ToolHandle< LVL1::TrigT1CaloLWHistogramTool > m_histTool
Definition: L1CaloPprPlotManager.h:161
LArFCAL1A
@ LArFCAL1A
Definition: L1CaloPprPlotManager.h:65
L1CaloPprPlotManager::m_p_offline_had_valueVsLumi
TProfile * m_p_offline_had_valueVsLumi
Definition: L1CaloPprPlotManager.h:189
L1CaloPprPlotManager::fillDifferentialOfflineHistos
virtual void fillDifferentialOfflineHistos(const xAOD::TriggerTower *trigTower, unsigned int &coolId, CalLayerEnum theLayer, double &value)
Definition: L1CaloPprPlotManager.cxx:611
CalLayerEnum
CalLayerEnum
Definition: L1CaloPprPlotManager.h:78
L1CaloPprPlotManager::m_h_online_em_etaPhiValueRMS
TH2F_LW * m_h_online_em_etaPhiValueRMS
Definition: L1CaloPprPlotManager.h:194
L1CaloPprPlotManager::m_ppmAdcMinValue
int m_ppmAdcMinValue
Definition: L1CaloPprPlotManager.h:220
L1CaloPprPlotManager::m_lumiNo
unsigned int m_lumiNo
Definition: L1CaloPprPlotManager.h:221
L1CaloPprPlotManager::Analyze
void Analyze(const EventContext &ctx, const xAOD::TriggerTower *trigTower, bool channelDisabled)
Definition: L1CaloPprPlotManager.cxx:144
L1CaloPprPlotManager::m_map_offline_coolIDProfile_ValueVsLumi
std::map< unsigned int, TProfile * > m_map_offline_coolIDProfile_ValueVsLumi
Definition: L1CaloPprPlotManager.h:215
L1CaloPprPlotManager::m_monitoringTitle
std::string m_monitoringTitle
Definition: L1CaloPprPlotManager.h:175
L1CaloPprPlotManager::m_firstRun
bool m_firstRun
Definition: L1CaloPprPlotManager.h:218
L1CaloPprPlotManager::MakeSummary
virtual StatusCode MakeSummary()
Definition: L1CaloPprPlotManager.cxx:678
L1CaloPprPlotManager::doMonitoring
virtual bool doMonitoring(double &value)=0
Generated on Thu Jul 4 2024 21:19:30 for ATLAS Offline Software by   doxygen 1.8.18