CMS 3D CMS Logo

List of all members | Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | Static Private Attributes
GctFormatTranslateV38 Class Reference

Unpacks/packs the V38 raw format. More...

#include <GctFormatTranslateV38.h>

Inheritance diagram for GctFormatTranslateV38:
GctFormatTranslateBase

Public Member Functions

bool convertBlock (const unsigned char *d, const GctBlockHeader &hdr) override
 Get digis from the block - will return true if it succeeds, false otherwise. More...
 
 GctFormatTranslateV38 (bool hltMode=false, bool unpackSharedRegions=false, unsigned numberOfGctSamplesToUnpack=1, unsigned numberOfRctSamplesToUnpack=1)
 Constructor. More...
 
GctBlockHeader generateBlockHeader (const unsigned char *data) const override
 Generate a block header from four 8-bit values. More...
 
 ~GctFormatTranslateV38 () override
 Destructor. More...
 
- Public Member Functions inherited from GctFormatTranslateBase
 GctFormatTranslateBase (bool hltMode=false, bool unpackSharedRegions=false)
 Constructor. More...
 
const std::string & getBlockDescription (const GctBlockHeader &header) const
 Get block description. More...
 
void setPackingBxId (uint32_t bxId)
 
void setPackingEventId (uint32_t eventId)
 
void setUnpackCollections (GctUnpackCollections *const collections)
 Set the pointer to the unpack collections. More...
 
virtual ~GctFormatTranslateBase ()
 Destructor. More...
 

Protected Member Functions

const BlockLengthMapblockLengthMap () const final
 get the static block ID to block-length map. More...
 
const BlockNameMapblockNameMap () const final
 get the static block ID to blockname map. More...
 
uint32_t generateRawHeader (const uint32_t blockId, const uint32_t nSamples, const uint32_t bxId, const uint32_t eventId) const override
 Returns a raw 32-bit header word generated from the blockId, number of time samples, bunch-crossing and event IDs. More...
 
const BlockIdToEmCandIsoBoundMapinternEmIsoBounds () const final
 get the static intern EM cand isolated boundary map. More...
 
const BlkToRctCrateMaprctEmCrateMap () const final
 get static the block ID to RCT crate map for electrons. More...
 
const BlkToRctCrateMaprctJetCrateMap () const final
 get the static block ID to RCT crate map for jets More...
 
- Protected Member Functions inherited from GctFormatTranslateBase
void blockDoNothing (const unsigned char *d, const GctBlockHeader &hdr)
 The null unpack function - obviously common to all formats. More...
 
bool checkBlock (const GctBlockHeader &hdr) const
 Performs checks on the block header to see if the block is possible to unpack or not. More...
 
GctUnpackCollections *const colls () const
 Protected access to the GCT Unpack Collections. More...
 
L1GctJetCandCollection *const gctJets (const unsigned cat) const
 Get a specific jet candandiate collection using the JetCandCategory enumeration. More...
 
bool hltMode () const
 Protected interface to get HLT optimisation mode flag. More...
 
const uint32_t packingBxId () const
 Get the BxId to be used when packing data. More...
 
const uint32_t packingEventId () const
 Get the EventId to be used when packing data. More...
 
const SourceCardRoutingsrcCardRouting () const
 Protected interface to the unpackSharedRegions commissioning option. More...
 
bool unpackSharedRegions () const
 
void writeRawHeader (unsigned char *data, uint32_t blockId, uint32_t nSamples) const
 Writes a raw block header into the raw data array for a given block ID and number of time-samples. More...
 

Private Types

typedef std::map< unsigned int, PtrToUnpackFnBlockIdToUnpackFnMap
 Typedef for a block ID to unpack function map. More...
 
typedef void(GctFormatTranslateV38::* PtrToUnpackFn) (const unsigned char *, const GctBlockHeader &)
 Function pointer typdef to a block unpack function. More...
 

Private Member Functions

void blockToFibres (const unsigned char *d, const GctBlockHeader &hdr)
 unpack Fibres More...
 
void blockToFibresAndToRctEmCand (const unsigned char *d, const GctBlockHeader &hdr)
 unpack Fibres and RCT EM Candidates More...
 
void blockToGctEmCandsAndEnergySums (const unsigned char *d, const GctBlockHeader &hdr)
 unpack GCT EM Candidates and energy sums. More...
 
void blockToGctInternEmCand (const unsigned char *d, const GctBlockHeader &hdr)
 unpack GCT internal EM Candidates More...
 
void blockToGctInternEtSums (const unsigned char *d, const GctBlockHeader &hdr)
 unpack GCT internal Et sums More...
 
void blockToGctInternEtSumsAndJetCluster (const unsigned char *d, const GctBlockHeader &hdr)
 unpack GCT internal output of leaf jet finder More...
 
void blockToGctInternHtMissPostWheel (const unsigned char *d, const GctBlockHeader &hdr)
 unpack GCT internal Missing Ht data that is either wheel output or concJet input (i.e. after wheel processing). More...
 
void blockToGctInternHtMissPreWheel (const unsigned char *d, const GctBlockHeader &hdr)
 unpack GCT internal Missing Ht data that is being input to the wheels. More...
 
void blockToGctInternRingSums (const unsigned char *d, const GctBlockHeader &hdr)
 unpack GCT internal HF ring sums More...
 
void blockToGctJetCandsAndCounts (const unsigned char *d, const GctBlockHeader &hdr)
 Unpack GCT Jet Candidates and jet counts. More...
 
void blockToGctJetClusterMinimal (const unsigned char *d, const GctBlockHeader &hdr)
 unpack GCT internal input to wheel jet sort More...
 
void blockToGctJetPreCluster (const unsigned char *d, const GctBlockHeader &hdr)
 unpack GCT internal shared jet finder info More...
 
void blockToGctTrigObjects (const unsigned char *d, const GctBlockHeader &hdr)
 unpack GCT internal wheel and conc jets More...
 
void blockToGctWheelInputInternEtAndRingSums (const unsigned char *d, const GctBlockHeader &hdr)
 unpack GCT internal input to wheel More...
 
void blockToGctWheelOutputInternEtAndRingSums (const unsigned char *d, const GctBlockHeader &hdr)
 unpack GCT internal output of wheel More...
 
void blockToRctCaloRegions (const unsigned char *d, const GctBlockHeader &hdr)
 Unpack RCT Calo Regions. More...
 
void blockToRctEmCand (const unsigned char *d, const GctBlockHeader &hdr)
 unpack RCT EM Candidates More...
 

Private Attributes

const unsigned m_numberOfGctSamplesToUnpack
 Number of BXs of GCT data to unpack (assuming they are in the raw data) More...
 
const unsigned m_numberOfRctSamplesToUnpack
 

Static Private Attributes

static const BlockLengthMap m_blockLength
 Map to translate block number to fundamental size of a block (i.e. for 1 time-sample). More...
 
static const BlockNameMap m_blockName
 Map to hold a description for each block number. More...
 
static const BlockIdToUnpackFnMap m_blockUnpackFn
 Block ID to unpack function map. More...
 
static const BlockIdToEmCandIsoBoundMap m_internEmIsoBounds
 
static const BlkToRctCrateMap m_rctEmCrate
 Map to relate capture block ID to the RCT crate the data originated from (for electrons). More...
 
static const BlkToRctCrateMap m_rctJetCrate
 Map to relate capture block ID to the RCT crate the data originated from (for jets). More...
 

Additional Inherited Members

- Protected Types inherited from GctFormatTranslateBase
typedef std::map< unsigned int, unsigned int > BlkToRctCrateMap
 Typedef for mapping block ID to RCT crate. More...
 
typedef std::map< unsigned int, IsoBoundaryPairBlockIdToEmCandIsoBoundMap
 A typdef for mapping Block IDs to IsoBoundaryPairs. More...
 
typedef std::map< unsigned int, unsigned int > BlockLengthMap
 Block ID to Block Length map. More...
 
typedef std::pair< unsigned int, unsigned int > BlockLengthPair
 Block ID/length pair. More...
 
typedef std::map< unsigned int, std::string > BlockNameMap
 Block ID to Block Description map. More...
 
typedef std::pair< unsigned int, std::string > BlockNamePair
 Block ID/Description pair. More...
 
enum  EmCandCatagory { NON_ISO_EM_CANDS, ISO_EM_CANDS, NUM_EM_CAND_CATEGORIES }
 An enum of the EM candidate types. More...
 
typedef std::pair< unsigned int, unsigned int > IsoBoundaryPair
 
enum  JetCandCategory { TAU_JETS, FORWARD_JETS, CENTRAL_JETS, NUM_JET_CATEGORIES }
 Useful enumeration for jet candidate pack/unpack. More...
 

Detailed Description

Unpacks/packs the V38 raw format.

Author
Robert Frazier

Definition at line 17 of file GctFormatTranslateV38.h.

Member Typedef Documentation

◆ BlockIdToUnpackFnMap

typedef std::map<unsigned int, PtrToUnpackFn> GctFormatTranslateV38::BlockIdToUnpackFnMap
private

Typedef for a block ID to unpack function map.

Definition at line 78 of file GctFormatTranslateV38.h.

◆ PtrToUnpackFn

typedef void(GctFormatTranslateV38::* GctFormatTranslateV38::PtrToUnpackFn) (const unsigned char *, const GctBlockHeader &)
private

Function pointer typdef to a block unpack function.

Definition at line 76 of file GctFormatTranslateV38.h.

Constructor & Destructor Documentation

◆ GctFormatTranslateV38()

GctFormatTranslateV38::GctFormatTranslateV38 ( bool  hltMode = false,
bool  unpackSharedRegions = false,
unsigned  numberOfGctSamplesToUnpack = 1,
unsigned  numberOfRctSamplesToUnpack = 1 
)
explicit

Constructor.

Parameters
hltMode- set true to unpack only BX zero and GCT output data (i.e. to run as quick as possible).
unpackSharedRegions- this is a commissioning option to unpack the shared RCT calo regions.

Definition at line 576 of file GctFormatTranslateV38.cc.

◆ ~GctFormatTranslateV38()

GctFormatTranslateV38::~GctFormatTranslateV38 ( )
override

Destructor.

Definition at line 584 of file GctFormatTranslateV38.cc.

584 {}

Member Function Documentation

◆ blockLengthMap()

const BlockLengthMap& GctFormatTranslateV38::blockLengthMap ( ) const
inlinefinalprotectedvirtual

get the static block ID to block-length map.

Implements GctFormatTranslateBase.

Definition at line 47 of file GctFormatTranslateV38.h.

References m_blockLength.

Referenced by generateBlockHeader().

◆ blockNameMap()

const BlockNameMap& GctFormatTranslateV38::blockNameMap ( ) const
inlinefinalprotectedvirtual

get the static block ID to blockname map.

Implements GctFormatTranslateBase.

Definition at line 51 of file GctFormatTranslateV38.h.

References m_blockName.

◆ blockToFibres()

void GctFormatTranslateV38::blockToFibres ( const unsigned char *  d,
const GctBlockHeader hdr 
)
private

unpack Fibres

Definition at line 977 of file GctFormatTranslateV38.cc.

977  {
978  // Don't want to do this in HLT optimisation mode!
979  if (hltMode()) {
980  LogDebug("GCT") << "HLT mode - skipping unpack of GCT Fibres";
981  return;
982  }
983 
984  unsigned int id = hdr.blockId();
985  unsigned int nSamples = hdr.nSamples();
986  unsigned int length = hdr.blockLength();
987 
988  // re-interpret pointer
989  const uint32_t* p = reinterpret_cast<const uint32_t*>(d);
990 
991  for (unsigned int i = 0; i < length; ++i) {
992  for (unsigned int bx = 0; bx < nSamples; ++bx) {
993  colls()->gctFibres()->push_back(L1GctFibreWord(*p, id, i, bx));
994  ++p;
995  }
996  }
997 }

References GctBlockHeader::blockId(), GctBlockHeader::blockLength(), simKBmtfDigis_cfi::bx, GctFormatTranslateBase::colls(), ztail::d, GctUnpackCollections::gctFibres(), GctFormatTranslateBase::hltMode(), mps_fire::i, LogDebug, PresampleTask_cfi::nSamples, GctBlockHeader::nSamples(), and AlCaHLTBitMon_ParallelJobs::p.

Referenced by blockToFibresAndToRctEmCand().

◆ blockToFibresAndToRctEmCand()

void GctFormatTranslateV38::blockToFibresAndToRctEmCand ( const unsigned char *  d,
const GctBlockHeader hdr 
)
private

unpack Fibres and RCT EM Candidates

Definition at line 999 of file GctFormatTranslateV38.cc.

999  {
1000  this->blockToRctEmCand(d, hdr);
1001  this->blockToFibres(d, hdr);
1002 }

References blockToFibres(), and blockToRctEmCand().

◆ blockToGctEmCandsAndEnergySums()

void GctFormatTranslateV38::blockToGctEmCandsAndEnergySums ( const unsigned char *  d,
const GctBlockHeader hdr 
)
private

unpack GCT EM Candidates and energy sums.

Definition at line 660 of file GctFormatTranslateV38.cc.

660  {
661  const unsigned int id = hdr.blockId();
662  const unsigned int nSamples = hdr.nSamples();
663 
664  // Re-interpret pointer. p16 will be pointing at the 16 bit word that
665  // contains the rank0 non-isolated electron of the zeroth time-sample.
666  const uint16_t* p16 = reinterpret_cast<const uint16_t*>(d);
667 
668  // UNPACK EM CANDS
669 
670  const unsigned int emCandCategoryOffset =
671  nSamples * 4; // Offset to jump from the non-iso electrons to the isolated ones.
672  const unsigned int timeSampleOffset = nSamples * 2; // Offset to jump to next candidate pair in the same time-sample.
673 
674  unsigned int samplesToUnpack =
675  std::min(nSamples, m_numberOfGctSamplesToUnpack); // Unpack as many as asked for if they are in the raw data
676  unsigned int centralSample =
677  (unsigned)std::ceil((double)nSamples / 2.) - 1; // think this works when nSamples is even, need to check!!!
678  unsigned int firstSample = centralSample - (unsigned)std::ceil((double)samplesToUnpack / 2.) + 1;
679  unsigned int lastSample = centralSample + (unsigned)(samplesToUnpack / 2);
680 
681  LogDebug("GCT") << "Unpacking output EM. Central sample=" << centralSample << " first=" << firstSample
682  << " last=" << lastSample;
683 
684  for (unsigned int iso = 0; iso < 2; ++iso) // loop over non-iso/iso candidate pairs
685  {
686  bool isoFlag = (iso == 1);
687 
688  // Get the correct collection to put them in.
690  if (isoFlag) {
691  em = colls()->gctIsoEm();
692  } else {
693  em = colls()->gctNonIsoEm();
694  }
695 
696  for (unsigned int bx = firstSample; bx <= lastSample; ++bx) // loop over samples to be unpacked
697  {
698  // cand0Offset will give the offset on p16 to get the rank 0 candidate
699  // of the correct category and timesample.
700  const unsigned int cand0Offset = iso * emCandCategoryOffset + bx * 2;
701 
702  em->push_back(L1GctEmCand(p16[cand0Offset], isoFlag, id, 0, (int)bx - (int)centralSample)); // rank0 electron
703  em->push_back(L1GctEmCand(
704  p16[cand0Offset + timeSampleOffset], isoFlag, id, 1, (int)bx - (int)centralSample)); // rank1 electron
705  em->push_back(L1GctEmCand(p16[cand0Offset + 1], isoFlag, id, 2, (int)bx - (int)centralSample)); // rank2 electron
706  em->push_back(L1GctEmCand(
707  p16[cand0Offset + timeSampleOffset + 1], isoFlag, id, 3, (int)bx - (int)centralSample)); // rank3 electron
708 
709  LogDebug("GCT") << "Unpacked a bunch of EG. iso=" << iso << " bx=" << bx << std::endl;
710  }
711  }
712 
713  p16 += emCandCategoryOffset * 2; // Move the pointer over the data we've already unpacked.
714 
715  // UNPACK ENERGY SUMS
716 
717  for (unsigned int bx = firstSample; bx <= lastSample; ++bx) // loop over all time samples
718  {
719  const unsigned int offset = bx * 2;
720  colls()->gctEtTot()->push_back(L1GctEtTotal(p16[offset], (int)bx - (int)centralSample)); // Et total
721  colls()->gctEtHad()->push_back(L1GctEtHad(p16[offset + 1], (int)bx - (int)centralSample)); // Et hadronic
722  }
723 
724  p16 += nSamples * 2;
725 
726  // 32-bit pointer for getting Missing Et.
727  const uint32_t* p32 = reinterpret_cast<const uint32_t*>(p16);
728 
729  for (unsigned int bx = firstSample; bx <= lastSample; ++bx) {
730  colls()->gctEtMiss()->push_back(L1GctEtMiss(p32[bx], (int)bx - (int)centralSample)); // Et Miss
731  LogDebug("GCT") << "Unpacked energy sums bx=" << bx << std::endl;
732  }
733 }

References GctBlockHeader::blockId(), simKBmtfDigis_cfi::bx, reco::ceil(), GctFormatTranslateBase::colls(), ztail::d, castor_dqm_sourceclient-live_cfg::firstSample, GctUnpackCollections::gctEtHad(), GctUnpackCollections::gctEtMiss(), GctUnpackCollections::gctEtTot(), GctUnpackCollections::gctIsoEm(), GctUnpackCollections::gctNonIsoEm(), CastorRawToDigi_cfi::lastSample, LogDebug, m_numberOfGctSamplesToUnpack, min(), PresampleTask_cfi::nSamples, GctBlockHeader::nSamples(), and hltrates_dqm_sourceclient-live_cfg::offset.

◆ blockToGctInternEmCand()

void GctFormatTranslateV38::blockToGctInternEmCand ( const unsigned char *  d,
const GctBlockHeader hdr 
)
private

unpack GCT internal EM Candidates

Definition at line 805 of file GctFormatTranslateV38.cc.

805  {
806  // Don't want to do this in HLT optimisation mode!
807  if (hltMode()) {
808  LogDebug("GCT") << "HLT mode - skipping unpack of internal EM Cands";
809  return;
810  }
811 
812  unsigned int id = hdr.blockId();
813  unsigned int nSamples = hdr.nSamples();
814  unsigned int numCandPairs = hdr.blockLength();
815 
816  // Debug assertion to prevent problems if definitions not up to date.
817  auto found = internEmIsoBounds().find(id);
819 
820  unsigned int lowerIsoPairBound = found->second.first;
821  unsigned int upperIsoPairBound = found->second.second;
822 
823  // Re-interpret pointer to 16 bits so it sees one candidate at a time.
824  const uint16_t* p = reinterpret_cast<const uint16_t*>(d);
825 
826  // Loop over timesamples (i.e. bunch crossings)
827  for (unsigned int bx = 0; bx < nSamples; ++bx) {
828  // Loop over candidate pairs (i.e. each iteration unpacks a pair of candidates)
829  for (unsigned int candPair = 0; candPair < numCandPairs; ++candPair) {
830  // Is the candidate electron pair an isolated pair or not?
831  bool iso = ((candPair >= lowerIsoPairBound) && (candPair <= upperIsoPairBound));
832 
833  // Loop over the two electron candidates in each pair
834  for (unsigned int i = 0; i < 2; ++i) {
835  unsigned offset = 2 * (bx + candPair * nSamples) + i;
836  uint16_t candRaw = p[offset];
837  colls()->gctInternEm()->push_back(L1GctInternEmCand(candRaw, iso, id, candPair * 2 + i, bx));
838  }
839  }
840  }
841 }

References cms::cuda::assert(), GctBlockHeader::blockId(), GctBlockHeader::blockLength(), simKBmtfDigis_cfi::bx, GctFormatTranslateBase::colls(), ztail::d, end, newFWLiteAna::found, GctUnpackCollections::gctInternEm(), GctFormatTranslateBase::hltMode(), mps_fire::i, internEmIsoBounds(), LogDebug, PresampleTask_cfi::nSamples, GctBlockHeader::nSamples(), hltrates_dqm_sourceclient-live_cfg::offset, and AlCaHLTBitMon_ParallelJobs::p.

◆ blockToGctInternEtSums()

void GctFormatTranslateV38::blockToGctInternEtSums ( const unsigned char *  d,
const GctBlockHeader hdr 
)
private

unpack GCT internal Et sums

Definition at line 1004 of file GctFormatTranslateV38.cc.

1004  {
1005  // Don't want to do this in HLT optimisation mode!
1006 
1007  if (hltMode()) {
1008  LogDebug("GCT") << "HLT mode - skipping unpack of internal Et Sums";
1009  return;
1010  }
1011 
1012  unsigned int id = hdr.blockId();
1013  unsigned int nSamples = hdr.nSamples();
1014  unsigned int length = hdr.blockLength();
1015 
1016  // Re-interpret pointer to 32 bits
1017  const uint32_t* p = reinterpret_cast<const uint32_t*>(d);
1018 
1019  for (unsigned int i = 0; i < length; ++i) {
1020  // Loop over timesamples (i.e. bunch crossings)
1021  for (unsigned int bx = 0; bx < nSamples; ++bx) {
1022  colls()->gctInternEtSums()->push_back(L1GctInternEtSum::fromTotalEtOrHt(id, i, bx, *p));
1023  ++p;
1024  }
1025  }
1026 }

References GctBlockHeader::blockId(), GctBlockHeader::blockLength(), simKBmtfDigis_cfi::bx, GctFormatTranslateBase::colls(), ztail::d, L1GctInternEtSum::fromTotalEtOrHt(), GctUnpackCollections::gctInternEtSums(), GctFormatTranslateBase::hltMode(), mps_fire::i, LogDebug, PresampleTask_cfi::nSamples, GctBlockHeader::nSamples(), and AlCaHLTBitMon_ParallelJobs::p.

◆ blockToGctInternEtSumsAndJetCluster()

void GctFormatTranslateV38::blockToGctInternEtSumsAndJetCluster ( const unsigned char *  d,
const GctBlockHeader hdr 
)
private

unpack GCT internal output of leaf jet finder

Definition at line 1028 of file GctFormatTranslateV38.cc.

1028  {
1029  // Don't want to do this in HLT optimisation mode!
1030  if (hltMode()) {
1031  LogDebug("GCT") << "HLT mode - skipping unpack of internal Jet Cands";
1032  return;
1033  }
1034 
1035  unsigned int id = hdr.blockId();
1036  unsigned int nSamples = hdr.nSamples();
1037  unsigned int length = hdr.blockLength();
1038 
1039  // Re-interpret pointer to 32 bits
1040  const uint32_t* p = reinterpret_cast<const uint32_t*>(d);
1041 
1042  for (unsigned int i = 0; i < length; ++i) {
1043  // Loop over timesamples (i.e. bunch crossings)
1044  for (unsigned int bx = 0; bx < nSamples; ++bx) {
1045  if (i < 2)
1046  colls()->gctInternEtSums()->push_back(L1GctInternEtSum::fromJetMissEt(id, i, bx, *p));
1047  if (i == 3) {
1048  colls()->gctInternEtSums()->push_back(L1GctInternEtSum::fromJetTotEt(id, i, bx, *p));
1049  colls()->gctInternEtSums()->push_back(L1GctInternEtSum::fromJetTotHt(id, i, bx, *p));
1050  }
1051  if (i > 4)
1053  ++p;
1054  }
1055  }
1056 }

References GctBlockHeader::blockId(), GctBlockHeader::blockLength(), simKBmtfDigis_cfi::bx, GctFormatTranslateBase::colls(), ztail::d, L1GctInternJetData::fromJetCluster(), L1GctInternEtSum::fromJetMissEt(), L1GctInternEtSum::fromJetTotEt(), L1GctInternEtSum::fromJetTotHt(), GctUnpackCollections::gctInternEtSums(), GctUnpackCollections::gctInternJets(), GctFormatTranslateBase::hltMode(), mps_fire::i, LogDebug, PresampleTask_cfi::nSamples, GctBlockHeader::nSamples(), and AlCaHLTBitMon_ParallelJobs::p.

◆ blockToGctInternHtMissPostWheel()

void GctFormatTranslateV38::blockToGctInternHtMissPostWheel ( const unsigned char *  d,
const GctBlockHeader hdr 
)
private

unpack GCT internal Missing Ht data that is either wheel output or concJet input (i.e. after wheel processing).

Definition at line 1252 of file GctFormatTranslateV38.cc.

1252  {
1253  // Don't want to do this in HLT optimisation mode!
1254  if (hltMode()) {
1255  LogDebug("GCT") << "HLT mode - skipping unpack of post-wheel internal Missing Ht data";
1256  return;
1257  }
1258 
1259  unsigned int id = hdr.blockId();
1260  unsigned int nSamples = hdr.nSamples();
1261  unsigned int length = hdr.blockLength();
1262 
1263  // Re-interpret pointer to 32 bits
1264  const uint32_t* p = reinterpret_cast<const uint32_t*>(d);
1265 
1266  for (unsigned int iLength = 0; iLength < length; ++iLength) {
1267  // Loop over timesamples (i.e. bunch crossings)
1268  for (unsigned int bx = 0; bx < nSamples; ++bx) {
1269  if (iLength % 2) {
1270  colls()->gctInternHtMiss()->push_back(L1GctInternHtMiss::unpackerMissHty(id, iLength, bx, *p));
1271  } // Hty on odd numbers
1272  else {
1273  colls()->gctInternHtMiss()->push_back(L1GctInternHtMiss::unpackerMissHtx(id, iLength, bx, *p));
1274  } // Htx on even numbers
1275  ++p;
1276  }
1277  }
1278 }

References GctBlockHeader::blockId(), GctBlockHeader::blockLength(), simKBmtfDigis_cfi::bx, GctFormatTranslateBase::colls(), ztail::d, GctUnpackCollections::gctInternHtMiss(), GctFormatTranslateBase::hltMode(), LogDebug, PresampleTask_cfi::nSamples, GctBlockHeader::nSamples(), AlCaHLTBitMon_ParallelJobs::p, L1GctInternHtMiss::unpackerMissHtx(), and L1GctInternHtMiss::unpackerMissHty().

◆ blockToGctInternHtMissPreWheel()

void GctFormatTranslateV38::blockToGctInternHtMissPreWheel ( const unsigned char *  d,
const GctBlockHeader hdr 
)
private

unpack GCT internal Missing Ht data that is being input to the wheels.

Definition at line 1229 of file GctFormatTranslateV38.cc.

1229  {
1230  // Don't want to do this in HLT optimisation mode!
1231  if (hltMode()) {
1232  LogDebug("GCT") << "HLT mode - skipping unpack of pre-wheel internal Missing Ht data";
1233  return;
1234  }
1235 
1236  unsigned int id = hdr.blockId();
1237  unsigned int nSamples = hdr.nSamples();
1238  unsigned int length = hdr.blockLength();
1239 
1240  // Re-interpret pointer to 32 bits
1241  const uint32_t* p = reinterpret_cast<const uint32_t*>(d);
1242 
1243  for (unsigned int iLength = 0; iLength < length; ++iLength) {
1244  // Loop over timesamples (i.e. bunch crossings)
1245  for (unsigned int bx = 0; bx < nSamples; ++bx) {
1246  colls()->gctInternHtMiss()->push_back(L1GctInternHtMiss::unpackerMissHtxHty(id, iLength, bx, *p));
1247  ++p;
1248  }
1249  }
1250 }

References GctBlockHeader::blockId(), GctBlockHeader::blockLength(), simKBmtfDigis_cfi::bx, GctFormatTranslateBase::colls(), ztail::d, GctUnpackCollections::gctInternHtMiss(), GctFormatTranslateBase::hltMode(), LogDebug, PresampleTask_cfi::nSamples, GctBlockHeader::nSamples(), AlCaHLTBitMon_ParallelJobs::p, and L1GctInternHtMiss::unpackerMissHtxHty().

◆ blockToGctInternRingSums()

void GctFormatTranslateV38::blockToGctInternRingSums ( const unsigned char *  d,
const GctBlockHeader hdr 
)
private

unpack GCT internal HF ring sums

Definition at line 1139 of file GctFormatTranslateV38.cc.

1139  {
1140  // Don't want to do this in HLT optimisation mode!
1141  if (hltMode()) {
1142  LogDebug("GCT") << "HLT mode - skipping unpack of internal HF ring data";
1143  return;
1144  }
1145 
1146  unsigned int id = hdr.blockId();
1147  unsigned int nSamples = hdr.nSamples();
1148  unsigned int length = hdr.blockLength();
1149 
1150  // Re-interpret pointer to 32 bits
1151  const uint32_t* p = reinterpret_cast<const uint32_t*>(d);
1152 
1153  for (unsigned int i = 0; i < length / 2; ++i) {
1154  // Loop over timesamples (i.e. bunch crossings)
1155  for (unsigned int bx = 0; bx < nSamples; ++bx) {
1157  ++p;
1158  }
1159  for (unsigned int bx = 0; bx < nSamples; ++bx) {
1161  ++p;
1162  }
1163  }
1164 }

References GctBlockHeader::blockId(), GctBlockHeader::blockLength(), simKBmtfDigis_cfi::bx, GctFormatTranslateBase::colls(), ztail::d, L1GctInternHFData::fromConcBitCounts(), L1GctInternHFData::fromConcRingSums(), GctUnpackCollections::gctInternHFData(), GctFormatTranslateBase::hltMode(), mps_fire::i, LogDebug, PresampleTask_cfi::nSamples, GctBlockHeader::nSamples(), and AlCaHLTBitMon_ParallelJobs::p.

◆ blockToGctJetCandsAndCounts()

void GctFormatTranslateV38::blockToGctJetCandsAndCounts ( const unsigned char *  d,
const GctBlockHeader hdr 
)
private

Unpack GCT Jet Candidates and jet counts.

Definition at line 735 of file GctFormatTranslateV38.cc.

735  {
736  const unsigned int id = hdr.blockId(); // Capture block ID.
737  const unsigned int nSamples = hdr.nSamples(); // Number of time-samples.
738 
739  // Re-interpret block payload pointer to 16 bits so it sees one candidate at a time.
740  // p16 points to the start of the block payload, at the rank0 tau jet candidate.
741  const uint16_t* p16 = reinterpret_cast<const uint16_t*>(d);
742 
743  // UNPACK JET CANDS
744 
745  const unsigned int jetCandCategoryOffset = nSamples * 4; // Offset to jump from one jet category to the next.
746  const unsigned int timeSampleOffset = nSamples * 2; // Offset to jump to next candidate pair in the same time-sample.
747 
748  unsigned int samplesToUnpack =
749  std::min(nSamples, m_numberOfGctSamplesToUnpack); // Unpack as many as asked for if they are in the raw data
750  unsigned int centralSample =
751  (unsigned)std::ceil((double)nSamples / 2.) - 1; // think this works when nSamples is even, need to check!!!
752  unsigned int firstSample = centralSample - (unsigned)std::ceil((double)samplesToUnpack / 2.) + 1;
753  unsigned int lastSample = centralSample + (unsigned)(samplesToUnpack / 2);
754 
755  LogDebug("GCT") << "Unpacking output Jets. Samples to unpack=" << samplesToUnpack << " central=" << centralSample
756  << " first=" << firstSample << " last=" << lastSample;
757 
758  // Loop over the different catagories of jets
759  for (unsigned int iCat = 0; iCat < NUM_JET_CATEGORIES; ++iCat) {
760  L1GctJetCandCollection* const jets = gctJets(iCat);
761  assert(jets->empty()); // The supplied vector should be empty.
762 
763  bool tauflag = (iCat == TAU_JETS);
764  bool forwardFlag = (iCat == FORWARD_JETS);
765 
766  // Loop over the different timesamples (bunch crossings).
767  for (unsigned int bx = firstSample; bx <= lastSample; ++bx) {
768  // cand0Offset will give the offset on p16 to get the rank 0 Jet Cand of the correct category and timesample.
769  const unsigned int cand0Offset = iCat * jetCandCategoryOffset + bx * 2;
770 
771  // Rank 0 Jet.
772  jets->push_back(L1GctJetCand(p16[cand0Offset], tauflag, forwardFlag, id, 0, (int)bx - (int)centralSample));
773  // Rank 1 Jet.
774  jets->push_back(
775  L1GctJetCand(p16[cand0Offset + timeSampleOffset], tauflag, forwardFlag, id, 1, (int)bx - (int)centralSample));
776  // Rank 2 Jet.
777  jets->push_back(L1GctJetCand(p16[cand0Offset + 1], tauflag, forwardFlag, id, 2, (int)bx - (int)centralSample));
778  // Rank 3 Jet.
779  jets->push_back(L1GctJetCand(
780  p16[cand0Offset + timeSampleOffset + 1], tauflag, forwardFlag, id, 3, (int)bx - (int)centralSample));
781  }
782  }
783 
784  p16 += NUM_JET_CATEGORIES * jetCandCategoryOffset; // Move the pointer over the data we've already unpacked.
785 
786  // NOW UNPACK: HFBitCounts, HFRingEtSums and Missing Ht
787 
788  // Re-interpret block payload pointer to 32 bits so it sees six jet counts at a time.
789  const uint32_t* p32 = reinterpret_cast<const uint32_t*>(p16);
790 
791  for (unsigned int bx = firstSample; bx <= lastSample; ++bx) // loop over all time samples
792  {
793  // Channel 0 carries both HF counts and sums
794  colls()->gctHfBitCounts()->push_back(
795  L1GctHFBitCounts::fromConcHFBitCounts(id, 6, (int)bx - (int)centralSample, p32[bx]));
796  colls()->gctHfRingEtSums()->push_back(
797  L1GctHFRingEtSums::fromConcRingSums(id, 6, (int)bx - (int)centralSample, p32[bx]));
798 
799  // Channel 1 carries Missing HT.
800  colls()->gctHtMiss()->push_back(L1GctHtMiss(p32[bx + nSamples], (int)bx - (int)centralSample));
801  }
802 }

References cms::cuda::assert(), GctBlockHeader::blockId(), simKBmtfDigis_cfi::bx, reco::ceil(), GctFormatTranslateBase::colls(), ztail::d, castor_dqm_sourceclient-live_cfg::firstSample, GctFormatTranslateBase::FORWARD_JETS, L1GctHFBitCounts::fromConcHFBitCounts(), L1GctHFRingEtSums::fromConcRingSums(), GctUnpackCollections::gctHfBitCounts(), GctUnpackCollections::gctHfRingEtSums(), GctUnpackCollections::gctHtMiss(), GctFormatTranslateBase::gctJets(), singleTopDQM_cfi::jets, CastorRawToDigi_cfi::lastSample, LogDebug, m_numberOfGctSamplesToUnpack, min(), PresampleTask_cfi::nSamples, GctBlockHeader::nSamples(), GctFormatTranslateBase::NUM_JET_CATEGORIES, and GctFormatTranslateBase::TAU_JETS.

◆ blockToGctJetClusterMinimal()

void GctFormatTranslateV38::blockToGctJetClusterMinimal ( const unsigned char *  d,
const GctBlockHeader hdr 
)
private

unpack GCT internal input to wheel jet sort

Definition at line 1085 of file GctFormatTranslateV38.cc.

1085  {
1086  // Don't want to do this in HLT optimisation mode!
1087  if (hltMode()) {
1088  LogDebug("GCT") << "HLT mode - skipping unpack of internal Jet Cands";
1089  return;
1090  }
1091 
1092  unsigned int id = hdr.blockId();
1093  unsigned int nSamples = hdr.nSamples();
1094  unsigned int length = hdr.blockLength();
1095 
1096  // Re-interpret pointer to 16 bits so it sees one candidate at a time.
1097  const uint16_t* p = reinterpret_cast<const uint16_t*>(d);
1098 
1099  for (unsigned int i = 0; i < length; ++i) {
1100  // Loop over timesamples (i.e. bunch crossings)
1101  for (unsigned int bx = 0; bx < nSamples; ++bx) {
1102  colls()->gctInternJets()->push_back(
1104  ++p;
1105  colls()->gctInternJets()->push_back(
1107  ++p;
1108  }
1109  }
1110 }

References GctBlockHeader::blockId(), GctBlockHeader::blockLength(), simKBmtfDigis_cfi::bx, GctFormatTranslateBase::colls(), ztail::d, L1GctInternJetData::fromJetClusterMinimal(), GctUnpackCollections::gctInternJets(), GctFormatTranslateBase::hltMode(), mps_fire::i, LogDebug, PresampleTask_cfi::nSamples, GctBlockHeader::nSamples(), and AlCaHLTBitMon_ParallelJobs::p.

◆ blockToGctJetPreCluster()

void GctFormatTranslateV38::blockToGctJetPreCluster ( const unsigned char *  d,
const GctBlockHeader hdr 
)
private

unpack GCT internal shared jet finder info

Definition at line 1112 of file GctFormatTranslateV38.cc.

1112  {
1113  // Don't want to do this in HLT optimisation mode!
1114  if (hltMode()) {
1115  LogDebug("GCT") << "HLT mode - skipping unpack of internal Jet Cands";
1116  return;
1117  }
1118 
1119  unsigned int id = hdr.blockId();
1120  unsigned int nSamples = hdr.nSamples();
1121  unsigned int length = hdr.blockLength();
1122 
1123  // Re-interpret pointer to 16 bits so it sees one candidate at a time.
1124  const uint16_t* p = reinterpret_cast<const uint16_t*>(d);
1125 
1126  for (unsigned int i = 0; i < length; ++i) {
1127  // Loop over timesamples (i.e. bunch crossings)
1128  for (unsigned int bx = 0; bx < nSamples; ++bx) {
1129  colls()->gctInternJets()->push_back(
1131  ++p;
1132  colls()->gctInternJets()->push_back(
1134  ++p;
1135  }
1136  }
1137 }

References GctBlockHeader::blockId(), GctBlockHeader::blockLength(), simKBmtfDigis_cfi::bx, GctFormatTranslateBase::colls(), ztail::d, L1GctInternJetData::fromJetPreCluster(), GctUnpackCollections::gctInternJets(), GctFormatTranslateBase::hltMode(), mps_fire::i, LogDebug, PresampleTask_cfi::nSamples, GctBlockHeader::nSamples(), and AlCaHLTBitMon_ParallelJobs::p.

◆ blockToGctTrigObjects()

void GctFormatTranslateV38::blockToGctTrigObjects ( const unsigned char *  d,
const GctBlockHeader hdr 
)
private

unpack GCT internal wheel and conc jets

Definition at line 1058 of file GctFormatTranslateV38.cc.

1058  {
1059  // Don't want to do this in HLT optimisation mode!
1060  if (hltMode()) {
1061  LogDebug("GCT") << "HLT mode - skipping unpack of internal Jet Cands";
1062  return;
1063  }
1064 
1065  unsigned int id = hdr.blockId();
1066  unsigned int nSamples = hdr.nSamples();
1067  unsigned int length = hdr.blockLength();
1068 
1069  // Re-interpret pointer to 16 bits so it sees one candidate at a time.
1070  const uint16_t* p = reinterpret_cast<const uint16_t*>(d);
1071 
1072  for (unsigned int i = 0; i < length; ++i) {
1073  // Loop over timesamples (i.e. bunch crossings)
1074  for (unsigned int bx = 0; bx < nSamples; ++bx) {
1075  colls()->gctInternJets()->push_back(
1077  ++p;
1078  colls()->gctInternJets()->push_back(
1080  ++p;
1081  }
1082  }
1083 }

References GctBlockHeader::blockId(), GctBlockHeader::blockLength(), simKBmtfDigis_cfi::bx, GctFormatTranslateBase::colls(), ztail::d, L1GctInternJetData::fromGctTrigObject(), GctUnpackCollections::gctInternJets(), GctFormatTranslateBase::hltMode(), mps_fire::i, LogDebug, PresampleTask_cfi::nSamples, GctBlockHeader::nSamples(), and AlCaHLTBitMon_ParallelJobs::p.

◆ blockToGctWheelInputInternEtAndRingSums()

void GctFormatTranslateV38::blockToGctWheelInputInternEtAndRingSums ( const unsigned char *  d,
const GctBlockHeader hdr 
)
private

unpack GCT internal input to wheel

Definition at line 1166 of file GctFormatTranslateV38.cc.

1166  {
1167  // Don't want to do this in HLT optimisation mode!
1168  if (hltMode()) {
1169  LogDebug("GCT") << "HLT mode - skipping unpack of wheel input internal Et sums and HF ring data";
1170  return;
1171  }
1172 
1173  unsigned int id = hdr.blockId();
1174  unsigned int nSamples = hdr.nSamples();
1175  unsigned int length = hdr.blockLength();
1176 
1177  // Re-interpret pointer to 32 bits
1178  const uint32_t* p = reinterpret_cast<const uint32_t*>(d);
1179 
1180  for (unsigned int i = 0; i < length; ++i) {
1181  // Loop over timesamples (i.e. bunch crossings)
1182  for (unsigned int bx = 0; bx < nSamples; ++bx) {
1183  if (i < 3) {
1184  colls()->gctInternEtSums()->push_back(L1GctInternEtSum::fromTotalEtOrHt(id, i, bx, *p));
1185  } else if (i > 2 && i < 9) {
1186  colls()->gctInternEtSums()->push_back(L1GctInternEtSum::fromMissEtxOrEty(id, i, bx, *p));
1187  } else if (i > 8 && i < 15) {
1189  } else if (i > 14) {
1191  }
1192  ++p;
1193  }
1194  }
1195 }

References GctBlockHeader::blockId(), GctBlockHeader::blockLength(), simKBmtfDigis_cfi::bx, GctFormatTranslateBase::colls(), ztail::d, L1GctInternEtSum::fromMissEtxOrEty(), L1GctInternEtSum::fromTotalEtOrHt(), L1GctInternHFData::fromWheelBitCounts(), L1GctInternHFData::fromWheelRingSums(), GctUnpackCollections::gctInternEtSums(), GctUnpackCollections::gctInternHFData(), GctFormatTranslateBase::hltMode(), mps_fire::i, LogDebug, PresampleTask_cfi::nSamples, GctBlockHeader::nSamples(), and AlCaHLTBitMon_ParallelJobs::p.

◆ blockToGctWheelOutputInternEtAndRingSums()

void GctFormatTranslateV38::blockToGctWheelOutputInternEtAndRingSums ( const unsigned char *  d,
const GctBlockHeader hdr 
)
private

unpack GCT internal output of wheel

Definition at line 1197 of file GctFormatTranslateV38.cc.

1198  {
1199  // Don't want to do this in HLT optimisation mode!
1200  if (hltMode()) {
1201  LogDebug("GCT") << "HLT mode - skipping unpack of wheel output internal Et sums and HF ring data";
1202  return;
1203  }
1204 
1205  unsigned int id = hdr.blockId();
1206  unsigned int nSamples = hdr.nSamples();
1207  unsigned int length = hdr.blockLength();
1208 
1209  // Re-interpret pointer to 32 bits
1210  const uint32_t* p = reinterpret_cast<const uint32_t*>(d);
1211 
1212  for (unsigned int i = 0; i < length; ++i) {
1213  // Loop over timesamples (i.e. bunch crossings)
1214  for (unsigned int bx = 0; bx < nSamples; ++bx) {
1215  if (i < 1) {
1216  colls()->gctInternEtSums()->push_back(L1GctInternEtSum::fromTotalEtOrHt(id, i, bx, *p));
1217  } else if (i > 0 && i < 3) {
1218  colls()->gctInternEtSums()->push_back(L1GctInternEtSum::fromMissEtxOrEty(id, i, bx, *p));
1219  } else if (i > 2 && i < 5) {
1221  } else if (i > 4) {
1223  }
1224  ++p;
1225  }
1226  }
1227 }

References GctBlockHeader::blockId(), GctBlockHeader::blockLength(), simKBmtfDigis_cfi::bx, GctFormatTranslateBase::colls(), ztail::d, L1GctInternEtSum::fromMissEtxOrEty(), L1GctInternEtSum::fromTotalEtOrHt(), L1GctInternHFData::fromWheelBitCounts(), L1GctInternHFData::fromWheelRingSums(), GctUnpackCollections::gctInternEtSums(), GctUnpackCollections::gctInternHFData(), GctFormatTranslateBase::hltMode(), mps_fire::i, LogDebug, PresampleTask_cfi::nSamples, GctBlockHeader::nSamples(), and AlCaHLTBitMon_ParallelJobs::p.

◆ blockToRctCaloRegions()

void GctFormatTranslateV38::blockToRctCaloRegions ( const unsigned char *  d,
const GctBlockHeader hdr 
)
private

Unpack RCT Calo Regions.

Definition at line 904 of file GctFormatTranslateV38.cc.

904  {
905  // Don't want to do this in HLT optimisation mode!
906  if (hltMode()) {
907  LogDebug("GCT") << "HLT mode - skipping unpack of RCT Regions";
908  return;
909  }
910 
911  unsigned int id = hdr.blockId();
912  unsigned int nSamples = hdr.nSamples();
913  unsigned int length = hdr.blockLength();
914 
915  // Debug assertion to prevent problems if definitions not up to date.
916  auto found = rctJetCrateMap().find(id);
917  assert(found != rctJetCrateMap().end());
918 
919  // get crate (need this to get ieta and iphi)
920  unsigned int crate = found->second;
921 
922  // re-interpret pointer
923  const uint16_t* p = reinterpret_cast<const uint16_t*>(d);
924 
925  // eta and phi
926  unsigned int ieta;
927  unsigned int iphi;
928 
929  for (unsigned int i = 0; i < length; ++i) {
930  for (uint16_t bx = 0; bx < nSamples; ++bx) {
931  // First figure out eta and phi
932  if (crate < 9) { // negative eta
933  ieta = 12 - i;
934  iphi = 2 * ((11 - crate) % 9);
935  } else { // positive eta
936  ieta = 9 + i;
937  iphi = 2 * ((20 - crate) % 9);
938  }
939 
940  // Skip the first four regions (i.e. where i<2) which are duplicates (shared data).
941  if (i > 1) {
942  // First region is phi=0
943  colls()->rctCalo()->push_back(L1CaloRegion::makeRegionFromUnpacker(*p, ieta, iphi, id, i, bx));
944  ++p;
945  // Second region is phi=1
946  if (iphi > 0) {
947  iphi -= 1;
948  } else {
949  iphi = 17;
950  }
951  colls()->rctCalo()->push_back(L1CaloRegion::makeRegionFromUnpacker(*p, ieta, iphi, id, i, bx));
952  ++p;
953  }
954  // Unpack the shared data if asked for debugging
955  else if (unpackSharedRegions()) {
956  // First region is phi=0
957  colls()->rctCalo()->push_back(L1CaloRegion::makeRegionFromUnpacker(*p, ieta, iphi, id, i, bx));
958  ++p;
959  // Second region is phi=1
960  if (iphi > 0) {
961  iphi -= 1;
962  } else {
963  iphi = 17;
964  }
965  colls()->rctCalo()->push_back(L1CaloRegion::makeRegionFromUnpacker(*p, ieta, iphi, id, i, bx));
966  ++p;
967 
968  } else { // Skip the shared data
969  ++p;
970  ++p;
971  }
972  }
973  }
974 }

References cms::cuda::assert(), GctBlockHeader::blockId(), GctBlockHeader::blockLength(), simKBmtfDigis_cfi::bx, GctFormatTranslateBase::colls(), ztail::d, end, newFWLiteAna::found, GctFormatTranslateBase::hltMode(), mps_fire::i, LEDCalibrationChannels::ieta, LEDCalibrationChannels::iphi, LogDebug, L1CaloRegion::makeRegionFromUnpacker(), PresampleTask_cfi::nSamples, GctBlockHeader::nSamples(), AlCaHLTBitMon_ParallelJobs::p, GctUnpackCollections::rctCalo(), rctJetCrateMap(), and GctFormatTranslateBase::unpackSharedRegions().

◆ blockToRctEmCand()

void GctFormatTranslateV38::blockToRctEmCand ( const unsigned char *  d,
const GctBlockHeader hdr 
)
private

unpack RCT EM Candidates

Definition at line 845 of file GctFormatTranslateV38.cc.

845  {
846  // Don't want to do this in HLT optimisation mode!
847  if (hltMode()) {
848  LogDebug("GCT") << "HLT mode - skipping unpack of RCT EM Cands";
849  return;
850  }
851 
852  unsigned int id = hdr.blockId();
853  unsigned int nSamples = hdr.nSamples();
854  unsigned int length = hdr.blockLength();
855 
856  // re-interpret pointer
857  const uint16_t* p = reinterpret_cast<const uint16_t*>(d);
858 
859  // arrays of source card data
860  uint16_t sfp[2][4]; // [ cycle ] [ SFP ]
861  uint16_t eIsoRank[4];
862  uint16_t eIsoCard[4];
863  uint16_t eIsoRgn[4];
864  uint16_t eNonIsoRank[4];
865  uint16_t eNonIsoCard[4];
866  uint16_t eNonIsoRgn[4];
867  uint16_t MIPbits[7][2];
868  uint16_t QBits[7][2];
869 
870  unsigned int bx = 0;
871 
872  auto found = rctEmCrateMap().find(id);
873  assert(found != rctEmCrateMap().end());
874  // loop over crates
875  for (unsigned int crate = found->second; crate < found->second + length / 3; ++crate) {
876  // read SC SFP words
877  for (unsigned short iSfp = 0; iSfp < 4; ++iSfp) {
878  for (unsigned short cyc = 0; cyc < 2; ++cyc) {
879  if (iSfp == 0) {
880  sfp[cyc][iSfp] = 0;
881  } // muon bits
882  else { // EM candidate
883  sfp[cyc][iSfp] = *p;
884  ++p;
885  }
886  }
887  p = p + 2 * (nSamples - 1);
888  }
889 
890  // fill SC arrays
891  srcCardRouting().SFPtoEMU(eIsoRank, eIsoCard, eIsoRgn, eNonIsoRank, eNonIsoCard, eNonIsoRgn, MIPbits, QBits, sfp);
892 
893  // create EM cands
894  for (unsigned short int i = 0; i < 4; ++i) {
895  colls()->rctEm()->push_back(L1CaloEmCand(eIsoRank[i], eIsoRgn[i], eIsoCard[i], crate, true, i, bx));
896  }
897  for (unsigned short int i = 0; i < 4; ++i) {
898  colls()->rctEm()->push_back(L1CaloEmCand(eNonIsoRank[i], eNonIsoRgn[i], eNonIsoCard[i], crate, false, i, bx));
899  }
900  }
901 }

References cms::cuda::assert(), GctBlockHeader::blockId(), GctBlockHeader::blockLength(), simKBmtfDigis_cfi::bx, GctFormatTranslateBase::colls(), ztail::d, end, newFWLiteAna::found, GctFormatTranslateBase::hltMode(), mps_fire::i, LogDebug, PresampleTask_cfi::nSamples, GctBlockHeader::nSamples(), AlCaHLTBitMon_ParallelJobs::p, GctUnpackCollections::rctEm(), rctEmCrateMap(), edm::second(), SourceCardRouting::SFPtoEMU(), and GctFormatTranslateBase::srcCardRouting().

Referenced by blockToFibresAndToRctEmCand().

◆ convertBlock()

bool GctFormatTranslateV38::convertBlock ( const unsigned char *  d,
const GctBlockHeader hdr 
)
overridevirtual

Get digis from the block - will return true if it succeeds, false otherwise.

Implements GctFormatTranslateBase.

Definition at line 615 of file GctFormatTranslateV38.cc.

615  {
616  // if the block has no time samples, don't bother with it.
617  if (hdr.nSamples() < 1) {
618  return true;
619  }
620 
621  if (!checkBlock(hdr)) {
622  return false;
623  } // Check the block to see if it's possible to unpack.
624 
625  // The header validity check above will protect against
626  // the map::find() method returning the end of the map,
627  // assuming the block header definitions are up-to-date.
628  (this->*m_blockUnpackFn.find(hdr.blockId())->second)(data,
629  hdr); // Calls the correct unpack function, based on block ID.
630 
631  return true;
632 }

References GctBlockHeader::blockId(), GctFormatTranslateBase::checkBlock(), data, m_blockUnpackFn, GctBlockHeader::nSamples(), and edm::second().

◆ generateBlockHeader()

GctBlockHeader GctFormatTranslateV38::generateBlockHeader ( const unsigned char *  data) const
overridevirtual

Generate a block header from four 8-bit values.

Implements GctFormatTranslateBase.

Definition at line 586 of file GctFormatTranslateV38.cc.

586  {
587  // Turn the four 8-bit header words into the full 32-bit header.
588  uint32_t hdr = data[0] + (data[1] << 8) + (data[2] << 16) + (data[3] << 24);
589 
590  // Bit mapping of V35 header:
591  // --------------------------
592  // 11:0 => block_id Unique pipeline identifier.
593  // - 3:0 =>> pipe_id There can be up to 16 different pipelines per FPGA.
594  // - 6:4 =>> reserved Do not use yet. Set to zero.
595  // - 11:7 =>> fpga geograpical add The VME geographical address of the FPGA.
596  // 15:12 => event_id Determined locally. Not reset by Resync.
597  // 19:16 => number_of_time_samples If time samples 15 or more then value = 15.
598  // 31:20 => event_bcid The bunch crossing the data was recorded.
599 
600  unsigned blockId = hdr & 0xfff;
601  unsigned blockLength = 0; // Set to zero until we know it's a valid block
602  unsigned nSamples = (hdr >> 16) & 0xf;
603  unsigned bxId = (hdr >> 20) & 0xfff;
604  unsigned eventId = (hdr >> 12) & 0xf;
605  bool valid = (blockLengthMap().find(blockId) != blockLengthMap().end());
606 
607  if (valid) {
608  blockLength = blockLengthMap().find(blockId)->second;
609  }
610 
611  return GctBlockHeader(blockId, blockLength, nSamples, bxId, eventId, valid);
612 }

References blockLengthMap(), data, PresampleTask_cfi::nSamples, and validateGeometry_cfg::valid.

◆ generateRawHeader()

uint32_t GctFormatTranslateV38::generateRawHeader ( const uint32_t  blockId,
const uint32_t  nSamples,
const uint32_t  bxId,
const uint32_t  eventId 
) const
overrideprotectedvirtual

Returns a raw 32-bit header word generated from the blockId, number of time samples, bunch-crossing and event IDs.

Implements GctFormatTranslateBase.

Definition at line 636 of file GctFormatTranslateV38.cc.

639  {
640  // Bit mapping of V35 header:
641  // --------------------------
642  // 11:0 => block_id Unique pipeline identifier.
643  // - 3:0 =>> pipe_id There can be up to 16 different pipelines per FPGA.
644  // - 6:4 =>> reserved Do not use yet. Set to zero.
645  // - 11:7 =>> fpga geograpical add The VME geographical address of the FPGA.
646  // 15:12 => event_id Determined locally. Not reset by Resync.
647  // 19:16 => number_of_time_samples If time samples 15 or more then value = 15.
648  // 31:20 => event_bxId The bunch crossing the data was recorded.
649 
650  return ((bxId & 0xfff) << 20) | ((nSamples & 0xf) << 16) | ((eventId & 0xf) << 12) | (blockId & 0xfff);
651 }

References PresampleTask_cfi::nSamples.

◆ internEmIsoBounds()

const BlockIdToEmCandIsoBoundMap& GctFormatTranslateV38::internEmIsoBounds ( ) const
inlinefinalprotectedvirtual

get the static intern EM cand isolated boundary map.

Implements GctFormatTranslateBase.

Definition at line 61 of file GctFormatTranslateV38.h.

References m_internEmIsoBounds.

Referenced by blockToGctInternEmCand().

◆ rctEmCrateMap()

const BlkToRctCrateMap& GctFormatTranslateV38::rctEmCrateMap ( ) const
inlinefinalprotectedvirtual

get static the block ID to RCT crate map for electrons.

Implements GctFormatTranslateBase.

Definition at line 53 of file GctFormatTranslateV38.h.

References m_rctEmCrate.

Referenced by blockToRctEmCand().

◆ rctJetCrateMap()

const BlkToRctCrateMap& GctFormatTranslateV38::rctJetCrateMap ( ) const
inlinefinalprotectedvirtual

get the static block ID to RCT crate map for jets

Implements GctFormatTranslateBase.

Definition at line 57 of file GctFormatTranslateV38.h.

References m_rctJetCrate.

Referenced by blockToRctCaloRegions().

Member Data Documentation

◆ m_blockLength

const GctFormatTranslateV38::BlockLengthMap GctFormatTranslateV38::m_blockLength
staticprivate

Map to translate block number to fundamental size of a block (i.e. for 1 time-sample).

Definition at line 83 of file GctFormatTranslateV38.h.

Referenced by blockLengthMap().

◆ m_blockName

const GctFormatTranslateV38::BlockNameMap GctFormatTranslateV38::m_blockName
staticprivate

Map to hold a description for each block number.

Definition at line 86 of file GctFormatTranslateV38.h.

Referenced by blockNameMap().

◆ m_blockUnpackFn

const GctFormatTranslateV38::BlockIdToUnpackFnMap GctFormatTranslateV38::m_blockUnpackFn
staticprivate

Block ID to unpack function map.

Definition at line 99 of file GctFormatTranslateV38.h.

Referenced by convertBlock().

◆ m_internEmIsoBounds

const GctFormatTranslateV38::BlockIdToEmCandIsoBoundMap GctFormatTranslateV38::m_internEmIsoBounds
staticprivate
Initial value:
= {
{0x680, IsoBoundaryPair(8, 15)},
{0x800, IsoBoundaryPair(0, 9)},
{0x803, IsoBoundaryPair(0, 1)},
{0x880, IsoBoundaryPair(0, 7)},
{0x883, IsoBoundaryPair(0, 1)},
{0xc00, IsoBoundaryPair(0, 9)},
{0xc03, IsoBoundaryPair(0, 1)},
{0xc80, IsoBoundaryPair(0, 7)},
{0xc83, IsoBoundaryPair(0, 1)}}

A map of Block IDs to IsoBoundaryPairs for storing the location of the isolated Internal EM cands in the pipeline, as this differs with Block ID.

Definition at line 96 of file GctFormatTranslateV38.h.

Referenced by internEmIsoBounds().

◆ m_numberOfGctSamplesToUnpack

const unsigned GctFormatTranslateV38::m_numberOfGctSamplesToUnpack
private

Number of BXs of GCT data to unpack (assuming they are in the raw data)

Number of BXs of RCT data to unpack (assuming they are in the raw data)

Definition at line 102 of file GctFormatTranslateV38.h.

Referenced by blockToGctEmCandsAndEnergySums(), and blockToGctJetCandsAndCounts().

◆ m_numberOfRctSamplesToUnpack

const unsigned GctFormatTranslateV38::m_numberOfRctSamplesToUnpack
private

Definition at line 105 of file GctFormatTranslateV38.h.

◆ m_rctEmCrate

const GctFormatTranslateV38::BlkToRctCrateMap GctFormatTranslateV38::m_rctEmCrate
staticprivate
Initial value:
= {
{0x804, 13}, {0x884, 9}, {0xc04, 4}, {0xc84, 0}}

Map to relate capture block ID to the RCT crate the data originated from (for electrons).

Definition at line 89 of file GctFormatTranslateV38.h.

Referenced by rctEmCrateMap().

◆ m_rctJetCrate

const GctFormatTranslateV38::BlkToRctCrateMap GctFormatTranslateV38::m_rctJetCrate
staticprivate
Initial value:
= {
{0x900, 9},
{0x908, 10},
{0x988, 17},
{0xa00, 12},
{0xa08, 13},
{0xa88, 11},
{0xb00, 15},
{0xb08, 16},
{0xb88, 14},
{0xd00, 0},
{0xd08, 1},
{0xd88, 8},
{0xe00, 3},
{0xe08, 4},
{0xe88, 2},
{0xf00, 6},
{0xf08, 7},
{0xf88, 5}
}

Map to relate capture block ID to the RCT crate the data originated from (for jets).

Definition at line 92 of file GctFormatTranslateV38.h.

Referenced by rctJetCrateMap().

L1GctInternJetData::fromJetClusterMinimal
static L1GctInternJetData fromJetClusterMinimal(L1CaloRegionDetId rgn, uint16_t capBlock, uint16_t capIndex, int16_t bx, uint32_t data)
construct from "jet_cluster_minimal"
Definition: L1GctInternJetData.cc:67
L1GctHtMiss
Persistable copy of missing Et measured at Level-1.
Definition: L1GctHtMiss.h:16
l1t_dqm_sourceclient-live_cfg.numberOfGctSamplesToUnpack
numberOfGctSamplesToUnpack
Definition: l1t_dqm_sourceclient-live_cfg.py:80
GctBlockHeader
Simple class for holding the basic attributes of an 32-bit block header.
Definition: GctBlockHeader.h:15
L1GctInternEtSum::fromJetTotHt
static L1GctInternEtSum fromJetTotHt(uint16_t capBlock, uint16_t capIndex, int16_t bx, uint32_t data)
Definition: L1GctInternEtSum.cc:30
l1GctHwDigis_cfi.numberOfRctSamplesToUnpack
numberOfRctSamplesToUnpack
Definition: l1GctHwDigis_cfi.py:9
GctFormatTranslateBase::FORWARD_JETS
Definition: GctFormatTranslateBase.h:61
mps_fire.i
i
Definition: mps_fire.py:355
L1GctJetCand
Level-1 Trigger jet candidate.
Definition: L1GctJetCand.h:17
GctUnpackCollections::gctInternHtMiss
L1GctInternHtMissCollection *const gctInternHtMiss() const
Internal missing Ht collection.
Definition: GctUnpackCollections.h:49
GctFormatTranslateV38::blockLengthMap
const BlockLengthMap & blockLengthMap() const final
get the static block ID to block-length map.
Definition: GctFormatTranslateV38.h:47
L1GctHFBitCounts::fromConcHFBitCounts
static L1GctHFBitCounts fromConcHFBitCounts(const uint16_t capBlock, const uint16_t capIndex, const int16_t bx, const uint32_t data)
Definition: L1GctHFBitCounts.cc:14
GctUnpackCollections::rctEm
L1CaloEmCollection *const rctEm() const
Input electrons from the RCT to the GCT.
Definition: GctUnpackCollections.h:31
GctFormatTranslateBase::NUM_JET_CATEGORIES
Definition: GctFormatTranslateBase.h:61
min
T min(T a, T b)
Definition: MathUtil.h:58
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
GctFormatTranslateV38::blockToRctEmCand
void blockToRctEmCand(const unsigned char *d, const GctBlockHeader &hdr)
unpack RCT EM Candidates
Definition: GctFormatTranslateV38.cc:845
GctUnpackCollections::gctInternEm
L1GctInternEmCandCollection *const gctInternEm() const
Internal EM candidate collection.
Definition: GctUnpackCollections.h:37
L1GctJetCandCollection
std::vector< L1GctJetCand > L1GctJetCandCollection
Definition: L1GctCollections.h:31
GctFormatTranslateBase::unpackSharedRegions
bool unpackSharedRegions() const
Definition: GctFormatTranslateBase.h:101
L1GctEmCand
Level-1 Trigger EM candidate at output of GCT.
Definition: L1GctEmCand.h:21
cms::cuda::assert
assert(be >=bs)
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:215
GctUnpackCollections::gctHfBitCounts
L1GctHFBitCountsCollection *const gctHfBitCounts() const
GCT output: Hadronic-Forward bit-counts collection.
Definition: GctUnpackCollections.h:67
GctUnpackCollections::gctHfRingEtSums
L1GctHFRingEtSumsCollection *const gctHfRingEtSums() const
GCT output: Hadronic-Forward ring-sums collection.
Definition: GctUnpackCollections.h:70
singleTopDQM_cfi.jets
jets
Definition: singleTopDQM_cfi.py:42
GctFormatTranslateV38::internEmIsoBounds
const BlockIdToEmCandIsoBoundMap & internEmIsoBounds() const final
get the static intern EM cand isolated boundary map.
Definition: GctFormatTranslateV38.h:61
L1GctInternHFData::fromConcBitCounts
static L1GctInternHFData fromConcBitCounts(const uint16_t capBlock, const uint16_t capIndex, const int16_t bx, const uint32_t data)
Definition: L1GctInternHFData.cc:22
GctBlockHeader::blockId
uint32_t blockId() const
Get the block ID.
Definition: GctBlockHeader.h:27
L1GctInternJetData::fromJetPreCluster
static L1GctInternJetData fromJetPreCluster(L1CaloRegionDetId rgn, uint16_t capBlock, uint16_t capIndex, int16_t bx, uint32_t data)
construct from "jet_precluster"
Definition: L1GctInternJetData.cc:52
newFWLiteAna.found
found
Definition: newFWLiteAna.py:118
PresampleTask_cfi.nSamples
nSamples
Definition: PresampleTask_cfi.py:7
GctUnpackCollections::gctNonIsoEm
L1GctEmCandCollection *const gctNonIsoEm() const
GCT output: Non-isolated EM candidate collection.
Definition: GctUnpackCollections.h:57
validateGeometry_cfg.valid
valid
Definition: validateGeometry_cfg.py:21
end
#define end
Definition: vmac.h:39
LEDCalibrationChannels.iphi
iphi
Definition: LEDCalibrationChannels.py:64
simKBmtfDigis_cfi.bx
bx
Definition: simKBmtfDigis_cfi.py:55
GctFormatTranslateBase::IsoBoundaryPair
std::pair< unsigned int, unsigned int > IsoBoundaryPair
Definition: GctFormatTranslateBase.h:76
L1GctInternJetData::fromGctTrigObject
static L1GctInternJetData fromGctTrigObject(L1CaloRegionDetId rgn, uint16_t capBlock, uint16_t capIndex, int16_t bx, uint32_t data)
construct from "gct_trig_object"
Definition: L1GctInternJetData.cc:82
L1GctEtMiss
Persistable copy of missing Et measured at Level-1.
Definition: L1GctEtMiss.h:17
reco::ceil
constexpr int32_t ceil(float num)
Definition: constexpr_cmath.h:7
L1CaloRegionDetId
Definition: L1CaloRegionDetId.h:18
L1GctInternJetData::fromJetCluster
static L1GctInternJetData fromJetCluster(L1CaloRegionDetId rgn, uint16_t capBlock, uint16_t capIndex, int16_t bx, uint32_t data)
construct from "jet_cluster"
Definition: L1GctInternJetData.cc:37
GctFormatTranslateBase::GctFormatTranslateBase
GctFormatTranslateBase(bool hltMode=false, bool unpackSharedRegions=false)
Constructor.
Definition: GctFormatTranslateBase.cc:11
GctUnpackCollections::gctInternJets
L1GctInternJetDataCollection *const gctInternJets() const
Internal Jet candidate collection.
Definition: GctUnpackCollections.h:40
CastorRawToDigi_cfi.lastSample
lastSample
Definition: CastorRawToDigi_cfi.py:23
GctFormatTranslateV38::m_numberOfGctSamplesToUnpack
const unsigned m_numberOfGctSamplesToUnpack
Number of BXs of GCT data to unpack (assuming they are in the raw data)
Definition: GctFormatTranslateV38.h:102
GctUnpackCollections::gctHtMiss
L1GctHtMissCollection *const gctHtMiss() const
GCT output: Missing Ht collection.
Definition: GctUnpackCollections.h:78
L1GctInternHtMiss::unpackerMissHtxHty
static L1GctInternHtMiss unpackerMissHtxHty(const uint16_t capBlock, const uint16_t capIndex, const int16_t bx, const uint32_t data)
Named ctor for making missing Ht x & y components object from unpacker raw data (wheel input).
Definition: L1GctInternHtMiss.cc:28
L1CaloRegion::makeRegionFromUnpacker
static L1CaloRegion makeRegionFromUnpacker(const uint16_t data, const unsigned ieta, const unsigned iphi, const uint16_t block, const uint16_t index, const int16_t bx)
constructor from raw data and GCT indices for unpacking
Definition: L1CaloRegion.cc:78
L1GctInternHtMiss::unpackerMissHty
static L1GctInternHtMiss unpackerMissHty(const uint16_t capBlock, const uint16_t capIndex, const int16_t bx, const uint32_t data)
Named ctor for making missing Ht y-component object from unpacker raw data.
Definition: L1GctInternHtMiss.cc:20
L1GctInternEmCand
Definition: L1GctInternEmCand.h:18
L1GctEtTotal
Persistable copy of total Et measured at Level-1.
Definition: L1GctEtTotal.h:17
GctUnpackCollections::gctInternHFData
L1GctInternHFDataCollection *const gctInternHFData() const
Internal Hadronic-Forward bit-counts/ring-sums data collection.
Definition: GctUnpackCollections.h:46
L1GctInternHFData::fromConcRingSums
static L1GctInternHFData fromConcRingSums(const uint16_t capBlock, const uint16_t capIndex, const int16_t bx, const uint32_t data)
Definition: L1GctInternHFData.cc:9
GctFormatTranslateBase::hltMode
bool hltMode() const
Protected interface to get HLT optimisation mode flag.
Definition: GctFormatTranslateBase.h:100
LEDCalibrationChannels.ieta
ieta
Definition: LEDCalibrationChannels.py:63
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:670
castor_dqm_sourceclient-live_cfg.firstSample
firstSample
Definition: castor_dqm_sourceclient-live_cfg.py:64
L1GctHFRingEtSums::fromConcRingSums
static L1GctHFRingEtSums fromConcRingSums(const uint16_t capBlock, const uint16_t capIndex, const int16_t bx, const uint32_t data)
Definition: L1GctHFRingEtSums.cc:14
GctUnpackCollections::rctCalo
L1CaloRegionCollection *const rctCalo() const
Input calo regions from the RCT to the GCT.
Definition: GctUnpackCollections.h:32
GctFormatTranslateBase::colls
GctUnpackCollections *const colls() const
Protected access to the GCT Unpack Collections.
Definition: GctFormatTranslateBase.h:97
GctFormatTranslateV38::m_numberOfRctSamplesToUnpack
const unsigned m_numberOfRctSamplesToUnpack
Definition: GctFormatTranslateV38.h:105
L1GctInternHFData::fromWheelRingSums
static L1GctInternHFData fromWheelRingSums(const uint16_t capBlock, const uint16_t capIndex, const int16_t bx, const uint32_t data)
Definition: L1GctInternHFData.cc:37
GctBlockHeader::blockLength
uint32_t blockLength() const
Get the fundamental block length (for 1 time sample)
Definition: GctBlockHeader.h:30
GctFormatTranslateV38::rctJetCrateMap
const BlkToRctCrateMap & rctJetCrateMap() const final
get the static block ID to RCT crate map for jets
Definition: GctFormatTranslateV38.h:57
SourceCardRouting::SFPtoEMU
void SFPtoEMU(unsigned short(&eIsoRank)[4], unsigned short(&eIsoCardId)[4], unsigned short(&eIsoRegionId)[4], unsigned short(&eNonIsoRank)[4], unsigned short(&eNonIsoCardId)[4], unsigned short(&eNonIsoRegionId)[4], unsigned short(&MIPbits)[7][2], unsigned short(&Qbits)[7][2], unsigned short(&SFP)[2][4]) const
Definition: SourceCardRouting.cc:68
L1GctInternEtSum::fromTotalEtOrHt
static L1GctInternEtSum fromTotalEtOrHt(uint16_t capBlock, uint16_t capIndex, int16_t bx, uint32_t data)
Definition: L1GctInternEtSum.cc:59
GctUnpackCollections::gctIsoEm
L1GctEmCandCollection *const gctIsoEm() const
GCT output: Isolated EM candidate collection.
Definition: GctUnpackCollections.h:54
GctFormatTranslateBase::gctJets
L1GctJetCandCollection *const gctJets(const unsigned cat) const
Get a specific jet candandiate collection using the JetCandCategory enumeration.
Definition: GctFormatTranslateBase.cc:30
GctFormatTranslateBase::TAU_JETS
Definition: GctFormatTranslateBase.h:61
GctFormatTranslateV38::blockToFibres
void blockToFibres(const unsigned char *d, const GctBlockHeader &hdr)
unpack Fibres
Definition: GctFormatTranslateV38.cc:977
GctBlockHeader::nSamples
uint32_t nSamples() const
Get the number of time samples.
Definition: GctBlockHeader.h:33
L1GctEtHad
Persistable copy of total Ht measured at Level-1.
Definition: L1GctEtHad.h:17
GctFormatTranslateV38::m_blockUnpackFn
static const BlockIdToUnpackFnMap m_blockUnpackFn
Block ID to unpack function map.
Definition: GctFormatTranslateV38.h:99
L1GctEmCandCollection
std::vector< L1GctEmCand > L1GctEmCandCollection
Definition: L1GctCollections.h:30
GctFormatTranslateV38::rctEmCrateMap
const BlkToRctCrateMap & rctEmCrateMap() const final
get static the block ID to RCT crate map for electrons.
Definition: GctFormatTranslateV38.h:53
L1GctInternHFData::fromWheelBitCounts
static L1GctInternHFData fromWheelBitCounts(const uint16_t capBlock, const uint16_t capIndex, const int16_t bx, const uint32_t data)
Definition: L1GctInternHFData.cc:50
GctUnpackCollections::gctEtHad
L1GctEtHadCollection *const gctEtHad() const
GCT output: Hadronic transverse-energy (Ht) collection.
Definition: GctUnpackCollections.h:74
L1GctInternEtSum::fromMissEtxOrEty
static L1GctInternEtSum fromMissEtxOrEty(uint16_t capBlock, uint16_t capIndex, int16_t bx, uint32_t data)
Definition: L1GctInternEtSum.cc:73
GctUnpackCollections::gctEtMiss
L1GctEtMissCollection *const gctEtMiss() const
GCT output: Missing Et collection.
Definition: GctUnpackCollections.h:77
data
char data[epos_bytes_allocation]
Definition: EPOS_Wrapper.h:79
L1GctFibreWord
Global Calorimeter Trigger SC -> CC fibre data word.
Definition: L1GctFibreWord.h:17
ztail.d
d
Definition: ztail.py:151
GctUnpackCollections::gctEtTot
L1GctEtTotalCollection *const gctEtTot() const
GCT output: Total Et collection.
Definition: GctUnpackCollections.h:73
GctFormatTranslateBase::srcCardRouting
const SourceCardRouting & srcCardRouting() const
Protected interface to the unpackSharedRegions commissioning option.
Definition: GctFormatTranslateBase.h:104
GctFormatTranslateBase::checkBlock
bool checkBlock(const GctBlockHeader &hdr) const
Performs checks on the block header to see if the block is possible to unpack or not.
Definition: GctFormatTranslateBase.cc:47
hltrates_dqm_sourceclient-live_cfg.offset
offset
Definition: hltrates_dqm_sourceclient-live_cfg.py:82
L1CaloEmCand
Level-1 Region Calorimeter Trigger EM candidate.
Definition: L1CaloEmCand.h:17
L1GctInternEtSum::fromJetMissEt
static L1GctInternEtSum fromJetMissEt(uint16_t capBlock, uint16_t capIndex, int16_t bx, uint32_t data)
Definition: L1GctInternEtSum.cc:45
GctUnpackCollections::gctFibres
L1GctFibreCollection *const gctFibres() const
Raw fibre input to the GCT.
Definition: GctUnpackCollections.h:30
GctUnpackCollections::gctInternEtSums
L1GctInternEtSumCollection *const gctInternEtSums() const
Internal Et Sum collection.
Definition: GctUnpackCollections.h:43
L1GctInternHtMiss::unpackerMissHtx
static L1GctInternHtMiss unpackerMissHtx(const uint16_t capBlock, const uint16_t capIndex, const int16_t bx, const uint32_t data)
Named ctor for making missing Ht x-component object from unpacker raw data.
Definition: L1GctInternHtMiss.cc:12
L1GctInternEtSum::fromJetTotEt
static L1GctInternEtSum fromJetTotEt(uint16_t capBlock, uint16_t capIndex, int16_t bx, uint32_t data)
Definition: L1GctInternEtSum.cc:16