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.key().empty() || !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 
83  ATH_MSG_INFO("Input containers=" << m_rawSCContainerKey << " / " << m_rawSCEtRecoContainerKey);
84 
85 
87  ATH_CHECK(m_bcContKey.initialize());
89 
96  ATH_CHECK(m_actualMuKey.initialize());
98 
99  // Property check:
100  constexpr unsigned expSize=MAXLYRNS*2+1;
101  if (m_layerNames.size() != expSize) {
102  ATH_MSG_ERROR("Unexpected size of LayerNames property. Expect "<< expSize << " entries, found "<< m_layerNames.size() << " entries");
103  return StatusCode::FAILURE;
104  }
105 
106  if (m_isADCBaseline) {
107  ATH_MSG_INFO("IsADCBas set to true");
108  }
110 }
111 
112 
114  float digi_eta;
115  float digi_phi;
119  int digi_adc;
129  unsigned int digi_lb;
132 
133 };
134 
135 
136 struct SC_MonValues {
137  float sc_eta;
138  float sc_phi;
139  int sc_ieta;
140  int sc_iphi;
142  float sc_et_ofl;
144  float sc_et_onl;
146  float sc_time;
147  int sc_bcid;
148  unsigned int sc_lb;
149  bool sc_zeroET;
160 };
161 
162 
163 StatusCode LArDigitalTriggMonAlg::fillHistograms(const EventContext& ctx) const
164 {
165 
166  ATH_MSG_DEBUG("in fillHists()" );
167 
168  // General Monitored variables
169  auto lumi_block = Monitored::Scalar<unsigned int>("lumi_block", 0);
170  auto time_stamp = Monitored::Scalar<unsigned int>("time_stamp", 0);
171  auto BCID = Monitored::Scalar<int>("BCID",0);
172  auto Pedestal = Monitored::Scalar<float>("Pedestal",0.0);
173  auto PedestalRMS = Monitored::Scalar<float>("PedestalRMS",0.0);
174 
175  // From digi loop
176  auto Digi_Nsamples = Monitored::Scalar<int>("Digi_Nsamples",-1); // MNsamples
177  auto Digi_SCChannel = Monitored::Scalar<int>("Digi_SCChannel",-1); // MSCChannel
178  auto Digi_latomeSourceId = Monitored::Scalar<int>("Digi_latomeSourceId",-1); // MlatomeSourceId
179  auto Digi_latomeSourceIdBIN = Monitored::Scalar<int>("Digi_latomeSourceIdBIN",1); // MlatomeSourceIdBIN
180  auto Digi_phi = Monitored::Scalar<float>("Digi_phi",0.0); // MSCphi
181  auto Digi_eta = Monitored::Scalar<float>("Digi_eta",0.0); // MSCeta
182  auto Digi_iphi = Monitored::Scalar<int>("Digi_iphi",0.0);
183  auto Digi_ieta = Monitored::Scalar<int>("Digi_ieta",0.0);
184  auto Digi_maxpos = Monitored::Scalar<int>("Digi_maxpos",-1); // Mmaxpos
185  auto Digi_partition = Monitored::Scalar<int>("Digi_partition",-1); // Mpartition
186  auto Digi_sampos = Monitored::Scalar<int>("Digi_sampos",-1); // Msampos
187  auto Digi_ADC = Monitored::Scalar<int>("Digi_ADC",-1); // MADC
188  auto Digi_Diff_ADC_Ped = Monitored::Scalar<float>("Digi_Diff_ADC_Ped", -999); // Diff_ADC_Pedestal
189  auto Digi_Diff_ADC0_Ped = Monitored::Scalar<float>("Digi_Diff_ADC0_Ped", -999); // Pedestal diff
190  auto Digi_Diff_ADC_Ped_Norm = Monitored::Scalar<float>("Digi_Diff_ADC_Ped_Norm",-999); // Diff_ADC_Pedestal_Norm
191  auto Digi_ADC_RMS = Monitored::Scalar<float>("Digi_ADC_RMS",-1); // Digi_ADC_RMS
192 
193  // cuts
194  auto notBadQual = Monitored::Scalar<bool>("notBadQual",false);
195  auto ADCped10RMS = Monitored::Scalar<bool>("ADCped10RMS",false);
196  auto passDigiNom = Monitored::Scalar<bool>("passDigiNom",false);
197  auto badNotMasked = Monitored::Scalar<bool>("badNotMasked",false);
198 
199  // cuts which are used in both loops
200  auto notMasked = Monitored::Scalar<bool>("notMasked",false);
201 
202  // From SC loop
203  auto SC_SCChannel = Monitored::Scalar<int>("SC_SCChannel",-1); // MSCChannel
204  auto SC_latomeSourceId = Monitored::Scalar<int>("SC_latomeSourceId",-1); // MlatomeSourceId
205  auto SC_partition = Monitored::Scalar<int>("SC_partition",-1); // Mpartition
206  auto SC_phi = Monitored::Scalar<float>("SC_phi",0.0); // MSCphi
207  auto SC_eta = Monitored::Scalar<float>("SC_eta",0.0); // MSCeta
208  auto SC_iphi = Monitored::Scalar<int>("SC_iphi",0.0);
209  auto SC_ieta = Monitored::Scalar<int>("SC_ieta",0.0);
210  auto SC_energy_onl = Monitored::Scalar<int>("SC_energy_onl",0.0); // Menergy_onl
211  auto SC_ET_onl = Monitored::Scalar<float>("SC_ET_onl",0.0); // Menergy_onl
212  auto SC_ET_onl_muscaled = Monitored::Scalar<float>("SC_ET_onl_muscaled",0.0); // Menergy_onl
213  auto SC_energy_ofl = Monitored::Scalar<int>("SC_energy_ofl",0.0); // Menergy_ofl
214  auto SC_ET_ofl = Monitored::Scalar<float>("SC_ET_ofl",0.0); // Menergy_onl
215  auto SC_ET_diff = Monitored::Scalar<int>("SC_ET_diff",0.0); // MSCEt_diff
216  auto SC_time = Monitored::Scalar<float>("SC_time",0.0); // MSCtime
217  auto SC_latomeSourceIdBIN = Monitored::Scalar<int>("SC_latomeSourceIdBIN",1); // MlatomeSourceIdBIN
218  auto SC_AvEnergyOverMu = Monitored::Scalar<float>("SC_AvEnergyOverMu",0); // LMAvEnergyOverMu
219  // cuts
220  auto passTauSel = Monitored::Scalar<bool>("passTauSel",false);
221  auto nonZeroET = Monitored::Scalar<bool>("nonZeroET",false); // eTgt0GeV
222  auto zeroET = Monitored::Scalar<bool>("zeroET",false); // eTgt0GeV
223  auto nonZeroETofl = Monitored::Scalar<bool>("nonZeroETofl",false); // eTgt0GeV
224  auto onlofflEmismatch = Monitored::Scalar<bool>("onlofflEmismatch",false);
225  auto notSatur = Monitored::Scalar<bool>("notSatur",false);
226  auto notOFCbOF = Monitored::Scalar<bool>("notOFCbOF",false);
227  auto tauGt3 = Monitored::Scalar<bool>("tauGt3",false);
228  auto nonZeroEtau = Monitored::Scalar<bool>("nonZeroEtau",false);
229  auto eTgt1GeV = Monitored::Scalar<bool>("eTgt1GeV",false);
230  auto eTlt1GeV = Monitored::Scalar<bool>("eTlt1GeV",false);
231  auto eTgt0p325GeV = Monitored::Scalar<bool>("eTgt0p325GeV",false);
232  auto eTgt0lt0p325GeV = Monitored::Scalar<bool>("eTgt0lt0p325GeV",false);
233  auto eTgt10GeV = Monitored::Scalar<bool>("eTgt10GeV",false);
234  auto eTlt10GeV = Monitored::Scalar<bool>("eTlt10GeV",false);
235  auto eToflGt1GeV = Monitored::Scalar<bool>("eToflGt1GeV",false);
236 
237 
238  //auto passSCNom = Monitored::Scalar<bool>("passSCNom",false); // pass tau, not satur, not OFCb OF, not masked nonZeroET < 10 GeV
239  auto passSCNomInvalid = Monitored::Scalar<bool>("passSCNomInvalid",false); // pass tau, not satur, not OFCb OF, not masked and raw E = -99999
240  auto passSCNom0_0p325 = Monitored::Scalar<bool>("passSCNom0_0p325",false); // pass tau, not satur, not OFCb OF, not masked nonZeroET < 0.2 GeV
241  auto passSCNom0p325_1 = Monitored::Scalar<bool>("passSCNom0p325_1",false); // pass tau, not satur, not OFCb OF, not masked 0.2 < ET < 1 GeV
242  auto passSCNom1 = Monitored::Scalar<bool>("passSCNom1",false); // pass tau, not satur, not OFCb OF, not masked eTgt1GeV
243  auto passSCNom10 = Monitored::Scalar<bool>("passSCNom10",false); // pass tau, not satur, not OFCb OF, not masked eTgt10GeV
244  auto passSCNom10tauGt3 = Monitored::Scalar<bool>("passSCNom10tauGt3",false); // pass tau, not satur, not OFCb OF, not masked eTgt10GeV tauGt3
245  auto saturNotMasked = Monitored::Scalar<bool>("saturNotMasked",false); // notSatur is false, notMasked is false
246  auto OFCbOFNotMasked = Monitored::Scalar<bool>("OFCbOFNotMasked",false); // notOFCbOF is false, notMasked is false
247  auto notMaskedEoflNe0 = Monitored::Scalar<bool>("notMaskedEoflNe0",false); // not masked OSUM, not satur, not OFCb OF, ET ofl != 0
248  auto notMaskedEoflGt1 = Monitored::Scalar<bool>("notMaskedEoflGt1",false); // not masked OSUM, not satur, not OFCb OF, ET ofl > 1
249 
250  // From LATOME header loop
251  auto thisEvent=this->GetEventInfo(ctx);
252 
253  const std::vector<unsigned> streamsThisEvent=LArMon::trigStreamMatching(m_streams,thisEvent->streamTags());
254 
256  const LArOnOffIdMapping* cabling=*cablingHdl;
257 
258  SG::ReadHandle<LArDigitContainer> hLArDigitContainer;
259  if (!m_digitContainerKey.empty()) {
260  hLArDigitContainer= SG::ReadHandle<LArDigitContainer>{m_digitContainerKey,ctx}; //"SC"
261  if (!hLArDigitContainer.isValid()) {
262  ATH_MSG_WARNING("The requested digit container key could not be retrieved. Was there a problem retrieving information from the run logger?");
263  }
264  }
265  else {
266  ATH_MSG_DEBUG("hLArDigitContainer.size() " << hLArDigitContainer->size());
267  }
268 
269 
270  SG::ReadHandle<LArRawSCContainer> hSCetContainer;
271  if (!m_rawSCContainerKey.empty()) {
272  hSCetContainer = SG::ReadHandle<LArRawSCContainer>{m_rawSCContainerKey, ctx}; //"SC_ET"
273  if (!hSCetContainer.isValid()) {
274  ATH_MSG_WARNING("The requested SC ET container key could not be retrieved. Was there a problem retrieving information from the run logger?");
275  }
276  }
277  else {
278  ATH_MSG_DEBUG("hSCetContainer.size() " << hSCetContainer->size());
279  }
280 
281  SG::ReadHandle<LArRawSCContainer> hSCetRecoContainer;
283  hSCetRecoContainer = SG::ReadHandle<LArRawSCContainer>{m_rawSCEtRecoContainerKey, ctx}; //"SC_ET_RECO"
284  if (!hSCetRecoContainer.isValid()) {
285  ATH_MSG_WARNING("The requested SC ET reco container key could not be retrieved. Was there a problem retrieving information from the run logger?");
286  }
287  }
288  else {
289  ATH_MSG_DEBUG("hSCetRecoContainer.size() " << hSCetRecoContainer->size());
290  }
291 
292  SG::ReadHandle<LArLATOMEHeaderContainer> hLArLATOMEHeaderContainer{m_LATOMEHeaderContainerKey,ctx}; //"SC_LATOME_HEADER"
293  if (!hLArLATOMEHeaderContainer.isValid()) {
294  ATH_MSG_WARNING("The requested LATOME header container key could not be retrieved. Was there a problem retrieving information from the run logger?");
295  }else{
296  ATH_MSG_DEBUG("hLArLATOMEHeaderContainer.size() " << hLArLATOMEHeaderContainer->size());
297  }
298 
299  if (isEmptyCont(hLArDigitContainer) && isEmptyCont(hSCetContainer) && isEmptyCont(hSCetRecoContainer) && isEmptyCont(hLArLATOMEHeaderContainer)) {
300  //Make this only warning, come CI tests use the runs without DT info
301  ATH_MSG_WARNING("All of the requested containers are empty. Was there a problem retrieving information from the run logger?");
302  return StatusCode::SUCCESS;
303  }
304 
305  BCID = thisEvent->bcid(); // - 88)%((36+7)*4 + 36 + 31);
306  lumi_block = thisEvent->lumiBlock();
307  time_stamp = thisEvent->timeStamp();
308 
309  float mu = lbInteractionsPerCrossing(ctx);
310  float event_mu = lbLuminosityPerBCID(ctx);
311 
312  ATH_MSG_DEBUG("mu (LB): " << mu);
313  ATH_MSG_DEBUG("mu (BCID): " << event_mu);
314  ATH_MSG_DEBUG("Event number: " << thisEvent->eventNumber());
315  ATH_MSG_DEBUG("LB number: " << thisEvent->lumiBlock());
316  ATH_MSG_DEBUG("BCID: " << thisEvent->bcid());
318  const ILArPedestal* pedestals = *pedestalHdl;
319 
321  const CaloSuperCellDetDescrManager* ddman = *caloSuperCellMgrHandle;
322 
323  // retrieve BadChannel info:
324  const LArBadChannelCont* bcCont = nullptr;
326  bcCont = (*bcContHdl);
327 
328  if ((hLArDigitContainer.isValid())) {
329  std::vector<std::vector<Digi_MonValues>> digiMonValueVec(m_layerNames.size());
330  for (auto& innerVec : digiMonValueVec) {
331  innerVec.reserve(1600); // (m_layerNcells[ilayer]) * nsamples;
332  }
333 
334  // Loop over digits
335  for (const LArDigit* pLArDigit : *hLArDigitContainer) {
336  HWIdentifier id = pLArDigit->hardwareID(); // gives online ID
337  // skip disconnected channels:
338  if (!cabling->isOnlineConnected(id))
339  continue;
340 
341  const unsigned trueNSamples = pLArDigit->nsamples();
342  if (trueNSamples == 0)
343  continue;
344  Digi_Nsamples = trueNSamples; // Fill the monitored variable
345  const int cgain = pLArDigit->gain();
346 
347  const Identifier offlineID = cabling->cnvToIdentifier(id);
348  const CaloDetDescrElement* caloDetElement = ddman->get_element(offlineID);
349  if (caloDetElement == 0) {
350  ATH_MSG_ERROR("Cannot retrieve caloDetElement");
351  continue;
352  }
353  Digi_eta = caloDetElement->eta_raw();
354  Digi_phi = caloDetElement->phi_raw();
355 
356  Digi_ieta = m_SCID_helper->eta(offlineID);
357  Digi_iphi = m_SCID_helper->phi(offlineID);
358 
359  const int calosample = caloDetElement->getSampling();
360 
361  const unsigned iLyrNS = m_caloSamplingToLyrNS[calosample];
362  const int side = m_LArOnlineIDHelper->pos_neg(id);
363  const unsigned iLyr = iLyrNS * 2 + side;
364  auto& lvaluemap_digi = digiMonValueVec[iLyr];
365  auto& lvaluemap_digi_ALL = digiMonValueVec.back();
366 
367  // Determine to which partition this channel belongs to
368  const int ThisPartition = whatPartition(id, side);
369  Digi_partition = ThisPartition; // Fill the monitored variable
370 
371  fill(m_scMonGroupName, Digi_Nsamples);
372 
373  // Check if this is a maskedOSUM SC
374  notMasked = true;
375  if (m_bcMask.cellShouldBeMasked(bcCont, id)) {
376  notMasked = false;
377  }
378 
379  if (pedestals) {
380  Pedestal = pedestals->pedestal(id, cgain);
381  PedestalRMS = pedestals->pedestalRMS(id, cgain);
382  } else
383  ATH_MSG_INFO("Pedestal values not received");
384 
385  const LArSCDigit* scdigi = dynamic_cast<const LArSCDigit*>(pLArDigit);
386  if (!scdigi) {
387  ATH_MSG_DEBUG(" CAN'T CAST ");
388  } else {
389  Digi_SCChannel = scdigi->Channel();
390  Digi_latomeSourceId = scdigi->SourceId();
391  Digi_latomeSourceIdBIN = getXbinFromSourceID(Digi_latomeSourceId);
392  }
393  // Retrieve samples
394  const std::vector<short>* digito = &pLArDigit->samples();
395 
396  // retrieve the max sample digit ie digitot.back().
397  std::vector<short>::const_iterator maxSam = std::max_element(digito->begin(), digito->end());
398  int thismaxPos = std::distance(digito->begin(), maxSam);
399  Digi_maxpos = thismaxPos + 1; // count samples [1,5]
400  float ADC_max = pLArDigit->samples().at(Digi_maxpos - 1);
401 
402  float ADC_0 = pLArDigit->samples().at(0);
403  if (m_isADCBaseline) { // SC_ADC_BAS, have to divide by 8
404  ADC_0 = ADC_0 / 8;
405  }
406 
407  float samp_sum = std::accumulate(digito->begin(), digito->end(), 0.0);
408  float samp_mean = samp_sum / static_cast<float>(trueNSamples);
409  float sq_sum = std::inner_product(digito->begin(), digito->end(), digito->begin(), 0.0);
410  float rms_arg = sq_sum / static_cast<float>(trueNSamples) - samp_mean * samp_mean;
411 
412  if (rms_arg < 0)
413  Digi_ADC_RMS = -1;
414  else
415  Digi_ADC_RMS = std::sqrt(rms_arg);
416 
417 
418  // Start Loop over samples
419  Digi_Diff_ADC0_Ped = ADC_0 - Pedestal;
420  for (unsigned i = 0; i < trueNSamples; ++i) {
421  badNotMasked = false;
422  notBadQual = false;
423  ADCped10RMS = false;
424  passDigiNom = false;
425  Digi_sampos = i + 1;
426  Digi_ADC = pLArDigit->samples().at(i);
427  if (m_isADCBaseline) { // SC_ADC_BAS, have to divide by 8
428  Digi_ADC = Digi_ADC / 8;
429  }
430 
431  Digi_Diff_ADC_Ped = Digi_ADC - Pedestal;
432  if (ADC_max != Pedestal) {
433  Digi_Diff_ADC_Ped_Norm = (Digi_ADC - Pedestal) / std::abs(ADC_max - Pedestal);
434  }
435 
436  // Some selections
437  if (Digi_ADC != -1) {
438  notBadQual = true;
439  } else {
440  if (notMasked) {
441  badNotMasked = true;
442  }
443  }
444  if (ADC_max - Pedestal > 10 * PedestalRMS) {
445  ADCped10RMS = true;
446  }
447  if (notMasked && notBadQual && ADCped10RMS) {
448  passDigiNom = true;
449  }
450 
451  lvaluemap_digi.emplace_back(Digi_eta, Digi_phi, Digi_ieta, Digi_iphi, Digi_sampos, Digi_ADC, Digi_latomeSourceIdBIN, Pedestal, Digi_maxpos,
452  Digi_partition, Digi_Diff_ADC_Ped_Norm, Digi_Diff_ADC_Ped, Digi_Diff_ADC0_Ped, Digi_ADC_RMS, BCID, lumi_block, passDigiNom,
453  badNotMasked);
454  lvaluemap_digi_ALL.emplace_back(Digi_eta, Digi_phi, Digi_ieta, Digi_iphi, Digi_sampos, Digi_ADC, Digi_latomeSourceIdBIN, Pedestal, Digi_maxpos,
455  Digi_partition, Digi_Diff_ADC_Ped_Norm, Digi_Diff_ADC_Ped, Digi_Diff_ADC0_Ped, Digi_ADC_RMS, BCID, lumi_block, passDigiNom,
456  badNotMasked);
457 
458  } // End loop over samples
459 
460  } // End of loop on LArDigit
461 
462  // fill, for every layer/threshold
463  for (size_t ilayer = 0; ilayer < digiMonValueVec.size(); ++ilayer) {
464  const auto& tool = digiMonValueVec[ilayer];
465  auto digi_part_eta = Monitored::Collection("Digi_part_eta", tool, [](const auto& v) { return v.digi_eta; });
466  auto digi_part_phi = Monitored::Collection("Digi_part_phi", tool, [](const auto& v) { return v.digi_phi; });
467  auto digi_part_ieta = Monitored::Collection("Digi_part_ieta", tool, [](const auto& v) { return v.digi_ieta; });
468  auto digi_part_iphi = Monitored::Collection("Digi_part_iphi", tool, [](const auto& v) { return v.digi_iphi; });
469  auto digi_part_sampos = Monitored::Collection("Digi_part_sampos", tool, [](const auto& v) { return v.digi_sampos; });
470  auto digi_part_adc = Monitored::Collection("Digi_part_adc", tool, [](const auto& v) { return v.digi_adc; });
471  auto digi_part_latomesourceidbin = Monitored::Collection("Digi_part_latomesourceidbin", tool, [](const auto& v) { return v.digi_latomesourceidbin; });
472  auto digi_part_pedestal = Monitored::Collection("Digi_part_pedestal", tool, [](const auto& v) { return v.digi_pedestal; });
473  auto digi_part_maxpos = Monitored::Collection("Digi_part_maxpos", tool, [](const auto& v) { return v.digi_maxpos; });
474  auto digi_part_partition = Monitored::Collection("Digi_part_partition", tool, [](const auto& v) { return v.digi_partition; });
475  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; });
476  auto digi_part_diff_adc_ped = Monitored::Collection("Digi_part_diff_adc_ped", tool, [](const auto& v) { return v.digi_diff_adc_ped; });
477  auto digi_part_diff_adc0_ped = Monitored::Collection("Digi_part_diff_adc0_ped", tool, [](const auto& v) { return v.digi_diff_adc0_ped; });
478  auto digi_part_bcid = Monitored::Collection("Digi_part_BCID", tool, [](const auto& v) { return v.digi_bcid; });
479  auto digi_part_lb = Monitored::Collection("Digi_part_LB", tool, [](const auto& v) { return v.digi_lb; });
480  auto digi_part_passDigiNom = Monitored::Collection("Digi_part_passDigiNom", tool, [](const auto& v) { return v.digi_passDigiNom; });
481  auto digi_part_badNotMasked = Monitored::Collection("Digi_part_badNotMasked", tool, [](const auto& v) { return v.digi_badNotMasked; });
482  auto digi_part_adc_rms = Monitored::Collection("Digi_part_adc_rms", tool, [](const auto& v) { return v.digi_adc_rms; });
483 
484  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,
485  digi_part_adc, digi_part_latomesourceidbin, digi_part_pedestal, digi_part_maxpos, digi_part_diff_adc_ped_norm, digi_part_diff_adc_ped,
486  digi_part_diff_adc0_ped, digi_part_adc_rms, digi_part_bcid, digi_part_lb, digi_part_passDigiNom, digi_part_badNotMasked);
487  }
488 
489  } // End if(LArDigitContainer is valid)
490 
491 
492  if (!isEmptyCont(hSCetContainer) && !isEmptyCont(hSCetRecoContainer)) {
493  LArRawSCContainer::const_iterator itSC = hSCetContainer->begin();
494  LArRawSCContainer::const_iterator itSC_e= hSCetContainer->end();
495  LArRawSCContainer::const_iterator itSCReco = hSCetRecoContainer->begin();
496  const LArRawSC* rawSC = 0;
497  const LArRawSC* rawSCReco = 0;
498 
499  std::vector<std::vector<SC_MonValues>> scMonValueVec(m_layerNames.size());
500  for (auto& innerVec : scMonValueVec) {
501  innerVec.reserve(1600); // (m_layerNcells[ilayer]) * nsamples;
502  }
503 
504  // Loop over SCs
505  for (; itSC != itSC_e; ++itSC, ++itSCReco) {
506  rawSC = *itSC;
507  if (itSCReco < hSCetRecoContainer->end()) {
508  rawSCReco = *itSCReco;
509  } else {
510  //temporarily removed
511  //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?");
512  rawSCReco = 0;
513  }
514  SC_SCChannel = rawSC->chan();
515  HWIdentifier id = rawSC->hardwareID(); // gives online ID
516  // skip disconnected channels:
517  if (!cabling->isOnlineConnected(id))
518  continue;
519 
520  const Identifier offlineID = cabling->cnvToIdentifier(id); // converts online to offline ID
521  // Get Physical Coordinates
522  const CaloDetDescrElement* caloDetElement = ddman->get_element(offlineID);
523  if (caloDetElement == 0) {
524  ATH_MSG_ERROR("Cannot retrieve (eta,phi) coordinates for raw channels");
525  ATH_MSG_ERROR(" ==============> " << std::hex << "; offlineID = " << offlineID << "online ID =" << m_LArOnlineIDHelper->channel_name(id)
526  << "; rawSC->SourceId() = " << rawSC->SourceId());
527  continue;
528  }
529  SC_eta = caloDetElement->eta_raw();
530  SC_phi = caloDetElement->phi_raw();
531 
532  SC_ieta = m_SCID_helper->eta(offlineID);
533  SC_iphi = m_SCID_helper->phi(offlineID);
534  int calosample = caloDetElement->getSampling();
535 
536  const unsigned iLyrNS = m_caloSamplingToLyrNS[calosample];
537  const unsigned side = m_LArOnlineIDHelper->pos_neg(id);
538  const unsigned iLyr = iLyrNS * 2 + side;
539 
540  auto& lvaluemap_sc = scMonValueVec[iLyr];
541  auto& lvaluemap_sc_ALL = scMonValueVec.back();
542 
543  SC_latomeSourceIdBIN = getXbinFromSourceID(rawSC->SourceId());
544 
545  // initialise cuts
546  notMasked = false;
547  passTauSel = false;
548  nonZeroET = false;
549  zeroET = false;
550  notSatur = false;
551  nonZeroEtau = false;
552  eTgt0p325GeV = false;
553  eTgt0lt0p325GeV = false;
554  eTgt1GeV = false;
555  eTlt1GeV = false;
556  eTgt10GeV = false;
557  eTlt10GeV = false;
558  notOFCbOF = false;
559  tauGt3 = false;
560  onlofflEmismatch = false;
561  passSCNom0_0p325 = false;
562  passSCNom0p325_1 = false;
563  passSCNom1 = false;
564  passSCNom10 = false;
565  passSCNom10tauGt3 = false;
566  saturNotMasked = false;
567  OFCbOFNotMasked = false;
568  notMaskedEoflNe0 = false;
569  notMaskedEoflGt1 = false;
570  nonZeroETofl = false;
571  eToflGt1GeV = false;
572  passSCNomInvalid = false;
573  // Check if this is a maskedOSUM SC
574  if (!m_bcMask.cellShouldBeMasked(bcCont, id)) {
575  notMasked = true;
576  }
577  // popopopo
578  if (rawSCReco != 0 && rawSCReco->passTauSelection().size() > 0) { // only compare Et if tau selection is passed
579  if (rawSCReco->passTauSelection().at(0) == true)
580  passTauSel = true;
581  }
582  unsigned int bcid_ind = 0;
583  if (rawSC->energies().size() > 0) {
584  for (auto& SCe : rawSC->bcids()) {
585  if (SCe == BCID)
586  break;
587  bcid_ind++;
588  }
589  if (bcid_ind >= rawSC->bcids().size()) {
590  ATH_MSG_WARNING("BCID not found in SC bcids list!! " << BCID << " BCIDs size: " << rawSC->bcids().size() << ", proposed index: " << bcid_ind);
591  } else if (rawSC->bcids().at(bcid_ind) != BCID) {
592  ATH_MSG_WARNING("BCID not found in SC bcids list!! " << BCID << " " << rawSC->bcids().at(bcid_ind));
593  }
594 
595  if (rawSC->energies().size() > bcid_ind) {
596  SC_energy_onl = rawSC->energies().at(bcid_ind);
597  } else {
598  ATH_MSG_WARNING("rawSC energies vector is too small for the requested BCID index " << bcid_ind << " (size is " << rawSC->energies().size()
599  << ", bcid vec size is " << rawSC->bcids().size() << ")");
600  SC_energy_onl = 0;
601  }
602  } else {
603  ATH_MSG_WARNING("rawSC energies vector is empty!");
604  SC_energy_onl = 0;
605  }
606 
607  if (rawSCReco != 0) {
608  if (rawSCReco->energies().size() > 0) {
609  SC_energy_ofl = rawSCReco->energies().at(0); // algorithm already selects the correct energy
610  } else {
611  ATH_MSG_WARNING("rawSCReco energies vector is empty!");
612  SC_energy_ofl = 0;
613  }
614  }
615  SC_ET_diff = SC_energy_onl - SC_energy_ofl;
616  SC_ET_onl = (SC_energy_onl * 12.5) / 1000; // Converted to GeV
617  SC_ET_ofl = (SC_energy_ofl * 12.5) / 1000; // Converted to GeV
618  SC_ET_onl_muscaled = event_mu > 0. ? SC_ET_onl / event_mu : SC_ET_onl;
619  int Etau = 0;
620  if (rawSCReco != 0) {
621  if (rawSCReco->tauEnergies().size() > 0) {
622  Etau = rawSCReco->tauEnergies().at(0);
623  }
624  }
625  SC_time = (SC_energy_ofl != 0) ? (float)Etau / (float)SC_energy_ofl : Etau;
626 
627  ATH_MSG_DEBUG("Energy onl - Energy ofl: " << SC_energy_onl << ", " << SC_energy_ofl << std::endl);
628  if (SC_ET_onl != 0) {
629  nonZeroET = true;
630  } else {
631  zeroET = true;
632  }
633  if (SC_ET_onl > 0.325) {
634  eTgt0p325GeV = true;
635  } else if (SC_ET_onl < 0.325 && SC_ET_onl > 0.) {
636  eTgt0lt0p325GeV = true;
637  }
638  if (SC_ET_onl > 1) {
639  eTgt1GeV = true;
640  }
641  if (SC_ET_onl < 1) {
642  eTlt1GeV = true;
643  }
644  if (SC_ET_onl > 10) {
645  eTgt10GeV = true;
646  }
647  if (SC_ET_onl < 10) {
648  eTlt10GeV = true;
649  }
650  if (SC_ET_ofl != 0) {
651  nonZeroETofl = true;
652  }
653  if (SC_ET_ofl > 1) {
654  eToflGt1GeV = true;
655  }
656  if (rawSC->satur().size() > bcid_ind) {
657  if (rawSC->satur().at(bcid_ind)) {
658  if (notMasked) {
659  saturNotMasked = true;
660  }
661  } else {
662  notSatur = true;
663  }
664  }
665  if (Etau != 0) {
666  nonZeroEtau = true;
667  }
668  if (rawSCReco != 0 && rawSCReco->ofcbOverflow() == false) {
669  notOFCbOF = true;
670  } else {
671  if (notMasked) {
672  OFCbOFNotMasked = true;
673  }
674  }
675  if (std::abs(SC_time) > 3) {
676  tauGt3 = true;
677  }
678 
679  if (notMasked && notSatur && notOFCbOF) {
680  if (nonZeroETofl) {
681  notMaskedEoflNe0 = true;
682  }
683  if (eToflGt1GeV) {
684  notMaskedEoflGt1 = true;
685  }
686  if (SC_energy_onl == -99999) {
687  passSCNomInvalid = true;
688  }
689 
690  //if ( passTauSel ){
691  //if ( nonZeroET && eTgt0lt0p325GeV ){
692  if (eTgt0lt0p325GeV) {
693  passSCNom0_0p325 = true;
694  }
695  if (eTgt0p325GeV && eTlt1GeV) {
696  passSCNom0p325_1 = true;
697  }
698  if (eTgt1GeV) {
699  passSCNom1 = true;
700  }
701  if (eTgt10GeV) {
702  passSCNom10 = true;
703  if (tauGt3) {
704  passSCNom10tauGt3 = true;
705  }
706  }
707  if (SC_energy_onl != SC_energy_ofl) {
708  onlofflEmismatch = true;
709  }
710  //}
711  } // end nominal selections
712 
713  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,
714  lumi_block, zeroET, passSCNomInvalid, passSCNom0_0p325, passSCNom0p325_1, passSCNom1, passSCNom10, passSCNom10tauGt3, saturNotMasked, OFCbOFNotMasked, notMaskedEoflNe0,
715  notMaskedEoflGt1);
716  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,
717  BCID, lumi_block, zeroET, passSCNomInvalid, passSCNom0_0p325, passSCNom0p325_1, passSCNom1, passSCNom10, passSCNom10tauGt3, saturNotMasked, OFCbOFNotMasked,
718  notMaskedEoflNe0, notMaskedEoflGt1);
719 
720  } // end loop over SCs
721 
722  // fill, for every layer/threshold
723  for (size_t ilayer = 0; ilayer < scMonValueVec.size(); ++ilayer) {
724  const auto& tool = scMonValueVec[ilayer];
725  auto sc_part_eta = Monitored::Collection("SC_part_eta", tool, [](const auto& v) { return v.sc_eta; });
726  auto sc_part_phi = Monitored::Collection("SC_part_phi", tool, [](const auto& v) { return v.sc_phi; });
727  auto sc_part_ieta = Monitored::Collection("SC_part_ieta", tool, [](const auto& v) { return v.sc_ieta; });
728  auto sc_part_iphi = Monitored::Collection("SC_part_iphi", tool, [](const auto& v) { return v.sc_iphi; });
729  auto sc_part_latomesourceidbin = Monitored::Collection("SC_part_latomesourceidbin", tool, [](const auto& v) { return v.sc_latomesourceidbin; });
730  auto sc_part_et_ofl = Monitored::Collection("SC_part_et_ofl", tool, [](const auto& v) { return v.sc_et_ofl; });
731  auto sc_part_et_diff = Monitored::Collection("SC_part_et_diff", tool, [](const auto& v) { return v.sc_et_diff; });
732  auto sc_part_et_onl = Monitored::Collection("SC_part_et_onl", tool, [](const auto& v) { return v.sc_et_onl; });
733  auto sc_part_et_onl_muscaled = Monitored::Collection("SC_part_et_onl_muscaled", tool, [](const auto& v) { return v.sc_et_onl_muscaled; });
734  auto sc_part_time = Monitored::Collection("SC_part_time", tool, [](const auto& v) { return v.sc_time; });
735  auto sc_part_bcid = Monitored::Collection("SC_part_BCID", tool, [](const auto& v) { return v.sc_bcid; });
736  auto sc_part_lb = Monitored::Collection("SC_part_LB", tool, [](const auto& v) { return v.sc_lb; });
737  // auto sc_part_passSCNom = Monitored::Collection("SC_part_passSCNom", tool, [](const auto& v) { return v.sc_passSCNom; });
738  auto sc_zeroET = Monitored::Collection("SC_part_zeroET", tool, [](const auto& v) { return v.sc_zeroET; });
739  auto sc_part_passSCNomInvalid = Monitored::Collection("SC_part_passSCNomInvalid", tool, [](const auto& v) { return v.sc_passSCNomInvalid; });
740  auto sc_part_passSCNom0_0p325 = Monitored::Collection("SC_part_passSCNom0_0p325", tool, [](const auto& v) { return v.sc_passSCNom0_0p325; });
741  auto sc_part_passSCNom0p325_1 = Monitored::Collection("SC_part_passSCNom0p325_1", tool, [](const auto& v) { return v.sc_passSCNom0p325_1; });
742  auto sc_part_passSCNom1 = Monitored::Collection("SC_part_passSCNom1", tool, [](const auto& v) { return v.sc_passSCNom1; });
743  auto sc_part_passSCNom10 = Monitored::Collection("SC_part_passSCNom10", tool, [](const auto& v) { return v.sc_passSCNom10; });
744  auto sc_part_passSCNom10tauGt3 = Monitored::Collection("SC_part_passSCNom10tauGt3", tool, [](const auto& v) { return v.sc_passSCNom10tauGt3; });
745  auto sc_part_saturNotMasked = Monitored::Collection("SC_part_saturNotMasked", tool, [](const auto& v) { return v.sc_saturNotMasked; });
746  auto sc_part_OFCbOFNotMasked = Monitored::Collection("SC_part_OFCbOFNotMasked", tool, [](const auto& v) { return v.sc_OFCbOFNotMasked; });
747  auto sc_part_notMaskedEoflNe0 = Monitored::Collection("SC_part_notMaskedEoflNe0", tool, [](const auto& v) { return v.sc_notMaskedEoflNe0; });
748  auto sc_part_notMaskedEoflGt1 = Monitored::Collection("SC_part_notMaskedEoflGt1", tool, [](const auto& v) { return v.sc_notMaskedEoflGt1; });
749 
750 
751  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,
752  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,
753  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,
754  sc_part_notMaskedEoflGt1);
755  }
756 
757 
758  } // End if(LArSCContainer is valid)
759 
760 
761 
762  // LATOME event size
763  if ((hLArLATOMEHeaderContainer.isValid())) {
764  auto event_size = Monitored::Scalar<float>("event_size", 0);
765  for (const LArLATOMEHeader* pLArLATOMEHeader : *hLArLATOMEHeaderContainer) {
766  event_size += pLArLATOMEHeader->ROBFragSize() + 48; // 48 is the offset between rod_ndata and ROB fragment size
767  }
768  event_size /= (1024 * 1024 / 4);
769  fill(m_scMonGroupName, lumi_block, event_size);
770  }
771 
772  // end LATOME event size
773 
774  return StatusCode::SUCCESS;
775  }
776 
777 /*---------------------------------------------------------*/
781 {
783  if(side==0) return 0;
784  else return 1;
785  } else if (m_LArOnlineIDHelper->isEMECchannel(id)) {
786  if(side==0) return 2;
787  else return 3;
788  } else if (m_LArOnlineIDHelper->isHECchannel(id)) {
789  if(side==0) return 4;
790  else return 5;
791  } else {
792  if(side==0) return 6;
793  else return 7;
794  }
795 }
796 
797 
798 
799 unsigned LArDigitalTriggMonAlg::getXbinFromSourceID(const unsigned sourceID) const
800 {
801  // int NLatomeBins = 117;
802  int detStartingBin=m_NLatomeBins;
803  const unsigned detID = sourceID >> 16;
804  const unsigned value = sourceID & 0xF;
805  auto mapit=m_LatomeDetBinMappingQ.find(detID);
806  if (mapit!=m_LatomeDetBinMappingQ.end()) {
807  detStartingBin=mapit->second;
808  }
809 
810  unsigned binx = detStartingBin+value;
811  if (binx>m_NLatomeBins){
812  ATH_MSG_WARNING("something wrong with binning, filling overflowbin");
813  binx=m_NLatomeBins;
814  }
815 
816  return binx;
817 }
818 
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:147
SC_MonValues::sc_et_diff
int sc_et_diff
Definition: LArDigitalTriggMonAlg.cxx:143
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:780
SC_MonValues::sc_iphi
int sc_iphi
Definition: LArDigitalTriggMonAlg.cxx:140
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:145
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:128
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:115
athena.value
value
Definition: athena.py:124
LArDigitalTriggMonAlg::m_problemsToMask
Gaudi::Property< std::vector< std::string > > m_problemsToMask
Definition: LArDigitalTriggMonAlg.h:77
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
SC_MonValues::sc_latomesourceidbin
int sc_latomesourceidbin
Definition: LArDigitalTriggMonAlg.cxx:141
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:117
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:151
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:126
LArDigitalTriggMonAlg::MAXLYRNS
@ MAXLYRNS
Definition: LArDigitalTriggMonAlg.h:96
CaloSuperCellDetDescrManager
Definition: CaloDetDescrManager.h:490
Digi_MonValues::digi_passDigiNom
bool digi_passDigiNom
Definition: LArDigitalTriggMonAlg.cxx:130
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:153
SC_MonValues::sc_saturNotMasked
bool sc_saturNotMasked
Definition: LArDigitalTriggMonAlg.cxx:156
Digi_MonValues::digi_eta
float digi_eta
Definition: LArDigitalTriggMonAlg.cxx:114
LArDigitalTriggMonAlg::m_actualMuKey
SG::ReadDecorHandleKey< xAOD::EventInfo > m_actualMuKey
Definition: LArDigitalTriggMonAlg.h:88
SC_MonValues::sc_notMaskedEoflNe0
bool sc_notMaskedEoflNe0
Definition: LArDigitalTriggMonAlg.cxx:158
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:118
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:799
SC_MonValues::sc_passSCNomInvalid
bool sc_passSCNomInvalid
Definition: LArDigitalTriggMonAlg.cxx:150
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:144
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:124
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
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
SC_MonValues::sc_notMaskedEoflGt1
bool sc_notMaskedEoflGt1
Definition: LArDigitalTriggMonAlg.cxx:159
Digi_MonValues::digi_badNotMasked
bool digi_badNotMasked
Definition: LArDigitalTriggMonAlg.cxx:131
Digi_MonValues::digi_partition
int digi_partition
Definition: LArDigitalTriggMonAlg.cxx:123
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:138
Digi_MonValues::digi_diff_adc_ped
float digi_diff_adc_ped
Definition: LArDigitalTriggMonAlg.cxx:125
Digi_MonValues::digi_maxpos
int digi_maxpos
Definition: LArDigitalTriggMonAlg.cxx:122
Digi_MonValues::digi_ieta
int digi_ieta
Definition: LArDigitalTriggMonAlg.cxx:116
HWIdentifier.h
AtlCoolConsole.tool
tool
Definition: AtlCoolConsole.py:452
SC_MonValues::sc_time
float sc_time
Definition: LArDigitalTriggMonAlg.cxx:146
SC_MonValues::sc_lb
unsigned int sc_lb
Definition: LArDigitalTriggMonAlg.cxx:148
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:129
LArOnlineID_Base::isEMBchannel
bool isEMBchannel(const HWIdentifier id) const
Definition: LArOnlineID_Base.cxx:1648
SC_MonValues
Definition: LArDigitalTriggMonAlg.cxx:136
LArRawSC::bcids
const std::vector< unsigned short > & bcids() const
Definition: LArRawSC.h:104
Digi_MonValues::digi_latomesourceidbin
int digi_latomesourceidbin
Definition: LArDigitalTriggMonAlg.cxx:120
SC_MonValues::sc_ieta
int sc_ieta
Definition: LArDigitalTriggMonAlg.cxx:139
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
python.PyAthena.v
v
Definition: PyAthena.py:154
Digi_MonValues::digi_adc_rms
float digi_adc_rms
Definition: LArDigitalTriggMonAlg.cxx:127
LArLATOMEHeader
Holds information from the LATOME Header.
Definition: LArLATOMEHeader.h:19
SC_MonValues::sc_eta
float sc_eta
Definition: LArDigitalTriggMonAlg.cxx:137
runIDAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runIDAlign.py:107
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:142
SC_MonValues::sc_zeroET
bool sc_zeroET
Definition: LArDigitalTriggMonAlg.cxx:149
AthCommonMsg< Gaudi::Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
Digi_MonValues
Definition: LArDigitalTriggMonAlg.cxx:113
SC_MonValues::sc_passSCNom10
bool sc_passSCNom10
Definition: LArDigitalTriggMonAlg.cxx:154
SC_MonValues::sc_passSCNom0p325_1
bool sc_passSCNom0p325_1
Definition: LArDigitalTriggMonAlg.cxx:152
LArDigitalTriggMonAlg::m_rawSCEtRecoContainerKey
SG::ReadHandleKey< LArRawSCContainer > m_rawSCEtRecoContainerKey
Definition: LArDigitalTriggMonAlg.h:71
SC_MonValues::sc_OFCbOFNotMasked
bool sc_OFCbOFNotMasked
Definition: LArDigitalTriggMonAlg.cxx:157
Digi_MonValues::digi_adc
int digi_adc
Definition: LArDigitalTriggMonAlg.cxx:119
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
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
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:155
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
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:163
LArDigitalTriggMonAlg::initialize
virtual StatusCode initialize() override
initialize
Definition: LArDigitalTriggMonAlg.cxx:67
LArDigitalTriggMonAlg::m_scMonGroupName
Gaudi::Property< std::string > m_scMonGroupName
Definition: LArDigitalTriggMonAlg.h:63
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
Digi_MonValues::digi_pedestal
float digi_pedestal
Definition: LArDigitalTriggMonAlg.cxx:121
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