hgcal::econd Namespace Reference

Classes
class	Emulator
	Pure virtual base class for a ECON-D event emulator implementation. More...
struct	EmulatorParameters
struct	ERxData
	parsed e-rx data More...
class	HGCalModuleTreeReader
class	TrivialEmulator
	A "trivial" ECON-D emulator emulating non-empty ECON-D events. More...

Typedefs
typedef std::pair< EventId, ERxInput >	ECONDInput
	ECON-D inputs for a given event. More...
typedef std::map< EventId, ERxInput >	ECONDInputColl
	collection of ECON-D inputs More...
typedef std::vector< bool >	ERxChannelEnable
	list of channels enabled in eRx More...
typedef std::pair< uint8_t, uint8_t >	ERxId_t
	chip/half More...
typedef std::map< ERxId_t, ERxData >	ERxInput
	eRx data maps More...
typedef std::tuple< uint32_t, uint32_t, uint32_t >	EventId
	Event index (L1A/BX/orbit) More...

Enumerations
enum	ToTStatus { ZeroSuppressed = 0x0, noZeroSuppressed_TOASuppressed = 0x1, invalid = 0x2, AutomaticFull = 0x3 }

Functions
uint32_t	buildIdleWord (uint8_t bufStat, uint8_t err, uint8_t rr, uint32_t progPattern)
std::vector< uint32_t >	eRxSubPacketHeader (uint8_t stat, uint8_t ham, bool bitE, uint16_t common_mode0, uint16_t common_mode1, const ERxChannelEnable &channel_enable)
std::vector< uint32_t >	eRxSubPacketHeader (uint8_t stat, uint8_t ham, bool bitE, uint16_t common_mode0, uint16_t common_mode1, uint64_t channels_map)
std::vector< uint32_t >	eventPacketHeader (uint16_t header, uint16_t payload, bool bitP, bool bitE, uint8_t ht, uint8_t ebo, bool bitM, bool bitT, uint8_t hamming, uint16_t bx, uint16_t l1a, uint8_t orb, bool bitS, uint8_t RR)
std::vector< uint32_t >	produceERxData (const ERxChannelEnable &, const ERxData &, bool passZS, bool passZSm1, bool hasToA, bool char_mode)

Typedef Documentation

ECONDInput

typedef std::pair<EventId, ERxInput> hgcal::econd::ECONDInput

ECON-D inputs for a given event.

Definition at line 32 of file SlinkTypes.h.

ECONDInputColl

typedef std::map<EventId, ERxInput> hgcal::econd::ECONDInputColl

collection of ECON-D inputs

Definition at line 35 of file SlinkTypes.h.

ERxChannelEnable

typedef std::vector<bool> hgcal::econd::ERxChannelEnable

list of channels enabled in eRx

Definition at line 38 of file SlinkTypes.h.

ERxId_t

typedef std::pair<uint8_t, uint8_t> hgcal::econd::ERxId_t

chip/half

Definition at line 17 of file SlinkTypes.h.

ERxInput

typedef std::map<ERxId_t, ERxData> hgcal::econd::ERxInput

eRx data maps

Definition at line 29 of file SlinkTypes.h.

EventId

typedef std::tuple<uint32_t, uint32_t, uint32_t> hgcal::econd::EventId

Event index (L1A/BX/orbit)

Definition at line 14 of file SlinkTypes.h.

Enumeration Type Documentation

ToTStatus

enum hgcal::econd::ToTStatus

Enumerator
ZeroSuppressed
noZeroSuppressed_TOASuppressed
invalid
AutomaticFull

Definition at line 6 of file HGCalRawDataDefinitions.h.

{ ZeroSuppressed = 0x0, noZeroSuppressed_TOASuppressed = 0x1, invalid = 0x2, AutomaticFull = 0x3 };

Function Documentation

buildIdleWord()

uint32_t hgcal::econd::buildIdleWord	(	uint8_t	bufStat,
		uint8_t	err,
		uint8_t	rr,
		uint32_t	progPattern
	)

builds a trailing idle word

Note

based on Fig. 33 of the ECON-D specs

Returns

a 32b word with the idle word

Definition at line 159 of file HGCalRawDataPackingTools.cc.

References submitPVResolutionJobs::err, and findQualityFiles::rr.

Referenced by hgcal::HGCalFrameGenerator::produceECONEvent().

                                                                                                 {
  return (progPattern & 0xffffff) << 8 | (rr & 0x3) << 6 | (err & 0x7) << 3 | (bufStat & 0x7) << 0;
}

eRxSubPacketHeader() [1/2]

std::vector< uint32_t > hgcal::econd::eRxSubPacketHeader	(	uint8_t	stat,
		uint8_t	ham,
		bool	bitE,
		uint16_t	common_mode0,
		uint16_t	common_mode1,
		const ERxChannelEnable &	channel_enable
	)

returns the words for a new eRx header

Note

based on Fig. 33 of ECON-D specifications

Returns

a vector with 1 or 2 32b words

Definition at line 80 of file HGCalRawDataPackingTools.cc.

References mps_fire::i.

Referenced by hgcal::HGCalFrameGenerator::generateERxData().

                                                                                               {
  uint64_t channels_map64b(0);
  size_t i = 0;
  for (const auto& ch : channel_enable)
    channels_map64b |= (ch << i++);
  return hgcal::econd::eRxSubPacketHeader(stat, hamming, bitE, common_mode0, common_mode1, channels_map64b);
}

eRxSubPacketHeader() [2/2]

std::vector< uint32_t > hgcal::econd::eRxSubPacketHeader	(	uint8_t	stat,
		uint8_t	ham,
		bool	bitE,
		uint16_t	common_mode0,
		uint16_t	common_mode1,
		uint64_t	channels_map
	)

Definition at line 94 of file HGCalRawDataPackingTools.cc.

References hgcal::CHMAP0_MASK, hgcal::CHMAP0_POS, hgcal::CHMAP32_MASK, hgcal::CHMAP32_POS, hgcal::COMMONMODE0_MASK, hgcal::COMMONMODE0_POS, hgcal::COMMONMODE1_MASK, hgcal::COMMONMODE1_POS, hgcal::ERX_E_POS, hgcal::ERXFORMAT_POS, hgcal::ERXHAM_MASK, hgcal::ERXHAM_POS, hgcal::ERXSTAT_MASK, hgcal::ERXSTAT_POS, and RecoTauValidation_cfi::header.

                                                                                                                   {
  std::vector<uint32_t> header = {
      (stat & hgcal::ECOND_FRAME::ERXSTAT_MASK) << hgcal::ECOND_FRAME::ERXSTAT_POS |
      (hamming & hgcal::ECOND_FRAME::ERXHAM_MASK) << hgcal::ECOND_FRAME::ERXHAM_POS |
      (common_mode0 & hgcal::ECOND_FRAME::COMMONMODE0_MASK) << hgcal::ECOND_FRAME::COMMONMODE0_POS |
      (common_mode1 & hgcal::ECOND_FRAME::COMMONMODE1_MASK) << hgcal::ECOND_FRAME::COMMONMODE1_POS};

  //summarize the channel status map
  const uint32_t chmapw0(channels_map & hgcal::ECOND_FRAME::CHMAP0_MASK),
      chmapw1((channels_map >> 32) & hgcal::ECOND_FRAME::CHMAP32_MASK);

  //add the channel map
  if (chmapw0 == 0 && chmapw1 == 0) {  // empty channels map (empty eRx)
    header[0] |= (bitE << hgcal::ECOND_FRAME::ERX_E_POS);
    header[0] |= (1 << hgcal::ECOND_FRAME::ERXFORMAT_POS);  //raise the F bit (empty eRX)
  } else {
    header[0] |= (chmapw1 & hgcal::ECOND_FRAME::CHMAP32_MASK) << hgcal::ECOND_FRAME::CHMAP32_POS;
    header.push_back((chmapw0 & hgcal::ECOND_FRAME::CHMAP0_MASK) << hgcal::ECOND_FRAME::CHMAP0_POS);
  }

  return header;
}

eventPacketHeader()

std::vector< uint32_t > hgcal::econd::eventPacketHeader	(	uint16_t	header,
		uint16_t	payload,
		bool	bitP,
		bool	bitE,
		uint8_t	ht,
		uint8_t	ebo,
		bool	bitM,
		bool	bitT,
		uint8_t	hamming,
		uint16_t	bx,
		uint16_t	l1a,
		uint8_t	orb,
		bool	bitS,
		uint8_t	RR
	)

builds the two ECON-D header words

Note

based on Fig. 33 of the ECON-D specs

Returns

a vector of size 2 with the ECON-D header

Definition at line 124 of file HGCalRawDataPackingTools.cc.

References hgcal::BITE_POS, hgcal::BITM_POS, hgcal::BITP_POS, hgcal::BITS_POS, hgcal::BITT_POS, nano_mu_digi_cff::bx, hgcal::BX_MASK, hgcal::BX_POS, computeCRC8bit(), hgcal::EBO_MASK, hgcal::EBO_POS, hgcal::EHCRC_MASK, hgcal::EHCRC_POS, hgcal::EHHAM_MASK, hgcal::EHHAM_POS, RecoTauValidation_cfi::header, hgcal::HEADER_MASK, hgcal::HEADER_POS, hgcal::HT_MASK, hgcal::HT_POS, hgcal::L1A_MASK, hgcal::L1A_POS, hgcal::ORBIT_MASK, hgcal::ORBIT_POS, jetsAK4_Puppi_cff::payload, hgcal::PAYLOAD_MASK, hgcal::PAYLOAD_POS, findQualityFiles::rr, hgcal::RR_MASK, and hgcal::RR_POS.

Referenced by hgcal::HGCalFrameGenerator::produceECONEvent().

                                                                  {
  std::vector<uint32_t> words(2, 0);

  words[0] = (header & hgcal::ECOND_FRAME::HEADER_MASK) << hgcal::ECOND_FRAME::HEADER_POS |
             (payload & hgcal::ECOND_FRAME::PAYLOAD_MASK) << hgcal::ECOND_FRAME::PAYLOAD_POS |
             bitP << hgcal::ECOND_FRAME::BITP_POS | bitE << hgcal::ECOND_FRAME::BITE_POS |
             (ht & hgcal::ECOND_FRAME::HT_MASK) << hgcal::ECOND_FRAME::HT_POS |
             (ebo & hgcal::ECOND_FRAME::EBO_MASK) << hgcal::ECOND_FRAME::EBO_POS |
             bitM << hgcal::ECOND_FRAME::BITM_POS | bitT << hgcal::ECOND_FRAME::BITT_POS |
             (ehHam & hgcal::ECOND_FRAME::EHHAM_MASK) << hgcal::ECOND_FRAME::EHHAM_POS;

  words[1] = (bx & hgcal::ECOND_FRAME::BX_MASK) << hgcal::ECOND_FRAME::BX_POS |
             (l1a & hgcal::ECOND_FRAME::L1A_MASK) << hgcal::ECOND_FRAME::L1A_POS |
             (orb & hgcal::ECOND_FRAME::ORBIT_MASK) << hgcal::ECOND_FRAME::ORBIT_POS |
             bitS << hgcal::ECOND_FRAME::BITS_POS | (rr & hgcal::ECOND_FRAME::RR_MASK) << hgcal::ECOND_FRAME::RR_POS;

  const auto crc = computeCRC8bit(words);
  words[1] |= (crc & hgcal::ECOND_FRAME::EHCRC_MASK) << hgcal::ECOND_FRAME::EHCRC_POS;

  return words;
}

produceERxData()

std::vector< uint32_t > hgcal::econd::produceERxData	(	const ERxChannelEnable &	channel_enable,
		const ERxData &	erx,
		bool	passZS,
		bool	passZSm1,
		bool	hasToA,
		bool	char_mode
	)

pack the ROC data to the ECON-D format dependending on:

• characterization mode : (TcTp + ADC + TOT + TOA) fixed 32b
• normal mode : size and fields depend on the TcTp flags

  Note

  based on Fig. 20 of ECON-D specifications

  Returns

  a vector of new words

Definition at line 6 of file HGCalRawDataPackingTools.cc.

References hgcal::econd::ERxData::adc, hgcal::econd::ERxData::adcm, AutomaticFull, data, Exception, mps_fire::i, createfilelist::int, noZeroSuppressed_TOASuppressed, hgcal::econd::ERxData::tctp, hgcal::econd::ERxData::toa, hgcal::econd::ERxData::tot, testProducerWithPsetDescEmpty_cfi::x1, testProducerWithPsetDescEmpty_cfi::x2, and siStripShotFilter_cfi::ZeroSuppressed.

Referenced by hgcal::HGCalFrameGenerator::generateERxData().

                                                                   {
  auto format_word = [&erx, &passZS, &passZSm1, &hasToA, &char_mode](size_t i) -> std::pair<uint32_t, uint8_t> {
    if (i >= erx.tctp.size())
      throw cms::Exception("HGCalEmulator")
          << "Not enough channels in eRx data payload: " << i << " >= " << erx.tctp.size() << ".";
    if (char_mode)  // characterisation mode is easy
      return std::make_pair(((uint8_t)erx.tctp.at(i) & 0x3) << 30 | (erx.adc.at(i) & 0x3ff) << 20 |
                                (erx.tot.at(i) & 0x3ff) << 10 | (erx.toa.at(i) & 0x3ff),
                            32);
    switch (erx.tctp.at(i)) {
      case ToTStatus::ZeroSuppressed: {
        if (!passZS)
          throw cms::Exception("HGCalEmulator") << "ToT status is ZeroSuppressed, but event frame does not pass ZS.";
        if (passZSm1) {
          if (hasToA)
            return std::make_pair((0x1 << 30) | ((erx.adcm.at(i) & 0x3ff) << 20) | ((erx.adc.at(i) & 0x3ff) << 10) |
                                      (erx.toa.at(i) & 0x3ff),
                                  32);
          else
            return std::make_pair(((erx.adcm.at(i) & 0x3ff) << 10) | (erx.adc.at(i) & 0x3ff), 24);
        }
        // at this point, does not have any BX-1 ZS info
        if (hasToA)
          return std::make_pair((0x3 << 20) | ((erx.adc.at(i) & 0x3ff) << 10) | (erx.toa.at(i) & 0x3ff), 24);
        return std::make_pair((0x1 << 10) | (erx.adc.at(i) & 0x3ff), 16);
      }
      case ToTStatus::noZeroSuppressed_TOASuppressed:
        return std::make_pair((0x2 << 20) | ((erx.adcm.at(i) & 0x3ff) << 10) | (erx.adc.at(i) & 0x3ff), 24);
      case ToTStatus::invalid:
        return std::make_pair(
            (0x2 << 30) | ((erx.adcm.at(i) & 0x3ff) << 20) | ((erx.adc.at(i) & 0x3ff) << 10) | (erx.toa.at(i) & 0x3ff),
            32);
      case ToTStatus::AutomaticFull:
        return std::make_pair(
            (0x3 << 30) | ((erx.adcm.at(i) & 0x3ff) << 20) | ((erx.tot.at(i) & 0x3ff) << 10) | (erx.toa.at(i) & 0x3ff),
            32);
      default:
        throw cms::Exception("HGCalEmulator")
            << "Invalid ToT status retrieved for channel " << i << ": " << (int)erx.tctp.at(i) << ".";
    }
  };

  std::vector<uint32_t> data{0};
  std::vector<uint32_t>::iterator it_data = data.begin();

  uint8_t msb = 0;
  for (size_t i = 0; i < channel_enable.size(); ++i) {
    if (!channel_enable.at(i))
      continue;
    const auto [word, nbits] = format_word(i);  // retrieve the channel word in its proper formatting

    if (msb >= 32)  // if we are already at the next word
      it_data = data.insert(data.end(), 0);
    msb %= 32;  // 0 <= msb < 32

    if (msb > 0)  // do we have some room for additional information?
      *it_data &= ((1 << msb) - 1);
    if (msb + nbits > 32) {  // spilling onto the next word
      uint8_t nbits_word1 = 32 - msb - nbits;
      *it_data |= (word & ((1 << nbits_word1) - 1)) << msb;
      it_data = data.insert(data.end(), word >> nbits_word1);
    } else  // everything fits into one word
      *it_data |= word << msb;
    msb += nbits;
  }
  return data;
}