ATLAS Offline Software
LArDigitalTriggMonAlg.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 
6 // ********************************************************************
7 //
8 // NAME: LArDigitalTriggMonAlg.cxx
9 // PACKAGE: LArMonitoring
10 //
11 // AUTHOR: Pavol Strizenec (pavol@mail.cern.ch)
12 // Ljiljana Morvaj (ljiljana.morvaj@cern.ch)
13 // Yesenia Hernadez (yesenia@cern.ch)
14 // Based on LAtDigitMon tool by L. Hellary and LArOddCellsMonTool.cxx by Benjamin Trocme
15 //
16 // Monitor a few things in the LArDigit...
17 //
18 // 1) Check that the highest value of the LArDigit is contained in an interval.
19 // If it is not the case increment 3 histograms for each subdetector:
20 // a) Out of range histograms
21 // b) The average histograms: give the average value of the highest digit sample
22 // c) Channel VS FEB histograms: gives wich slot on wich FEB has his highest digit sample ou of the range
23 // 2) Check if a digits samples are in saturation. If it's the case increment the saturation histograms.
24 //
25 // Available cuts in the jo file:
26 //
27 // a) SampleRangeLow-SampleRangeUp: range to check the digit sample.
28 // b) ADCcut : To select Digits Samples with signal.
29 // c) ADCsature: lowest value to check if a Digit sample is in saturation.
30 // ********************************************************************
31 
32 #include "LArDigitalTriggMonAlg.h"
33 
34 //Histograms
35 //LAr infos:
38 #include "LArRawEvent/LArDigit.h"
39 #include "CaloGeoHelpers/CaloSampling.h"
40 #include "LArRawEvent/LArSCDigit.h"
43 #include "LArTrigStreamMatching.h"
44 
46 
47 //STL:
48 #include <sstream>
49 #include <iomanip>
50 #include <cmath>
51 #include <vector>
52 #include <algorithm>
53 #include <set>
54 
55 template<typename C>
56 bool isEmptyCont(C& c) {
57  return (!c.isValid() || c->size()==0);
58 }
59 
60 
61 /*---------------------------------------------------------*/
63 {
64 }
65 
66 /*---------------------------------------------------------*/
68 {
69  ATH_MSG_INFO( "Initialize LArDigitalTriggMonAlg" );
70 
72  ATH_CHECK(detStore()->retrieve( m_LArOnlineIDHelper, "LArOnline_SuperCellID" ));
73 
75  ATH_CHECK(detStore()->retrieve( m_SCID_helper, "CaloCell_SuperCell_ID" ).isSuccess());
76 
77  ATH_MSG_INFO("Building tool map");
78  m_toolmapLayerNames_digi = Monitored::buildToolMap<int>( m_tools, "LArDigitalTriggerMon_digi", m_layerNames);
79  m_toolmapLayerNames_sc = Monitored::buildToolMap<int>( m_tools, "LArDigitalTriggerMon_sc", m_layerNames);
80 
81  ATH_MSG_INFO("Done building tool map");
82 
84  ATH_CHECK(m_bcContKey.initialize());
86 
93  ATH_CHECK(m_actualMuKey.initialize());
95 
96  // Property check:
97  constexpr unsigned expSize=MAXLYRNS*2+1;
98  if (m_layerNames.size() != expSize) {
99  ATH_MSG_ERROR("Unexpected size of LayerNames property. Expect "<< expSize << " entries, found "<< m_layerNames.size() << " entries");
100  return StatusCode::FAILURE;
101  }
102 
103  if (m_isADCBaseline) {
104  ATH_MSG_INFO("IsADCBas set to true");
105  }
107 }
108 
109 
111  float digi_eta;
112  float digi_phi;
116  int digi_adc;
125  unsigned int digi_lb;
128 
129 };
130 
131 
132 struct SC_MonValues {
133  float sc_eta;
134  float sc_phi;
135  int sc_ieta;
136  int sc_iphi;
138  float sc_et_ofl;
140  float sc_et_onl;
142  float sc_time;
143  int sc_bcid;
144  unsigned int sc_lb;
145  bool sc_zeroET;
156 };
157 
158 
159 StatusCode LArDigitalTriggMonAlg::fillHistograms(const EventContext& ctx) const
160 {
161 
162  ATH_MSG_DEBUG("in fillHists()" );
163 
164  // General Monitored variables
165  auto lumi_block = Monitored::Scalar<unsigned int>("lumi_block", 0);
166  auto time_stamp = Monitored::Scalar<unsigned int>("time_stamp", 0);
167  auto BCID = Monitored::Scalar<int>("BCID",0);
168  auto Pedestal = Monitored::Scalar<float>("Pedestal",0.0);
169  auto PedestalRMS = Monitored::Scalar<float>("PedestalRMS",0.0);
170 
171  // From digi loop
172  auto Digi_Nsamples = Monitored::Scalar<int>("Digi_Nsamples",-1); // MNsamples
173  auto Digi_SCChannel = Monitored::Scalar<int>("Digi_SCChannel",-1); // MSCChannel
174  auto Digi_latomeSourceId = Monitored::Scalar<int>("Digi_latomeSourceId",-1); // MlatomeSourceId
175  auto Digi_latomeSourceIdBIN = Monitored::Scalar<int>("Digi_latomeSourceIdBIN",1); // MlatomeSourceIdBIN
176  auto Digi_phi = Monitored::Scalar<float>("Digi_phi",0.0); // MSCphi
177  auto Digi_eta = Monitored::Scalar<float>("Digi_eta",0.0); // MSCeta
178  auto Digi_iphi = Monitored::Scalar<int>("Digi_iphi",0.0);
179  auto Digi_ieta = Monitored::Scalar<int>("Digi_ieta",0.0);
180  auto Digi_maxpos = Monitored::Scalar<int>("Digi_maxpos",-1); // Mmaxpos
181  auto Digi_partition = Monitored::Scalar<int>("Digi_partition",-1); // Mpartition
182  auto Digi_sampos = Monitored::Scalar<int>("Digi_sampos",-1); // Msampos
183  auto Digi_ADC = Monitored::Scalar<int>("Digi_ADC",-1); // MADC
184  auto Digi_Diff_ADC_Ped = Monitored::Scalar<float>("Digi_Diff_ADC_Ped", -999); // Diff_ADC_Pedestal
185  auto Digi_Diff_ADC0_Ped = Monitored::Scalar<float>("Digi_Diff_ADC0_Ped", -999); // Pedestal diff
186  auto Digi_Diff_ADC_Ped_Norm = Monitored::Scalar<float>("Digi_Diff_ADC_Ped_Norm",-999); // Diff_ADC_Pedestal_Norm
187  // cuts
188  auto notBadQual = Monitored::Scalar<bool>("notBadQual",false);
189  auto ADCped10RMS = Monitored::Scalar<bool>("ADCped10RMS",false);
190  auto passDigiNom = Monitored::Scalar<bool>("passDigiNom",false);
191  auto badNotMasked = Monitored::Scalar<bool>("badNotMasked",false);
192 
193  // cuts which are used in both loops
194  auto notMasked = Monitored::Scalar<bool>("notMasked",false);
195 
196  // From SC loop
197  auto SC_SCChannel = Monitored::Scalar<int>("SC_SCChannel",-1); // MSCChannel
198  auto SC_latomeSourceId = Monitored::Scalar<int>("SC_latomeSourceId",-1); // MlatomeSourceId
199  auto SC_partition = Monitored::Scalar<int>("SC_partition",-1); // Mpartition
200  auto SC_phi = Monitored::Scalar<float>("SC_phi",0.0); // MSCphi
201  auto SC_eta = Monitored::Scalar<float>("SC_eta",0.0); // MSCeta
202  auto SC_iphi = Monitored::Scalar<int>("SC_iphi",0.0);
203  auto SC_ieta = Monitored::Scalar<int>("SC_ieta",0.0);
204  auto SC_energy_onl = Monitored::Scalar<int>("SC_energy_onl",0.0); // Menergy_onl
205  auto SC_ET_onl = Monitored::Scalar<float>("SC_ET_onl",0.0); // Menergy_onl
206  auto SC_ET_onl_muscaled = Monitored::Scalar<float>("SC_ET_onl_muscaled",0.0); // Menergy_onl
207  auto SC_energy_ofl = Monitored::Scalar<int>("SC_energy_ofl",0.0); // Menergy_ofl
208  auto SC_ET_ofl = Monitored::Scalar<float>("SC_ET_ofl",0.0); // Menergy_onl
209  auto SC_ET_diff = Monitored::Scalar<int>("SC_ET_diff",0.0); // MSCEt_diff
210  auto SC_time = Monitored::Scalar<float>("SC_time",0.0); // MSCtime
211  auto SC_latomeSourceIdBIN = Monitored::Scalar<int>("SC_latomeSourceIdBIN",1); // MlatomeSourceIdBIN
212  auto SC_AvEnergyOverMu = Monitored::Scalar<float>("SC_AvEnergyOverMu",0); // LMAvEnergyOverMu
213  // cuts
214  auto passTauSel = Monitored::Scalar<bool>("passTauSel",false);
215  auto nonZeroET = Monitored::Scalar<bool>("nonZeroET",false); // eTgt0GeV
216  auto zeroET = Monitored::Scalar<bool>("zeroET",false); // eTgt0GeV
217  auto nonZeroETofl = Monitored::Scalar<bool>("nonZeroETofl",false); // eTgt0GeV
218  auto onlofflEmismatch = Monitored::Scalar<bool>("onlofflEmismatch",false);
219  auto notSatur = Monitored::Scalar<bool>("notSatur",false);
220  auto notOFCbOF = Monitored::Scalar<bool>("notOFCbOF",false);
221  auto tauGt3 = Monitored::Scalar<bool>("tauGt3",false);
222  auto nonZeroEtau = Monitored::Scalar<bool>("nonZeroEtau",false);
223  auto eTgt1GeV = Monitored::Scalar<bool>("eTgt1GeV",false);
224  auto eTlt1GeV = Monitored::Scalar<bool>("eTlt1GeV",false);
225  auto eTgt0p325GeV = Monitored::Scalar<bool>("eTgt0p325GeV",false);
226  auto eTgt0lt0p325GeV = Monitored::Scalar<bool>("eTgt0lt0p325GeV",false);
227  auto eTgt10GeV = Monitored::Scalar<bool>("eTgt10GeV",false);
228  auto eTlt10GeV = Monitored::Scalar<bool>("eTlt10GeV",false);
229  auto eToflGt1GeV = Monitored::Scalar<bool>("eToflGt1GeV",false);
230 
231 
232  //auto passSCNom = Monitored::Scalar<bool>("passSCNom",false); // pass tau, not satur, not OFCb OF, not masked nonZeroET < 10 GeV
233  auto passSCNomInvalid = Monitored::Scalar<bool>("passSCNomInvalid",false); // pass tau, not satur, not OFCb OF, not masked and raw E = -99999
234  auto passSCNom0_0p325 = Monitored::Scalar<bool>("passSCNom0_0p325",false); // pass tau, not satur, not OFCb OF, not masked nonZeroET < 0.2 GeV
235  auto passSCNom0p325_1 = Monitored::Scalar<bool>("passSCNom0p325_1",false); // pass tau, not satur, not OFCb OF, not masked 0.2 < ET < 1 GeV
236  auto passSCNom1 = Monitored::Scalar<bool>("passSCNom1",false); // pass tau, not satur, not OFCb OF, not masked eTgt1GeV
237  auto passSCNom10 = Monitored::Scalar<bool>("passSCNom10",false); // pass tau, not satur, not OFCb OF, not masked eTgt10GeV
238  auto passSCNom10tauGt3 = Monitored::Scalar<bool>("passSCNom10tauGt3",false); // pass tau, not satur, not OFCb OF, not masked eTgt10GeV tauGt3
239  auto saturNotMasked = Monitored::Scalar<bool>("saturNotMasked",false); // notSatur is false, notMasked is false
240  auto OFCbOFNotMasked = Monitored::Scalar<bool>("OFCbOFNotMasked",false); // notOFCbOF is false, notMasked is false
241  auto notMaskedEoflNe0 = Monitored::Scalar<bool>("notMaskedEoflNe0",false); // not masked OSUM, not satur, not OFCb OF, ET ofl != 0
242  auto notMaskedEoflGt1 = Monitored::Scalar<bool>("notMaskedEoflGt1",false); // not masked OSUM, not satur, not OFCb OF, ET ofl > 1
243 
244  // From LATOME header loop
245  auto thisEvent=this->GetEventInfo(ctx);
246 
247  const std::vector<unsigned> streamsThisEvent=LArMon::trigStreamMatching(m_streams,thisEvent->streamTags());
248 
250  const LArOnOffIdMapping* cabling=*cablingHdl;
251 
252  SG::ReadHandle<LArDigitContainer> hLArDigitContainer{m_digitContainerKey,ctx}; //"SC"
253  if (!hLArDigitContainer.isValid()) {
254  ATH_MSG_WARNING("The requested digit container key could not be retrieved. Was there a problem retrieving information from the run logger?");
255  }else{
256  ATH_MSG_DEBUG("hLArDigitContainer.size() " << hLArDigitContainer->size());
257  }
258  SG::ReadHandle<LArRawSCContainer > hSCetContainer{m_rawSCContainerKey,ctx}; //"SC_ET"
259  if (!hSCetContainer.isValid()) {
260  ATH_MSG_WARNING("The requested SC ET container key could not be retrieved. Was there a problem retrieving information from the run logger?");
261  }else{
262  ATH_MSG_DEBUG("hSCetContainer.size() " << hSCetContainer->size());
263  }
264  SG::ReadHandle<LArRawSCContainer > hSCetRecoContainer{m_rawSCEtRecoContainerKey,ctx}; //"SC_ET_RECO"
265  if (!hSCetRecoContainer.isValid()) {
266  ATH_MSG_WARNING("The requested SC ET reco container key could not be retrieved. Was there a problem retrieving information from the run logger?");
267  }else{
268  ATH_MSG_DEBUG("hSCetRecoContainer.size() " << hSCetRecoContainer->size());
269  }
270 
271 
272  SG::ReadHandle<LArLATOMEHeaderContainer> hLArLATOMEHeaderContainer{m_LATOMEHeaderContainerKey,ctx}; //"SC_LATOME_HEADER"
273  if (!hLArLATOMEHeaderContainer.isValid()) {
274  ATH_MSG_WARNING("The requested LATOME header container key could not be retrieved. Was there a problem retrieving information from the run logger?");
275  }else{
276  ATH_MSG_DEBUG("hLArLATOMEHeaderContainer.size() " << hLArLATOMEHeaderContainer->size());
277  }
278 
279  if (isEmptyCont(hLArDigitContainer) && isEmptyCont(hSCetContainer) && isEmptyCont(hSCetRecoContainer) && isEmptyCont(hLArLATOMEHeaderContainer)) {
280  //Make this only warning, come CI tests use the runs without DT info
281  ATH_MSG_WARNING("All of the requested containers are empty. Was there a problem retrieving information from the run logger?");
282  return StatusCode::SUCCESS;
283  }
284 
285  BCID = thisEvent->bcid(); // - 88)%((36+7)*4 + 36 + 31);
286  lumi_block = thisEvent->lumiBlock();
287  time_stamp = thisEvent->timeStamp();
288 
289  float mu = lbInteractionsPerCrossing(ctx);
290  float event_mu = lbLuminosityPerBCID(ctx);
291 
292  ATH_MSG_DEBUG("mu (LB): " << mu);
293  ATH_MSG_DEBUG("mu (BCID): " << event_mu);
294  ATH_MSG_DEBUG("Event number: " << thisEvent->eventNumber());
295  ATH_MSG_DEBUG("LB number: " << thisEvent->lumiBlock());
296  ATH_MSG_DEBUG("BCID: " << thisEvent->bcid());
298  const ILArPedestal* pedestals = *pedestalHdl;
299 
301  const CaloSuperCellDetDescrManager* ddman = *caloSuperCellMgrHandle;
302 
303  // retrieve BadChannel info:
304  const LArBadChannelCont* bcCont = nullptr;
306  bcCont = (*bcContHdl);
307 
308  if ((hLArDigitContainer.isValid())) {
309  std::vector<std::vector<Digi_MonValues>> digiMonValueVec(m_layerNames.size());
310  for (auto& innerVec : digiMonValueVec) {
311  innerVec.reserve(1600); // (m_layerNcells[ilayer]) * nsamples;
312  }
313 
314  // Loop over digits
315  for (const LArDigit* pLArDigit : *hLArDigitContainer) {
316  HWIdentifier id = pLArDigit->hardwareID(); // gives online ID
317  // skip disconnected channels:
318  if (!cabling->isOnlineConnected(id))
319  continue;
320 
321  const unsigned trueNSamples = pLArDigit->nsamples();
322  if (trueNSamples == 0)
323  continue;
324  Digi_Nsamples = trueNSamples; // Fill the monitored variable
325  const int cgain = pLArDigit->gain();
326 
327  const Identifier offlineID = cabling->cnvToIdentifier(id);
328  const CaloDetDescrElement* caloDetElement = ddman->get_element(offlineID);
329  if (caloDetElement == 0) {
330  ATH_MSG_ERROR("Cannot retrieve caloDetElement");
331  continue;
332  }
333  Digi_eta = caloDetElement->eta_raw();
334  Digi_phi = caloDetElement->phi_raw();
335 
336  Digi_ieta = m_SCID_helper->eta(offlineID);
337  Digi_iphi = m_SCID_helper->phi(offlineID);
338 
339  const int calosample = caloDetElement->getSampling();
340 
341  const unsigned iLyrNS = m_caloSamplingToLyrNS[calosample];
342  const int side = m_LArOnlineIDHelper->pos_neg(id);
343  const unsigned iLyr = iLyrNS * 2 + side;
344  auto& lvaluemap_digi = digiMonValueVec[iLyr];
345  auto& lvaluemap_digi_ALL = digiMonValueVec.back();
346 
347  // Determine to which partition this channel belongs to
348  const int ThisPartition = whatPartition(id, side);
349  Digi_partition = ThisPartition; // Fill the monitored variable
350 
351  fill(m_scMonGroupName, Digi_Nsamples);
352 
353  // Check if this is a maskedOSUM SC
354  notMasked = true;
355  if (m_bcMask.cellShouldBeMasked(bcCont, id)) {
356  notMasked = false;
357  }
358 
359  if (pedestals) {
360  Pedestal = pedestals->pedestal(id, cgain);
361  PedestalRMS = pedestals->pedestalRMS(id, cgain);
362  } else
363  ATH_MSG_INFO("Pedestal values not received");
364 
365  const LArSCDigit* scdigi = dynamic_cast<const LArSCDigit*>(pLArDigit);
366  if (!scdigi) {
367  ATH_MSG_DEBUG(" CAN'T CAST ");
368  } else {
369  Digi_SCChannel = scdigi->Channel();
370  Digi_latomeSourceId = scdigi->SourceId();
371  Digi_latomeSourceIdBIN = getXbinFromSourceID(Digi_latomeSourceId);
372  }
373  // Retrieve samples
374  const std::vector<short>* digito = &pLArDigit->samples();
375 
376  // retrieve the max sample digit ie digitot.back().
377  std::vector<short>::const_iterator maxSam = std::max_element(digito->begin(), digito->end());
378  int thismaxPos = std::distance(digito->begin(), maxSam);
379  Digi_maxpos = thismaxPos + 1; // count samples [1,5]
380  float ADC_max = pLArDigit->samples().at(Digi_maxpos - 1);
381 
382  float ADC_0 = pLArDigit->samples().at(0);
383  if (m_isADCBaseline) { // SC_ADC_BAS, have to divide by 8
384  ADC_0 = ADC_0 / 8;
385  }
386 
387  // Start Loop over samples
388  Digi_Diff_ADC0_Ped = ADC_0 - Pedestal;
389  for (unsigned i = 0; i < trueNSamples; ++i) {
390  badNotMasked = false;
391  notBadQual = false;
392  ADCped10RMS = false;
393  passDigiNom = false;
394  Digi_sampos = i + 1;
395  Digi_ADC = pLArDigit->samples().at(i);
396  if (m_isADCBaseline) { // SC_ADC_BAS, have to divide by 8
397  Digi_ADC = Digi_ADC / 8;
398  }
399 
400  Digi_Diff_ADC_Ped = Digi_ADC - Pedestal;
401  if (ADC_max != Pedestal) {
402  Digi_Diff_ADC_Ped_Norm = (Digi_ADC - Pedestal) / std::abs(ADC_max - Pedestal);
403  }
404 
405  // Some selections
406  if (Digi_ADC != -1) {
407  notBadQual = true;
408  } else {
409  if (notMasked) {
410  badNotMasked = true;
411  }
412  }
413  if (ADC_max - Pedestal > 10 * PedestalRMS) {
414  ADCped10RMS = true;
415  }
416  if (notMasked && notBadQual && ADCped10RMS) {
417  passDigiNom = true;
418  }
419 
420  lvaluemap_digi.emplace_back(Digi_eta, Digi_phi, Digi_ieta, Digi_iphi, Digi_sampos, Digi_ADC, Digi_latomeSourceIdBIN, Pedestal, Digi_maxpos,
421  Digi_partition, Digi_Diff_ADC_Ped_Norm, Digi_Diff_ADC_Ped, Digi_Diff_ADC0_Ped, BCID, lumi_block, passDigiNom,
422  badNotMasked);
423  lvaluemap_digi_ALL.emplace_back(Digi_eta, Digi_phi, Digi_ieta, Digi_iphi, Digi_sampos, Digi_ADC, Digi_latomeSourceIdBIN, Pedestal, Digi_maxpos,
424  Digi_partition, Digi_Diff_ADC_Ped_Norm, Digi_Diff_ADC_Ped, Digi_Diff_ADC0_Ped, BCID, lumi_block, passDigiNom,
425  badNotMasked);
426 
427  } // End loop over samples
428 
429  } // End of loop on LArDigit
430 
431  // fill, for every layer/threshold
432  for (size_t ilayer = 0; ilayer < digiMonValueVec.size(); ++ilayer) {
433  const auto& tool = digiMonValueVec[ilayer];
434  auto digi_part_eta = Monitored::Collection("Digi_part_eta", tool, [](const auto& v) { return v.digi_eta; });
435  auto digi_part_phi = Monitored::Collection("Digi_part_phi", tool, [](const auto& v) { return v.digi_phi; });
436  auto digi_part_ieta = Monitored::Collection("Digi_part_ieta", tool, [](const auto& v) { return v.digi_ieta; });
437  auto digi_part_iphi = Monitored::Collection("Digi_part_iphi", tool, [](const auto& v) { return v.digi_iphi; });
438  auto digi_part_sampos = Monitored::Collection("Digi_part_sampos", tool, [](const auto& v) { return v.digi_sampos; });
439  auto digi_part_adc = Monitored::Collection("Digi_part_adc", tool, [](const auto& v) { return v.digi_adc; });
440  auto digi_part_latomesourceidbin = Monitored::Collection("Digi_part_latomesourceidbin", tool, [](const auto& v) { return v.digi_latomesourceidbin; });
441  auto digi_part_pedestal = Monitored::Collection("Digi_part_pedestal", tool, [](const auto& v) { return v.digi_pedestal; });
442  auto digi_part_maxpos = Monitored::Collection("Digi_part_maxpos", tool, [](const auto& v) { return v.digi_maxpos; });
443  auto digi_part_partition = Monitored::Collection("Digi_part_partition", tool, [](const auto& v) { return v.digi_partition; });
444  auto digi_part_diff_adc_ped_norm = Monitored::Collection("Digi_part_diff_adc_ped_norm", tool, [](const auto& v) { return v.digi_diff_adc_ped_norm; });
445  auto digi_part_diff_adc_ped = Monitored::Collection("Digi_part_diff_adc_ped", tool, [](const auto& v) { return v.digi_diff_adc_ped; });
446  auto digi_part_diff_adc0_ped = Monitored::Collection("Digi_part_diff_adc0_ped", tool, [](const auto& v) { return v.digi_diff_adc0_ped; });
447  auto digi_part_bcid = Monitored::Collection("Digi_part_BCID", tool, [](const auto& v) { return v.digi_bcid; });
448  auto digi_part_lb = Monitored::Collection("Digi_part_LB", tool, [](const auto& v) { return v.digi_lb; });
449  auto digi_part_passDigiNom = Monitored::Collection("Digi_part_passDigiNom", tool, [](const auto& v) { return v.digi_passDigiNom; });
450  auto digi_part_badNotMasked = Monitored::Collection("Digi_part_badNotMasked", tool, [](const auto& v) { return v.digi_badNotMasked; });
451 
452  fill(m_tools[m_toolmapLayerNames_digi.at(m_layerNames[ilayer])], digi_part_eta, digi_part_phi, digi_part_ieta, digi_part_iphi, digi_part_sampos,
453  digi_part_adc, digi_part_latomesourceidbin, digi_part_pedestal, digi_part_maxpos, digi_part_diff_adc_ped_norm, digi_part_diff_adc_ped,
454  digi_part_diff_adc0_ped, digi_part_bcid, digi_part_lb, digi_part_passDigiNom, digi_part_badNotMasked);
455  }
456 
457  } // End if(LArDigitContainer is valid)
458 
459 
460  if (hSCetContainer.isValid() && hSCetRecoContainer.isValid()) {
461  LArRawSCContainer::const_iterator itSC = hSCetContainer->begin();
462  LArRawSCContainer::const_iterator itSC_e= hSCetContainer->end();
463  LArRawSCContainer::const_iterator itSCReco = hSCetRecoContainer->begin();
464  const LArRawSC* rawSC = 0;
465  const LArRawSC* rawSCReco = 0;
466 
467  std::vector<std::vector<SC_MonValues>> scMonValueVec(m_layerNames.size());
468  for (auto& innerVec : scMonValueVec) {
469  innerVec.reserve(1600); // (m_layerNcells[ilayer]) * nsamples;
470  }
471 
472  // Loop over SCs
473  for (; itSC != itSC_e; ++itSC, ++itSCReco) {
474  rawSC = *itSC;
475  if (itSCReco < hSCetRecoContainer->end()) {
476  rawSCReco = *itSCReco;
477  } else {
478  //temporarily removed
479  //ATH_MSG_WARNING("Looping SC ET container, but we have reached the end of the SC ET Reco iterator. Check the sizes of these containers. Is SC ET Reco size zero? Is there a problem with the digit container name sent by the run logger?");
480  rawSCReco = 0;
481  }
482  SC_SCChannel = rawSC->chan();
483  HWIdentifier id = rawSC->hardwareID(); // gives online ID
484  // skip disconnected channels:
485  if (!cabling->isOnlineConnected(id))
486  continue;
487 
488  const Identifier offlineID = cabling->cnvToIdentifier(id); // converts online to offline ID
489  // Get Physical Coordinates
490  const CaloDetDescrElement* caloDetElement = ddman->get_element(offlineID);
491  if (caloDetElement == 0) {
492  ATH_MSG_ERROR("Cannot retrieve (eta,phi) coordinates for raw channels");
493  ATH_MSG_ERROR(" ==============> " << std::hex << "; offlineID = " << offlineID << "online ID =" << m_LArOnlineIDHelper->channel_name(id)
494  << "; rawSC->SourceId() = " << rawSC->SourceId());
495  continue;
496  }
497  SC_eta = caloDetElement->eta_raw();
498  SC_phi = caloDetElement->phi_raw();
499 
500  SC_ieta = m_SCID_helper->eta(offlineID);
501  SC_iphi = m_SCID_helper->phi(offlineID);
502  int calosample = caloDetElement->getSampling();
503 
504  const unsigned iLyrNS = m_caloSamplingToLyrNS[calosample];
505  const unsigned side = m_LArOnlineIDHelper->pos_neg(id);
506  const unsigned iLyr = iLyrNS * 2 + side;
507 
508  auto& lvaluemap_sc = scMonValueVec[iLyr];
509  auto& lvaluemap_sc_ALL = scMonValueVec.back();
510 
511  SC_latomeSourceIdBIN = getXbinFromSourceID(rawSC->SourceId());
512 
513  // initialise cuts
514  notMasked = false;
515  passTauSel = false;
516  nonZeroET = false;
517  zeroET = false;
518  notSatur = false;
519  nonZeroEtau = false;
520  eTgt0p325GeV = false;
521  eTgt0lt0p325GeV = false;
522  eTgt1GeV = false;
523  eTlt1GeV = false;
524  eTgt10GeV = false;
525  eTlt10GeV = false;
526  notOFCbOF = false;
527  tauGt3 = false;
528  onlofflEmismatch = false;
529  passSCNom0_0p325 = false;
530  passSCNom0p325_1 = false;
531  passSCNom1 = false;
532  passSCNom10 = false;
533  passSCNom10tauGt3 = false;
534  saturNotMasked = false;
535  OFCbOFNotMasked = false;
536  notMaskedEoflNe0 = false;
537  notMaskedEoflGt1 = false;
538  nonZeroETofl = false;
539  eToflGt1GeV = false;
540  passSCNomInvalid = false;
541  // Check if this is a maskedOSUM SC
542  if (!m_bcMask.cellShouldBeMasked(bcCont, id)) {
543  notMasked = true;
544  }
545  // popopopo
546  if (rawSCReco != 0 && rawSCReco->passTauSelection().size() > 0) { // only compare Et if tau selection is passed
547  if (rawSCReco->passTauSelection().at(0) == true)
548  passTauSel = true;
549  }
550  unsigned int bcid_ind = 0;
551  if (rawSC->energies().size() > 0) {
552  for (auto& SCe : rawSC->bcids()) {
553  if (SCe == BCID)
554  break;
555  bcid_ind++;
556  }
557  if (bcid_ind >= rawSC->bcids().size()) {
558  ATH_MSG_WARNING("BCID not found in SC bcids list!! " << BCID << " BCIDs size: " << rawSC->bcids().size() << ", proposed index: " << bcid_ind);
559  } else if (rawSC->bcids().at(bcid_ind) != BCID) {
560  ATH_MSG_WARNING("BCID not found in SC bcids list!! " << BCID << " " << rawSC->bcids().at(bcid_ind));
561  }
562 
563  if (rawSC->energies().size() > bcid_ind) {
564  SC_energy_onl = rawSC->energies().at(bcid_ind);
565  } else {
566  ATH_MSG_WARNING("rawSC energies vector is too small for the requested BCID index " << bcid_ind << " (size is " << rawSC->energies().size()
567  << ", bcid vec size is " << rawSC->bcids().size() << ")");
568  SC_energy_onl = 0;
569  }
570  } else {
571  ATH_MSG_WARNING("rawSC energies vector is empty!");
572  SC_energy_onl = 0;
573  }
574 
575  if (rawSCReco != 0) {
576  if (rawSCReco->energies().size() > 0) {
577  SC_energy_ofl = rawSCReco->energies().at(0); // algorithm already selects the correct energy
578  } else {
579  ATH_MSG_WARNING("rawSCReco energies vector is empty!");
580  SC_energy_ofl = 0;
581  }
582  }
583  SC_ET_diff = SC_energy_onl - SC_energy_ofl;
584  SC_ET_onl = (SC_energy_onl * 12.5) / 1000; // Converted to GeV
585  SC_ET_ofl = (SC_energy_ofl * 12.5) / 1000; // Converted to GeV
586  SC_ET_onl_muscaled = event_mu > 0. ? SC_ET_onl / event_mu : SC_ET_onl;
587  int Etau = 0;
588  if (rawSCReco != 0) {
589  if (rawSCReco->tauEnergies().size() > 0) {
590  Etau = rawSCReco->tauEnergies().at(0);
591  }
592  }
593  SC_time = (SC_energy_ofl != 0) ? (float)Etau / (float)SC_energy_ofl : Etau;
594 
595  ATH_MSG_DEBUG("Energy onl - Energy ofl: " << SC_energy_onl << ", " << SC_energy_ofl << std::endl);
596  if (SC_ET_onl != 0) {
597  nonZeroET = true;
598  } else {
599  zeroET = true;
600  }
601  if (SC_ET_onl > 0.325) {
602  eTgt0p325GeV = true;
603  } else if (SC_ET_onl < 0.325 && SC_ET_onl > 0.) {
604  eTgt0lt0p325GeV = true;
605  }
606  if (SC_ET_onl > 1) {
607  eTgt1GeV = true;
608  }
609  if (SC_ET_onl < 1) {
610  eTlt1GeV = true;
611  }
612  if (SC_ET_onl > 10) {
613  eTgt10GeV = true;
614  }
615  if (SC_ET_onl < 10) {
616  eTlt10GeV = true;
617  }
618  if (SC_ET_ofl != 0) {
619  nonZeroETofl = true;
620  }
621  if (SC_ET_ofl > 1) {
622  eToflGt1GeV = true;
623  }
624  if (rawSC->satur().size() > bcid_ind) {
625  if (rawSC->satur().at(bcid_ind)) {
626  if (notMasked) {
627  saturNotMasked = true;
628  }
629  } else {
630  notSatur = true;
631  }
632  }
633  if (Etau != 0) {
634  nonZeroEtau = true;
635  }
636  if (rawSCReco != 0 && rawSCReco->ofcbOverflow() == false) {
637  notOFCbOF = true;
638  } else {
639  if (notMasked) {
640  OFCbOFNotMasked = true;
641  }
642  }
643  if (std::abs(SC_time) > 3) {
644  tauGt3 = true;
645  }
646 
647  if (notMasked && notSatur && notOFCbOF) {
648  if (nonZeroETofl) {
649  notMaskedEoflNe0 = true;
650  }
651  if (eToflGt1GeV) {
652  notMaskedEoflGt1 = true;
653  }
654  if (SC_energy_onl == -99999) {
655  passSCNomInvalid = true;
656  }
657 
658  //if ( passTauSel ){
659  //if ( nonZeroET && eTgt0lt0p325GeV ){
660  if (eTgt0lt0p325GeV) {
661  passSCNom0_0p325 = true;
662  }
663  if (eTgt0p325GeV && eTlt1GeV) {
664  passSCNom0p325_1 = true;
665  }
666  if (eTgt1GeV) {
667  passSCNom1 = true;
668  }
669  if (eTgt10GeV) {
670  passSCNom10 = true;
671  if (tauGt3) {
672  passSCNom10tauGt3 = true;
673  }
674  }
675  if (SC_energy_onl != SC_energy_ofl) {
676  onlofflEmismatch = true;
677  }
678  //}
679  } // end nominal selections
680 
681  lvaluemap_sc.emplace_back(SC_eta, SC_phi, SC_ieta, SC_iphi, SC_latomeSourceIdBIN, SC_ET_ofl, SC_ET_diff, SC_ET_onl, SC_ET_onl_muscaled, SC_time, BCID,
682  lumi_block, zeroET, passSCNomInvalid, passSCNom0_0p325, passSCNom0p325_1, passSCNom1, passSCNom10, passSCNom10tauGt3, saturNotMasked, OFCbOFNotMasked, notMaskedEoflNe0,
683  notMaskedEoflGt1);
684  lvaluemap_sc_ALL.emplace_back(SC_eta, SC_phi, SC_ieta, SC_iphi, SC_latomeSourceIdBIN, SC_ET_ofl, SC_ET_diff, SC_ET_onl, SC_ET_onl_muscaled, SC_time,
685  BCID, lumi_block, zeroET, passSCNomInvalid, passSCNom0_0p325, passSCNom0p325_1, passSCNom1, passSCNom10, passSCNom10tauGt3, saturNotMasked, OFCbOFNotMasked,
686  notMaskedEoflNe0, notMaskedEoflGt1);
687 
688  } // end loop over SCs
689 
690  // fill, for every layer/threshold
691  for (size_t ilayer = 0; ilayer < scMonValueVec.size(); ++ilayer) {
692  const auto& tool = scMonValueVec[ilayer];
693  auto sc_part_eta = Monitored::Collection("SC_part_eta", tool, [](const auto& v) { return v.sc_eta; });
694  auto sc_part_phi = Monitored::Collection("SC_part_phi", tool, [](const auto& v) { return v.sc_phi; });
695  auto sc_part_ieta = Monitored::Collection("SC_part_ieta", tool, [](const auto& v) { return v.sc_ieta; });
696  auto sc_part_iphi = Monitored::Collection("SC_part_iphi", tool, [](const auto& v) { return v.sc_iphi; });
697  auto sc_part_latomesourceidbin = Monitored::Collection("SC_part_latomesourceidbin", tool, [](const auto& v) { return v.sc_latomesourceidbin; });
698  auto sc_part_et_ofl = Monitored::Collection("SC_part_et_ofl", tool, [](const auto& v) { return v.sc_et_ofl; });
699  auto sc_part_et_diff = Monitored::Collection("SC_part_et_diff", tool, [](const auto& v) { return v.sc_et_diff; });
700  auto sc_part_et_onl = Monitored::Collection("SC_part_et_onl", tool, [](const auto& v) { return v.sc_et_onl; });
701  auto sc_part_et_onl_muscaled = Monitored::Collection("SC_part_et_onl_muscaled", tool, [](const auto& v) { return v.sc_et_onl_muscaled; });
702  auto sc_part_time = Monitored::Collection("SC_part_time", tool, [](const auto& v) { return v.sc_time; });
703  auto sc_part_bcid = Monitored::Collection("SC_part_BCID", tool, [](const auto& v) { return v.sc_bcid; });
704  auto sc_part_lb = Monitored::Collection("SC_part_LB", tool, [](const auto& v) { return v.sc_lb; });
705  // auto sc_part_passSCNom = Monitored::Collection("SC_part_passSCNom", tool, [](const auto& v) { return v.sc_passSCNom; });
706  auto sc_zeroET = Monitored::Collection("SC_part_zeroET", tool, [](const auto& v) { return v.sc_zeroET; });
707  auto sc_part_passSCNomInvalid = Monitored::Collection("SC_part_passSCNomInvalid", tool, [](const auto& v) { return v.sc_passSCNomInvalid; });
708  auto sc_part_passSCNom0_0p325 = Monitored::Collection("SC_part_passSCNom0_0p325", tool, [](const auto& v) { return v.sc_passSCNom0_0p325; });
709  auto sc_part_passSCNom0p325_1 = Monitored::Collection("SC_part_passSCNom0p325_1", tool, [](const auto& v) { return v.sc_passSCNom0p325_1; });
710  auto sc_part_passSCNom1 = Monitored::Collection("SC_part_passSCNom1", tool, [](const auto& v) { return v.sc_passSCNom1; });
711  auto sc_part_passSCNom10 = Monitored::Collection("SC_part_passSCNom10", tool, [](const auto& v) { return v.sc_passSCNom10; });
712  auto sc_part_passSCNom10tauGt3 = Monitored::Collection("SC_part_passSCNom10tauGt3", tool, [](const auto& v) { return v.sc_passSCNom10tauGt3; });
713  auto sc_part_saturNotMasked = Monitored::Collection("SC_part_saturNotMasked", tool, [](const auto& v) { return v.sc_saturNotMasked; });
714  auto sc_part_OFCbOFNotMasked = Monitored::Collection("SC_part_OFCbOFNotMasked", tool, [](const auto& v) { return v.sc_OFCbOFNotMasked; });
715  auto sc_part_notMaskedEoflNe0 = Monitored::Collection("SC_part_notMaskedEoflNe0", tool, [](const auto& v) { return v.sc_notMaskedEoflNe0; });
716  auto sc_part_notMaskedEoflGt1 = Monitored::Collection("SC_part_notMaskedEoflGt1", tool, [](const auto& v) { return v.sc_notMaskedEoflGt1; });
717 
718 
719  fill(m_tools[m_toolmapLayerNames_sc.at(m_layerNames[ilayer])], sc_part_eta, sc_part_phi, sc_part_ieta, sc_part_iphi, sc_part_latomesourceidbin,
720  sc_part_et_ofl, sc_part_et_diff, sc_part_et_onl, sc_part_et_onl_muscaled, sc_part_time, sc_part_bcid, sc_part_lb, sc_zeroET, sc_part_passSCNomInvalid,
721  sc_part_passSCNom0_0p325, sc_part_passSCNom0p325_1, sc_part_passSCNom1, sc_part_passSCNom10, sc_part_passSCNom10tauGt3, sc_part_saturNotMasked, sc_part_OFCbOFNotMasked, sc_part_notMaskedEoflNe0,
722  sc_part_notMaskedEoflGt1);
723  }
724 
725 
726  } // End if(LArSCContainer is valid)
727 
728 
729 
730  // LATOME event size
731  if ((hLArLATOMEHeaderContainer.isValid())) {
732  auto event_size = Monitored::Scalar<float>("event_size", 0);
733  for (const LArLATOMEHeader* pLArLATOMEHeader : *hLArLATOMEHeaderContainer) {
734  event_size += pLArLATOMEHeader->ROBFragSize() + 48; // 48 is the offset between rod_ndata and ROB fragment size
735  }
736  event_size /= (1024 * 1024 / 4);
737  fill(m_scMonGroupName, lumi_block, event_size);
738  }
739 
740  // end LATOME event size
741 
742  return StatusCode::SUCCESS;
743  }
744 
745 /*---------------------------------------------------------*/
749 {
751  if(side==0) return 0;
752  else return 1;
753  } else if (m_LArOnlineIDHelper->isEMECchannel(id)) {
754  if(side==0) return 2;
755  else return 3;
756  } else if (m_LArOnlineIDHelper->isHECchannel(id)) {
757  if(side==0) return 4;
758  else return 5;
759  } else {
760  if(side==0) return 6;
761  else return 7;
762  }
763 }
764 
765 
766 
767 unsigned LArDigitalTriggMonAlg::getXbinFromSourceID(const unsigned sourceID) const
768 {
769  // int NLatomeBins = 117;
770  int detStartingBin=m_NLatomeBins;
771  const unsigned detID = sourceID >> 16;
772  const unsigned value = sourceID & 0xF;
773  auto mapit=m_LatomeDetBinMappingQ.find(detID);
774  if (mapit!=m_LatomeDetBinMappingQ.end()) {
775  detStartingBin=mapit->second;
776  }
777 
778  unsigned binx = detStartingBin+value;
779  if (binx>m_NLatomeBins){
780  ATH_MSG_WARNING("something wrong with binning, filling overflowbin");
781  binx=m_NLatomeBins;
782  }
783 
784  return binx;
785 }
786 
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
LArRawSC
Liquid Argon SuperCell raw data.
Definition: LArRawSC.h:19
ILArPedestal::pedestal
virtual float pedestal(const HWIdentifier &id, int gain) const =0
SC_MonValues::sc_bcid
int sc_bcid
Definition: LArDigitalTriggMonAlg.cxx:143
SC_MonValues::sc_et_diff
int sc_et_diff
Definition: LArDigitalTriggMonAlg.cxx:139
LArDigitalTriggMonAlg::m_bcContKey
SG::ReadCondHandleKey< LArBadChannelCont > m_bcContKey
Definition: LArDigitalTriggMonAlg.h:76
AthMonitorAlgorithm::lbInteractionsPerCrossing
virtual float lbInteractionsPerCrossing(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Calculate instantaneous number of interactions, i.e.
Definition: AthMonitorAlgorithm.cxx:239
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
LArDigitalTriggMonAlg::whatPartition
int whatPartition(HWIdentifier id, int side) const
private methods:
Definition: LArDigitalTriggMonAlg.cxx:748
SC_MonValues::sc_iphi
int sc_iphi
Definition: LArDigitalTriggMonAlg.cxx:136
LArDigitalTriggMonAlg::m_caloSamplingToLyrNS
const std::array< unsigned, CaloSampling::Unknown > m_caloSamplingToLyrNS
Definition: LArDigitalTriggMonAlg.h:100
SC_MonValues::sc_et_onl_muscaled
float sc_et_onl_muscaled
Definition: LArDigitalTriggMonAlg.cxx:141
LArDigitalTriggMonAlg::m_isADCBaseline
Gaudi::Property< bool > m_isADCBaseline
Definition: LArDigitalTriggMonAlg.h:56
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
LArDigitalTriggMonAlg::m_LArOnlineIDHelper
const LArOnline_SuperCellID * m_LArOnlineIDHelper
Definition: LArDigitalTriggMonAlg.h:150
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
LArRawSC::SourceId
unsigned int SourceId() const
Definition: LArRawSC.h:95
ILArPedestal
Definition: ILArPedestal.h:12
LArBadXCont
Conditions-Data class holding LAr Bad Channel or Bad Feb information.
Definition: LArBadChannelCont.h:28
LArRawSC::hardwareID
const HWIdentifier & hardwareID() const
Definition: LArRawSC.h:89
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
DMTest::C
C_v1 C
Definition: C.h:26
LArPedestalSC.h
CaloDetDescrManager_Base::get_element
const CaloDetDescrElement * get_element(const Identifier &cellId) const
get element by its identifier
Definition: CaloDetDescrManager.cxx:159
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
Digi_MonValues::digi_bcid
int digi_bcid
Definition: LArDigitalTriggMonAlg.cxx:124
LArLATOMEHeaderContainer.h
LArBadChannelMask::buildBitMask
StatusCode buildBitMask(const std::vector< std::string > &problemsToMask, MsgStream &msg)
Definition: LArBadChannelMask.cxx:10
Digi_MonValues::digi_phi
float digi_phi
Definition: LArDigitalTriggMonAlg.cxx:112
athena.value
value
Definition: athena.py:124
LArDigitalTriggMonAlg::m_problemsToMask
Gaudi::Property< std::vector< std::string > > m_problemsToMask
Definition: LArDigitalTriggMonAlg.h:77
SC_MonValues::sc_latomesourceidbin
int sc_latomesourceidbin
Definition: LArDigitalTriggMonAlg.cxx:137
HWIdentifier
Definition: HWIdentifier.h:13
LArBadChannelMask::cellShouldBeMasked
bool cellShouldBeMasked(const LArBadChannelCont *bcCont, const HWIdentifier &hardwareId) const
Definition: LArBadChannelMask.h:42
LArSCDigit::SourceId
unsigned int SourceId() const
Definition: LArSCDigit.h:45
Digi_MonValues::digi_iphi
int digi_iphi
Definition: LArDigitalTriggMonAlg.cxx:114
LArDigitalTriggMonAlg::m_toolmapLayerNames_sc
std::map< std::string, int > m_toolmapLayerNames_sc
Definition: LArDigitalTriggMonAlg.h:147
LArRawSC::satur
const std::vector< bool > & satur() const
Definition: LArRawSC.h:107
LArRawSC::tauEnergies
const std::vector< int > & tauEnergies() const
Definition: LArRawSC.h:110
SC_MonValues::sc_passSCNom0_0p325
bool sc_passSCNom0_0p325
Definition: LArDigitalTriggMonAlg.cxx:147
LArDigitalTriggMonAlg::m_layerNames
StringArrayProperty m_layerNames
Definition: LArDigitalTriggMonAlg.h:91
CaloDetDescrElement::eta_raw
float eta_raw() const
cell eta_raw
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:350
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:92
LArTrigStreamMatching.h
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition: MonitoredCollection.h:38
Digi_MonValues::digi_diff_adc0_ped
float digi_diff_adc0_ped
Definition: LArDigitalTriggMonAlg.cxx:123
LArDigitalTriggMonAlg::MAXLYRNS
@ MAXLYRNS
Definition: LArDigitalTriggMonAlg.h:96
CaloSuperCellDetDescrManager
Definition: CaloDetDescrManager.h:490
Digi_MonValues::digi_passDigiNom
bool digi_passDigiNom
Definition: LArDigitalTriggMonAlg.cxx:126
AthMonitorAlgorithm::lbLuminosityPerBCID
virtual float lbLuminosityPerBCID(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Calculate the instantaneous luminosity per bunch crossing.
Definition: AthMonitorAlgorithm.cxx:267
TRT::Hit::side
@ side
Definition: HitInfo.h:83
PixelByteStreamErrors::BCID
@ BCID
Definition: PixelByteStreamErrors.h:13
SC_MonValues::sc_passSCNom1
bool sc_passSCNom1
Definition: LArDigitalTriggMonAlg.cxx:149
SC_MonValues::sc_saturNotMasked
bool sc_saturNotMasked
Definition: LArDigitalTriggMonAlg.cxx:152
Digi_MonValues::digi_eta
float digi_eta
Definition: LArDigitalTriggMonAlg.cxx:111
LArDigitalTriggMonAlg::m_actualMuKey
SG::ReadDecorHandleKey< xAOD::EventInfo > m_actualMuKey
Definition: LArDigitalTriggMonAlg.h:88
SC_MonValues::sc_notMaskedEoflNe0
bool sc_notMaskedEoflNe0
Definition: LArDigitalTriggMonAlg.cxx:154
LArDigitalTriggMonAlg::m_NLatomeBins
Gaudi::Property< unsigned > m_NLatomeBins
Definition: LArDigitalTriggMonAlg.h:55
LArDigitalTriggMonAlg::m_keyPedestalSC
SG::ReadCondHandleKey< ILArPedestal > m_keyPedestalSC
Handle to pedestal.
Definition: LArDigitalTriggMonAlg.h:80
LArDigitalTriggMonAlg::m_LatomeDetBinMappingQ
const std::map< unsigned, unsigned > m_LatomeDetBinMappingQ
Definition: LArDigitalTriggMonAlg.h:133
LArOnline_SuperCellID::isHECchannel
bool isHECchannel(const HWIdentifier id) const override final
Definition: LArOnline_SuperCellID.cxx:359
Digi_MonValues::digi_sampos
int digi_sampos
Definition: LArDigitalTriggMonAlg.cxx:115
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
LArDigit.h
LArDigitalTriggMonAlg::~LArDigitalTriggMonAlg
virtual ~LArDigitalTriggMonAlg()
Default destructor.
Definition: LArDigitalTriggMonAlg.cxx:62
LArDigit
Liquid Argon digit base class.
Definition: LArDigit.h:25
lumiFormat.i
int i
Definition: lumiFormat.py:85
LArDigitalTriggMonAlg::m_bcMask
LArBadChannelMask m_bcMask
Handle to bad-channel mask.
Definition: LArDigitalTriggMonAlg.h:75
LArDigitalTriggMonAlg::m_SCID_helper
const CaloCell_SuperCell_ID * m_SCID_helper
Definition: LArDigitalTriggMonAlg.h:151
LArDigitalTriggMonAlg.h
LArOnline_SuperCellID::isEMECchannel
bool isEMECchannel(const HWIdentifier id) const override final
Definition: LArOnline_SuperCellID.cxx:402
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
LArDigitalTriggMonAlg::getXbinFromSourceID
unsigned getXbinFromSourceID(const unsigned sourceID) const
Definition: LArDigitalTriggMonAlg.cxx:767
SC_MonValues::sc_passSCNomInvalid
bool sc_passSCNomInvalid
Definition: LArDigitalTriggMonAlg.cxx:146
LArRawSC::chan
short chan() const
Definition: LArRawSC.h:92
LArSCDigit.h
LArOnlineID_Base::pos_neg
int pos_neg(const HWIdentifier id) const
Return the side of a hardware cell identifier pos_neg = [0,1] positive-side or negative-side Barrel...
Definition: LArOnlineID_Base.cxx:1950
CaloCell_SuperCell_ID.h
Helper class for offline supercell identifiers.
CaloCell_Base_ID::eta
int eta(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
SC_MonValues::sc_et_onl
float sc_et_onl
Definition: LArDigitalTriggMonAlg.cxx:140
LArDigitalTriggMonAlg::m_LATOMEHeaderContainerKey
SG::ReadHandleKey< LArLATOMEHeaderContainer > m_LATOMEHeaderContainerKey
Definition: LArDigitalTriggMonAlg.h:72
AthMonitorAlgorithm::fill
void fill(const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
Fills a vector of variables to a group by reference.
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
LArSCDigit::Channel
short Channel() const
Definition: LArSCDigit.h:42
isEmptyCont
bool isEmptyCont(C &c)
Definition: LArDigitalTriggMonAlg.cxx:56
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
Digi_MonValues::digi_diff_adc_ped_norm
float digi_diff_adc_ped_norm
Definition: LArDigitalTriggMonAlg.cxx:121
LArDigitalTriggMonAlg::m_streams
Gaudi::Property< std::vector< std::string > > m_streams
Give the name of the streams you want to monitor:
Definition: LArDigitalTriggMonAlg.h:60
LArSCDigit
Base class for LArDigits taken by LATOME.
Definition: LArSCDigit.h:19
SC_MonValues::sc_notMaskedEoflGt1
bool sc_notMaskedEoflGt1
Definition: LArDigitalTriggMonAlg.cxx:155
Digi_MonValues::digi_badNotMasked
bool digi_badNotMasked
Definition: LArDigitalTriggMonAlg.cxx:127
Digi_MonValues::digi_partition
int digi_partition
Definition: LArDigitalTriggMonAlg.cxx:120
LArDigitalTriggMonAlg::m_toolmapLayerNames_digi
std::map< std::string, int > m_toolmapLayerNames_digi
Definition: LArDigitalTriggMonAlg.h:146
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition: AthMonitorAlgorithm.h:338
LArDigitalTriggMonAlg::m_caloSuperCellMgrKey
SG::ReadCondHandleKey< CaloSuperCellDetDescrManager > m_caloSuperCellMgrKey
Handle to Super Cell DD Manager.
Definition: LArDigitalTriggMonAlg.h:83
SC_MonValues::sc_phi
float sc_phi
Definition: LArDigitalTriggMonAlg.cxx:134
Digi_MonValues::digi_diff_adc_ped
float digi_diff_adc_ped
Definition: LArDigitalTriggMonAlg.cxx:122
Digi_MonValues::digi_maxpos
int digi_maxpos
Definition: LArDigitalTriggMonAlg.cxx:119
Digi_MonValues::digi_ieta
int digi_ieta
Definition: LArDigitalTriggMonAlg.cxx:113
HWIdentifier.h
AtlCoolConsole.tool
tool
Definition: AtlCoolConsole.py:452
SC_MonValues::sc_time
float sc_time
Definition: LArDigitalTriggMonAlg.cxx:142
SC_MonValues::sc_lb
unsigned int sc_lb
Definition: LArDigitalTriggMonAlg.cxx:144
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
LArRawSC::passTauSelection
const std::vector< bool > & passTauSelection() const
Definition: LArRawSC.h:113
CaloCell_Base_ID::phi
int phi(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
Digi_MonValues::digi_lb
unsigned int digi_lb
Definition: LArDigitalTriggMonAlg.cxx:125
LArOnlineID_Base::isEMBchannel
bool isEMBchannel(const HWIdentifier id) const
Definition: LArOnlineID_Base.cxx:1648
SC_MonValues
Definition: LArDigitalTriggMonAlg.cxx:132
LArRawSC::bcids
const std::vector< unsigned short > & bcids() const
Definition: LArRawSC.h:104
Digi_MonValues::digi_latomesourceidbin
int digi_latomesourceidbin
Definition: LArDigitalTriggMonAlg.cxx:117
SC_MonValues::sc_ieta
int sc_ieta
Definition: LArDigitalTriggMonAlg.cxx:135
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
python.PyAthena.v
v
Definition: PyAthena.py:154
LArLATOMEHeader
Holds information from the LATOME Header.
Definition: LArLATOMEHeader.h:19
SC_MonValues::sc_eta
float sc_eta
Definition: LArDigitalTriggMonAlg.cxx:133
CaloDetDescrElement::getSampling
CaloCell_ID::CaloSample getSampling() const
cell sampling
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:395
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
SC_MonValues::sc_et_ofl
float sc_et_ofl
Definition: LArDigitalTriggMonAlg.cxx:138
SC_MonValues::sc_zeroET
bool sc_zeroET
Definition: LArDigitalTriggMonAlg.cxx:145
AthCommonMsg< Gaudi::Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
Digi_MonValues
Definition: LArDigitalTriggMonAlg.cxx:110
SC_MonValues::sc_passSCNom10
bool sc_passSCNom10
Definition: LArDigitalTriggMonAlg.cxx:150
SC_MonValues::sc_passSCNom0p325_1
bool sc_passSCNom0p325_1
Definition: LArDigitalTriggMonAlg.cxx:148
LArDigitalTriggMonAlg::m_rawSCEtRecoContainerKey
SG::ReadHandleKey< LArRawSCContainer > m_rawSCEtRecoContainerKey
Definition: LArDigitalTriggMonAlg.h:71
SC_MonValues::sc_OFCbOFNotMasked
bool sc_OFCbOFNotMasked
Definition: LArDigitalTriggMonAlg.cxx:153
Digi_MonValues::digi_adc
int digi_adc
Definition: LArDigitalTriggMonAlg.cxx:116
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
LArRawSC::ofcbOverflow
bool ofcbOverflow() const
Definition: LArRawSC.h:120
LArMon::trigStreamMatching
std::vector< unsigned > trigStreamMatching(const std::vector< std::string > &streamsFromJobO, const std::vector< xAOD::EventInfo::StreamTag > &streamInEvent)
Definition: LArTrigStreamMatching.cxx:7
LArOnlineID_Base::channel_name
std::string channel_name(const HWIdentifier id) const
Return a string corresponding to a feedthrough name given an identifier.
Definition: LArOnlineID_Base.cxx:221
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:51
ILArPedestal::pedestalRMS
virtual float pedestalRMS(const HWIdentifier &id, int gain) const =0
access to RMS of Pedestal index by Identifier, and gain setting
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
LArDigitalTriggMonAlg::m_cablingKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey
Definition: LArDigitalTriggMonAlg.h:66
python.compressB64.c
def c
Definition: compressB64.py:93
SC_MonValues::sc_passSCNom10tauGt3
bool sc_passSCNom10tauGt3
Definition: LArDigitalTriggMonAlg.cxx:151
LArDigitalTriggMonAlg::m_digitContainerKey
SG::ReadHandleKey< LArDigitContainer > m_digitContainerKey
Handle to EventData (input)
Definition: LArDigitalTriggMonAlg.h:69
LArDigitalTriggMonAlg::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const override
adds event to the monitoring histograms
Definition: LArDigitalTriggMonAlg.cxx:159
LArDigitalTriggMonAlg::initialize
virtual StatusCode initialize() override
initialize
Definition: LArDigitalTriggMonAlg.cxx:67
LArDigitalTriggMonAlg::m_scMonGroupName
Gaudi::Property< std::string > m_scMonGroupName
Definition: LArDigitalTriggMonAlg.h:63
Digi_MonValues::digi_pedestal
float digi_pedestal
Definition: LArDigitalTriggMonAlg.cxx:118
LArOnlineID.h
CaloDetDescrElement::phi_raw
float phi_raw() const
cell phi_raw
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:352
python.LArMinBiasAlgConfig.float
float
Definition: LArMinBiasAlgConfig.py:65
LArOnOffIdMapping
Definition: LArOnOffIdMapping.h:20
LArRawSC::energies
const std::vector< int > & energies() const
Definition: LArRawSC.h:101
LArDigitalTriggMonAlg::m_rawSCContainerKey
SG::ReadHandleKey< LArRawSCContainer > m_rawSCContainerKey
Definition: LArDigitalTriggMonAlg.h:70
Identifier
Definition: IdentifierFieldParser.cxx:14