13 #include "eformat/SourceIdentifier.h"
23 #include "../L1CaloSubBlock.h"
24 #include "../L1CaloSrcIdMap.h"
37 return (crate << 8) | (1 << 4) |
module;
43 return (crateModuleMask(crate,
module) << 16) | (pin << 8) | asic;
47 return twoBytePedCor > 511? (twoBytePedCor - 1024): twoBytePedCor;
51 std::string noAuxSuffix(
const std::string&
name) {
52 if ((
name.size() > 4) && (
name.substr(
name.size()-4, 4) ==
"Aux.")) {
53 return name.substr(0,
name.size() - 4);
66 m_errorTool(
"LVL1BS::L1CaloErrorByteStreamTool/L1CaloErrorByteStreamTool"),
67 m_ppmMaps(
"LVL1::PpmMappingTool/PpmMappingTool"),
68 m_robDataProvider(
"ROBDataProviderSvc",
name),
72 declareInterface<PpmByteStreamReadV1V2Tool>(
this);
74 "Crate/Module/Channel to Eta/Phi/Layer mapping tool");
76 "Get ROB source IDs service");
93 return StatusCode::SUCCESS;
101 return StatusCode::SUCCESS;
119 for (; rob != robEnd; ++rob, ++robCounter) {
122 if (!
sc.isSuccess()) {
128 return StatusCode::SUCCESS;
143 const std::vector<uint32_t>& vID(
ppmSourceIDs(state, sgKey));
147 ATH_MSG_DEBUG(
"Number of ROB fragments:" << robFrags.size());
150 return StatusCode::SUCCESS;
158 auto rob = **robIter;
161 "Treating ROB fragment source id #" << MSG::hex << rob.rob_source_id());
171 if (rob.nstatus() > 0) {
177 return StatusCode::FAILURE;
185 rob.rod_data(payloadBeg);
186 payloadEnd = payloadBeg + rob.rod_ndata();
191 return StatusCode::FAILURE;
196 uint16_t rodVer = rob.rod_version() & 0xffff;
197 uint32_t rodRunNumber = rob.rod_run_no() & 0xffffff;
198 state.
m_verCode = ((rodVer & 0xfff) << 4) | 1;
203 return StatusCode::FAILURE;
206 ATH_MSG_DEBUG(
"Treating crate " << rodCrate <<
" slink " << rodSlink);
210 return StatusCode::FAILURE;
214 "Run number: " << MSG::dec << rodRunNumber <<
endmsg
215 <<
"Version code: 0x" << MSG::hex <<
int(state.
m_verCode) << MSG::dec
216 <<
endmsg <<
"LUT triggered slice offset: "
219 <<
endmsg <<
"FADC baseline lower bound: "
249 }
else if (
blockType == (subBlock | 1)) {
255 case eformat::TDAQ_CALO_PREPROC:
268 return StatusCode::SUCCESS;
285 return StatusCode::FAILURE;
287 return StatusCode::SUCCESS;
321 <<
"' for rob version '"
323 << MSG::dec <<
"'" );
324 return StatusCode::FAILURE;
326 return StatusCode::SUCCESS;
333 uint8_t totSlice = 3 * numLut + numFadc;
336 for (
int asic = 0 ; asic < 4 ; ++asic ) {
337 for (
int mcm = 0 ; mcm < 16 ; ++mcm ) {
339 std::vector<uint32_t> rotated(totSlice);
342 for (
uint8_t bit = 0 ; bit < 11 ; ++bit ) {
343 if ( state.
m_ppBlock[
slice * 11 + asic * (11 * totSlice) + bit + 1] & (1 << mcm))
344 rotated[
slice] |= (1 << bit);
348 bool nonZeroData =
false;
351 || rotated[
slice + numLut]
352 || rotated[
slice + 2 * numLut + numFadc]) {
358 std::vector<uint8_t> lcpVal;
359 std::vector<uint8_t> lcpBcidVec;
360 std::vector<uint8_t> ljeVal;
361 std::vector<uint8_t> ljeSat80Vec;
362 std::vector<int16_t> pedCor;
363 std::vector<uint8_t> pedEn;
365 std::vector<uint16_t> adcVal;
366 std::vector<uint8_t> adcExt;
370 lcpVal.push_back(rotated[
slice] & 0xff);
371 ljeVal.push_back(rotated[
slice + numLut] & 0xff);
372 pedCor.push_back(::pedCorrection(rotated[
slice + 2 * numLut + numFadc] & 0x3ff));
374 lcpBcidVec.push_back((rotated[
slice] >> 8) & 0x7);
375 ljeSat80Vec.push_back((rotated[
slice + numLut] >> 8) & 0x7);
376 pedEn.push_back((rotated[
slice + 2 * numLut + numFadc] >> 10) & 0x1);
381 if (rotated[
slice + numLut]) {
389 adcVal.push_back(rotated[
slice + 2 * numLut] & 0x3ff);
390 adcExt.push_back((rotated[
slice + 2 * numLut] >> 10 & 0
x1) & 0x3ff);
400 std::move(lcpBcidVec),
402 std::move(ljeSat80Vec),
411 return StatusCode::SUCCESS;
422 present =
br.getField(1);
432 std::vector<uint16_t> adcVal = {0 , 0, 0, 0, 0};
433 std::vector<uint8_t> adcExt = {0 , 0, 0, 0, 0};
436 uint8_t minIndex = minHeader % 5;
437 if (minHeader < 15) {
438 if (minHeader < 10) {
441 fmt = 2 +
br.getField( 2);
445 lutVal =
br.getField(3);
451 lutVal =
br.getField(8);
452 lutExt =
br.getField(1);
453 lutSat =
br.getField(1);
454 lutPeak =
br.getField(1);
459 adcExt[
i] =
br.getField(1);
483 std::vector<uint8_t> {lutVal},
484 std::vector<uint8_t> {uint8_t(lutExt | (lutSat << 1) | (lutPeak << 2))},
491 }
catch (
const std::out_of_range& ex) {
495 return StatusCode::SUCCESS;
502 std::vector<uint16_t>
adc = {0, 0, 0, 0, 0};
509 longField =
br.getField(1);
510 numBits = longField == 0? 4: (
format * 2);
512 numBits =
i == 0? 4: (
format + 2);
516 minAdc =
br.getField(numBits);
517 if (longField == 0) {
521 adc[
i] = minAdc +
br.getField(numBits);
529 adc[minIndex] = minAdc;
548 const uint8_t nTotal = numAdc + numLut;
549 const uint8_t wordsPerBlock = 8;
550 const uint8_t iBlk = inData / wordsPerBlock;
555 uint16_t subword = (word >> 16 *
i) & 0x7ff;
556 state.
m_ppLuts[iChan].push_back(subword);
559 }
else if (iBlk < nTotal) {
561 uint16_t subword = (word >> (16 *
i)) & 0x7ff;
562 state.
m_ppFadcs[iChan].push_back(subword);
568 sc = StatusCode::FAILURE;
579 return StatusCode::SUCCESS;
582 return StatusCode::SUCCESS;
584 return StatusCode::FAILURE;
599 std::vector<uint8_t> haveLut(numLut, 0);
600 std::vector<uint8_t> lcpVal(numLut, 0);
602 std::vector<uint8_t> lcpExt(numLut, 0);
603 std::vector<uint8_t> lcpSat(numLut, 0);
604 std::vector<uint8_t> lcpPeak(numLut, 0);
605 std::vector<uint8_t> lcpBcidVec(numLut, 0);
607 std::vector<uint8_t> ljeVal(numLut, 0);
609 std::vector<uint8_t> ljeLow(numLut, 0);
610 std::vector<uint8_t> ljeHigh(numLut, 0);
611 std::vector<uint8_t> ljeRes(numLut, 0);
612 std::vector<uint8_t> ljeSat80Vec(numLut, 0);
614 std::vector<uint16_t> adcVal(numAdc, 0);
615 std::vector<uint8_t> adcExt(numAdc, 0);
616 std::vector<int16_t> pedCor(numLut, 0);
617 std::vector<uint8_t> pedEn(numLut, 0);
620 int8_t minIndex = -1;
623 present =
br.getField(1);
631 for(
uint i=0;
i < numLut; ++
i) {
632 lcpPeak[
i] =
br.getField(1);
637 ljeLow[
i] =
br.getField(1);
644 if (lcpPeak[
i] == 1) {
645 lcpVal[
i] =
br.getField(4);
649 if (lcpPeak[
i] == 1){
650 ljeVal[
i] =
br.getField(3);
657 haveLut[
i] =
br.getField(1);
665 adcExt[
i] =
br.getField(1);
670 if (haveLut[
i] == 1) {
671 lcpVal[
i] =
br.getField(8);
672 lcpExt[
i] =
br.getField(1);
673 lcpSat[
i] =
br.getField(1);
674 lcpPeak[
i] =
br.getField(1);
679 if (haveLut[
i] == 1) {
680 ljeVal[
i] =
br.getField(8);
681 ljeLow[
i] =
br.getField(1);
682 ljeHigh[
i] =
br.getField(1);
683 ljeRes[
i] =
br.getField(1);
696 pedCor[
i] =
br.getField(6) + pedCorBase;
708 pedCor[
i] = ::pedCorrection(
val);
709 pedEn[
i] =
br.getField(1);
714 lcpBcidVec[
i] =
uint8_t((lcpPeak[
i] << 2) | (lcpSat[
i] << 1) | lcpExt[
i]);
715 ljeSat80Vec[
i] =
uint8_t((ljeRes[
i] << 2) | (ljeHigh[
i] << 1) | ljeLow[
i]);
720 std::move(lcpVal), std::move(lcpBcidVec),
721 std::move(ljeVal), std::move(ljeSat80Vec),
722 std::move(adcVal), std::move(adcExt),
723 std::move(pedCor), std::move(pedEn)));
725 }
catch (
const std::out_of_range& ex) {
730 return StatusCode::SUCCESS;
736 int8_t&
encoding, int8_t& minIndex)
const
741 minHeader =
br.getField(4);
743 minIndex = minHeader % 5;
745 if (minHeader < 10) {
757 }
else if (numAdc == 7) {
759 }
else if (numAdc < 16) {
764 uint8_t fieldSize = 1 << numBits;
765 minHeader =
br.getField(numBits);
766 uint8_t encValue = fieldSize - 1;
767 if (minHeader == encValue) {
771 minHeader +=
br.getField(2) << numBits;
772 minIndex = minHeader % fieldSize;
773 encValue = 3 * fieldSize;
775 if (minHeader < encValue) {
794 return std::vector<uint16_t>(numAdc,
val);
796 std::vector<uint16_t>
adc(numAdc, 0);
798 adc[minIndex] = minAdc;
804 std::vector<uint16_t>
adc(numAdc, 0);
810 adc[minIndex] = minAdc;
812 adc[minIndex ==
i? 0:
i] =
br.getField(
824 return StatusCode::SUCCESS;
827 return StatusCode::FAILURE;
829 return StatusCode::FAILURE;
843 std::vector<uint8_t> lcpVal;
844 std::vector<uint8_t> lcpBcidVec;
846 std::vector<uint8_t> ljeVal;
847 std::vector<uint8_t> ljeSat80Vec;
851 std::vector<uint16_t> adcVal;
852 std::vector<uint8_t> adcExt;
853 std::vector<int16_t> pedCor;
854 std::vector<uint8_t> pedEn;
856 for (
int i = 0;
i < numLut; ++
i) {
857 lcpVal.push_back(
br.getField(8));
858 lcpBcidVec.push_back(
br.getField(3));
861 for (
int i = 0;
i < numLut; ++
i) {
862 ljeVal.push_back(
br.getField(8));
863 ljeSat80Vec.push_back(
br.getField(3));
866 for (
int i = 0;
i < numAdc; ++
i) {
867 adcVal.push_back(
br.getField(10));
868 adcExt.push_back(
br.getField(1));
871 for (
int i = 0;
i < numLut; ++
i) {
873 pedCor.push_back(pedCorrection(
pc));
874 pedEn.push_back(
br.getField(1));
876 }
catch (
const std::out_of_range& ex) {
883 std::move(lcpVal), std::move(lcpBcidVec),
884 std::move(ljeVal), std::move(ljeSat80Vec),
885 std::move(adcVal), std::move(adcExt),
886 std::move(pedCor), std::move(pedEn)));
889 return StatusCode::SUCCESS;
903 return StatusCode::SUCCESS;
919 if (
tt->coolId() >> 16 & crateModuleMask(crate,
module)){
933 std::vector<uint8_t>&& lcpVal,
934 std::vector<uint8_t>&& lcpBcidVec,
935 std::vector<uint8_t>&& ljeVal,
936 std::vector<uint8_t>&& ljeSat80Vec,
937 std::vector<uint16_t>&& adcVal,
938 std::vector<uint8_t>&& adcExt,
939 std::vector<int16_t>&& pedCor,
940 std::vector<uint8_t>&& pedEn)
const
951 return StatusCode::SUCCESS;
958 phi = 4 * pin + asic;
965 std::move(lcpVal), std::move(ljeVal),
966 std::move(pedCor), std::move(pedEn),
967 std::move(lcpBcidVec), std::move(adcVal),
968 std::move(adcExt), std::move(ljeSat80Vec),
971 return StatusCode::SUCCESS;
979 std::vector<uint8_t>&& luts,
980 std::vector<uint8_t>&& lcpBcidVec,
981 std::vector<uint16_t>&& fadc,
982 std::vector<uint8_t>&& bcidExt
985 std::vector<uint8_t> ljeSat80Vec;
987 std::vector<int16_t> pedCor;
988 std::vector<uint8_t> pedEn;
992 std::move(luts), std::move(lcpBcidVec),
993 std::move(luts) , std::move(ljeSat80Vec),
994 std::move(fadc), std::move(bcidExt),
995 std::move(pedCor), std::move(pedEn))
998 return StatusCode::SUCCESS;
1006 const std::vector<uint16_t>& luts,
1007 const std::vector<uint16_t>& fadc
1010 std::vector<uint8_t> lcpVal;
1011 std::vector<uint8_t> lcpBcidVec;
1013 std::vector<uint16_t> adcVal;
1014 std::vector<uint8_t> adcExt;
1016 for(
auto lut: luts) {
1017 lcpVal.push_back(BitField::get<uint8_t>(lut, 0, 8));
1018 lcpBcidVec.push_back(BitField::get<uint8_t>(lut, 8, 3));
1022 adcExt.push_back(BitField::get<uint8_t>(
f, 0, 1));
1023 adcVal.push_back(BitField::get<uint16_t>(
f, 1, 10));
1028 std::move(lcpVal), std::move(lcpBcidVec),
1029 std::move(adcVal), std::move(adcExt)));
1031 return StatusCode::SUCCESS;
1039 const int crates = 8;
1045 for (
int crate = 0; crate < crates; ++crate) {
1048 eformat::TDAQ_CALO_PREPROC);
1051 if (crate > 1 && crate < 6) {
1053 if (crate < 4 && slink == 0) {
1065 const std::string& sgKey)
const
1070 if (sgKey.find(
"Muon") != std::string::npos) {
1072 }
else if (sgKey.find(
"Spare") != std::string::npos) {
1098 if ((iBit + numBits) <= 31) {
1105 result = field1 | (field2 << nb1);
1111 throw std::out_of_range(
"Requested too much bits from ppm block");