User will overwrite this function. Histogram booking is no longer done in C++. This function is called in execute once the filters are all passed.
166{
167
169
170
176
177
194
195
200
201
203
204
222
239
240
241
252
253
254 auto thisEvent=this->GetEventInfo(ctx);
255
257
260
262 if (!m_digitContainerKey.
empty()) {
264 if (!hLArDigitContainer.
isValid()) {
265 ATH_MSG_WARNING(
"The requested digit container key could not be retrieved. Was there a problem retrieving information from the run logger?");
266 }
267 }
268 else {
269 ATH_MSG_DEBUG(
"hLArDigitContainer.size() " << hLArDigitContainer->size());
270 }
271
272
273 SG::ReadHandle<LArRawSCContainer> hSCetContainer;
276 if (!hSCetContainer.
isValid()) {
277 ATH_MSG_WARNING(
"The requested SC ET container key could not be retrieved. Was there a problem retrieving information from the run logger?");
278 }
279 }
280 else {
281 ATH_MSG_DEBUG(
"hSCetContainer.size() " << hSCetContainer->size());
282 }
283
284 SG::ReadHandle<LArRawSCContainer> hSCetRecoContainer;
287 if (!hSCetRecoContainer.
isValid()) {
288 ATH_MSG_WARNING(
"The requested SC ET reco container key could not be retrieved. Was there a problem retrieving information from the run logger?");
289 }
290 }
291 else {
292 ATH_MSG_DEBUG(
"hSCetRecoContainer.size() " << hSCetRecoContainer->size());
293 }
294
295 SG::ReadHandle<LArLATOMEHeaderContainer> hLArLATOMEHeaderContainer;
298 if (!hLArLATOMEHeaderContainer.
isValid()) {
299 ATH_MSG_WARNING(
"The requested LATOME header container key could not be retrieved. Was there a problem retrieving information from the run logger?");
300 }else{
301 ATH_MSG_DEBUG(
"hLArLATOMEHeaderContainer.size() " << hLArLATOMEHeaderContainer->size());
302 }
303 }
304 else {
306 }
307
309
310 ATH_MSG_WARNING(
"All of the requested containers are empty. Was there a problem retrieving information from the run logger?");
311 return StatusCode::SUCCESS;
312 }
313
314 BCID = thisEvent->bcid();
315 lumi_block = thisEvent->lumiBlock();
316 time_stamp = thisEvent->timeStamp();
317
320
327 const ILArPedestal* pedestals = *pedestalHdl;
328
330 const CaloSuperCellDetDescrManager* ddman = *caloSuperCellMgrHandle;
331
332
334 SG::ReadCondHandle<LArBadChannelCont> bcContHdl{
m_bcContKey, ctx};
335 bcCont = (*bcContHdl);
336
338 std::vector<std::vector<Digi_MonValues>> digiMonValueVec(
m_layerNames.size());
339 for (auto& innerVec : digiMonValueVec) {
340 innerVec.reserve(1600);
341 }
342
343
344 for (const LArDigit* pLArDigit : *hLArDigitContainer) {
345 HWIdentifier id = pLArDigit->hardwareID();
346
347 if (!
cabling->isOnlineConnected(
id))
348 continue;
349
350 const unsigned trueNSamples = pLArDigit->nsamples();
351 if (trueNSamples == 0)
352 continue;
353 Digi_Nsamples = trueNSamples;
354 const int cgain = pLArDigit->gain();
355
356 const Identifier offlineID =
cabling->cnvToIdentifier(
id);
357 const CaloDetDescrElement* caloDetElement = ddman->
get_element(offlineID);
358 if (caloDetElement == 0) {
360 continue;
361 }
362 Digi_eta = caloDetElement->
eta_raw();
363 Digi_phi = caloDetElement->
phi_raw();
364
367
368 const int calosample = caloDetElement->
getSampling();
369
372 const unsigned iLyr = iLyrNS * 2 +
side;
373 auto& lvaluemap_digi = digiMonValueVec[iLyr];
374 auto& lvaluemap_digi_ALL = digiMonValueVec.back();
375
376
378 Digi_partition = ThisPartition;
379
380 fill(m_scMonGroupName, Digi_Nsamples);
381
382
383 notMasked = true;
385 notMasked = false;
386 }
387
388 if (pedestals) {
389 Pedestal = pedestals->
pedestal(
id, cgain);
391 } else
393
394 const LArSCDigit* scdigi = dynamic_cast<const LArSCDigit*>(pLArDigit);
395 if (!scdigi) {
397 } else {
398 Digi_SCChannel = scdigi->
Channel();
399 Digi_latomeSourceId = scdigi->
SourceId();
401 }
402
403 const std::vector<short>* digito = &pLArDigit->samples();
404
405
406 std::vector<short>::const_iterator maxSam = std::max_element(digito->begin(), digito->end());
407 int thismaxPos = std::distance(digito->begin(), maxSam);
408 Digi_maxpos = thismaxPos + 1;
409 float ADC_max = pLArDigit->samples().at(Digi_maxpos - 1);
410
411 float ADC_0 = pLArDigit->samples().at(0);
412 if (m_isADCBaseline) {
413 ADC_0 = ADC_0 / 8;
414 }
415
416 float samp_sum = std::accumulate(digito->begin(), digito->end(), 0.0);
417 float samp_mean = samp_sum / static_cast<float>(trueNSamples);
418 float sq_sum = std::inner_product(digito->begin(), digito->end(), digito->begin(), 0.0);
419 float rms_arg = sq_sum / static_cast<float>(trueNSamples) - samp_mean * samp_mean;
420
421 if (rms_arg < 0)
422 Digi_ADC_RMS = -1;
423 else
424 Digi_ADC_RMS = std::sqrt(rms_arg);
425
426
427
428 Digi_Diff_ADC0_Ped = ADC_0 - Pedestal;
429 for (
unsigned i = 0;
i < trueNSamples; ++
i) {
430 badNotMasked = false;
431 notBadQual = false;
432 ADCped10RMS = false;
433 passDigiNom = false;
435 Digi_ADC = pLArDigit->samples().at(i);
436 if (m_isADCBaseline) {
437 Digi_ADC = Digi_ADC / 8;
438 }
439
440 Digi_Diff_ADC_Ped = Digi_ADC - Pedestal;
441 if (ADC_max != Pedestal) {
442 Digi_Diff_ADC_Ped_Norm = (Digi_ADC - Pedestal) / std::abs(ADC_max - Pedestal);
443 }
444
445
446 if (Digi_ADC != -1) {
447 notBadQual = true;
448 } else {
449 if (notMasked) {
450 badNotMasked = true;
451 }
452 }
453 if (ADC_max - Pedestal > 10 * PedestalRMS) {
454 ADCped10RMS = true;
455 }
456 if (notMasked && notBadQual && ADCped10RMS) {
457 passDigiNom = true;
458 }
459
460 lvaluemap_digi.emplace_back(Digi_eta, Digi_phi, Digi_ieta, Digi_iphi, Digi_sampos, Digi_ADC, Digi_latomeSourceIdBIN, Pedestal, Digi_maxpos,
461 Digi_partition, Digi_Diff_ADC_Ped_Norm, Digi_Diff_ADC_Ped, Digi_Diff_ADC0_Ped, Digi_ADC_RMS, BCID, lumi_block, passDigiNom,
462 badNotMasked);
463 lvaluemap_digi_ALL.emplace_back(Digi_eta, Digi_phi, Digi_ieta, Digi_iphi, Digi_sampos, Digi_ADC, Digi_latomeSourceIdBIN, Pedestal, Digi_maxpos,
464 Digi_partition, Digi_Diff_ADC_Ped_Norm, Digi_Diff_ADC_Ped, Digi_Diff_ADC0_Ped, Digi_ADC_RMS, BCID, lumi_block, passDigiNom,
465 badNotMasked);
466
467 }
468
469 }
470
471
472 for (size_t ilayer = 0; ilayer < digiMonValueVec.size(); ++ilayer) {
473 const auto&
tool = digiMonValueVec[ilayer];
474 auto digi_part_eta =
Monitored::Collection(
"Digi_part_eta", tool, [](
const auto& v) {
return v.digi_eta; });
475 auto digi_part_phi =
Monitored::Collection(
"Digi_part_phi", tool, [](
const auto& v) {
return v.digi_phi; });
476 auto digi_part_ieta =
Monitored::Collection(
"Digi_part_ieta", tool, [](
const auto& v) {
return v.digi_ieta; });
477 auto digi_part_iphi =
Monitored::Collection(
"Digi_part_iphi", tool, [](
const auto& v) {
return v.digi_iphi; });
478 auto digi_part_sampos =
Monitored::Collection(
"Digi_part_sampos", tool, [](
const auto& v) {
return v.digi_sampos; });
479 auto digi_part_adc =
Monitored::Collection(
"Digi_part_adc", tool, [](
const auto& v) {
return v.digi_adc; });
480 auto digi_part_latomesourceidbin =
Monitored::Collection(
"Digi_part_latomesourceidbin", tool, [](
const auto& v) {
return v.digi_latomesourceidbin; });
481 auto digi_part_pedestal =
Monitored::Collection(
"Digi_part_pedestal", tool, [](
const auto& v) {
return v.digi_pedestal; });
482 auto digi_part_maxpos =
Monitored::Collection(
"Digi_part_maxpos", tool, [](
const auto& v) {
return v.digi_maxpos; });
483 auto digi_part_partition =
Monitored::Collection(
"Digi_part_partition", tool, [](
const auto& v) {
return v.digi_partition; });
484 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; });
485 auto digi_part_diff_adc_ped =
Monitored::Collection(
"Digi_part_diff_adc_ped", tool, [](
const auto& v) {
return v.digi_diff_adc_ped; });
486 auto digi_part_diff_adc0_ped =
Monitored::Collection(
"Digi_part_diff_adc0_ped", tool, [](
const auto& v) {
return v.digi_diff_adc0_ped; });
487 auto digi_part_bcid =
Monitored::Collection(
"Digi_part_BCID", tool, [](
const auto& v) {
return v.digi_bcid; });
489 auto digi_part_passDigiNom =
Monitored::Collection(
"Digi_part_passDigiNom", tool, [](
const auto& v) {
return v.digi_passDigiNom; });
490 auto digi_part_badNotMasked =
Monitored::Collection(
"Digi_part_badNotMasked", tool, [](
const auto& v) {
return v.digi_badNotMasked; });
491 auto digi_part_adc_rms =
Monitored::Collection(
"Digi_part_adc_rms", tool, [](
const auto& v) {
return v.digi_adc_rms; });
492
493 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,
494 digi_part_adc, digi_part_latomesourceidbin, digi_part_pedestal, digi_part_maxpos, digi_part_diff_adc_ped_norm, digi_part_diff_adc_ped,
495 digi_part_diff_adc0_ped, digi_part_adc_rms, digi_part_bcid, digi_part_lb, digi_part_passDigiNom, digi_part_badNotMasked);
496 }
497
498 }
499
500
505 const LArRawSC* rawSC = 0;
506 const LArRawSC* rawSCReco = 0;
507
508 std::vector<std::vector<SC_MonValues>> scMonValueVec(
m_layerNames.size());
509 for (auto& innerVec : scMonValueVec) {
510 innerVec.reserve(1600);
511 }
512
513
514 for (; itSC != itSC_e; ++itSC, ++itSCReco) {
515 rawSC = *itSC;
516 if (itSCReco < hSCetRecoContainer->
end()) {
517 rawSCReco = *itSCReco;
518 } else {
519
520
521 rawSCReco = 0;
522 }
523 SC_SCChannel = rawSC->
chan();
525
526 if (!
cabling->isOnlineConnected(
id))
527 continue;
528
529 const Identifier offlineID =
cabling->cnvToIdentifier(
id);
530
531 const CaloDetDescrElement* caloDetElement = ddman->
get_element(offlineID);
532 if (caloDetElement == 0) {
533 ATH_MSG_ERROR(
"Cannot retrieve (eta,phi) coordinates for raw channels");
535 <<
"; rawSC->SourceId() = " << rawSC->
SourceId());
536 continue;
537 }
538 SC_eta = caloDetElement->
eta_raw();
539 SC_phi = caloDetElement->
phi_raw();
540
544
547 const unsigned iLyr = iLyrNS * 2 +
side;
548
549 auto& lvaluemap_sc = scMonValueVec[iLyr];
550 auto& lvaluemap_sc_ALL = scMonValueVec.back();
551
553
556
557
558 notMasked = false;
559 passTauSel = false;
560 nonZeroET = false;
561 zeroET = false;
562 notSatur = false;
563 nonZeroEtau = false;
564 eTgt0p325GeV = false;
565 eTgt0lt0p325GeV = false;
566 eTgt1GeV = false;
567 eTlt1GeV = false;
568 eTgt10GeV = false;
569 eTlt10GeV = false;
570 notOFCbOF = false;
571 tauGt3 = false;
572 onlofflEmismatch = false;
573 passSCNom0_0p325 = false;
574 passSCNom0p325_1 = false;
575 passSCNom1 = false;
576 passSCNom10 = false;
577 passSCNom10tauGt3 = false;
578 saturNotMasked = false;
579 OFCbOFNotMasked = false;
580 notMaskedEoflNe0 = false;
581 notMaskedEoflGt1 = false;
582 nonZeroETofl = false;
583 eToflGt1GeV = false;
584 passSCNomInvalid = false;
585 SC_ltdbsourceid = -1;
586
588 notMasked = true;
589 }
590
593 passTauSel = true;
594 }
595 unsigned int bcid_ind = 0;
597 for (
auto& SCe : rawSC->
bcids()) {
598 if (SCe == BCID)
599 break;
600 bcid_ind++;
601 }
602 if (bcid_ind >= rawSC->
bcids().size()) {
603 ATH_MSG_WARNING(
"BCID not found in SC bcids list!! " << BCID <<
" BCIDs size: " << rawSC->
bcids().size() <<
", proposed index: " << bcid_ind);
604 }
else if (rawSC->
bcids().at(bcid_ind) != BCID) {
605 ATH_MSG_WARNING(
"BCID not found in SC bcids list!! " << BCID <<
" " << rawSC->
bcids().at(bcid_ind));
606 }
607
608 if (rawSC->
energies().size() > bcid_ind) {
609 SC_energy_onl = rawSC->
energies().at(bcid_ind);
610 } else {
611 ATH_MSG_WARNING(
"rawSC energies vector is too small for the requested BCID index " << bcid_ind <<
" (size is " << rawSC->
energies().size()
612 <<
", bcid vec size is " << rawSC->
bcids().size() <<
")");
613 SC_energy_onl = 0;
614 }
615 } else {
617 SC_energy_onl = 0;
618 }
619
620 if (rawSCReco != 0) {
621 if (rawSCReco->
energies().size() > 0) {
622 SC_energy_ofl = rawSCReco->
energies().at(0);
623 } else {
625 SC_energy_ofl = 0;
626 }
627 }
628 SC_ET_diff = SC_energy_onl - SC_energy_ofl;
629 SC_ET_onl = (SC_energy_onl * 12.5) / 1000;
630 SC_ET_ofl = (SC_energy_ofl * 12.5) / 1000;
631 SC_ET_onl_muscaled = event_mu > 0. ? SC_ET_onl / event_mu : SC_ET_onl;
632 int Etau = 0;
633 if (rawSCReco != 0) {
636 }
637 }
638 SC_time = (SC_energy_ofl != 0) ? (
float)Etau / (
float)SC_energy_ofl : Etau;
639
640 ATH_MSG_DEBUG(
"Energy onl - Energy ofl: " << SC_energy_onl <<
", " << SC_energy_ofl << std::endl);
641 if (SC_ET_onl != 0) {
642 nonZeroET = true;
643 } else {
644 zeroET = true;
645 }
646 if (SC_ET_onl > 0.325) {
647 eTgt0p325GeV = true;
648 } else if (SC_ET_onl < 0.325 && SC_ET_onl > 0.) {
649 eTgt0lt0p325GeV = true;
650 }
651 if (SC_ET_onl > 1) {
652 eTgt1GeV = true;
653 }
654 if (SC_ET_onl < 1) {
655 eTlt1GeV = true;
656 }
657 if (SC_ET_onl > 10) {
658 eTgt10GeV = true;
659 }
660 if (SC_ET_onl < 10) {
661 eTlt10GeV = true;
662 }
663 if (SC_ET_ofl != 0) {
664 nonZeroETofl = true;
665 }
666 if (SC_ET_ofl > 1) {
667 eToflGt1GeV = true;
668 }
669 if (rawSC->
satur().size() > bcid_ind) {
670 if (rawSC->
satur().at(bcid_ind)) {
671 if (notMasked) {
672 saturNotMasked = true;
673 }
674 } else {
675 notSatur = true;
676 }
677 }
678 if (Etau != 0) {
679 nonZeroEtau = true;
680 }
681 if (rawSCReco != 0 && rawSCReco->
ofcbOverflow() ==
false) {
682 notOFCbOF = true;
683 } else {
684 if (notMasked) {
685 OFCbOFNotMasked = true;
686 }
687 }
688 if (std::abs(SC_time) > 3) {
689 tauGt3 = true;
690 }
691
692 if (notMasked && notSatur && notOFCbOF) {
693 if (nonZeroETofl) {
694 notMaskedEoflNe0 = true;
695 }
696 if (eToflGt1GeV) {
697 notMaskedEoflGt1 = true;
698 }
699 if (SC_energy_onl == -99999) {
700 passSCNomInvalid = true;
701 SC_ltdbsourceid = ltdbHash;
702 }
703
704
705
706 if (eTgt0lt0p325GeV) {
707 passSCNom0_0p325 = true;
708 }
709 if (eTgt0p325GeV && eTlt1GeV) {
710 passSCNom0p325_1 = true;
711 }
712 if (eTgt1GeV) {
713 passSCNom1 = true;
714 }
715 if (eTgt10GeV) {
716 passSCNom10 = true;
717 if (tauGt3) {
718 passSCNom10tauGt3 = true;
719 }
720 }
721 if (SC_energy_onl != SC_energy_ofl) {
722 onlofflEmismatch = true;
723 }
724
725 }
726
727 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,
728 lumi_block, SC_ltdbsourceid, zeroET, passSCNomInvalid, passSCNom0_0p325, passSCNom0p325_1, passSCNom1, passSCNom10, passSCNom10tauGt3, saturNotMasked, OFCbOFNotMasked, notMaskedEoflNe0,
729 notMaskedEoflGt1);
730 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,
731 BCID, lumi_block, SC_ltdbsourceid, zeroET, passSCNomInvalid, passSCNom0_0p325, passSCNom0p325_1, passSCNom1, passSCNom10, passSCNom10tauGt3, saturNotMasked, OFCbOFNotMasked,
732 notMaskedEoflNe0, notMaskedEoflGt1);
733
734 }
735
736
737 for (size_t ilayer = 0; ilayer < scMonValueVec.size(); ++ilayer) {
738 const auto&
tool = scMonValueVec[ilayer];
743 auto sc_part_latomesourceidbin =
Monitored::Collection(
"SC_part_latomesourceidbin", tool, [](
const auto& v) {
return v.sc_latomesourceidbin; });
744 auto sc_part_et_ofl =
Monitored::Collection(
"SC_part_et_ofl", tool, [](
const auto& v) {
return v.sc_et_ofl; });
745 auto sc_part_et_diff =
Monitored::Collection(
"SC_part_et_diff", tool, [](
const auto& v) {
return v.sc_et_diff; });
746 auto sc_part_et_onl =
Monitored::Collection(
"SC_part_et_onl", tool, [](
const auto& v) {
return v.sc_et_onl; });
747 auto sc_part_et_onl_muscaled =
Monitored::Collection(
"SC_part_et_onl_muscaled", tool, [](
const auto& v) {
return v.sc_et_onl_muscaled; });
751 auto sc_part_ltdbsourceid =
Monitored::Collection(
"SC_part_ltdbsourceid", tool, [](
const auto& v) {
return v.sc_ltdbsourceid; });
752
753 auto sc_zeroET =
Monitored::Collection(
"SC_part_zeroET", tool, [](
const auto& v) {
return v.sc_zeroET; });
754 auto sc_part_passSCNomInvalid =
Monitored::Collection(
"SC_part_passSCNomInvalid", tool, [](
const auto& v) {
return v.sc_passSCNomInvalid; });
755 auto sc_part_passSCNom0_0p325 =
Monitored::Collection(
"SC_part_passSCNom0_0p325", tool, [](
const auto& v) {
return v.sc_passSCNom0_0p325; });
756 auto sc_part_passSCNom0p325_1 =
Monitored::Collection(
"SC_part_passSCNom0p325_1", tool, [](
const auto& v) {
return v.sc_passSCNom0p325_1; });
757 auto sc_part_passSCNom1 =
Monitored::Collection(
"SC_part_passSCNom1", tool, [](
const auto& v) {
return v.sc_passSCNom1; });
758 auto sc_part_passSCNom10 =
Monitored::Collection(
"SC_part_passSCNom10", tool, [](
const auto& v) {
return v.sc_passSCNom10; });
759 auto sc_part_passSCNom10tauGt3 =
Monitored::Collection(
"SC_part_passSCNom10tauGt3", tool, [](
const auto& v) {
return v.sc_passSCNom10tauGt3; });
760 auto sc_part_saturNotMasked =
Monitored::Collection(
"SC_part_saturNotMasked", tool, [](
const auto& v) {
return v.sc_saturNotMasked; });
761 auto sc_part_OFCbOFNotMasked =
Monitored::Collection(
"SC_part_OFCbOFNotMasked", tool, [](
const auto& v) {
return v.sc_OFCbOFNotMasked; });
762 auto sc_part_notMaskedEoflNe0 =
Monitored::Collection(
"SC_part_notMaskedEoflNe0", tool, [](
const auto& v) {
return v.sc_notMaskedEoflNe0; });
763 auto sc_part_notMaskedEoflGt1 =
Monitored::Collection(
"SC_part_notMaskedEoflGt1", tool, [](
const auto& v) {
return v.sc_notMaskedEoflGt1; });
764
765
766 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,
767 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_part_ltdbsourceid, sc_zeroET, sc_part_passSCNomInvalid,
768 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,
769 sc_part_notMaskedEoflGt1);
770 }
771
772
773 }
774
775
776
777
779 auto event_size = Monitored::Scalar<float>("event_size", 0);
780 for (const LArLATOMEHeader* pLArLATOMEHeader : *hLArLATOMEHeaderContainer) {
781 event_size += pLArLATOMEHeader->ROBFragSize() + 48;
782 }
783 event_size /= (1024 * 1024 / 4);
784 fill(m_scMonGroupName, lumi_block, event_size);
785 }
786
787
788
789 return StatusCode::SUCCESS;
790 }
LArBadXCont< LArBadChannel > LArBadChannelCont
int phi(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
int eta(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
float eta_raw() const
cell eta_raw
CaloCell_ID::CaloSample getSampling() const
cell sampling
float phi_raw() const
cell phi_raw
const CaloDetDescrElement * get_element(const Identifier &cellId) const
get element by its identifier
DataModel_detail::const_iterator< DataVector > const_iterator
virtual float pedestal(const HWIdentifier &id, int gain) const =0
virtual float pedestalRMS(const HWIdentifier &id, int gain) const =0
access to RMS of Pedestal index by Identifier, and gain setting
bool cellShouldBeMasked(const LArBadChannelCont *bcCont, const HWIdentifier &hardwareId) const
const CaloCell_SuperCell_ID * m_SCID_helper
std::map< std::string, int > m_toolmapLayerNames_sc
SG::ReadCondHandleKey< ILArPedestal > m_keyPedestalSC
Handle to pedestal.
SG::ReadHandleKey< LArRawSCContainer > m_rawSCContainerKey
int whatPartition(HWIdentifier id, int side) const
private methods:
SG::ReadHandleKey< LArLATOMEHeaderContainer > m_LATOMEHeaderContainerKey
unsigned getXbinFromSourceID(const unsigned sourceID) const
StringArrayProperty m_layerNames
SG::ReadHandleKey< LArRawSCContainer > m_rawSCEtRecoContainerKey
const LArOnline_SuperCellID * m_LArOnlineIDHelper
const std::array< unsigned, CaloSampling::Unknown > m_caloSamplingToLyrNS
SG::ReadCondHandleKey< CaloSuperCellDetDescrManager > m_caloSuperCellMgrKey
Handle to Super Cell DD Manager.
LArBadChannelMask m_bcMask
Handle to bad-channel mask.
std::map< std::string, int > m_toolmapLayerNames_digi
SG::ReadCondHandleKey< LArBadChannelCont > m_bcContKey
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...
std::string channel_name(const HWIdentifier id) const
Return a string corresponding to a feedthrough name given an identifier.
IdentifierHash feb_Hash(HWIdentifier febId) const
Create feb hash identifiers from feb identifiers.
HWIdentifier feb_Id(int barrel_ec, int pos_neg, int feedthrough, int slot) const
Create feb_Id from fields.
unsigned int SourceId() const
const std::vector< bool > & satur() const
const std::vector< bool > & passTauSelection() const
const std::vector< unsigned short > & bcids() const
bool ofcbOverflow() const
const std::vector< int > & tauEnergies() const
const std::vector< int > & energies() const
const HWIdentifier & hardwareID() const
unsigned int SourceId() const
Declare a monitored scalar variable.
virtual bool isValid() override final
Can the handle be successfully dereferenced?
bool empty() const
Test if the key is blank.
virtual float lbInteractionsPerCrossing(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Calculate instantaneous number of interactions, i.e.
virtual float lbLuminosityPerBCID(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Calculate the instantaneous luminosity per bunch crossing.
std::vector< unsigned > trigStreamMatching(const std::vector< std::string > &streamsFromJobO, const std::vector< xAOD::EventInfo::StreamTag > &streamInEvent)
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
void fill(H5::Group &out_file, size_t iterations)
1.14.0