LVL1::MuCTPIBits Namespace Reference

Classes
struct	Candidate
struct	Multiplicity
struct	Slice
struct	TimesliceHeader
struct	TopoTOB

Enumerations
enum	WordType : uint8_t {   WordType::Undefined =0, WordType::Timeslice, WordType::Multiplicity, WordType::Candidate,   WordType::Topo, WordType::Status, WordType::MAX }
enum	SubsysID : uint8_t {   SubsysID::Undefined =0, SubsysID::Barrel, SubsysID::Forward, SubsysID::Endcap,   SubsysID::MAX }

Functions
constexpr uint32_t	maskedWord (uint32_t word, uint32_t shift, uint32_t mask)
	Extract sub-word from 32-bit word by applying a shift and a mask. More...
constexpr uint32_t	maskedWord (uint64_t word, uint32_t shift, uint32_t mask)
	Extract sub-word from 64-bit word by applying a shift and a mask. More...
constexpr uint32_t	buildWord (uint32_t value, uint32_t shift, uint32_t mask)
	Extract sub-word from 32-bit word by applying a shift and a mask. More...
constexpr bool	wordEquals (uint32_t word, uint32_t shift, uint32_t mask, uint32_t value)
	Compare a sub-word of a 32-bit word to an expected value. More...
constexpr WordType	getWordType (uint32_t word)
	Determine the type of a MUCTPI ROD word. More...
constexpr auto	timesliceHeader (uint32_t word)
	Decode timeslice word. More...
constexpr uint32_t	timesliceHeader (uint32_t bcid, uint32_t tobCount, uint32_t candCount)
	Encode timeslice word. More...
constexpr auto	topoHeader (uint32_t word)
	Decode topo word : More...
constexpr uint32_t	multiplicityWordNumber (uint32_t word)
	Decode the index of the multitpicity word, which is 1, 2, or 3. More...
constexpr std::array< uint32_t, 3 >	multiplicityWords (uint64_t multiplicity, uint32_t triggerBits, bool overflow)
	Encode the multiplicity words. More...
constexpr SubsysID	getSubsysID (uint32_t word)
	Decode the subsys ID from RoI candidate word. More...
std::vector< size_t >	getDataStatusWordErrors (uint32_t word)
	Decode the data status word (returns a vector of bit indices for the errors set - empty if no errors) More...
constexpr uint32_t	dataStatusWord (uint16_t status)
	Encode the data status word. More...

Variables
const uint32_t	RPCtoTGC_pt_map [7] = {0, 2, 4, 6, 8, 10, 12}

Enumeration Type Documentation

SubsysID

enum LVL1::MuCTPIBits::SubsysID : uint8_t

strong

Enumerator
Undefined
Barrel
Forward
Endcap
MAX

Definition at line 17 of file HelpersPhase1.h.

: uint8_t {Undefined=0, Barrel, Forward, Endcap, MAX};

WordType

enum LVL1::MuCTPIBits::WordType : uint8_t

strong

Enumerator
Undefined
Timeslice
Multiplicity
Candidate
Topo
Status
MAX

Definition at line 16 of file HelpersPhase1.h.

: uint8_t {Undefined=0, Timeslice, Multiplicity, Candidate, Topo, Status, MAX};

Function Documentation

buildWord()

constexpr uint32_t LVL1::MuCTPIBits::buildWord ( uint32_t  value, uint32_t  shift, uint32_t  mask  )

inlineconstexpr

Extract sub-word from 32-bit word by applying a shift and a mask.

Definition at line 54 of file HelpersPhase1.h.

                                                                                     {
    return ((value & mask) << shift);
  }

dataStatusWord()

constexpr uint32_t LVL1::MuCTPIBits::dataStatusWord ( uint16_t  status )

inlineconstexpr

Encode the data status word.

Definition at line 199 of file HelpersPhase1.h.

                                                            {
    uint32_t word = buildWord(RUN3_STATUS_WORD_ID_VAL, RUN3_STATUS_WORD_ID_SHIFT, RUN3_STATUS_WORD_ID_MASK);
    word |= status;
    return word;
  }

getDataStatusWordErrors()

std::vector<size_t> LVL1::MuCTPIBits::getDataStatusWordErrors ( uint32_t  word )

inline

Decode the data status word (returns a vector of bit indices for the errors set - empty if no errors)

Definition at line 186 of file HelpersPhase1.h.

                                                                  {
    uint16_t status = maskedWord(word, RUN3_STATUS_WORD_SHIFT, RUN3_STATUS_WORD_MASK);
    if (status==0) return {};
    std::vector<size_t> errors;
    for (size_t bit=0; bit<DataStatusWordErrors.size(); ++bit) {
      if (wordEquals(status, bit, 1u, 1u)) {
          errors.push_back(bit);
      }
    }
    return errors;
  }

getSubsysID()

constexpr SubsysID LVL1::MuCTPIBits::getSubsysID ( uint32_t  word )

inlineconstexpr

Decode the subsys ID from RoI candidate word.

Definition at line 174 of file HelpersPhase1.h.

                                                       {
    if (wordEquals(word, RUN3_SUBSYS_ADDRESS_EC_SHIFT, RUN3_SUBSYS_ADDRESS_EC_MASK, RUN3_SUBSYS_ADDRESS_EC_VAL)) {
      return SubsysID::Endcap;
    } else if (wordEquals(word, RUN3_SUBSYS_ADDRESS_BAFW_SHIFT, RUN3_SUBSYS_ADDRESS_BAFW_MASK, RUN3_SUBSYS_ADDRESS_FW_VAL)) {
      return SubsysID::Forward;
    } else if (wordEquals(word, RUN3_SUBSYS_ADDRESS_BAFW_SHIFT, RUN3_SUBSYS_ADDRESS_BAFW_MASK, RUN3_SUBSYS_ADDRESS_BA_VAL)) {
      return SubsysID::Barrel;
    }
    return SubsysID::Undefined;
  }

getWordType()

constexpr WordType LVL1::MuCTPIBits::getWordType ( uint32_t  word )

inlineconstexpr

Determine the type of a MUCTPI ROD word.

Definition at line 64 of file HelpersPhase1.h.

                                                       {
    if (wordEquals(word, RUN3_TIMESLICE_MULT_WORD_ID_SHIFT, RUN3_TIMESLICE_MULT_WORD_ID_MASK, RUN3_TIMESLICE_MULT_WORD_ID_VAL)) {
      if (wordEquals(word, RUN3_TIMESLICE_MULT_WORD_NUM_SHIFT, RUN3_TIMESLICE_MULT_WORD_NUM_MASK, RUN3_TIMESLICE_WORD_NUM_VAL)) {
    return WordType::Timeslice;
      }
      return WordType::Multiplicity;
    } else if (wordEquals(word, RUN3_CAND_WORD_ID_SHIFT, RUN3_CAND_WORD_ID_MASK, RUN3_CAND_WORD_ID_VAL)) {
      return WordType::Candidate;
    } else if (wordEquals(word, RUN3_TOPO_WORD_ID_SHIFT, RUN3_TOPO_WORD_ID_MASK, RUN3_TOPO_WORD_ID_VAL)) {
      return WordType::Topo;
    } else if (wordEquals(word, RUN3_STATUS_WORD_ID_SHIFT, RUN3_STATUS_WORD_ID_MASK, RUN3_STATUS_WORD_ID_VAL)) {
      return WordType::Status;
    }
    return WordType::Undefined;
  }

maskedWord() [1/2]

constexpr uint32_t LVL1::MuCTPIBits::maskedWord ( uint32_t  word, uint32_t  shift, uint32_t  mask  )

inlineconstexpr

Extract sub-word from 32-bit word by applying a shift and a mask.

Definition at line 44 of file HelpersPhase1.h.

                                                                                     {
    return ((word >> shift) & mask);
  }

maskedWord() [2/2]

constexpr uint32_t LVL1::MuCTPIBits::maskedWord ( uint64_t  word, uint32_t  shift, uint32_t  mask  )

inlineconstexpr

Extract sub-word from 64-bit word by applying a shift and a mask.

Definition at line 49 of file HelpersPhase1.h.

                                                                                     {
    return ((word >> shift) & mask);
  }

multiplicityWordNumber()

constexpr uint32_t LVL1::MuCTPIBits::multiplicityWordNumber ( uint32_t  word )

inlineconstexpr

Decode the index of the multitpicity word, which is 1, 2, or 3.

Definition at line 154 of file HelpersPhase1.h.

                                                                  {
    return maskedWord(word, RUN3_TIMESLICE_MULT_WORD_NUM_SHIFT, RUN3_TIMESLICE_MULT_WORD_NUM_MASK);
  }

multiplicityWords()

constexpr std::array<uint32_t,3> LVL1::MuCTPIBits::multiplicityWords ( uint64_t  multiplicity, uint32_t  triggerBits, bool  overflow  )

inlineconstexpr

Encode the multiplicity words.

Definition at line 159 of file HelpersPhase1.h.

                                                                                                                      {
    std::array<uint32_t,3> words{}; // zero-initialised
    for (uint32_t iWord=0; iWord<words.size(); ++iWord) {
      words[iWord] |= buildWord(RUN3_TIMESLICE_MULT_WORD_ID_VAL, RUN3_TIMESLICE_MULT_WORD_ID_SHIFT, RUN3_TIMESLICE_MULT_WORD_ID_MASK);
      words[iWord] |= buildWord(iWord+1, RUN3_TIMESLICE_MULT_WORD_NUM_SHIFT, RUN3_TIMESLICE_MULT_WORD_NUM_MASK);
    }
    words[0] |= maskedWord(multiplicity, RUN3_MULTIPLICITY_PART1_SHIFT, RUN3_MULTIPLICITY_PART1_MASK);
    words[1] |= maskedWord(multiplicity, RUN3_MULTIPLICITY_PART2_SHIFT, RUN3_MULTIPLICITY_PART2_MASK);
    words[2] |= maskedWord(multiplicity, RUN3_MULTIPLICITY_PART3_SHIFT, RUN3_MULTIPLICITY_PART3_MASK);
    words[2] |= maskedWord(triggerBits, RUN3_MULTIPLICITY_TRIGBITS_SHIFT, RUN3_MULTIPLICITY_TRIGBITS_MASK);
    words[2] |= maskedWord(static_cast<uint32_t>(overflow), RUN3_MULTIPLICITY_OVERFLOW_SHIFT, RUN3_MULTIPLICITY_OVERFLOW_MASK);
    return words;
  }

timesliceHeader() [1/2]

constexpr uint32_t LVL1::MuCTPIBits::timesliceHeader ( uint32_t  bcid, uint32_t  tobCount, uint32_t  candCount  )

inlineconstexpr

Encode timeslice word.

Definition at line 94 of file HelpersPhase1.h.

                                                                                                  {
    uint32_t word{0};
    word |= buildWord(RUN3_TIMESLICE_MULT_WORD_ID_VAL, RUN3_TIMESLICE_MULT_WORD_ID_SHIFT, RUN3_TIMESLICE_MULT_WORD_ID_MASK);
    word |= buildWord(RUN3_TIMESLICE_WORD_NUM_VAL, RUN3_TIMESLICE_MULT_WORD_NUM_SHIFT, RUN3_TIMESLICE_MULT_WORD_NUM_MASK);
    word |= buildWord(bcid, RUN3_TIMESLICE_BCID_SHIFT, RUN3_TIMESLICE_BCID_MASK);
    word |= buildWord(tobCount, RUN3_TIMESLICE_NTOB_SHIFT, RUN3_TIMESLICE_NTOB_MASK);
    word |= buildWord(candCount, RUN3_TIMESLICE_NCAND_SHIFT, RUN3_TIMESLICE_NCAND_MASK);
    return word;
  }

timesliceHeader() [2/2]

constexpr auto LVL1::MuCTPIBits::timesliceHeader ( uint32_t  word )

inlineconstexpr

Decode timeslice word.

Definition at line 81 of file HelpersPhase1.h.

                                                       {
    struct {
      uint32_t bcid{0};
      uint32_t tobCount{0};
      uint32_t candCount{0};
    } header;
    header.bcid = maskedWord(word, RUN3_TIMESLICE_BCID_SHIFT, RUN3_TIMESLICE_BCID_MASK);
    header.tobCount = maskedWord(word, RUN3_TIMESLICE_NTOB_SHIFT, RUN3_TIMESLICE_NTOB_MASK);
    header.candCount = maskedWord(word, RUN3_TIMESLICE_NCAND_SHIFT, RUN3_TIMESLICE_NCAND_MASK);
    return header;
  }

topoHeader()

constexpr auto LVL1::MuCTPIBits::topoHeader ( uint32_t  word )

inlineconstexpr

Decode topo word :

Definition at line 105 of file HelpersPhase1.h.

                                                  {
    struct {
      bool     flag0{0};
      bool     flag1{0};
      bool     flag2{0};
      bool     flag3{0};
      uint32_t pt{0};
      uint32_t etacode{0};
      uint32_t phicode{0};
      uint32_t barrel_eta_lookup{0};
      uint32_t barrel_phi_lookup{0};
      uint32_t hemi{0};
      uint32_t det{0};
      uint32_t sec{0};
      uint32_t roi{0};
    } header;
    header.flag0   = maskedWord(word, RUN3_TOPO_WORD_FLAGS_SHIFT,   0x1); //20
    header.flag1   = maskedWord(word, RUN3_TOPO_WORD_FLAGS_SHIFT+1, 0x1); //21
    header.flag2   = maskedWord(word, RUN3_TOPO_WORD_FLAGS_SHIFT+2, 0x1); //22
    header.flag3   = maskedWord(word, RUN3_TOPO_WORD_FLAGS_SHIFT+3, 0x1); //23
    header.pt      = maskedWord(word, RUN3_TOPO_WORD_PT_SHIFT,      RUN3_TOPO_WORD_PT_MASK);
    header.etacode = maskedWord(word, RUN3_TOPO_WORD_ETA_SHIFT,     RUN3_TOPO_WORD_ETA_MASK);
    header.phicode = maskedWord(word, RUN3_TOPO_WORD_PHI_SHIFT,     RUN3_TOPO_WORD_PHI_MASK);
    // HEMISPHERE 0: C-side (-) / 1: A-side (-)
    header.hemi    = maskedWord(word, RUN3_TOPO_WORD_HEMI_SHIFT,    RUN3_TOPO_WORD_HEMI_MASK);
    // Barrel: 00 - EC: 1X - FW: 01 - see: https://indico.cern.ch/event/864390/contributions/3642129/attachments/1945776/3234220/ctp_topo_encoding.pdf
    header.det     = maskedWord(word, RUN3_TOPO_WORD_DET_SHIFT,     RUN3_TOPO_WORD_DET_MASK);
    // set EC to 2 instead of sometimes 3 - see above why
    if (header.det > 2) header.det = 2;
    // Decode Barrel:
    if (header.det == 0){
      header.sec = header.phicode >> 3;
      header.barrel_eta_lookup = (header.etacode >> 1) & 0xf;
      header.barrel_phi_lookup = header.phicode & 0x7;
    }
    // FWD
    else if (header.det == 1){
      header.sec = header.phicode >> 3 ;
      header.roi = ((header.etacode & 0x1f) << 2) | ((header.phicode >> 1) & 0x3) ;
    }
    // EC
    else if (header.det == 2){
      header.sec = header.phicode >> 2 ;
      header.roi = ((header.etacode & 0x3f) << 2) | (header.phicode & 0x3) ;
    }
    return header;
  }

wordEquals()

constexpr bool LVL1::MuCTPIBits::wordEquals ( uint32_t  word, uint32_t  shift, uint32_t  mask, uint32_t  value  )

inlineconstexpr

Compare a sub-word of a 32-bit word to an expected value.

Definition at line 59 of file HelpersPhase1.h.

                                                                                                 {
    return maskedWord(word, shift, mask) == value;
  }

Variable Documentation

RPCtoTGC_pt_map

const uint32_t LVL1::MuCTPIBits::RPCtoTGC_pt_map[7] = {0, 2, 4, 6, 8, 10, 12}

Definition at line 20 of file HelpersPhase1.h.