LVL1BS::PpmCompressionV1 Class Reference

PPM Compressed Format Version 1.04 packing and unpacking utilities. More...

#include <PpmCompressionV1.h>

Collaboration diagram for LVL1BS::PpmCompressionV1:

Public Member Functions
	PpmCompressionV1 ()
	~PpmCompressionV1 ()

Static Public Member Functions
static bool	pack (PpmSubBlockV1 &subBlock)
	Pack data. More...
static bool	unpack (PpmSubBlockV1 &subBlock)
	Unpack data. More...

Static Private Member Functions
static bool	unpackV100 (PpmSubBlockV1 &subBlock)
static bool	unpackV101 (PpmSubBlockV1 &subBlock)
static bool	unpackV104 (PpmSubBlockV1 &subBlock)

Static Private Attributes
static const int	s_formatsV0 = 6
static const int	s_lowerRange = 12
static const int	s_upperRange = 3
static const int	s_formats = 7
static const int	s_fadcRange = 15
static const int	s_peakOnly = 4
static const int	s_lutDataBits = 8
static const int	s_lutBcidBits = 3
static const int	s_fadcDataBits = 10
static const int	s_glinkPins = 16
static const int	s_statusBits = 5
static const int	s_errorBits = 6
static const int	s_statusMask = 0x1f

Detailed Description

PPM Compressed Format Version 1.04 packing and unpacking utilities.

Based on:

"ATLAS L1Calo Pre-processor compressed S-Link data formats", Version 1.7, D.P.C.Sankey.

Author

Peter Faulkner

Definition at line 22 of file PpmCompressionV1.h.

Constructor & Destructor Documentation

PpmCompressionV1()

LVL1BS::PpmCompressionV1::PpmCompressionV1

(

)

~PpmCompressionV1()

LVL1BS::PpmCompressionV1::~PpmCompressionV1

(

)

Member Function Documentation

pack()

bool LVL1BS::PpmCompressionV1::pack ( PpmSubBlockV1 &  subBlock )

static

Pack data.

Definition at line 33 of file PpmCompressionV1.cxx.

{
  const int dataFormat = subBlock.format();
  if (dataFormat != L1CaloSubBlock::COMPRESSED &&
      dataFormat != L1CaloSubBlock::SUPERCOMPRESSED) return false;
  const int sliceL = subBlock.slicesLut();
  const int sliceF = subBlock.slicesFadc();
  if (sliceL != 1 || sliceF != 5) return false;
  const int trigOffset    = subBlock.fadcOffset() - subBlock.lutOffset();
  const int fadcBaseline  = subBlock.fadcBaseline();
  const int fadcThreshold = subBlock.fadcThreshold();
  const int channels      = subBlock.channelsPerSubBlock();
  subBlock.setStreamed();
  std::vector<uint32_t> compStats(s_formats);
  std::vector<int>      fadcDout(sliceF-1);
  std::vector<int>      fadcLens(sliceF-1);
  for (int chan = 0; chan < channels; ++chan) {
    std::vector<int> lutData;
    std::vector<int> lutBcid;
    std::vector<int> fadcData;
    std::vector<int> fadcBcid;
    subBlock.ppmData(chan, lutData, fadcData, lutBcid, fadcBcid);
    if (dataFormat == L1CaloSubBlock::SUPERCOMPRESSED) {
      int dataPresent = lutData[0] || lutBcid[0];
      if ( !dataPresent ) {
        for (int sl = 0; sl < sliceF; ++sl) {
     if (fadcData[sl] >= fadcThreshold || fadcBcid[sl]) {
       dataPresent = 1;
       break;
          }
        }
      }
      subBlock.packer(dataPresent, 1);
      if ( !dataPresent ) continue;
    }
    const int lutLen = subBlock.minBits(lutData[0]);
    int  minFadc   = 0;
    int  minOffset = 0;
    bool fadcSame  = true;
    for (int sl = 0; sl < sliceF; ++sl) {
      if (sl == 0) minFadc = fadcData[sl];
      if (fadcData[sl] < minFadc) {
        minFadc   = fadcData[sl];
   minOffset = sl;
      }
      if (fadcData[sl] != fadcData[0] || fadcBcid[sl] != 0) fadcSame = false;
    }
    if (minOffset) std::swap(fadcData[0], fadcData[minOffset]);
 
    int format = 0;
    if (lutData[0] == 0 && lutBcid[0] == 0 && fadcSame) { // format 6
      const int header = 15;
      subBlock.packer(header, 4);
      if (fadcData[0]) {
        subBlock.packer(1, 1);
   subBlock.packer(fadcData[0], s_fadcDataBits);
      } else subBlock.packer(0, 1);
      format = 6;
    } else {
      const bool minFadcInRange = minFadc >= fadcBaseline &&
                                  minFadc <= fadcBaseline + s_fadcRange;
      int  anyFadcBcid = 0;
      int  maxFadcLen = 0;
      int  idx = 0;
      for (int sl = 0; sl < sliceF; ++sl) {
        if (sl != 0) {
     fadcDout[idx] = fadcData[sl] - minFadc;
     fadcLens[idx] = subBlock.minBits(fadcDout[idx]);
     if (idx == 0 || fadcLens[idx] > maxFadcLen) {
       maxFadcLen = fadcLens[idx];
     }
     ++idx;
        }
   if (sl != trigOffset) anyFadcBcid |= fadcBcid[sl];
   else if (fadcBcid[sl] != (lutBcid[0] & 0x1)) anyFadcBcid |= 1;
      }
      if (lutData[0] == 0 && lutBcid[0] == 0 &&
                          !anyFadcBcid && minFadcInRange && maxFadcLen < 4) {
        // formats 0,1
        int header = minOffset;
   if (maxFadcLen == 3) header += 5;
   subBlock.packer(header, 4);
   minFadc -= fadcBaseline;
   subBlock.packer(minFadc, 4);
   if (maxFadcLen < 2) maxFadcLen = 2;
   for (int idx = 0; idx < sliceF-1; ++idx) {
     subBlock.packer(fadcDout[idx], maxFadcLen);
        }
   format = maxFadcLen - 2;
      } else if (lutLen <= 3 && ((lutData[0] == 0 && lutBcid[0] == 0) ||
                                 (lutData[0]  > 0 && lutBcid[0] == s_peakOnly))
                 && !anyFadcBcid && minFadcInRange && maxFadcLen <= 4) {
        // format 2
   const int header = minOffset + 10;
   subBlock.packer(header, 4);
   format = 2;
   subBlock.packer(format - 2, 2);
        if (lutData[0]) {
     subBlock.packer(1, 1);
     subBlock.packer(lutData[0], 3);
   } else subBlock.packer(0, 1);
   minFadc -= fadcBaseline;
   subBlock.packer(minFadc, 4);
   for (int idx = 0; idx < sliceF-1; ++idx) {
     subBlock.packer(fadcDout[idx], 4);
        }
      } else {
        // formats 3,4,5
   const int header = minOffset + 10;
   subBlock.packer(header, 4);
   if ( !minFadcInRange) {
     const int minFadcLen = subBlock.minBits(minFadc);
     if (minFadcLen > maxFadcLen) maxFadcLen = minFadcLen;
   }
   format = 5;
   if (maxFadcLen <= 8) format = 4;
   if (maxFadcLen <= 6) format = 3;
        subBlock.packer(format - 2, 2);
   if (lutData[0] || lutBcid[0]) subBlock.packer(1, 1);
   else subBlock.packer(0, 1);
   subBlock.packer(anyFadcBcid, 1);
   if (lutData[0] || lutBcid[0]) {
     subBlock.packer(lutData[0], s_lutDataBits);
     subBlock.packer(lutBcid[0], s_lutBcidBits);
   }
   if (anyFadcBcid) {
     for (int idx = 0; idx < sliceF; ++idx) {
       subBlock.packer(fadcBcid[idx], 1);
          }
        }
   if (minFadcInRange) {
     subBlock.packer(0, 1);
     minFadc -= fadcBaseline;
     subBlock.packer(minFadc, 4);
        } else {
     subBlock.packer(1, 1);
          subBlock.packer(minFadc, format * 2);
        }
   for (int idx = 0; idx < sliceF-1; ++idx) {
     if (fadcLens[idx] <= 4) {
       subBlock.packer(0, 1);
       subBlock.packer(fadcDout[idx], 4);
          } else {
       subBlock.packer(1, 1);
       subBlock.packer(fadcDout[idx], format * 2);
          }
        }
      }
    }
    ++compStats[format];
  }
  // Errors
  std::vector<int> status(s_glinkPins);
  std::vector<int> error(s_glinkPins);
  int statusBit = 0;
  int errorBit  = 0;
  for (int pin = 0; pin < s_glinkPins; ++pin) {
    const int errorWord = subBlock.ppmPinError(pin);
    status[pin] = errorWord &  s_statusMask;
    error[pin]  = errorWord >> s_statusBits;
    if (status[pin]) statusBit = 1;
    if (error[pin])  errorBit  = 1;
  }
  subBlock.packer(statusBit, 1);
  subBlock.packer(errorBit,  1);
  if (statusBit || errorBit) {
    for (int pin = 0; pin < s_glinkPins; ++pin) {
      if (status[pin] || error[pin]) subBlock.packer(1, 1);
      else subBlock.packer(0, 1);
    }
    for (int pin = 0; pin < s_glinkPins; ++pin) {
      if (status[pin] || error[pin]) {
        if (statusBit) subBlock.packer(status[pin], s_statusBits);
   if (errorBit)  subBlock.packer(error[pin],  s_errorBits);
      }
    }
  }
  subBlock.packerFlush();
  subBlock.setCompStats(compStats);
  return true;
}

unpack()

bool LVL1BS::PpmCompressionV1::unpack ( PpmSubBlockV1 &  subBlock )

static

Unpack data.

Definition at line 217 of file PpmCompressionV1.cxx.

{
  bool rc = false;
  switch (subBlock.seqno()) {
    case 0:
      rc = unpackV100(subBlock);
      break;
    case 1:
      rc = unpackV101(subBlock);
      break;
    case 2:
    case 3:
    case 4:
    case 5: // runs 88701-24 only
      rc = unpackV104(subBlock);
      break;
    default:
      subBlock.setUnpackErrorCode(L1CaloSubBlock::UNPACK_COMPRESSION_VERSION);
      break;
  }
  return rc;
}

unpackV100()

bool LVL1BS::PpmCompressionV1::unpackV100 ( PpmSubBlockV1 &  subBlock )

staticprivate

Definition at line 242 of file PpmCompressionV1.cxx.

{
  if (subBlock.format() != L1CaloSubBlock::COMPRESSED) {
    subBlock.setUnpackErrorCode(L1CaloSubBlock::UNPACK_FORMAT);
    return false;
  }
  const int sliceL = subBlock.slicesLut();
  const int sliceF = subBlock.slicesFadc();
  if (sliceL != 1 || sliceF != 5) {
    subBlock.setUnpackErrorCode(L1CaloSubBlock::UNPACK_COMPRESSION_SLICES);
    return false;
  }
  const int trigOffset = subBlock.fadcOffset();
  const int pedestal   = subBlock.pedestal();
  const int channels   = subBlock.channelsPerSubBlock();
  subBlock.setStreamed();
  subBlock.unpackerInit();
  std::vector<uint32_t> compStats(s_formatsV0);
  std::vector<int> lutData;
  std::vector<int> lutBcid;
  std::vector<int> fadcData;
  std::vector<int> fadcBcid;
  for (int chan = 0; chan < channels; ++chan) {
    lutData.clear();
    lutBcid.clear();
    fadcData.clear();
    fadcBcid.clear();
    int format = 0;
    const int header = subBlock.unpacker(4);
    if (header < 10) {
      // formats 0,1 - LUT zero, FADC around pedestal
      const int minOffset = header % 5;
                format    = header / 5;
      // LUT = 0
      lutData.push_back(0);
      lutBcid.push_back(0);
      // FADC
      const uint32_t minFadc = subBlock.unpacker(4) + pedestal - s_lowerRange;
      for (int sl = 0; sl < sliceF; ++sl) {
        if (sl == minOffset) fadcData.push_back(minFadc);
   else fadcData.push_back(subBlock.unpacker(format + 2) + minFadc);
   fadcBcid.push_back(0);
      }
    } else {
      // formats 2-5
      const int minOffset = header - 10;
                format = subBlock.unpacker(2) + 2;
      const int anyLut = subBlock.unpacker(1);
      int lut  = 0;
      int bcid = 0;
      if (format == 2) {
        // LUT
   if (anyLut) {
     lut  = subBlock.unpacker(3);
     bcid = s_peakOnly;  // just peak-finding BCID set
        }
   lutData.push_back(lut);
   lutBcid.push_back(bcid);
   // FADC as formats 0,1
        const int minFadc = subBlock.unpacker(4) + pedestal - s_lowerRange;
        for (int sl = 0; sl < sliceF; ++sl) {
          if (sl == minOffset) fadcData.push_back(minFadc);
     else fadcData.push_back(subBlock.unpacker(format + 2) + minFadc);
     fadcBcid.push_back(0);
        }
      } else {
        // formats 3,4,5 - full LUT word, variable FADC
   const int anyBcid = subBlock.unpacker(1);
   // LUT
   if (anyLut) {
     lut  = subBlock.unpacker(s_lutDataBits);
     bcid = subBlock.unpacker(s_lutBcidBits);
   }
        lutData.push_back(lut);
   lutBcid.push_back(bcid);
   // FADC
   for (int sl = 0; sl < sliceF; ++sl) {
     int fbcid = 0;
     if (sl == trigOffset) fbcid = bcid & 0x1; // take from LUT word
     else if (anyBcid) fbcid = subBlock.unpacker(1);
     fadcBcid.push_back(fbcid);
        }
   int minFadc = 0;
   if (subBlock.unpacker(1)) minFadc = subBlock.unpacker(format * 2);
   else minFadc = subBlock.unpacker(4) + pedestal - s_lowerRange;
   for (int sl = 0; sl < sliceF; ++sl) {
     int fadc = minFadc;
     if (sl != minOffset) {
       if (subBlock.unpacker(1)) fadc += subBlock.unpacker(format * 2);
       else                      fadc += subBlock.unpacker(4);
          }
     fadcData.push_back(fadc);
        }
      }
    }
    subBlock.fillPpmData(chan, lutData, fadcData, lutBcid, fadcBcid);
    ++compStats[format];
  }
  subBlock.setCompStats(compStats);
  const bool rc = subBlock.unpackerSuccess();
  if (!rc) subBlock.setUnpackErrorCode(L1CaloSubBlock::UNPACK_DATA_TRUNCATED);
  return rc;
}

unpackV101()

bool LVL1BS::PpmCompressionV1::unpackV101 ( PpmSubBlockV1 &  subBlock )

staticprivate

Definition at line 348 of file PpmCompressionV1.cxx.

{
  if (subBlock.format() != L1CaloSubBlock::COMPRESSED) {
    subBlock.setUnpackErrorCode(L1CaloSubBlock::UNPACK_FORMAT);
    return false;
  }
  const int sliceL = subBlock.slicesLut();
  const int sliceF = subBlock.slicesFadc();
  if (sliceL != 1 || sliceF != 5) {
    subBlock.setUnpackErrorCode(L1CaloSubBlock::UNPACK_COMPRESSION_SLICES);
    return false;
  }
  const int trigOffset = subBlock.fadcOffset();
  const int pedestal   = subBlock.pedestal();
  const int channels   = subBlock.channelsPerSubBlock();
  subBlock.setStreamed();
  subBlock.unpackerInit();
  std::vector<uint32_t> compStats(s_formats);
  std::vector<int> lutData;
  std::vector<int> lutBcid;
  std::vector<int> fadcData;
  std::vector<int> fadcBcid;
  for (int chan = 0; chan < channels; ++chan) {
    lutData.clear();
    lutBcid.clear();
    fadcData.clear();
    fadcBcid.clear();
    int format = 0;
    const int header = subBlock.unpacker(4);
    if (header < 10) {
      // formats 0,1 - LUT zero, FADC around pedestal
      const int minOffset = header % 5;
                format    = header / 5;
      // LUT = 0
      lutData.push_back(0);
      lutBcid.push_back(0);
      // FADC
      const int minFadc = subBlock.unpacker(4) + pedestal - s_lowerRange;
      fadcData.push_back(minFadc);
      fadcBcid.push_back(0);
      for (int sl = 1; sl < sliceF; ++sl) {
   fadcData.push_back(subBlock.unpacker(format + 2) + minFadc);
        fadcBcid.push_back(0);
      }
      if (minOffset) std::swap(fadcData[0], fadcData[minOffset]);
    } else if (header < 15) {
      // formats 2-5
      const int minOffset = header - 10;
                format = subBlock.unpacker(2) + 2;
      const int anyLut = subBlock.unpacker(1);
      int lut  = 0;
      int bcid = 0;
      if (format == 2) {
        // LUT
   if (anyLut) {
     lut  = subBlock.unpacker(3);
     bcid = s_peakOnly;  // just peak-finding BCID set
        }
   lutData.push_back(lut);
   lutBcid.push_back(bcid);
   // FADC as formats 0,1
        const int minFadc = subBlock.unpacker(4) + pedestal - s_lowerRange;
        fadcData.push_back(minFadc);
        fadcBcid.push_back(0);
        for (int sl = 1; sl < sliceF; ++sl) {
     fadcData.push_back(subBlock.unpacker(format + 2) + minFadc);
          fadcBcid.push_back(0);
        }
        if (minOffset) std::swap(fadcData[0], fadcData[minOffset]);
      } else {
        // formats 3,4,5 - full LUT word, variable FADC
   const int anyBcid = subBlock.unpacker(1);
   // LUT
   if (anyLut) {
     lut  = subBlock.unpacker(s_lutDataBits);
     bcid = subBlock.unpacker(s_lutBcidBits);
   }
        lutData.push_back(lut);
   lutBcid.push_back(bcid);
   // FADC
   for (int sl = 0; sl < sliceF; ++sl) {
     int fbcid = 0;
     if (sl == trigOffset) fbcid = bcid & 0x1; // take from LUT word
     else if (anyBcid) fbcid = subBlock.unpacker(1);
     fadcBcid.push_back(fbcid);
        }
   int minFadc = 0;
   if (subBlock.unpacker(1)) minFadc = subBlock.unpacker(format * 2);
   else minFadc = subBlock.unpacker(4) + pedestal - s_lowerRange;
   fadcData.push_back(minFadc);
   for (int sl = 1; sl < sliceF; ++sl) {
     int len = 4;
     if (subBlock.unpacker(1)) len = format * 2;
     fadcData.push_back(subBlock.unpacker(len) + minFadc);
        }
   if (minOffset) std::swap(fadcData[0], fadcData[minOffset]);
      }
    } else {
      // format 6 - LUT zero, FADC all equal
      format = 6;
      // LUT
      lutData.push_back(0);
      lutBcid.push_back(0);
      // FADC
      int fadc = 0;
      if (subBlock.unpacker(1)) fadc = subBlock.unpacker(s_fadcDataBits);
      for (int sl = 0; sl < sliceF; ++sl) {
        fadcData.push_back(fadc);
        fadcBcid.push_back(0);
      }
    }
    subBlock.fillPpmData(chan, lutData, fadcData, lutBcid, fadcBcid);
    ++compStats[format];
  }
  // Errors
  const int statusBit = subBlock.unpacker(1);
  const int errorBit  = subBlock.unpacker(1);
  if (statusBit || errorBit) {
    std::vector<int> err(s_glinkPins);
    for (int pin = 0; pin < s_glinkPins; ++pin) {
      err[pin] = subBlock.unpacker(1);
    }
    for (int pin = 0; pin < s_glinkPins; ++pin) {
      if (err[pin]) {
        int status = 0;
   int error  = 0;
   if (statusBit) status = subBlock.unpacker(s_statusBits-1);
   if (errorBit)  error  = subBlock.unpacker(s_errorBits+1);
   subBlock.fillPpmPinError(pin, (error << (s_statusBits-1)) | status);
      }
    }
  }
  subBlock.setCompStats(compStats);
  const bool rc = subBlock.unpackerSuccess();
  if (!rc) subBlock.setUnpackErrorCode(L1CaloSubBlock::UNPACK_DATA_TRUNCATED);
  return rc;
}

unpackV104()

bool LVL1BS::PpmCompressionV1::unpackV104 ( PpmSubBlockV1 &  subBlock )

staticprivate

Definition at line 488 of file PpmCompressionV1.cxx.

{
  const int dataFormat = subBlock.format();
  if (dataFormat != L1CaloSubBlock::COMPRESSED &&
      dataFormat != L1CaloSubBlock::SUPERCOMPRESSED) {
    subBlock.setUnpackErrorCode(L1CaloSubBlock::UNPACK_FORMAT);
    return false;
  }
  const int compressionVersion = subBlock.seqno();
  if (compressionVersion == 2 && dataFormat != L1CaloSubBlock::COMPRESSED) {
    subBlock.setUnpackErrorCode(L1CaloSubBlock::UNPACK_FORMAT);
    return false;
  }
  if (compressionVersion == 5) {
    const int run = subBlock.runNumber();
    if (run < 88701 || run > 88724) {
      subBlock.setUnpackErrorCode(L1CaloSubBlock::UNPACK_COMPRESSION_VERSION);
      return false;
    }
  }
  const int sliceL = subBlock.slicesLut();
  const int sliceF = subBlock.slicesFadc();
  if (sliceL != 1 || sliceF != 5) {
    subBlock.setUnpackErrorCode(L1CaloSubBlock::UNPACK_COMPRESSION_SLICES);
    return false;
  }
  const int trigOffset   = subBlock.fadcOffset() - subBlock.lutOffset();
  const int fadcBaseline = subBlock.fadcBaseline();
  const int channels     = subBlock.channelsPerSubBlock();
  subBlock.setStreamed();
  subBlock.unpackerInit();
  std::vector<uint32_t> compStats(s_formats);
  std::vector<int> lutData;
  std::vector<int> lutBcid;
  std::vector<int> fadcData;
  std::vector<int> fadcBcid;
  for (int chan = 0; chan < channels; ++chan) {
    if (dataFormat == L1CaloSubBlock::SUPERCOMPRESSED) {
      if ( !subBlock.unpacker(1) ) continue;
    }
    lutData.clear();
    lutBcid.clear();
    fadcData.clear();
    fadcBcid.clear();
    int format = 0;
    const int header = subBlock.unpacker(4);
    if (header < 10) {
      // formats 0,1 - LUT zero, FADC around pedestal
      const int minOffset = header % 5;
                format    = header / 5;
      // LUT = 0
      lutData.push_back(0);
      lutBcid.push_back(0);
      // FADC
      const int minFadc = subBlock.unpacker(4) + fadcBaseline;
      fadcData.push_back(minFadc);
      fadcBcid.push_back(0);
      for (int sl = 1; sl < sliceF; ++sl) {
   fadcData.push_back(subBlock.unpacker(format + 2) + minFadc);
        fadcBcid.push_back(0);
      }
      if (minOffset) std::swap(fadcData[0], fadcData[minOffset]);
    } else if (header < 15) {
      // formats 2-5
      const int minOffset = header - 10;
                format = subBlock.unpacker(2) + 2;
      const int anyLut = subBlock.unpacker(1);
      int lut  = 0;
      int bcid = 0;
      if (format == 2) {
        // LUT
   if (anyLut) {
     lut  = subBlock.unpacker(3);
     bcid = s_peakOnly;  // just peak-finding BCID set
        }
   lutData.push_back(lut);
   lutBcid.push_back(bcid);
   // FADC as formats 0,1
        const int minFadc = subBlock.unpacker(4) + fadcBaseline;
        fadcData.push_back(minFadc);
        fadcBcid.push_back(0);
        for (int sl = 1; sl < sliceF; ++sl) {
     fadcData.push_back(subBlock.unpacker(format + 2) + minFadc);
          fadcBcid.push_back(0);
        }
        if (minOffset) std::swap(fadcData[0], fadcData[minOffset]);
      } else {
        // formats 3,4,5 - full LUT word, variable FADC
   const int anyBcid = subBlock.unpacker(1);
   // LUT
   if (anyLut) {
     lut  = subBlock.unpacker(s_lutDataBits);
     bcid = subBlock.unpacker(s_lutBcidBits);
   }
        lutData.push_back(lut);
   lutBcid.push_back(bcid);
   // FADC
   for (int sl = 0; sl < sliceF; ++sl) {
     int fbcid = 0;
     if (anyBcid) fbcid = subBlock.unpacker(1);
     else if (sl == trigOffset) fbcid = bcid & 0x1; // take from LUT word
     fadcBcid.push_back(fbcid);
        }
   int minFadc = 0;
   if (subBlock.unpacker(1)) minFadc = subBlock.unpacker(format * 2);
   else minFadc = subBlock.unpacker(4) + fadcBaseline;
   fadcData.push_back(minFadc);
   for (int sl = 1; sl < sliceF; ++sl) {
     int len = 4;
     if (subBlock.unpacker(1)) len = format * 2;
     fadcData.push_back(subBlock.unpacker(len) + minFadc);
        }
   if (minOffset) std::swap(fadcData[0], fadcData[minOffset]);
      }
    } else {
      // format 6 - LUT zero, FADC all equal
      format = 6;
      // LUT
      lutData.push_back(0);
      lutBcid.push_back(0);
      // FADC
      int fadc = 0;
      if (subBlock.unpacker(1)) fadc = subBlock.unpacker(s_fadcDataBits);
      for (int sl = 0; sl < sliceF; ++sl) {
        fadcData.push_back(fadc);
        fadcBcid.push_back(0);
      }
    }
    subBlock.fillPpmData(chan, lutData, fadcData, lutBcid, fadcBcid);
    ++compStats[format];
  }
  // Errors
  const int statusBit = subBlock.unpacker(1);
  const int errorBit  = subBlock.unpacker(1);
  const bool mcmAbsentIsError = compressionVersion < 4;
  const int sBits = (mcmAbsentIsError) ? s_statusBits - 1 : s_statusBits;
  const int eBits = (mcmAbsentIsError) ? s_errorBits  + 1 : s_errorBits;
  if (statusBit || errorBit) {
    std::vector<int> err(s_glinkPins);
    for (int pin = 0; pin < s_glinkPins; ++pin) {
      err[pin] = subBlock.unpacker(1);
    }
    for (int pin = 0; pin < s_glinkPins; ++pin) {
      if (err[pin]) {
        int status = 0;
   int error  = 0;
   if (statusBit) status = subBlock.unpacker(sBits);
   if (errorBit)  error  = subBlock.unpacker(eBits);
   subBlock.fillPpmPinError(pin, (error << sBits) | status);
      }
    }
    // There is a bug in versions < 4 but if I've understood it correctly
    // it is not possible to detect it reliably in data.
  }
  subBlock.setCompStats(compStats);
  bool rc = subBlock.unpackerSuccess();
  if (!rc) subBlock.setUnpackErrorCode(L1CaloSubBlock::UNPACK_DATA_TRUNCATED);
  else {
    // Check no more non-zero data - indicates corruption
    while (subBlock.unpackerSuccess()) {
      if (subBlock.unpacker(31)) {
        subBlock.setUnpackErrorCode(L1CaloSubBlock::UNPACK_EXCESS_DATA);
   rc = false;
   break;
      }
    }
  }
  return rc;
}

Member Data Documentation

s_errorBits

const int LVL1BS::PpmCompressionV1::s_errorBits = 6

staticprivate

Definition at line 45 of file PpmCompressionV1.h.

s_fadcDataBits

const int LVL1BS::PpmCompressionV1::s_fadcDataBits = 10

staticprivate

Definition at line 42 of file PpmCompressionV1.h.

s_fadcRange

const int LVL1BS::PpmCompressionV1::s_fadcRange = 15

staticprivate

Definition at line 38 of file PpmCompressionV1.h.

s_formats

const int LVL1BS::PpmCompressionV1::s_formats = 7

staticprivate

Definition at line 37 of file PpmCompressionV1.h.

s_formatsV0

const int LVL1BS::PpmCompressionV1::s_formatsV0 = 6

staticprivate

Definition at line 34 of file PpmCompressionV1.h.

s_glinkPins

const int LVL1BS::PpmCompressionV1::s_glinkPins = 16

staticprivate

Definition at line 43 of file PpmCompressionV1.h.

s_lowerRange

const int LVL1BS::PpmCompressionV1::s_lowerRange = 12

staticprivate

Definition at line 35 of file PpmCompressionV1.h.

s_lutBcidBits

const int LVL1BS::PpmCompressionV1::s_lutBcidBits = 3

staticprivate

Definition at line 41 of file PpmCompressionV1.h.

s_lutDataBits

const int LVL1BS::PpmCompressionV1::s_lutDataBits = 8

staticprivate

Definition at line 40 of file PpmCompressionV1.h.

s_peakOnly

const int LVL1BS::PpmCompressionV1::s_peakOnly = 4

staticprivate

Definition at line 39 of file PpmCompressionV1.h.

s_statusBits

const int LVL1BS::PpmCompressionV1::s_statusBits = 5

staticprivate

Definition at line 44 of file PpmCompressionV1.h.

s_statusMask

const int LVL1BS::PpmCompressionV1::s_statusMask = 0x1f

staticprivate

Definition at line 46 of file PpmCompressionV1.h.

s_upperRange

const int LVL1BS::PpmCompressionV1::s_upperRange = 3

staticprivate

Definition at line 36 of file PpmCompressionV1.h.

---

The documentation for this class was generated from the following files:

• PpmCompressionV1.h
• PpmCompressionV1.cxx