Execute method.
270 {
271
272
273
275
277 if ( eventInfo.isValid() ) {
280 m_evtNum = eventInfo->eventNumber();
284 } else {
291 }
292
293 std::ostringstream evState;
294 evState <<
"Run "<< std::setw(6) <<
m_runNum
296 <<
" Evt "<< std::setw(9) <<
m_evtNum
298 <<
" Flags 0x" << std::hex <<
m_tileFlag << std::dec;
299
300 std::ostringstream evtnum;
301 evtnum <<
"Run "<< std::setw(6) <<
m_runNum
303 <<
" Evt "<< std::setw(9) <<
m_evtNum
305
306 std::ostringstream nevtnum;
307 nevtnum << evtnum.str()
309
310 bool emptyBad = true;
311 bool badFromCell = false;
322
323 IdContext chan_context =
m_tileHWID->channel_context();
327 HWIdentifier ch_id =
m_tileHWID->channel_id(drawer_id,0);
328 m_tileHWID->get_hash(ch_id, hash, &chan_context);
330 std::fill(itr,itr+48,true);
331 }
332
335 if (statusOk) {
337
338 using namespace boost::local_time;
339 using namespace boost::posix_time;
340 static const time_zone_ptr gva_tz(new posix_time_zone((std::string)"CET+01CEST01:00:00,M3.5.0/02:00:00,M10.5.0/03:00:00"));
341 local_date_time gva_time(from_time_t(eventInfo->timeStamp()),gva_tz);
342 evState << " " << gva_time << " ";
343
344
345 const char *
part[5] = {
"UNK",
"LBA",
"LBC",
"EBA",
"EBC" };
349 int n2 = (n1 +
dn - 1) % 64;
351 evState <<
" " <<
part[
rr] <<std::setw(2)<<std::setfill(
'0')<<n1+1
352 <<
" - " <<
part[
rr] <<std::setw(2)<<std::setfill(
'0')<<n2+1
353 <<
" " <<
dn <<
" consec bad ";
354 }
360 int pp = 1;
361 for (
int rr = 1;
rr < 5; ++
rr) {
362 if ((p2 & pp) || (p1 & pp)) {
363 evState <<
" " <<
part[
rr];
364 if (p2 & pp) {
365 if (p0 & pp) evState << " off";
366 else evState << " OFF";
367 }
368 if (p1 & pp) {
369 if (p0 & pp) evState << " mask";
370 else evState << " MASK";
371 }
372 }
373 pp <<= 1;
374 }
375 evState <<
" " <<
dn <<
" consec bad ";
376 }
377
379 int n1 = -1;
380 int n2 = -1;
386 std::vector<int> allmod;
387 std::vector<int> consec;
388 for (
int ros = 1;
ros < 5; ++
ros) {
389 int drmax = 65;
390 for (
int dr = 0;
dr < drmax; ++
dr) {
395 if (dr < 64) allmod.push_back((ros << 8) + dr);
396 } else if (m1 >= 0) {
398 if (m1 == 0) drmax +=
dm;
399 if (dm > dn) {
404 consec.clear();
405 consec.push_back((ros << 8) + m1);
406 } else if (dm == dn) {
407 if (m1 < 64) consec.push_back((ros << 8) + m1);
408 }
410 }
411 }
412 }
413 evState << " DCS " << allmod.size() << " off ";
414 if (dn > 1) {
416 if (consec.size() > 1) evState << "*" << (consec.size());
417 evState << " consec "
418 <<
part[
rr] << std::setw(2) << std::setfill(
'0') << (n1 % 64) + 1 <<
" - "
419 << part[
rr] << std::setw(2) << std::setfill(
'0') << (n2 % 64) + 1 <<
" ";
422 for (
size_t n = 1;
n < consec.size(); ++
n) {
425 evState << part[m1 >> 8] << std::setw(2) << std::setfill(
'0') << (
m1 % 64) + 1 <<
" - "
426 << part[m2 >> 8] << std::setw(2) << std::setfill(
'0') << (
m2 % 64) + 1 <<
" ";
427 for (
size_t m = 0;
m < allmod.size(); ++
m) {
429 if (mm >= m1 && mm <= m2) {
430 allmod[
m] += n1 -
m1;
431 }
432 }
433 }
434 } else {
436 }
437 if (allmod.size() > (size_t) dn) {
438 for (
size_t m = 0;
m < allmod.size(); ++
m) {
440 if (!(mm >= n1 && mm <= n2)) {
441 evState << part[mm >> 8] << std::setw(2) << std::setfill(
'0') << (
mm % 64) + 1 <<
" ";
442 }
443 }
444 }
445 }
446
448 }
449
450 int rawdata = -1;
451 const TileCell* cellminCh = 0;
452 const TileCell* cellmaxCh = 0;
453 const TileCell* tcellminCh = 0;
454 const TileCell* tcellmaxCh = 0;
455
457
458
460
461 if (!cellContainer.isValid()) {
462
463 ATH_MSG_WARNING(
"Unable to read CaloCellContainer from EventStore, disable reading of this container");
465
466 } else {
467
468 float emin = 0.;
469 float emax = 0.;
470 float tmin = 0.;
471 float tmax = 0.;
474 float tcmin = 0.;
475 float tcmax = 0.;
478 const TileCell* tcellmin = 0;
479 const TileCell* tcellmax = 0;
480
481
482
483
484
485
487
488 for (const CaloCell* cell : *cellContainer) {
489
490 Identifier
id =
cell->ID();
492 const TileCell* tile_cell =
dynamic_cast<const TileCell*
> (
cell);
493 if (tile_cell==0) continue;
494 const CaloDetDescrElement * caloDDE =
cell->caloDDE();
495 IdentifierHash hash1 = caloDDE->
onl1();
496 IdentifierHash hash2 = caloDDE->
onl2();
499 if (rawdata < 0) {
501 }
502
503 bool bad1 = tile_cell->
badch1();
504 bool bad2 = tile_cell->
badch2();
505 float ene1 = tile_cell->
ene1();
506 float ene2 = tile_cell->
ene2();
507 float time1 = tile_cell->
time1();
508 float time2 = tile_cell->
time2();
517
518 float ene = tile_cell->
energy();
519 bool eneOk = false;
524 } else {
526 }
527
528 if (eneOk) {
529 if (bad1 && bad2) {
531 } else {
533 }
534 }
535
537 bool timeOk = false;
542 } else {
544 }
545
546 if (timeOk) {
547 if (time != 0.) {
549 } else {
551 }
552 }
553
554 if (timeOk && eneOk) {
555
557 <<
" cell " << std::left << std::setw(14) <<
m_tileID->to_string(
id,-2)
558 << " ene = " << ene << " time = " << time);
559
562
563 if (ene < emin) {
564 emin = ene;
566 } else if (ene > emax) {
567 emax = ene;
569 }
570
571 if (time<tmin) {
573 tcellmin = tile_cell;
574 }
575 else if (time>tmax) {
577 tcellmax = tile_cell;
578 }
579 }
580
581 if ( !(bad1 && bad2) ) {
582
583 bool ene1Ok = false;
584 bool time1Ok = false;
585
591 } else {
593 }
594
599 } else {
601 }
602
603 if (ene1Ok) {
605 }
606
607 if (time1Ok) {
608 if (time1 != 0.) {
610 } else {
612 }
613 }
614 }
615
616 bool ene2Ok = false;
617 bool time2Ok = false;
618
624 } else {
626 }
627
632 } else {
634 }
635
636 if (ene2Ok) {
638 }
639
640 if (time2Ok) {
641 if (time2 != 0.) {
643 } else {
645 }
646 }
647 }
648
649 bool over1=false;
650 bool over2=false;
651 if (checkOver) {
654 }
655
656 if ((ene1Ok && time1Ok) || over1) {
657
659 <<
" cell " << std::left << std::setw(14) <<
m_tileID->to_string(
id,-2)
660 << " ch_ene1 = " << ene1 << " ch_t1 = " << time1
661 << ((over1)?" overflow":""));
662
665
666 if (ene1 < chmin) {
668 cellminCh = tile_cell;
669 } else if (ene1 > chmax) {
671 cellmaxCh = tile_cell;
672 }
673
674 if (time1 < tcmin) {
675 tcmin = time1;
676 tcellminCh = tile_cell;
677 } else if (time1 > tcmax) {
678 tcmax = time1;
679 tcellmaxCh = tile_cell;
680 }
681 }
682
683 if ((ene2Ok && time2Ok) || over2) {
684
686 <<
" cell " << std::left << std::setw(14) <<
m_tileID->to_string(
id,-2)
687 << " ch_ene2 = " << ene2 << " ch_t2 = " << time2
688 << ((over2)?" overflow":""));
689
692
693 if (ene2 < chmin) {
695 cellminCh = tile_cell;
696 } else if (ene2 > chmax) {
698 cellmaxCh = tile_cell;
699 }
700
701 if (time2 < tcmin) {
702 tcmin = time2;
703 tcellminCh = tile_cell;
704 } else if (time2 > tcmax) {
705 tcmax = time2;
706 tcellmaxCh = tile_cell;
707 }
708 }
709
710 }
711 }
712 }
713
714 if (tcellmin && tcellmin != cellmin && tcellmin != cellmax) {
716 <<
" cell " << std::left << std::setw(14) <<
m_tileID->to_string(tcellmin->
ID(),-2)
717 <<
" ene = " << tcellmin->
energy()
718 <<
" tmin = " << tcellmin->
time());
719 }
720 if (tcellmax && tcellmax != cellmin && tcellmax != cellmax) {
722 <<
" cell " << std::left << std::setw(14) <<
m_tileID->to_string(tcellmax->
ID(),-2)
723 <<
" ene = " << tcellmax->
energy()
724 <<
" tmax = " << tcellmax->
energy());
725 }
726
727 if (tcellminCh && tcellminCh != cellminCh && tcellminCh != cellmaxCh) {
729 <<
" cell " << std::left << std::setw(14) <<
m_tileID->to_string(tcellminCh->
ID(),-2)
730 <<
" ch_ene = " << tcellminCh->
ene1() <<
" " << tcellminCh->
ene2()
731 <<
" ch_tmin = " << tcellminCh->
time1() <<
" " << tcellminCh->
time2());
732 }
733 if (tcellmaxCh && tcellmaxCh != cellminCh && tcellmaxCh != cellmaxCh) {
735 <<
" cell " << std::left << std::setw(14) <<
m_tileID->to_string(tcellmaxCh->
ID(),-2)
736 <<
" ch_ene = " << tcellmaxCh->
ene1() <<
" " << tcellmaxCh->
ene2()
737 <<
" ch_tmax = " << tcellmaxCh->
time1() <<
" " << tcellmaxCh->
time2());
738 }
739
740 if (cellmin) {
742 statusOk = true;
743 const char *
tit = (tcellmin ==
cellmin) ?
" tmin = ": ((tcellmax ==
cellmin) ?
" tmax = ":
" t = ");
744 if (cellminCh!=cellmin) {
746 <<
" cell " << std::left << std::setw(14) <<
m_tileID->to_string(
cellmin->ID(),-2)
747 << " emin = " << emin
749 << " accepted");
750
751 } else {
753 <<
" cell " << std::left << std::setw(14) <<
m_tileID->to_string(
cellmin->ID(),-2)
754 << " emin = " << emin
755 << " ch_emin = " << chmin
757 << " accepted");
758 }
759 }
760
761 if (cellminCh) {
763 statusOk = true;
764 const char *
tit = (tcellminCh == cellminCh) ?
" tmin = ": ((tcellmaxCh == cellminCh) ?
" tmax = ":
" t = ");
765 if (cellminCh!=cellmin) {
767 <<
" cell " << std::left << std::setw(14) <<
m_tileID->to_string(cellminCh->
ID(),-2)
768 << " ch_emin = " << chmin
769 << tit << cellminCh->
time()
770 << " accepted");
771 }
772 }
773
774 if (cellmax) {
776 statusOk = true;
777 const char *
tit = (tcellmin ==
cellmax) ?
" tmin = ": ((tcellmax ==
cellmax) ?
" tmax = ":
" t = ");
778 if (cellmaxCh!=cellmax) {
780 <<
" cell " << std::left << std::setw(14) <<
m_tileID->to_string(
cellmax->ID(),-2)
781 << " emax = " << emax
783 << " accepted");
784
785 } else {
787 <<
" cell " << std::left << std::setw(14) <<
m_tileID->to_string(
cellmax->ID(),-2)
788 << " emax = " << emax
789 << " ch_emax = " << chmax
791 << " accepted");
792 }
793 }
794
795 if (cellmaxCh) {
797 statusOk = true;
798 const char *
tit = (tcellminCh == cellmaxCh) ?
" tmin = ": ((tcellmaxCh == cellmaxCh) ?
" tmax = ":
" t = ");
799 if (cellmaxCh!=cellmax) {
801 <<
" cell " << std::left << std::setw(14) <<
m_tileID->to_string(cellmaxCh->
ID(),-2)
802 << " ch_emax = " << chmax
803 << tit << cellmaxCh->
time()
804 << " accepted");
805 }
806 }
807
808 emptyBad = false;
809 badFromCell = true;
810 }
811 }
812
813 const TileDQstatus* DQstatus(0);
814
816
817
819
821 ATH_MSG_WARNING(
"Unable to read TileRawChannelContainer from EventStore, disable reading of this container");
823
824 } else {
825
828 float tcmin = 0.;
829 float tcmax = 0.;
830 const TileRawChannel* minCh = 0;
831 const TileRawChannel* maxCh = 0;
832 const TileRawChannel* tminCh = 0;
833 const TileRawChannel* tmaxCh = 0;
837 bool fillChanEne = ( !
m_readCells && allowAmpCheck );
838 if (!fillChanEne) {
843 }
844
847 else
848 rawdata = 0;
849
850 IdContext chan_context =
m_tileHWID->channel_context();
853
854 int nbadMax = 0;
855 int nbadMBMax = 0;
856 const TileRawChannelCollection * collMax = 0;
857 const TileRawChannelCollection * collMBMax = 0;
858
859 bool someDQerrors = false;
860
861 for (const TileRawChannelCollection* rawChannelCollection : *rawChannelContainer) {
862
863 int frag = rawChannelCollection->identify();
864 bool eb = (frag > 0x2ff);
865 bool ebsp = (frag == 0x30e || frag == 0x411);
866
871
872 int chMBTS = -1;
873 if (eb) {
874 for (int ch: {12,4,0}) {
875 m_cabling->h2s_cell_id_index(ros,drawer,ch,index,pmt);
876 if (index == -2) {
878 break;
879 }
880 }
881 }
882
883 HWIdentifier ch_id =
m_tileHWID->channel_id(ros,drawer,0);
884 m_tileHWID->get_hash(ch_id, hash, &chan_context);
885 int hashNext =
index = (
int)hash + 48;
886
887
888
889 uint32_t RODBCID = rawChannelCollection->getRODBCID();
890 uint32_t DSPBCID = rawChannelCollection->getFragDSPBCID();
891 uint32_t GlobalCRCErr = rawChannelCollection->getFragGlobalCRC() & 0x1;
892 uint32_t FE_DMUmask = rawChannelCollection->getFragFEChipMask();
893 uint32_t ROD_DMUmask = rawChannelCollection->getFragRODChipMask();
894 uint32_t BCIDErr = rawChannelCollection->getFragBCID();
895 uint32_t MemoryParityErr = rawChannelCollection->getFragMemoryPar();
896 uint32_t HeaderFormatErr = rawChannelCollection->getFragHeaderBit();
897 uint32_t HeaderParityErr = rawChannelCollection->getFragHeaderPar();
898 uint32_t SampleFormatErr = rawChannelCollection->getFragSampleBit();
899 uint32_t SampleParityErr = rawChannelCollection->getFragSamplePar();
900 uint32_t SingleStrobeErr = rawChannelCollection->getFragSstrobe();
901 uint32_t DoubleStrobeErr = rawChannelCollection->getFragDstrobe();
902
903 if (RODBCID!=0 && RODBCID !=
m_evtBCID ) {
906 <<
" drw " <<
drwname(rawChannelCollection->identify())
907 << " ROD BCID " << RODBCID << " is wrong - skipping");
908
911 << " suppressing further messages about drawer 0x" << std::hex << rawChannelCollection->identify()
912 << std::dec << " being bad");
913 }
914 someDQerrors = true;
915 continue;
916 }
917
918 if (DSPBCID >= 0x7FFF
919 && GlobalCRCErr
920 && FE_DMUmask == 0xFFFF
921 && ROD_DMUmask == 0xFFFF
922 && BCIDErr == 0xFFFF
923 && MemoryParityErr == 0xFFFF
924 && HeaderFormatErr == 0xFFFF
925 && HeaderParityErr == 0xFFFF
926 && SampleFormatErr == 0xFFFF
927 && SampleParityErr == 0xFFFF
928 && SingleStrobeErr == 0xFFFF
929 && DoubleStrobeErr == 0xFFFF) {
930
933 <<
" drw " <<
drwname(rawChannelCollection->identify())
934 << " is OFF - skipping");
935
938 << " suppressing further messages about drawer 0x" << std::hex
939 << rawChannelCollection->identify()
940 << std::dec << " being bad");
941 }
942 continue;
943 }
944
945 if (DSPBCID == 0
946 && GlobalCRCErr == 0
947 && FE_DMUmask == 0
948 && ROD_DMUmask == 0
949 && BCIDErr == 0
950 && MemoryParityErr == 0
951 && HeaderFormatErr == 0
952 && HeaderParityErr == 0
953 && SampleFormatErr == 0
954 && SampleParityErr == 0
955 && SingleStrobeErr == 0
956 && DoubleStrobeErr == 0) {
957
960 <<
" drw " <<
drwname(rawChannelCollection->identify())
961 << " is MISSING - skipping");
962
965 << " suppressing further messages about drawer 0x" << std::hex
966 << rawChannelCollection->identify() << std::dec << " being bad");
967 }
968 continue;
969 }
970
971 if (GlobalCRCErr) {
972 GlobalCRCErr = 0xFFFF;
976 <<
" drw " <<
drwname(rawChannelCollection->identify())
977 << " global CRC error - skipping");
978
981 << " suppressing further messages about drawer 0x" << std::hex
982 << rawChannelCollection->identify() << std::dec << " being bad");
983 }
984 someDQerrors = true;
985 continue;
986 }
987 }
988
989 if (HeaderFormatErr || HeaderParityErr || SampleFormatErr || SampleParityErr ) {
990 FE_DMUmask = 0xFFFF;
991 } else {
992 if (eb) {
993 if (ebsp) FE_DMUmask<<=1;
994 FE_DMUmask = (FE_DMUmask & 0xFF) | ((FE_DMUmask & 0xF00)<<2);
995 }
996 }
997
998 FE_DMUmask = ~FE_DMUmask & 0xFFFF;
999 ROD_DMUmask = ~ROD_DMUmask & 0xFFFF;
1000
1001 if (BCIDErr & 0x2) {
1002 BCIDErr = 0xFFFF;
1006 <<
" drw " <<
drwname(rawChannelCollection->identify())
1007 << " BCID in DMU1 is bad - skipping");
1008
1011 << " suppressing further messages about drawer 0x"
1012 << std::hex << rawChannelCollection->identify() << std::dec << " being bad");
1013 }
1014 someDQerrors = true;
1015 continue;
1016 }
1017
1018 } else {
1019
1020 if ( DSPBCID!=0xDEAD && DSPBCID!=
m_evtBCID ) {
1021 BCIDErr = 0xFFFF;
1025 <<
" drw " <<
drwname(rawChannelCollection->identify())
1026 << " DSP BCID is wrong - skipping");
1027
1030 << " suppressing further messages about drawer 0x"
1031 << std::hex << rawChannelCollection->identify() << std::dec << " being bad");
1032 }
1033 someDQerrors = true;
1034 continue;
1035 }
1036 }
1037 }
1038
1039 uint32_t error = GlobalCRCErr | FE_DMUmask | ROD_DMUmask | BCIDErr | MemoryParityErr |
1040 HeaderFormatErr | HeaderParityErr | SampleFormatErr | SampleParityErr;
1041
1045 <<
" drw " <<
drwname(rawChannelCollection->identify())
1046 << " whole drawer is bad - skipping");
1047
1050 << " suppressing further messages about drawer 0x"
1051 << std::hex << rawChannelCollection->identify() << std::dec << " being bad");
1052 }
1053 someDQerrors = true;
1054 continue;
1055 }
1056
1057
1062 << " enabling messages about drawer 0x" << std::hex
1063 << rawChannelCollection->identify()
1064 << std::dec <<
" being bad after " <<
m_maxVerboseCnt.value() <<
" good events");
1065 }
1066 }
1067
1069 if (eb) {
1070 if (ebsp) {
1071 errMB &= 0x3cfe;
1072 } else {
1073 errMB &= 0x3cff;
1074 }
1075 }
1076 int nbadMB = 0;
1077 while (errMB) {
1078 if (errMB & 0xF) ++nbadMB;
1079 errMB >>= 4;
1080 }
1082 if (nbadMB > nbadMBMax) {
1083 nbadMBMax = nbadMB;
1084 collMBMax = rawChannelCollection;
1085 }
1086
1087 int nerr = 0;
1088 for (uint32_t i = 0x8000;
i != 0;
i >>= 1) {
1089 if (error&i) {
1090 ++nerr;
1092 } else {
1093 if (emptyBad && nbadMB < 4) {
1097 } else {
1099 }
1100 }
1101 }
1102
1103 int nbad = ((ebsp) ? nerr-5 : ((eb) ? nerr-4 : nerr));
1104
1106 someDQerrors = true;
1107 if (nbad > nbadMax) {
1108 nbadMax = nbad;
1109 collMax = rawChannelCollection;
1110 }
1111 }
1112 if (someDQerrors) {
1115 }
1116 }
1117
1118 if (allowAmpCheck || emptyBad) {
1119
1120 for (const TileRawChannel* rawChannel : *rawChannelCollection) {
1121
1122 HWIdentifier adcId = rawChannel->adc_HWID();
1123 HWIdentifier chId =
m_tileHWID->channel_id(adcId);
1124 m_tileHWID->get_hash(chId, hash, &chan_context);
1128 int ch_type = 0;
1129 if (channel == chMBTS) {
1130 ch_type = 2;
1131 } else if ( (ebsp && (channel == 18 || channel == 19 || channel == 12 || channel == 13) )
1132 || (eb && (channel == 0 || channel == 1 || channel == 12 || channel == 13) ) ) {
1133 ch_type = 1;
1134 }
1137 (DQstatus && !DQstatus->isAdcDQgood(ros,drawer,channel,adc)) ||
1139 }
1140
1141 if (allowAmpCheck) {
1142
1143 float amp = rawChannel->amplitude();
1144 float time = rawChannel->time();
1145 if (fillChanEne) {
1149 } else {
1152 }
1153
1158 continue;
1159
1160 bool ampOk = false;
1165 } else {
1167 }
1168
1169 bool timeOk = false;
1174 } else {
1176 }
1177
1178 if (ampOk && timeOk) {
1179
1181 <<
" chan " << std::left << std::setw(14) <<
m_tileHWID->to_string(adcId)
1182 << " ch_ene = " << amp << " ch_t = " << time);
1183
1185
1186 if (amp < chmin) {
1188 minCh = rawChannel;
1189 } else if (amp > chmax) {
1191 maxCh = rawChannel;
1192 }
1193
1194 if (time<tcmin) {
1196 tminCh = rawChannel;
1197 }
1198 else if (time>tcmax) {
1200 tmaxCh = rawChannel;
1201 }
1202 }
1203 }
1204 }
1205 }
1206
1207 for (index = hashNext - 48;
index < hashNext; ++
index) {
1208 if ((
m_chanSel[index] && rawdata) || someDQerrors) {
1210 <<
" drw " <<
drwname(rawChannelCollection->identify())
1211 << " nBadMB = " << nbadMB
1212 << " nBadDMU = " << nbad
1214 << " DSPBCID = " << rawChannelCollection->getFragDSPBCID()
1215 << " GlobCRC = " << rawChannelCollection->getFragGlobalCRC() << " " << GlobalCRCErr
1216 << " error = 0x" << std::hex << error
1217 << " FE_CRC = 0x" << rawChannelCollection->getFragFEChipMask() << " 0x" << FE_DMUmask
1218 << " ROD_CRC = 0x" << rawChannelCollection->getFragRODChipMask() << " 0x" << ROD_DMUmask
1219 << " BCIDErr = 0x" << rawChannelCollection->getFragBCID() << " 0x" << BCIDErr
1220 << " MemPar = 0x" << rawChannelCollection->getFragMemoryPar()
1221 << " HeadForm = 0x"<< rawChannelCollection->getFragHeaderBit()
1222 << " HeadPar = 0x" << rawChannelCollection->getFragHeaderPar()
1223 << " SampForm = 0x"<< rawChannelCollection->getFragSampleBit()
1224 << " SampPar = 0x" << rawChannelCollection->getFragSamplePar()
1225 << std::dec);
1226 break;
1227 }
1228 }
1229 }
1230
1233 statusOk = true;
1236 << " nBadMB = " << nbadMBMax
1237 << " accepted");
1238
1241 statusOk = true;
1244 << " nBadDMU = " << nbadMax
1245 << " accepted");
1246 }
1247
1248 if (tminCh && tminCh != minCh && tminCh != maxCh) {
1250 <<
" chan " << std::left << std::setw(14) <<
m_tileHWID->to_string(tminCh->
adc_HWID())
1252 <<
" tmin =" << tminCh->
time());
1253 }
1254
1255 if (tmaxCh && tmaxCh != minCh && tmaxCh != maxCh) {
1257 <<
" chan " << std::left << std::setw(14) <<
m_tileHWID->to_string(tmaxCh->
adc_HWID())
1259 <<
" tmax = " << tmaxCh->
time());
1260 }
1261
1262 if (minCh) {
1264 statusOk = true;
1265 const char *
tit = (tminCh == minCh) ?
" tmin = ": ((tmaxCh == minCh) ?
" tmax = ":
" t = ");
1267 <<
" chan " << std::left << std::setw(14) <<
m_tileHWID->to_string(minCh->
adc_HWID())
1268 << " ch_emin = " << chmin
1269 << tit << minCh->
time()
1270 << " accepted");
1271 }
1272 if (maxCh) {
1274 statusOk = true;
1275 const char *
tit = (tminCh == maxCh) ?
" tmin = ": ((tmaxCh == maxCh) ?
" tmax = ":
" t = ");
1277 <<
" chan " << std::left << std::setw(14) <<
m_tileHWID->to_string(maxCh->
adc_HWID())
1278 << " ch_emax = " << chmax
1279 << tit << maxCh->
time()
1280 << " accepted");
1281 }
1282 emptyBad = false;
1283 }
1284 }
1285
1286
1288
1289
1291
1292 if (!digitsContainer.isValid()) {
1293 ATH_MSG_WARNING(
"Unable to read TileDigitsContainer from EventStore, disable reading of this container");
1295
1296 } else {
1297
1298 IdContext chan_context =
m_tileHWID->channel_context();
1299 IdentifierHash
hash;
1301 int nConst = 0;
1302 int nJump = 0;
1303 int nDmuErr = 0;
1304 int nOverLG = 0;
1305 int nOverHG = 0;
1306 int nUnderLG = 0;
1307 int nUnderHG = 0;
1308
1309 for (const TileDigitsCollection * digitsCollection : *digitsContainer) {
1310
1311 int frag = digitsCollection->identify();
1312 bool eb = (frag > 0x2ff);
1313 bool ebsp = (frag == 0x30e || frag == 0x411);
1314
1315 int ros = frag >> 8;
1316 int drawer = frag & 0x3F;
1319
1320 int chMBTS = -1;
1321 if (eb) {
1322 for (int ch: {12,4,0}) {
1323 m_cabling->h2s_cell_id_index(ros,drawer,ch,index,pmt);
1324 if (index == -2) {
1326 break;
1327 }
1328 }
1329 }
1330
1331 int nChBadDB = 0;
1332 int nChBadNC = 0;
1333 int nChBad = 0;
1334 int nChTot = 0;
1335 int nChDmu[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
1336 int nChBadDmu[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
1337
1338 for (const TileDigits* tile_digits : *digitsCollection) {
1339
1340 ++nChTot;
1341
1342 HWIdentifier adcId = tile_digits->adc_HWID();
1343 HWIdentifier chId =
m_tileHWID->channel_id(adcId);
1344 m_tileHWID->get_hash(chId, hash, &chan_context);
1348 ++nChDmu[dmu];
1350 bool isConnected = (chEmpty < 2);
1351 if (!isConnected) ++nChBadNC;
1353 const char *cellname = "";
1354 int ch_type = 0;
1355 if (channel == chMBTS) {
1356 cellname = " MBTS";
1357 ch_type = 2;
1358 } else if ( (ebsp && (channel == 18 || channel == 19 || channel == 12 || channel == 13) )
1359 || (eb && (channel == 0 || channel == 1 || channel == 12 || channel == 13) ) ) {
1360 cellname = " GAP";
1361 ch_type = 1;
1362 } else if (chEmpty > 0) {
1363 cellname = " EMPTY";
1364 }
1365
1366 const char *badname = "";
1367 if (DQstatus && !DQstatus->isAdcDQgood(ros,drawer,channel,adc)) {
1368 badname = " BADDQ";
1369 if (isConnected) {
1370 ++nChBad;
1371 ++nChBadDmu[dmu];
1372 }
1374 badname = " BADDCS";
1375 }
else if (
m_tileBadChanTool->getAdcStatus(drawerIdx,channel,adc,ctx).isBad()) {
1376 badname = " BADDB";
1377 if (isConnected) {
1378 ++nChBadDB;
1379 }
1381 if (badFromCell) {
1382 if (ch_type != 2) badname = " BADQUAL";
1384 if (isConnected && ch_type!=2) {
1385 ++nChBad;
1386 ++nChBadDmu[dmu];
1387 }
1388 } else {
1389 badname = " BADUNKN";
1390 }
1391 }
else if (badFromCell &&
m_chanEne[hash] == 0.0) {
1392 badname = " BADDIGI";
1393 if (isConnected) {
1394 ++nChBad;
1395 ++nChBadDmu[dmu];
1396 }
1397 }
1398 const char *enename = " ene = ";
1399 const char *timename = " time = ";
1400 const char *qualname = " qual = ";
1401 if (badFromCell && badname[0] != 0) {
1402 enename = " BAD = ";
1404 qualname = " eDSP = ";
1406 }
1408 timename = " tDSP = ";
1410 }
1411 }
1412
1413 char badnm[30];
1414 sprintf(badnm," BADDIGIEX%s",badname);
1415 float dmin,dmax;
1416
1417 std::vector<float> samples = tile_digits->samples();
1418 int nSamp = samples.size();
1419 if (nSamp > 6) {
1420
1424
1426
1427 if (badname[0]==0) {
1428 if (err && err>-3) {
1429 if (isConnected || err != -2) {
1431 badname = badnm;
1432 ++nChBad;
1433 ++nChBadDmu[dmu];
1434 if (!isConnected) --nChBadNC;
1435 }
1436 if (err > 0) {
1437 if (err < 10) {
1439 } else if (err < 36) {
1441 }
1442 } else {
1443 badnm[9] = 48;
1444 }
1445 } else {
1446
1447
1449 if (warn) {
1451 sprintf(badnm," warningE%d%s",warn,badname);
1452 badname = badnm;
1453 }
1454 }
1455 }
1456
1457 if ((!err)
1458 && (useCh)
1459 && (badname[0] == 0 || badname[1] == 'w'
1461
1462 if (adc) {
1463
1467 ++nOverHG;
1468 }
1469 }
1473 ++nUnderHG;
1474 }
1475 }
1476
1477 } else {
1478
1482 ++nOverLG;
1483 }
1484 }
1488 ++nUnderLG;
1489 }
1490 }
1491 }
1492 }
1493
1494 bool someSampErrors = false;
1495
1497
1500
1501 float ped = samples[0];
1504 int nped = 1;
1505 int npedmax = 1;
1506 bool cnstPed = true;
1507 bool cnstPedmax = true;
1508 for (
int i = 1;
i < nSamp; ++
i) {
1509 float smp = samples[
i];
1510 float dped = smp -
ped;
1511 if (fabs(dped) < pedDelta) {
1512 ++nped;
1513 if (dped != 0.0) {
1514 cnstPed = false;
1516 }
1517 } else {
1518 if (nped>npedmax) {
1519 npedmax=nped;
1520 cnstPedmax = cnstPed;
1521 }
1522 cnstPed = true;
1524 nped = 1;
1525 }
1526 if (smp<dmin) {
1527 dmin = smp;
1528 } else if (smp>dmax) {
1529 dmax = smp;
1530 }
1531 }
1532 if (nped>npedmax) {
1533 npedmax=nped;
1534 cnstPedmax = cnstPed;
1535 }
1536
1537 if (dmax - dmin >= jumpDelta) {
1540 bool accCnst = false;
1541 bool accJump = false;
1542 bool cnstMin = true;
1543 bool cnstMax = true;
1544 bool jumpNeg = false;
1545 bool jumpPos = false;
1546 bool jumpEnd = false;
1547 bool jumpZer = false;
1548 bool jumpOve = false;
1549 bool narrowUp = false;
1550 bool narrowDown = false;
1551 if (npedmax >=
m_constLength && ((dmax-ped) >= jumpDelta || (ped-dmin) >= jumpDelta) ) {
1552 ++nConst;
1553 accCnst = true;
1554 }
1555 int nmin = 0;
1557 int pmin = -1;
1558 int pmax = -1;
1559 float abovemin = dmax;
1560 float belowmax = dmin;
1561 for (
int i = 0;
i < nSamp; ++
i) {
1562 float smp = samples[
i];
1563 if (smp - dmin < pedDelta) {
1564 ++nmin;
1566 if (smp != dmin) cnstMin = false;
1567 }
1568 if (dmax - smp < pedDelta) {
1571 if (smp != dmax) cnstMax = false;
1572 }
1573 if (smp < abovemin && smp > dmin) {
1574 abovemin = smp;
1575 }
1576 if (smp > belowmax && smp < dmax) {
1577 belowmax = smp;
1578 }
1579 }
1580 if (
nmax + nmin == nSamp) {
1581 if (
nmax > 1 && nmin > 1) {
1582 ++nJump;
1583 accJump = true;
1584 }
else if (
nmax == 1) {
1585 if (pmax < nSamp - 1) {
1586 ++nJump;
1587 accJump = true;
1588 jumpPos = true;
1589 cnstMax = false;
1590 }
1591 if (pmax == 0 || pmax == nSamp - 1) {
1592 jumpEnd = true;
1593 }
1594 } else if (nmin == 1) {
1595 ++nJump;
1596 accJump = true;
1597 jumpNeg = true;
1598 cnstMin = false;
1599 if (pmin == 0 || pmin == nSamp - 1) {
1600 jumpEnd = true;
1601 }
1602 }
1603 }
1604 if (dmin == 0.0) {
1605 if (!accJump) {
1606 ++nJump;
1607 accJump = true;
1608 cnstMin = false;
1609 cnstMax = false;
1610 }
1611 jumpZer = true;
1612 }
1614 if (!accJump) {
1615 ++nJump;
1616 accJump = true;
1617 cnstMin = false;
1618 cnstMax = false;
1619 }
1620 jumpOve = true;
1621 }
1623 if (pmax > 0 && pmax < nSamp-1 && std::max(samples[pmax-1], samples[pmax+1]) < dmin+secondMax) {
1624 if (!accJump) {
1625 ++nJump;
1626 accJump = true;
1627 cnstMax = false;
1628 if (nmin +
nmax != nSamp) {
1629 cnstMin = false;
1630 }
1631 }
1632 narrowUp = true;
1633 }
1634 if (pmin > 0 && pmin < nSamp - 1 && std::min(samples[pmin - 1], samples[pmin + 1]) > dmax - secondMax) {
1635 if (!accJump) {
1636 ++nJump;
1637 accJump = true;
1638 cnstMin = false;
1639 if (nmin +
nmax != nSamp) {
1640 cnstMax = false;
1641 }
1642 }
1643 narrowDown = true;
1644 }
1645
1646 if (accEmin || accEmax || accCnst || accJump) {
1647 someSampErrors = true;
1649 <<
" chan " << std::left << std::setw(14) <<
m_tileHWID->to_string(adcId)
1650 << enename <<
m_chanEne[hash] <<
" samp = " << samples[0]
1651 << " " << samples[1] << " " << samples[2] << " " << samples[3]
1652 << " " << samples[4] << " " << samples[5] << " " << samples[6]
1655 << cellname << badname
1656 << ((accEmin) ? " neg_e" : "")
1657 << ((accEmax) ? " pos_e" : "")
1658 << ((accCnst) ? " const" : "")
1659 << ((accCnst&&cnstPedmax) ? "Const" : "")
1660 << ((accJump) ? " jump" : "")
1661 << ((accJump&&jumpZer) ? "Zero" : "")
1662 << ((accJump&&jumpOve) ? "Over" : "")
1663 << ((accJump&&jumpPos) ? "SingleUp" : ((narrowUp) ? "NarrowUp" : "") )
1664 << ((accJump&&jumpNeg) ? "SingleDown" : ((narrowDown) ? "NarrowDown" : "") )
1665 << ((accJump&&jumpEnd) ? "AtEdge" : "")
1666 << ((accJump&&cnstMin) ? "ConstMin" : "")
1667 << ((accJump&&cnstMax) ? "ConstMax" : "")
1668 << " " << dmax-dmin);
1669 }
1670 }
1671 }
1672
1673 if (someSampErrors) {
1679 bool jumpZer = (dmin < 0.01);
1681 <<
" chan " << std::left << std::setw(14) <<
m_tileHWID->to_string(adcId)
1682 << enename <<
m_chanEne[hash] <<
" samp = " << samples[0]
1683 << " " << samples[1] << " " << samples[2] << " " << samples[3]
1684 << " " << samples[4] << " " << samples[5] << " " << samples[6]
1687 << cellname << badname
1688 << ((accEmin) ? " neg_e" : "")
1689 << ((accEmax) ? " pos_e" : "")
1690 <<((jumpZer) ? " underflow" : "")
1691 <<((jumpOve) ? " overflow" : "") );
1692 }
1693
1694 }
1695 }
1696 if (
m_checkDMUs && nChBad > 1 && nChBad + nChBadDB + nChBadNC < nChTot) {
1697 int nChBad1 = 0;
1698 int nChBad2 = 0;
1699 int nDmuBad1 = 0;
1700 int nDmuBad2 = 0;
1701 int nDmuBad = 0;
1702 int nDmuTot = 0;
1703 bool has23 = false;
1704 for (int dmu = 0; dmu < 16; ++dmu) {
1705 if (nChDmu[dmu] > 0) {
1706 ++nDmuTot;
1707 if (nChBadDmu[dmu] > 0) {
1708 ++nDmuBad;
1709 if (dmu < 8) {
1710 nChBad1 += nChBadDmu[dmu];
1711 ++nDmuBad1;
1712 } else {
1713 nChBad2 += nChBadDmu[dmu];
1714 ++nDmuBad2;
1715 }
1716 if (nChBadDmu[dmu] == 2 && nChDmu[dmu] == 3) has23 = true;
1717 }
1718 }
1719 }
1720 if (nDmuBad == 1 ) continue;
1721 if (nDmuBad == 2 && nChBad < 3) continue;
1722
1723 if (nDmuBad>2 || nChBad > 9 || nChTot > 19 || has23) {
1724
1725 ++nDmuErr;
1726
1727 for (const TileDigits* tile_digits : *digitsCollection) {
1728
1729 HWIdentifier adcId = tile_digits->adc_HWID();
1730 HWIdentifier chId =
m_tileHWID->channel_id(adcId);
1731 m_tileHWID->get_hash(chId, hash, &chan_context);
1733 std::vector<float> samples = tile_digits->samples();
1734
1735 if (!
m_chanSel[hash] && samples.size()>6) {
1739 const char *cellname = "";
1740 int ch_type = 0;
1741 if (channel == chMBTS) {
1742 cellname = " MBTS";
1743 ch_type = 2;
1744 } else if ( (ebsp && (channel == 18 || channel == 19 || channel == 12 || channel == 13) )
1745 || (eb && (channel == 0 || channel == 1 || channel == 12 || channel == 13) ) ) {
1746 cellname = " GAP";
1747 ch_type = 1;
1748 } else if (chEmpty > 0) {
1749 cellname = " EMPTY";
1750 }
1751 const char *badname = "";
1753 badname = " BADDB";
1754 } else if (DQstatus && !DQstatus->isAdcDQgood(ros, drawer, channel, adc)) {
1755 badname = " BADDQ";
1757 badname = " BADDCS";
1759 if (badFromCell) {
1760 if (ch_type != 2) badname = " BADQUAL";
1762 } else {
1763 badname = " BADUNKN";
1764 }
1765 }
else if (badFromCell &&
m_chanEne[hash] == 0.0) {
1766 badname = " BADDIGI";
1767 }
1768
1769 char badnm[30];
1770 sprintf(badnm, " BADDIGIEX%s", badname);
1771 float dmin, dmax;
1772
1775 if (err) {
1776 bool isConnected = (chEmpty < 2);
1777 if (isConnected || err != -2) {
1778 badname = badnm;
1779 }
1780 if (err > 0) {
1781 if (err < 10) {
1782 badnm[9] = 48 +
err;
1783 } else if (err < 36) {
1784 badnm[9] = 55 +
err;
1785 }
1786 } else {
1787 badnm[9] = 48;
1788 }
1789 }
1790
1791 const char *enename = " ene = ";
1792 const char *timename = " time = ";
1793 const char *qualname = " qual = ";
1794 if (badFromCell && badname[0] != 0) {
1795 enename = " BAD = ";
1797 qualname = " eDSP = ";
1799 }
1801 timename = " tDSP = ";
1803 }
1804 }
1805
1809 bool jumpZer = (dmin < 0.01);
1810
1812 <<
" chan " << std::left << std::setw(14) <<
m_tileHWID->to_string(adcId)
1813 << enename <<
m_chanEne[hash] <<
" samp = " << samples[0]
1814 << " " << samples[1] << " " << samples[2] << " " << samples[3]
1815 << " " << samples[4] << " " << samples[5] << " " << samples[6]
1818 << cellname << badname
1819 << ((accEmin) ? " neg_e" : "")
1820 << ((accEmax) ? " pos_e" : "")
1821 << ((jumpZer) ? " underflow" : "")
1822 << ((jumpOve) ? " overflow" : "") );
1823
1824 }
1825 }
1826 }
1827
1828 std::ostringstream badstr;
1829 badstr << " ch: " << nChBad1 << " + " << nChBad2 << " = " << nChBad << " / " << nChTot << " = " << 100*nChBad/nChTot
1830 << " % dmu: " << nDmuBad1 << " + " << nDmuBad2 << " = " << nDmuBad << " / " << nDmuTot << " ";
1831 for (int dmu=0; dmu<16; ++dmu) {
1832 if (nChDmu[dmu]>0) {
1833 badstr << " " << std::hex << dmu << "=" << nChBadDmu[dmu] << "/" << nChDmu[dmu];
1834 }
1835 }
1837 <<
" drw " <<
drwname(digitsCollection->identify()) << badstr.str());
1838 }
1839 }
1840
1841 if (nConst) {
1843 statusOk = true;
1845 << " n_const_sample_errors = " << nConst
1846 << " accepted");
1847 }
1848 if (nJump) {
1850 statusOk = true;
1852 << " n_jump_sample_errors = " << nJump
1853 << " accepted");
1854 }
1855 if (nOverLG) {
1857 statusOk = true;
1859 << " n_overflow_LG = " << nOverLG
1860 << " accepted");
1861 }
1862 if (nOverHG) {
1864 statusOk = true;
1866 << " n_overflow_HG = " << nOverHG
1867 << " accepted");
1868 }
1869 if (nUnderLG) {
1871 statusOk = true;
1873 << " n_underflow_LG = " << nUnderLG
1874 << " accepted");
1875 }
1876 if (nUnderHG) {
1878 statusOk = true;
1880 << " n_underflow_HG = " << nUnderHG
1881 << " accepted");
1882 }
1883 if (nDmuErr) {
1885 statusOk = true;
1887 << " n_DMU_errors = " << nDmuErr
1888 << " accepted");
1889 }
1890 }
1891 }
1892
1895 else
1897
1898 if (statusOk) {
1900
1901 } else {
1902
1903 }
1904
1905 return StatusCode::SUCCESS;
1906}
#define ATH_MSG_DEBUG(x,...)
#define ATH_MSG_WARNING(x,...)
#define ATH_MSG_VERBOSE(x,...)
size_t size() const
Number of registered mappings.
static std::string drwname(int id)
static const Attributes_t empty
virtual void setFilterPassed(bool state, const EventContext &ctx) const
float time() const
get time (data member)
double energy() const
get energy (data member)
Identifier ID() const
get ID (from cached data member) non-virtual and inline for fast access
IdentifierHash onl2() const
cell online identifier 2
IdentifierHash onl1() const
cell online identifier 1
static unsigned int getDrawerIdx(unsigned int ros, unsigned int drawer)
Returns a drawer hash.
Gaudi::Property< bool > m_checkOverHG
std::vector< float > m_chanEne
bool m_bitTimeCell[ptnlength]
const TileCablingService * m_cabling
Gaudi::Property< float > m_minTimeCell
int Are3FF(std::vector< float > &OptFilterDigits, int OptFilterGain, int ch_type)
std::vector< float > m_chanDsp
Gaudi::Property< std::vector< int > > m_drawer
bool m_bitEneChan[3][ptnlength]
ToolHandle< ITileBadChanTool > m_tileBadChanTool
Gaudi::Property< float > m_maxEneCell
SG::ReadHandleKey< TileDQstatus > m_dqStatusKey
std::vector< bool > m_chanSel
Gaudi::Property< float > m_underflowLG
Gaudi::Property< float > m_underflowHG
Gaudi::Property< bool > m_checkUnderHG
Gaudi::Property< bool > m_checkOverLG
std::vector< bool > m_chanToSkip
Gaudi::Property< float > m_maxTimeChan[3]
Gaudi::Property< float > m_pedDeltaLG
ToolHandle< ITileDCSTool > m_tileDCS
Gaudi::Property< float > m_overflowLG
Gaudi::Property< float > m_jumpDeltaLG
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerKey
Gaudi::Property< int > m_maxBadDMU
Gaudi::Property< bool > m_skipEmpty
Gaudi::Property< int > m_minBadMB
Gaudi::Property< float > m_minEneChan[3]
std::vector< bool > m_chanBad
bool m_bitTimeChan[3][ptnlength]
SG::ReadHandleKey< TileDigitsContainer > m_digitsContainerKey
SG::ReadHandleKey< CaloCellContainer > m_cellContainerKey
Gaudi::Property< bool > m_printOnly
Gaudi::Property< bool > m_checkUnderLG
Gaudi::Property< bool > m_checkDMUs
Gaudi::Property< float > m_minEneCell
Gaudi::Property< bool > m_skipMasked
Gaudi::Property< int > m_maxVerboseCnt
Gaudi::Property< bool > m_checkJumps
Gaudi::Property< float > m_maxTimeCell
Gaudi::Property< bool > m_checkError
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
const TileHWID * m_tileHWID
Gaudi::Property< float > m_maxEneChan[3]
std::vector< int > m_nDrawerOff
Gaudi::Property< int > m_minBadDMU
Gaudi::Property< bool > m_checkWarning
std::vector< float > m_chanTime
Gaudi::Property< float > m_jumpDeltaHG
std::vector< bool > m_drawerToSkip
Gaudi::Property< float > m_overflowHG
std::vector< float > m_chanTDsp
std::vector< float > m_chanQua
Gaudi::Property< float > m_minTimeChan[3]
Gaudi::Property< float > m_pedDeltaHG
Gaudi::Property< int > m_constLength
float m_ADCmaskValueMinusEps
Gaudi::Property< bool > m_skipMBTS
bool m_bitEneCell[ptnlength]
Gaudi::Property< bool > m_checkDCS
uint8_t qual1(void) const
get quality of first PMT (data member)
float time1(void) const
get time of first PMT
int gain2(void) const
get gain of second PMT
bool badch1(void) const
check if first PMT is in bad channel list and masked
uint8_t qbit2(void) const
get quality bits of second PMT (data member)
int gain1(void) const
get gain of first PMT
uint8_t qual2(void) const
get quality of second PMT (data member)
float ene1(void) const
get energy of first PMT
bool badch2(void) const
check if second PMT is in bad channel list and masked
float time2(void) const
get time of second PMT
uint8_t qbit1(void) const
get quality bits of first PMT (data member)
float ene2(void) const
get energy of second PMT
static int isChEmpty(int partition, int drawer, int ch)
True if channel is not fully implemented.
static int CorruptedData(int ros, int drawer, int channel, int gain, const std::vector< float > &digits, float &dmin, float &dmax, float ADCmaxMinusEps, float ADCmaskValueMinusEps)
@ OnlineMegaElectronVolts
float time(int ind=0) const
float amplitude(int ind=0) const
HWIdentifier adc_HWID(void) const
@ Tile
The Tile calorimeter.
@ Warning
The sub-detector issued a warning.
@ Error
The sub-detector issued an error.
time(flags, cells_name, *args, **kw)
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())