sistrip::fedchannelunpacker::detail Namespace Reference

Functions
template<uint16_t mask>
uint16_t	getADC_B1 (const uint8_t *data, uint_fast16_t wOffset, uint_fast8_t bOffset)
template<uint16_t mask>
uint16_t	getADC_B2 (const uint8_t *data, uint_fast16_t wOffset, uint_fast8_t bOffset)
template<uint8_t num_words>
uint16_t	getADC_W (const uint8_t *data, uint_fast16_t offset, uint8_t bits_shift)
uint16_t	readoutOrder (uint16_t physical_order)
template<uint_fast8_t num_bits, typename OUT >
StatusCode	unpackRawB (const FEDChannel &channel, OUT &&out)
template<uint8_t num_bits, typename OUT >
StatusCode	unpackRawW (const FEDChannel &channel, OUT &&out, uint8_t bits_shift=0)
template<uint_fast8_t num_bits, typename OUT >
StatusCode	unpackZSB (const FEDChannel &channel, OUT &&out, uint8_t headerLength, uint16_t stripStart)
template<uint8_t num_bits, typename OUT >
StatusCode	unpackZSW (const FEDChannel &channel, OUT &&out, uint8_t headerLength, uint16_t stripStart, uint8_t bits_shift=0)

Function Documentation

getADC_B1()

template<uint16_t mask>

uint16_t sistrip::fedchannelunpacker::detail::getADC_B1	(	const uint8_t *	data,
		uint_fast16_t	wOffset,
		uint_fast8_t	bOffset
	)

Definition at line 208 of file SiStripFEDBuffer.h.

References sistrip::BITS_PER_BYTE, data, and gpuClustering::pixelStatus::mask.

                                                                                           {
        // get ADC from one byte, until bOffset into the byte at wOffset (maximum decided by mask)
        return (data[wOffset ^ 7] >> (BITS_PER_BYTE - bOffset)) & mask;
      }

getADC_B2()

template<uint16_t mask>

uint16_t sistrip::fedchannelunpacker::detail::getADC_B2	(	const uint8_t *	data,
		uint_fast16_t	wOffset,
		uint_fast8_t	bOffset
	)

Definition at line 203 of file SiStripFEDBuffer.h.

References sistrip::BITS_PER_BYTE, data, and gpuClustering::pixelStatus::mask.

                                                                                           {
        // get ADC from two bytes, from wOffset until bOffset bits from the next byte (maximum decided by mask)
        return (((data[wOffset ^ 7]) << bOffset) + (data[(wOffset + 1) ^ 7] >> (BITS_PER_BYTE - bOffset))) & mask;
      }

getADC_W()

template<uint8_t num_words>

uint16_t sistrip::fedchannelunpacker::detail::getADC_W	(	const uint8_t *	data,
		uint_fast16_t	offset,
		uint8_t	bits_shift
	)

Definition at line 197 of file SiStripFEDBuffer.h.

References data, and hltrates_dqm_sourceclient-live_cfg::offset.

                                                                                       {
        // get ADC from one or two bytes (at most 10 bits), and shift if needed
        return (data[offset ^ 7] + (num_words == 2 ? ((data[(offset + 1) ^ 7] & 0x03) << 8) : 0)) << bits_shift;
      }

readoutOrder()

uint16_t sistrip::fedchannelunpacker::detail::readoutOrder ( uint16_t  physical_order )

inline

Definition at line 351 of file SiStripFEDBuffer.h.

Referenced by sistrip::fedchannelunpacker::unpackVirginRaw().

                                                            {
        return (4 * ((static_cast<uint16_t>((static_cast<float>(physical_order) / 8.0))) % 4) +
                static_cast<uint16_t>(static_cast<float>(physical_order) / 32.0) + 16 * (physical_order % 8));
      }

unpackRawB()

template<uint_fast8_t num_bits, typename OUT >

StatusCode sistrip::fedchannelunpacker::detail::unpackRawB	(	const FEDChannel &	channel,
		OUT &&	out
	)

Definition at line 234 of file SiStripFEDBuffer.h.

References sistrip::fedchannelunpacker::BAD_CHANNEL_LENGTH, sistrip::BITS_PER_BYTE, data, sistrip::FEDChannel::data(), sistrip::FEDChannel::length(), LogDebug, gpuClustering::pixelStatus::mask, sistrip::FEDChannel::offset(), MillePedeFileConverter_cfg::out, and sistrip::fedchannelunpacker::SUCCESS.

                                                                  {
        static_assert(num_bits <= 16, "Word length must be between 0 and 16.");
        if (channel.length() & 0xF000) {
          LogDebug("FEDBuffer") << "Channel length is invalid. Channel length is " << uint16_t(channel.length()) << ".";
          return StatusCode::BAD_CHANNEL_LENGTH;
        }
        constexpr uint16_t mask = (1 << num_bits) - 1;
        const uint8_t* const data = channel.data();
        const uint_fast16_t chEnd = channel.offset() + channel.length();
        uint_fast16_t wOffset = channel.offset() + 3;
        uint_fast8_t bOffset = 0;
        while (((wOffset + 1) < chEnd) || ((chEnd - wOffset) * BITS_PER_BYTE - bOffset >= num_bits)) {
          bOffset += num_bits;
          if ((num_bits > BITS_PER_BYTE) || (bOffset > BITS_PER_BYTE)) {
            bOffset -= BITS_PER_BYTE;
            **out++ = SiStripRawDigi(getADC_B2<mask>(data, wOffset, bOffset));
            ++wOffset;
          } else {
            **out++ = SiStripRawDigi(getADC_B1<mask>(data, wOffset, bOffset));
          }
          if (bOffset == BITS_PER_BYTE) {
            bOffset = 0;
            ++wOffset;
          }
        }
        return StatusCode::SUCCESS;
      }

unpackRawW()

template<uint8_t num_bits, typename OUT >

StatusCode sistrip::fedchannelunpacker::detail::unpackRawW	(	const FEDChannel &	channel,
		OUT &&	out,
		uint8_t	bits_shift = 0
	)

Definition at line 215 of file SiStripFEDBuffer.h.

References sistrip::fedchannelunpacker::BAD_CHANNEL_LENGTH, data, sistrip::FEDChannel::data(), sistrip::FEDChannel::length(), LogDebug, hltrates_dqm_sourceclient-live_cfg::offset, sistrip::FEDChannel::offset(), MillePedeFileConverter_cfg::out, and sistrip::fedchannelunpacker::SUCCESS.

                                                                                          {
        constexpr auto num_words = num_bits / 8;
        static_assert(((num_bits % 8) == 0) && (num_words > 0) && (num_words < 3));
        if ((num_words > 1) && ((channel.length() - 3) % num_words)) {
          LogDebug("FEDBuffer") << "Channel length is invalid. Raw channels have 3 header bytes and " << num_words
                                << " bytes per sample. "
                                << "Channel length is " << uint16_t(channel.length()) << ".";
          return StatusCode::BAD_CHANNEL_LENGTH;
        }
        const uint8_t* const data = channel.data();
        const uint_fast16_t end = channel.offset() + channel.length();
        for (uint_fast16_t offset = channel.offset() + 3; offset != end; offset += num_words) {
          *out++ = SiStripRawDigi(getADC_W<num_words>(data, offset, bits_shift));
        }
        return StatusCode::SUCCESS;
      }

unpackZSB()

template<uint_fast8_t num_bits, typename OUT >

StatusCode sistrip::fedchannelunpacker::detail::unpackZSB	(	const FEDChannel &	channel,
		OUT &&	out,
		uint8_t	headerLength,
		uint16_t	stripStart
	)

Definition at line 301 of file SiStripFEDBuffer.h.

References sistrip::fedchannelunpacker::BAD_CHANNEL_LENGTH, sistrip::BITS_PER_BYTE, data, sistrip::FEDChannel::data(), sistrip::FEDChannel::length(), LogDebug, gpuClustering::pixelStatus::mask, sistrip::FEDChannel::offset(), MillePedeFileConverter_cfg::out, sistrip::fedchannelunpacker::SUCCESS, and sistrip::fedchannelunpacker::UNORDERED_DATA.

                                                                                                            {
        constexpr uint16_t mask = (1 << num_bits) - 1;
        if (channel.length() & 0xF000) {
          LogDebug("FEDBuffer") << "Channel length is invalid. Channel length is " << uint16_t(channel.length()) << ".";
          return StatusCode::BAD_CHANNEL_LENGTH;
        }
        const uint8_t* const data = channel.data();
        uint_fast16_t wOffset = channel.offset() + headerLength;  // header is 2 (lite) or 7
        uint_fast8_t bOffset{0}, firstStrip{0}, nInCluster{0}, inCluster{0};
        const uint_fast16_t chEnd = channel.offset() + channel.length();
        while (((wOffset + 1) < chEnd) ||
               ((inCluster != nInCluster) && ((chEnd - wOffset) * BITS_PER_BYTE - bOffset >= num_bits))) {
          if (inCluster == nInCluster) {
            if (wOffset + 2 >= chEnd) {
              // offset should already be at end then (empty cluster)
              break;
            }
            if (bOffset) {
              ++wOffset;
              bOffset = 0;
            }
            const uint_fast8_t newFirstStrip = data[(wOffset++) ^ 7];
            if (newFirstStrip < (firstStrip + inCluster)) {
              LogDebug("FEDBuffer") << "First strip of new cluster is not greater than last strip of previous cluster. "
                                    << "Last strip of previous cluster is " << uint16_t(firstStrip + inCluster) << ". "
                                    << "First strip of new cluster is " << uint16_t(newFirstStrip) << ".";
              return StatusCode::UNORDERED_DATA;
            }
            firstStrip = newFirstStrip;
            nInCluster = data[(wOffset++) ^ 7];
            inCluster = 0;
            bOffset = 0;
          }
          bOffset += num_bits;
          if ((num_bits > BITS_PER_BYTE) || (bOffset > BITS_PER_BYTE)) {
            bOffset -= BITS_PER_BYTE;
            *out++ = SiStripDigi(stripStart + firstStrip + inCluster, getADC_B2<mask>(data, wOffset, bOffset));
            ++wOffset;
          } else {
            *out++ = SiStripDigi(stripStart + firstStrip + inCluster, getADC_B1<mask>(data, wOffset, bOffset));
          }
          ++inCluster;
          if (bOffset == BITS_PER_BYTE) {
            bOffset = 0;
            ++wOffset;
          }
        }
        return StatusCode::SUCCESS;
      }

unpackZSW()

template<uint8_t num_bits, typename OUT >

StatusCode sistrip::fedchannelunpacker::detail::unpackZSW	(	const FEDChannel &	channel,
		OUT &&	out,
		uint8_t	headerLength,
		uint16_t	stripStart,
		uint8_t	bits_shift = 0
	)

Definition at line 263 of file SiStripFEDBuffer.h.

References sistrip::fedchannelunpacker::BAD_CHANNEL_LENGTH, data, sistrip::FEDChannel::data(), sistrip::FEDChannel::length(), LogDebug, hltrates_dqm_sourceclient-live_cfg::offset, sistrip::FEDChannel::offset(), MillePedeFileConverter_cfg::out, sistrip::fedchannelunpacker::SUCCESS, and sistrip::fedchannelunpacker::UNORDERED_DATA.

                                                                                                                   {
        constexpr auto num_words = num_bits / 8;
        static_assert(((num_bits % 8) == 0) && (num_words > 0) && (num_words < 3));
        if (channel.length() & 0xF000) {
          LogDebug("FEDBuffer") << "Channel length is invalid. Channel length is " << uint16_t(channel.length()) << ".";
          return StatusCode::BAD_CHANNEL_LENGTH;
        }
        const uint8_t* const data = channel.data();
        uint_fast16_t offset = channel.offset() + headerLength;  // header is 2 (lite) or 7
        uint_fast8_t firstStrip{0}, nInCluster{0}, inCluster{0};
        const uint_fast16_t end = channel.offset() + channel.length();
        while (offset != end) {
          if (inCluster == nInCluster) {
            if (offset + 2 >= end) {
              // offset should already be at end then (empty cluster)
              break;
            }
            const uint_fast8_t newFirstStrip = data[(offset++) ^ 7];
            if (newFirstStrip < (firstStrip + inCluster)) {
              LogDebug("FEDBuffer") << "First strip of new cluster is not greater than last strip of previous cluster. "
                                    << "Last strip of previous cluster is " << uint16_t(firstStrip + inCluster) << ". "
                                    << "First strip of new cluster is " << uint16_t(newFirstStrip) << ".";
              return StatusCode::UNORDERED_DATA;
            }
            firstStrip = newFirstStrip;
            nInCluster = data[(offset++) ^ 7];
            inCluster = 0;
          }
          *out++ = SiStripDigi(stripStart + firstStrip + inCluster, getADC_W<num_words>(data, offset, bits_shift));
          offset += num_words;
          ++inCluster;
        }
        return StatusCode::SUCCESS;
      }