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.
165{
166
168
169
175
176
193
194
199
200
202
203
220
237
238
239
250
251
252 auto thisEvent=this->GetEventInfo(ctx);
253
255
258
260 if (!m_digitContainerKey.
empty()) {
262 if (!hLArDigitContainer.
isValid()) {
263 ATH_MSG_WARNING(
"The requested digit container key could not be retrieved. Was there a problem retrieving information from the run logger?");
264 }
265 }
266 else {
267 ATH_MSG_DEBUG(
"hLArDigitContainer.size() " << hLArDigitContainer->size());
268 }
269
270
271 SG::ReadHandle<LArRawSCContainer> hSCetContainer;
274 if (!hSCetContainer.
isValid()) {
275 ATH_MSG_WARNING(
"The requested SC ET container key could not be retrieved. Was there a problem retrieving information from the run logger?");
276 }
277 }
278 else {
279 ATH_MSG_DEBUG(
"hSCetContainer.size() " << hSCetContainer->size());
280 }
281
282 SG::ReadHandle<LArRawSCContainer> hSCetRecoContainer;
285 if (!hSCetRecoContainer.
isValid()) {
286 ATH_MSG_WARNING(
"The requested SC ET reco container key could not be retrieved. Was there a problem retrieving information from the run logger?");
287 }
288 }
289 else {
290 ATH_MSG_DEBUG(
"hSCetRecoContainer.size() " << hSCetRecoContainer->size());
291 }
292
294 if (!hLArLATOMEHeaderContainer.
isValid()) {
295 ATH_MSG_WARNING(
"The requested LATOME header container key could not be retrieved. Was there a problem retrieving information from the run logger?");
296 }else{
297 ATH_MSG_DEBUG(
"hLArLATOMEHeaderContainer.size() " << hLArLATOMEHeaderContainer->size());
298 }
299
301
302 ATH_MSG_WARNING(
"All of the requested containers are empty. Was there a problem retrieving information from the run logger?");
303 return StatusCode::SUCCESS;
304 }
305
306 BCID = thisEvent->bcid();
307 lumi_block = thisEvent->lumiBlock();
308 time_stamp = thisEvent->timeStamp();
309
312
319 const ILArPedestal* pedestals = *pedestalHdl;
320
322 const CaloSuperCellDetDescrManager* ddman = *caloSuperCellMgrHandle;
323
324
326 SG::ReadCondHandle<LArBadChannelCont> bcContHdl{
m_bcContKey, ctx};
327 bcCont = (*bcContHdl);
328
329 if ((hLArDigitContainer.
isValid())) {
330 std::vector<std::vector<Digi_MonValues>> digiMonValueVec(
m_layerNames.size());
331 for (auto& innerVec : digiMonValueVec) {
332 innerVec.reserve(1600);
333 }
334
335
336 for (const LArDigit* pLArDigit : *hLArDigitContainer) {
337 HWIdentifier id = pLArDigit->hardwareID();
338
339 if (!
cabling->isOnlineConnected(
id))
340 continue;
341
342 const unsigned trueNSamples = pLArDigit->nsamples();
343 if (trueNSamples == 0)
344 continue;
345 Digi_Nsamples = trueNSamples;
346 const int cgain = pLArDigit->gain();
347
348 const Identifier offlineID =
cabling->cnvToIdentifier(
id);
349 const CaloDetDescrElement* caloDetElement = ddman->
get_element(offlineID);
350 if (caloDetElement == 0) {
352 continue;
353 }
354 Digi_eta = caloDetElement->
eta_raw();
355 Digi_phi = caloDetElement->
phi_raw();
356
359
360 const int calosample = caloDetElement->
getSampling();
361
364 const unsigned iLyr = iLyrNS * 2 +
side;
365 auto& lvaluemap_digi = digiMonValueVec[iLyr];
366 auto& lvaluemap_digi_ALL = digiMonValueVec.back();
367
368
370 Digi_partition = ThisPartition;
371
372 fill(m_scMonGroupName, Digi_Nsamples);
373
374
375 notMasked = true;
377 notMasked = false;
378 }
379
380 if (pedestals) {
381 Pedestal = pedestals->
pedestal(
id, cgain);
383 } else
385
386 const LArSCDigit* scdigi = dynamic_cast<const LArSCDigit*>(pLArDigit);
387 if (!scdigi) {
389 } else {
390 Digi_SCChannel = scdigi->
Channel();
391 Digi_latomeSourceId = scdigi->
SourceId();
393 }
394
395 const std::vector<short>* digito = &pLArDigit->samples();
396
397
398 std::vector<short>::const_iterator maxSam = std::max_element(digito->begin(), digito->end());
399 int thismaxPos = std::distance(digito->begin(), maxSam);
400 Digi_maxpos = thismaxPos + 1;
401 float ADC_max = pLArDigit->samples().at(Digi_maxpos - 1);
402
403 float ADC_0 = pLArDigit->samples().at(0);
404 if (m_isADCBaseline) {
405 ADC_0 = ADC_0 / 8;
406 }
407
408 float samp_sum = std::accumulate(digito->begin(), digito->end(), 0.0);
409 float samp_mean = samp_sum / static_cast<float>(trueNSamples);
410 float sq_sum = std::inner_product(digito->begin(), digito->end(), digito->begin(), 0.0);
411 float rms_arg = sq_sum / static_cast<float>(trueNSamples) - samp_mean * samp_mean;
412
413 if (rms_arg < 0)
414 Digi_ADC_RMS = -1;
415 else
416 Digi_ADC_RMS = std::sqrt(rms_arg);
417
418
419
420 Digi_Diff_ADC0_Ped = ADC_0 - Pedestal;
421 for (
unsigned i = 0;
i < trueNSamples; ++
i) {
422 badNotMasked = false;
423 notBadQual = false;
424 ADCped10RMS = false;
425 passDigiNom = false;
427 Digi_ADC = pLArDigit->samples().at(i);
428 if (m_isADCBaseline) {
429 Digi_ADC = Digi_ADC / 8;
430 }
431
432 Digi_Diff_ADC_Ped = Digi_ADC - Pedestal;
433 if (ADC_max != Pedestal) {
434 Digi_Diff_ADC_Ped_Norm = (Digi_ADC - Pedestal) / std::abs(ADC_max - Pedestal);
435 }
436
437
438 if (Digi_ADC != -1) {
439 notBadQual = true;
440 } else {
441 if (notMasked) {
442 badNotMasked = true;
443 }
444 }
445 if (ADC_max - Pedestal > 10 * PedestalRMS) {
446 ADCped10RMS = true;
447 }
448 if (notMasked && notBadQual && ADCped10RMS) {
449 passDigiNom = true;
450 }
451
452 lvaluemap_digi.emplace_back(Digi_eta, Digi_phi, Digi_ieta, Digi_iphi, Digi_sampos, Digi_ADC, Digi_latomeSourceIdBIN, Pedestal, Digi_maxpos,
453 Digi_partition, Digi_Diff_ADC_Ped_Norm, Digi_Diff_ADC_Ped, Digi_Diff_ADC0_Ped, Digi_ADC_RMS, BCID, lumi_block, passDigiNom,
454 badNotMasked);
455 lvaluemap_digi_ALL.emplace_back(Digi_eta, Digi_phi, Digi_ieta, Digi_iphi, Digi_sampos, Digi_ADC, Digi_latomeSourceIdBIN, Pedestal, Digi_maxpos,
456 Digi_partition, Digi_Diff_ADC_Ped_Norm, Digi_Diff_ADC_Ped, Digi_Diff_ADC0_Ped, Digi_ADC_RMS, BCID, lumi_block, passDigiNom,
457 badNotMasked);
458
459 }
460
461 }
462
463
464 for (size_t ilayer = 0; ilayer < digiMonValueVec.size(); ++ilayer) {
465 const auto&
tool = digiMonValueVec[ilayer];
466 auto digi_part_eta =
Monitored::Collection(
"Digi_part_eta", tool, [](
const auto& v) {
return v.digi_eta; });
467 auto digi_part_phi =
Monitored::Collection(
"Digi_part_phi", tool, [](
const auto& v) {
return v.digi_phi; });
468 auto digi_part_ieta =
Monitored::Collection(
"Digi_part_ieta", tool, [](
const auto& v) {
return v.digi_ieta; });
469 auto digi_part_iphi =
Monitored::Collection(
"Digi_part_iphi", tool, [](
const auto& v) {
return v.digi_iphi; });
470 auto digi_part_sampos =
Monitored::Collection(
"Digi_part_sampos", tool, [](
const auto& v) {
return v.digi_sampos; });
471 auto digi_part_adc =
Monitored::Collection(
"Digi_part_adc", tool, [](
const auto& v) {
return v.digi_adc; });
472 auto digi_part_latomesourceidbin =
Monitored::Collection(
"Digi_part_latomesourceidbin", tool, [](
const auto& v) {
return v.digi_latomesourceidbin; });
473 auto digi_part_pedestal =
Monitored::Collection(
"Digi_part_pedestal", tool, [](
const auto& v) {
return v.digi_pedestal; });
474 auto digi_part_maxpos =
Monitored::Collection(
"Digi_part_maxpos", tool, [](
const auto& v) {
return v.digi_maxpos; });
475 auto digi_part_partition =
Monitored::Collection(
"Digi_part_partition", tool, [](
const auto& v) {
return v.digi_partition; });
476 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; });
477 auto digi_part_diff_adc_ped =
Monitored::Collection(
"Digi_part_diff_adc_ped", tool, [](
const auto& v) {
return v.digi_diff_adc_ped; });
478 auto digi_part_diff_adc0_ped =
Monitored::Collection(
"Digi_part_diff_adc0_ped", tool, [](
const auto& v) {
return v.digi_diff_adc0_ped; });
479 auto digi_part_bcid =
Monitored::Collection(
"Digi_part_BCID", tool, [](
const auto& v) {
return v.digi_bcid; });
481 auto digi_part_passDigiNom =
Monitored::Collection(
"Digi_part_passDigiNom", tool, [](
const auto& v) {
return v.digi_passDigiNom; });
482 auto digi_part_badNotMasked =
Monitored::Collection(
"Digi_part_badNotMasked", tool, [](
const auto& v) {
return v.digi_badNotMasked; });
483 auto digi_part_adc_rms =
Monitored::Collection(
"Digi_part_adc_rms", tool, [](
const auto& v) {
return v.digi_adc_rms; });
484
485 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,
486 digi_part_adc, digi_part_latomesourceidbin, digi_part_pedestal, digi_part_maxpos, digi_part_diff_adc_ped_norm, digi_part_diff_adc_ped,
487 digi_part_diff_adc0_ped, digi_part_adc_rms, digi_part_bcid, digi_part_lb, digi_part_passDigiNom, digi_part_badNotMasked);
488 }
489
490 }
491
492
497 const LArRawSC* rawSC = 0;
498 const LArRawSC* rawSCReco = 0;
499
500 std::vector<std::vector<SC_MonValues>> scMonValueVec(
m_layerNames.size());
501 for (auto& innerVec : scMonValueVec) {
502 innerVec.reserve(1600);
503 }
504
505
506 for (; itSC != itSC_e; ++itSC, ++itSCReco) {
507 rawSC = *itSC;
508 if (itSCReco < hSCetRecoContainer->
end()) {
509 rawSCReco = *itSCReco;
510 } else {
511
512
513 rawSCReco = 0;
514 }
515 SC_SCChannel = rawSC->
chan();
517
518 if (!
cabling->isOnlineConnected(
id))
519 continue;
520
521 const Identifier offlineID =
cabling->cnvToIdentifier(
id);
522
523 const CaloDetDescrElement* caloDetElement = ddman->
get_element(offlineID);
524 if (caloDetElement == 0) {
525 ATH_MSG_ERROR(
"Cannot retrieve (eta,phi) coordinates for raw channels");
527 <<
"; rawSC->SourceId() = " << rawSC->
SourceId());
528 continue;
529 }
530 SC_eta = caloDetElement->
eta_raw();
531 SC_phi = caloDetElement->
phi_raw();
532
536
539 const unsigned iLyr = iLyrNS * 2 +
side;
540
541 auto& lvaluemap_sc = scMonValueVec[iLyr];
542 auto& lvaluemap_sc_ALL = scMonValueVec.back();
543
545
546
547 notMasked = false;
548 passTauSel = false;
549 nonZeroET = false;
550 zeroET = false;
551 notSatur = false;
552 nonZeroEtau = false;
553 eTgt0p325GeV = false;
554 eTgt0lt0p325GeV = false;
555 eTgt1GeV = false;
556 eTlt1GeV = false;
557 eTgt10GeV = false;
558 eTlt10GeV = false;
559 notOFCbOF = false;
560 tauGt3 = false;
561 onlofflEmismatch = false;
562 passSCNom0_0p325 = false;
563 passSCNom0p325_1 = false;
564 passSCNom1 = false;
565 passSCNom10 = false;
566 passSCNom10tauGt3 = false;
567 saturNotMasked = false;
568 OFCbOFNotMasked = false;
569 notMaskedEoflNe0 = false;
570 notMaskedEoflGt1 = false;
571 nonZeroETofl = false;
572 eToflGt1GeV = false;
573 passSCNomInvalid = false;
574
576 notMasked = true;
577 }
578
581 passTauSel = true;
582 }
583 unsigned int bcid_ind = 0;
585 for (
auto& SCe : rawSC->
bcids()) {
586 if (SCe == BCID)
587 break;
588 bcid_ind++;
589 }
590 if (bcid_ind >= rawSC->
bcids().size()) {
591 ATH_MSG_WARNING(
"BCID not found in SC bcids list!! " << BCID <<
" BCIDs size: " << rawSC->
bcids().size() <<
", proposed index: " << bcid_ind);
592 }
else if (rawSC->
bcids().at(bcid_ind) != BCID) {
593 ATH_MSG_WARNING(
"BCID not found in SC bcids list!! " << BCID <<
" " << rawSC->
bcids().at(bcid_ind));
594 }
595
596 if (rawSC->
energies().size() > bcid_ind) {
597 SC_energy_onl = rawSC->
energies().at(bcid_ind);
598 } else {
599 ATH_MSG_WARNING(
"rawSC energies vector is too small for the requested BCID index " << bcid_ind <<
" (size is " << rawSC->
energies().size()
600 <<
", bcid vec size is " << rawSC->
bcids().size() <<
")");
601 SC_energy_onl = 0;
602 }
603 } else {
605 SC_energy_onl = 0;
606 }
607
608 if (rawSCReco != 0) {
609 if (rawSCReco->
energies().size() > 0) {
610 SC_energy_ofl = rawSCReco->
energies().at(0);
611 } else {
613 SC_energy_ofl = 0;
614 }
615 }
616 SC_ET_diff = SC_energy_onl - SC_energy_ofl;
617 SC_ET_onl = (SC_energy_onl * 12.5) / 1000;
618 SC_ET_ofl = (SC_energy_ofl * 12.5) / 1000;
619 SC_ET_onl_muscaled = event_mu > 0. ? SC_ET_onl / event_mu : SC_ET_onl;
620 int Etau = 0;
621 if (rawSCReco != 0) {
624 }
625 }
626 SC_time = (SC_energy_ofl != 0) ? (
float)Etau / (
float)SC_energy_ofl : Etau;
627
628 ATH_MSG_DEBUG(
"Energy onl - Energy ofl: " << SC_energy_onl <<
", " << SC_energy_ofl << std::endl);
629 if (SC_ET_onl != 0) {
630 nonZeroET = true;
631 } else {
632 zeroET = true;
633 }
634 if (SC_ET_onl > 0.325) {
635 eTgt0p325GeV = true;
636 } else if (SC_ET_onl < 0.325 && SC_ET_onl > 0.) {
637 eTgt0lt0p325GeV = true;
638 }
639 if (SC_ET_onl > 1) {
640 eTgt1GeV = true;
641 }
642 if (SC_ET_onl < 1) {
643 eTlt1GeV = true;
644 }
645 if (SC_ET_onl > 10) {
646 eTgt10GeV = true;
647 }
648 if (SC_ET_onl < 10) {
649 eTlt10GeV = true;
650 }
651 if (SC_ET_ofl != 0) {
652 nonZeroETofl = true;
653 }
654 if (SC_ET_ofl > 1) {
655 eToflGt1GeV = true;
656 }
657 if (rawSC->
satur().size() > bcid_ind) {
658 if (rawSC->
satur().at(bcid_ind)) {
659 if (notMasked) {
660 saturNotMasked = true;
661 }
662 } else {
663 notSatur = true;
664 }
665 }
666 if (Etau != 0) {
667 nonZeroEtau = true;
668 }
669 if (rawSCReco != 0 && rawSCReco->
ofcbOverflow() ==
false) {
670 notOFCbOF = true;
671 } else {
672 if (notMasked) {
673 OFCbOFNotMasked = true;
674 }
675 }
676 if (std::abs(SC_time) > 3) {
677 tauGt3 = true;
678 }
679
680 if (notMasked && notSatur && notOFCbOF) {
681 if (nonZeroETofl) {
682 notMaskedEoflNe0 = true;
683 }
684 if (eToflGt1GeV) {
685 notMaskedEoflGt1 = true;
686 }
687 if (SC_energy_onl == -99999) {
688 passSCNomInvalid = true;
689 }
690
691
692
693 if (eTgt0lt0p325GeV) {
694 passSCNom0_0p325 = true;
695 }
696 if (eTgt0p325GeV && eTlt1GeV) {
697 passSCNom0p325_1 = true;
698 }
699 if (eTgt1GeV) {
700 passSCNom1 = true;
701 }
702 if (eTgt10GeV) {
703 passSCNom10 = true;
704 if (tauGt3) {
705 passSCNom10tauGt3 = true;
706 }
707 }
708 if (SC_energy_onl != SC_energy_ofl) {
709 onlofflEmismatch = true;
710 }
711
712 }
713
714 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,
715 lumi_block, zeroET, passSCNomInvalid, passSCNom0_0p325, passSCNom0p325_1, passSCNom1, passSCNom10, passSCNom10tauGt3, saturNotMasked, OFCbOFNotMasked, notMaskedEoflNe0,
716 notMaskedEoflGt1);
717 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,
718 BCID, lumi_block, zeroET, passSCNomInvalid, passSCNom0_0p325, passSCNom0p325_1, passSCNom1, passSCNom10, passSCNom10tauGt3, saturNotMasked, OFCbOFNotMasked,
719 notMaskedEoflNe0, notMaskedEoflGt1);
720
721 }
722
723
724 for (size_t ilayer = 0; ilayer < scMonValueVec.size(); ++ilayer) {
725 const auto&
tool = scMonValueVec[ilayer];
730 auto sc_part_latomesourceidbin =
Monitored::Collection(
"SC_part_latomesourceidbin", tool, [](
const auto& v) {
return v.sc_latomesourceidbin; });
731 auto sc_part_et_ofl =
Monitored::Collection(
"SC_part_et_ofl", tool, [](
const auto& v) {
return v.sc_et_ofl; });
732 auto sc_part_et_diff =
Monitored::Collection(
"SC_part_et_diff", tool, [](
const auto& v) {
return v.sc_et_diff; });
733 auto sc_part_et_onl =
Monitored::Collection(
"SC_part_et_onl", tool, [](
const auto& v) {
return v.sc_et_onl; });
734 auto sc_part_et_onl_muscaled =
Monitored::Collection(
"SC_part_et_onl_muscaled", tool, [](
const auto& v) {
return v.sc_et_onl_muscaled; });
738
739 auto sc_zeroET =
Monitored::Collection(
"SC_part_zeroET", tool, [](
const auto& v) {
return v.sc_zeroET; });
740 auto sc_part_passSCNomInvalid =
Monitored::Collection(
"SC_part_passSCNomInvalid", tool, [](
const auto& v) {
return v.sc_passSCNomInvalid; });
741 auto sc_part_passSCNom0_0p325 =
Monitored::Collection(
"SC_part_passSCNom0_0p325", tool, [](
const auto& v) {
return v.sc_passSCNom0_0p325; });
742 auto sc_part_passSCNom0p325_1 =
Monitored::Collection(
"SC_part_passSCNom0p325_1", tool, [](
const auto& v) {
return v.sc_passSCNom0p325_1; });
743 auto sc_part_passSCNom1 =
Monitored::Collection(
"SC_part_passSCNom1", tool, [](
const auto& v) {
return v.sc_passSCNom1; });
744 auto sc_part_passSCNom10 =
Monitored::Collection(
"SC_part_passSCNom10", tool, [](
const auto& v) {
return v.sc_passSCNom10; });
745 auto sc_part_passSCNom10tauGt3 =
Monitored::Collection(
"SC_part_passSCNom10tauGt3", tool, [](
const auto& v) {
return v.sc_passSCNom10tauGt3; });
746 auto sc_part_saturNotMasked =
Monitored::Collection(
"SC_part_saturNotMasked", tool, [](
const auto& v) {
return v.sc_saturNotMasked; });
747 auto sc_part_OFCbOFNotMasked =
Monitored::Collection(
"SC_part_OFCbOFNotMasked", tool, [](
const auto& v) {
return v.sc_OFCbOFNotMasked; });
748 auto sc_part_notMaskedEoflNe0 =
Monitored::Collection(
"SC_part_notMaskedEoflNe0", tool, [](
const auto& v) {
return v.sc_notMaskedEoflNe0; });
749 auto sc_part_notMaskedEoflGt1 =
Monitored::Collection(
"SC_part_notMaskedEoflGt1", tool, [](
const auto& v) {
return v.sc_notMaskedEoflGt1; });
750
751
752 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,
753 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,
754 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,
755 sc_part_notMaskedEoflGt1);
756 }
757
758
759 }
760
761
762
763
764 if ((hLArLATOMEHeaderContainer.
isValid())) {
765 auto event_size = Monitored::Scalar<float>("event_size", 0);
766 for (const LArLATOMEHeader* pLArLATOMEHeader : *hLArLATOMEHeaderContainer) {
767 event_size += pLArLATOMEHeader->ROBFragSize() + 48;
768 }
769 event_size /= (1024 * 1024 / 4);
770 fill(m_scMonGroupName, lumi_block, event_size);
771 }
772
773
774
775 return StatusCode::SUCCESS;
776 }
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.
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