#include <L1GlobalTriggerEvmRawToDigi.h>

Inheritance diagram for L1GlobalTriggerEvmRawToDigi:

Public Member Functions
	L1GlobalTriggerEvmRawToDigi (const edm::ParameterSet &)
	constructor(s) More...

	~L1GlobalTriggerEvmRawToDigi () override
	destructor More...

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Private Member Functions
void	dumpFedRawData (const unsigned char *, int, std::ostream &)
	dump FED raw data More...

void	produce (edm::Event &, const edm::EventSetup &) override

void	produceEmptyProducts (edm::Event &)
	produce empty products in case of problems More...

void	unpackHeader (const unsigned char *, FEDHeader &)
	block unpackers More...

void	unpackTrailer (const unsigned char *, FEDTrailer &)
	unpack trailer word More...

Private Attributes
cms_uint16_t	m_activeBoardsMaskGt
	mask for active boards More...

int	m_bstLengthBytes
	length of BST record (in bytes) More...

int	m_evmGtFedId

edm::InputTag	m_evmGtInputTag
	input tags for GT EVM record More...

L1GtFdlWord *	m_gtFdlWord

L1GtfeExtWord *	m_gtfeWord

bool	m_isDebugEnabled

int	m_lowSkipBxInEvent

int	m_recordLength0
	total Bx's in the event, obtained from GTFE block More...

int	m_recordLength1
	corresponding to alternative 1 in altNrBxBoard() More...

L1TcsWord *	m_tcsWord

int	m_totalBxInEvent
	number of Bx for a board, obtained from GTFE block (record length & alternative) More...

int	m_unpackBxInEvent

int	m_uppSkipBxInEvent

int	m_verbosity
	verbosity level More...

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Description: unpack EVM raw data into digitized data.

Implementation: <TODO: enter implementation details>

Author: : Vasile Mihai Ghete - HEPHY Vienna

Description: unpack raw data into digitized data.

Implementation: <TODO: enter implementation details>

Author: : Vasile Mihai Ghete - HEPHY Vienna

Definition at line 43 of file L1GlobalTriggerEvmRawToDigi.h.

Constructor & Destructor Documentation

◆ L1GlobalTriggerEvmRawToDigi()

L1GlobalTriggerEvmRawToDigi::L1GlobalTriggerEvmRawToDigi ( const edm::ParameterSet & pSet )

explicit

constructor(s)

Definition at line 56 of file L1GlobaTriggerEvmRawToDigi.cc.

     :
  
       // input tag for EVM GT record
       m_evmGtInputTag(pSet.getParameter<edm::InputTag>("EvmGtInputTag")),
  
       // FED Id for GT EVM record
       // default value defined in DataFormats/FEDRawData/src/FEDNumbering.cc
       // default value: assume the EVM record is the first GT record
       m_evmGtFedId(pSet.getUntrackedParameter<int>("EvmGtFedId", FEDNumbering::MINTriggerGTPFEDID)),
  
       // mask for active boards
       m_activeBoardsMaskGt(pSet.getParameter<unsigned int>("ActiveBoardsMask")),
  
       // number of bunch crossing to be unpacked
       m_unpackBxInEvent(pSet.getParameter<int>("UnpackBxInEvent")),
  
       m_lowSkipBxInEvent(0),
       m_uppSkipBxInEvent(0),
  
       m_recordLength0(0),
       m_recordLength1(0),
  
       m_totalBxInEvent(0),
  
       // length of BST record (in bytes)
       m_bstLengthBytes(pSet.getParameter<int>("BstLengthBytes")),
  
       m_verbosity(pSet.getUntrackedParameter<int>("Verbosity", 0)),
  
       m_isDebugEnabled(edm::isDebugEnabled())
  
 {
   produces<L1GlobalTriggerEvmReadoutRecord>();
  
   if (m_verbosity && m_isDebugEnabled) {
     LogDebug("L1GlobalTriggerEvmRawToDigi")
         << "\nInput tag for EVM GT record:             " << m_evmGtInputTag
         << "\nFED Id for EVM GT record:                " << m_evmGtFedId
         << "\nMask for active boards (hex format):     " << std::hex << std::setw(sizeof(m_activeBoardsMaskGt) * 2)
         << std::setfill('0') << m_activeBoardsMaskGt << std::dec << std::setfill(' ')
         << "\nNumber of bunch crossing to be unpacked: " << m_unpackBxInEvent
         << "\nLength of BST message [bytes]:           " << m_bstLengthBytes << "\n"
         << std::endl;
   }
  
   if ((m_unpackBxInEvent > 0) && ((m_unpackBxInEvent % 2) == 0)) {
     m_unpackBxInEvent = m_unpackBxInEvent - 1;
  
     if (m_verbosity) {
       edm::LogInfo("L1GlobalTriggerEvmRawToDigi")
           << "\nWARNING: Number of bunch crossing to be unpacked rounded to: " << m_unpackBxInEvent
           << "\n         The number must be an odd number!\n"
           << std::endl;
     }
   }
  
   // create GTFE, TCS, FDL cards once per analyzer
   // content will be reset whenever needed
  
   m_gtfeWord = new L1GtfeExtWord();
   m_tcsWord = new L1TcsWord();
   m_gtFdlWord = new L1GtFdlWord();
   consumes<FEDRawDataCollection>(m_evmGtInputTag);
 }

References TauDecayModes::dec, LogDebug, m_activeBoardsMaskGt, m_bstLengthBytes, m_evmGtFedId, m_evmGtInputTag, m_gtFdlWord, m_gtfeWord, m_isDebugEnabled, m_tcsWord, m_unpackBxInEvent, and m_verbosity.

◆ ~L1GlobalTriggerEvmRawToDigi()

L1GlobalTriggerEvmRawToDigi::~L1GlobalTriggerEvmRawToDigi ( )

override

destructor

Definition at line 123 of file L1GlobaTriggerEvmRawToDigi.cc.

                                                           {
   delete m_gtfeWord;
   delete m_tcsWord;
   delete m_gtFdlWord;
 }

References m_gtFdlWord, m_gtfeWord, and m_tcsWord.

Member Function Documentation

◆ dumpFedRawData()

void L1GlobalTriggerEvmRawToDigi::dumpFedRawData	(	const unsigned char *	gtPtr,
		int	gtSize,
		std::ostream &	myCout
	)

private

dump FED raw data

Definition at line 739 of file L1GlobaTriggerEvmRawToDigi.cc.

                                                                                                            {
   LogDebug("L1GlobalTriggerEvmRawToDigi") << "\nDump FED raw data.\n" << std::endl;
  
   int wLength = L1GlobalTriggerReadoutSetup::WordLength;
   int uLength = L1GlobalTriggerReadoutSetup::UnitLength;
  
   int gtWords = gtSize / uLength;
   LogTrace("L1GlobalTriggerEvmRawToDigi") << "\nFED GT words (" << wLength << " bits):" << gtWords << "\n" << std::endl;
  
   const cms_uint64_t* payload = reinterpret_cast<cms_uint64_t*>(const_cast<unsigned char*>(gtPtr));
  
   for (unsigned int i = 0; i < gtSize / sizeof(cms_uint64_t); i++) {
     myCout << std::setw(4) << i << "  " << std::hex << std::setfill('0') << std::setw(16) << payload[i] << std::dec
            << std::setfill(' ') << std::endl;
   }
 }

References TauDecayModes::dec, mps_fire::i, LogDebug, LogTrace, jets_cff::payload, L1GlobalTriggerReadoutSetup::UnitLength, and L1GlobalTriggerReadoutSetup::WordLength.

Referenced by produce().

◆ produce()

void L1GlobalTriggerEvmRawToDigi::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	evSetup
	)

overrideprivate

Definition at line 132 of file L1GlobaTriggerEvmRawToDigi.cc.

                                                                                         {
   // get records from EventSetup
  
   //  board maps
   edm::ESHandle<L1GtBoardMaps> l1GtBM;
   evSetup.get<L1GtBoardMapsRcd>().get(l1GtBM);
  
   const std::vector<L1GtBoard> boardMaps = l1GtBM->gtBoardMaps();
   int boardMapsSize = boardMaps.size();
  
   typedef std::vector<L1GtBoard>::const_iterator CItBoardMaps;
  
   // create an ordered vector for the GT EVM record
   // header (pos 0 in record) and trailer (last position in record)
   // not included, as they are not in board list
   std::vector<L1GtBoard> gtRecordMap;
   gtRecordMap.reserve(boardMapsSize);
  
   for (int iPos = 0; iPos < boardMapsSize; ++iPos) {
     for (CItBoardMaps itBoard = boardMaps.begin(); itBoard != boardMaps.end(); ++itBoard) {
       if (itBoard->gtPositionEvmRecord() == iPos) {
         gtRecordMap.push_back(*itBoard);
         break;
       }
     }
   }
  
   // raw collection
  
   edm::Handle<FEDRawDataCollection> fedHandle;
   iEvent.getByLabel(m_evmGtInputTag, fedHandle);
  
   if (!fedHandle.isValid()) {
     if (m_verbosity) {
       edm::LogWarning("L1GlobalTriggerEvmRawToDigi")
           << "\nWarning: FEDRawDataCollection with input tag " << m_evmGtInputTag
           << "\nrequested in configuration, but not found in the event."
           << "\nQuit unpacking this event" << std::endl;
     }
  
     produceEmptyProducts(iEvent);
  
     return;
   }
  
   // retrieve data for Global Trigger EVM FED
   const FEDRawData& raw = (fedHandle.product())->FEDData(m_evmGtFedId);
  
   int gtSize = raw.size();
  
   // get a const pointer to the beginning of the data buffer
   const unsigned char* ptrGt = raw.data();
  
   // get a const pointer to the end of the data buffer
   const unsigned char* endPtrGt = ptrGt + gtSize;
  
   //
   if (m_verbosity && m_isDebugEnabled) {
     LogTrace("L1GlobalTriggerEvmRawToDigi") << "\n Size of raw data: " << gtSize << "\n" << std::endl;
  
     std::ostringstream myCoutStream;
     dumpFedRawData(ptrGt, gtSize, myCoutStream);
  
     LogTrace("L1GlobalTriggerEvmRawToDigi") << "\n Dump FEDRawData\n" << myCoutStream.str() << "\n" << std::endl;
   }
  
   // unpack header
   int headerSize = 8;
  
   if ((ptrGt + headerSize) > endPtrGt) {
     edm::LogError("L1GlobalTriggerEvmRawToDigi") << "\nError: Pointer after header greater than end pointer."
                                                  << "\n Put empty products in the event!"
                                                  << "\n Quit unpacking this event." << std::endl;
  
     produceEmptyProducts(iEvent);
  
     return;
   }
  
   FEDHeader cmsHeader(ptrGt);
   FEDTrailer cmsTrailer(ptrGt + gtSize - headerSize);
  
   unpackHeader(ptrGt, cmsHeader);
   ptrGt += headerSize;  // advance with header size
  
   // unpack first GTFE to find the length of the record and the active boards
   // here GTFE assumed immediately after the header
  
   bool gtfeUnpacked = false;
  
   // get the length of the BST message from parameter set or from event setup
  
   int bstLengthBytes = 0;
  
   if (m_bstLengthBytes < 0) {
     // length from event setup // TODO cache it, if too slow
  
     edm::ESHandle<L1GtParameters> l1GtPar;
     evSetup.get<L1GtParametersRcd>().get(l1GtPar);
     const L1GtParameters* m_l1GtPar = l1GtPar.product();
  
     bstLengthBytes = static_cast<int>(m_l1GtPar->gtBstLengthBytes());
  
   } else {
     // length from parameter set
     bstLengthBytes = m_bstLengthBytes;
   }
  
   if (m_verbosity) {
     LogTrace("L1GlobalTriggerEvmRawToDigi") << "\n Length of BST message (in bytes): " << bstLengthBytes << "\n"
                                             << std::endl;
   }
  
   for (CItBoardMaps itBoard = boardMaps.begin(); itBoard != boardMaps.end(); ++itBoard) {
     if (itBoard->gtBoardType() == GTFE) {
       // unpack GTFE
       if (itBoard->gtPositionEvmRecord() == 1) {
         // resize to the right size before unapacking
         m_gtfeWord->resize(bstLengthBytes);
  
         m_gtfeWord->unpack(ptrGt);
         ptrGt += m_gtfeWord->getSize();  // advance with GTFE block size
         gtfeUnpacked = true;
  
         if (m_verbosity && m_isDebugEnabled) {
           std::ostringstream myCoutStream;
           m_gtfeWord->print(myCoutStream);
           LogTrace("L1GlobalTriggerEvmRawToDigi") << myCoutStream.str() << "\n" << std::endl;
         }
  
         // break the loop - GTFE was found
         break;
  
       } else {
         if (m_verbosity) {
           edm::LogWarning("L1GlobalTriggerEvmRawToDigi")
               << "\nWarning: GTFE block found in raw data does not follow header."
               << "\nAssumed start position of the block is wrong!"
               << "\nQuit unpacking this event" << std::endl;
         }
  
         produceEmptyProducts(iEvent);
  
         return;
       }
     }
   }
  
   // quit if no GTFE found
   if (!gtfeUnpacked) {
     if (m_verbosity) {
       edm::LogWarning("L1GlobalTriggerEvmRawToDigi")
           << "\nWarning: no GTFE block found in raw data."
           << "\nCan not find the record length (BxInEvent) and the active boards!"
           << "\nQuit unpacking this event" << std::endl;
     }
  
     produceEmptyProducts(iEvent);
  
     return;
   }
  
   // life normal here, GTFE found
  
   // get list of active blocks
   // blocks not active are not written to the record
   cms_uint16_t activeBoardsGtInitial = m_gtfeWord->activeBoards();
   cms_uint16_t altNrBxBoardInitial = m_gtfeWord->altNrBxBoard();
  
   // mask some boards, if needed
   cms_uint16_t activeBoardsGt = activeBoardsGtInitial & m_activeBoardsMaskGt;
   m_gtfeWord->setActiveBoards(activeBoardsGt);
  
   if (m_verbosity) {
     LogDebug("L1GlobalTriggerEvmRawToDigi")
         << "\nActive boards before masking(hex format): " << std::hex << std::setw(sizeof(activeBoardsGtInitial) * 2)
         << std::setfill('0') << activeBoardsGtInitial << std::dec << std::setfill(' ')
         << "\nActive boards after masking(hex format):  " << std::hex << std::setw(sizeof(activeBoardsGt) * 2)
         << std::setfill('0') << activeBoardsGt << std::dec << std::setfill(' ') << " \n"
         << std::endl;
   }
  
   // loop over other blocks in the raw record, count them if they are active
  
   int numberGtfeBoards = 0;
   int numberFdlBoards = 0;
   int numberPsbBoards = 0;
   int numberGmtBoards = 0;
   int numberTcsBoards = 0;
   int numberTimBoards = 0;
  
   for (CItBoardMaps itBoard = boardMaps.begin(); itBoard != boardMaps.end(); ++itBoard) {
     int iActiveBit = itBoard->gtBitEvmActiveBoards();
     bool activeBoardToUnpack = false;
  
     if (iActiveBit >= 0) {
       activeBoardToUnpack = activeBoardsGt & (1 << iActiveBit);
     } else {
       // board not in the ActiveBoards for the record
       continue;
     }
  
     if (activeBoardToUnpack) {
       switch (itBoard->gtBoardType()) {
         case GTFE: {
           numberGtfeBoards++;
         }
  
         break;
         case FDL: {
           numberFdlBoards++;
         }
  
         break;
         case PSB: {
           numberPsbBoards++;
         }
  
         break;
         case GMT: {
           numberGmtBoards++;
         }
  
         break;
         case TCS: {
           numberTcsBoards++;
         }
  
         break;
         case TIM: {
           numberTimBoards++;
         }
  
         break;
         default: {
           // do nothing, all blocks are given in GtBoardType enum
           if (m_verbosity) {
             LogDebug("L1GlobalTriggerEvmRawToDigi")
                 << "\nBoard of type " << itBoard->gtBoardType() << " not expected  in record.\n"
                 << std::endl;
           }
  
         }
  
         break;
       }
     }
   }
  
   // produce the L1GlobalTriggerEvmReadoutRecord now, after we found how many
   // BxInEvent the record has and how many boards are active
   //LogDebug("L1GlobalTriggerEvmRawToDigi")
   //<< "\nL1GlobalTriggerEvmRawToDigi: producing L1GlobalTriggerEvmReadoutRecord\n"
   //<< std::endl;
  
   // get number of Bx in the event from GTFE block corresponding to alternative 0 and 1 in
   m_recordLength0 = m_gtfeWord->recordLength();
   m_recordLength1 = m_gtfeWord->recordLength1();
  
   int maxBxInEvent = std::max(m_recordLength0, m_recordLength1);
  
   std::unique_ptr<L1GlobalTriggerEvmReadoutRecord> gtReadoutRecord(
       new L1GlobalTriggerEvmReadoutRecord(maxBxInEvent, numberFdlBoards));
  
   // ... then unpack modules other than GTFE, if requested
  
   for (CItBoardMaps itBoard = gtRecordMap.begin(); itBoard != gtRecordMap.end(); ++itBoard) {
     int iActiveBit = itBoard->gtBitEvmActiveBoards();
  
     bool activeBoardToUnpack = false;
     bool activeBoardInitial = false;
  
     int altNrBxBoardVal = -1;
  
     if (iActiveBit >= 0) {
       activeBoardInitial = activeBoardsGtInitial & (1 << iActiveBit);
       activeBoardToUnpack = activeBoardsGt & (1 << iActiveBit);
  
       altNrBxBoardVal = (altNrBxBoardInitial & (1 << iActiveBit)) >> iActiveBit;
  
       if (altNrBxBoardVal == 1) {
         m_totalBxInEvent = m_recordLength1;
       } else if (altNrBxBoardVal == 0) {
         m_totalBxInEvent = m_recordLength0;
       } else {
         if (m_verbosity) {
           edm::LogWarning("L1GlobalTriggerEvmRawToDigi")
               << "\n\nWARNING: Wrong value altNrBxBoardVal = " << altNrBxBoardVal << " for board " << std::hex
               << (itBoard->gtBoardId()) << std::dec << "\n  iActiveBit =            " << iActiveBit
               << "\n  altNrBxBoardInitial = 0x" << std::hex << altNrBxBoardInitial << std::dec
               << "\n  activeBoardsGt =      0x" << std::hex << activeBoardsGt << std::dec
               << "\n  activeBoardInitial =    " << activeBoardInitial
               << "\n  activeBoardToUnpack =   " << activeBoardToUnpack << "\n Set altNrBxBoardVal tentatively to "
               << m_recordLength0 << "\n Job may crash or produce wrong results!\n\n"
               << std::endl;
         }
  
         m_totalBxInEvent = m_recordLength0;
       }
  
       // number of BX required to be unpacked
  
       if (m_unpackBxInEvent > m_totalBxInEvent) {
         if (m_verbosity) {
           LogDebug("L1GlobalTriggerEvmRawToDigi")
               << "\nWARNING: Number of available bunch crosses for board" << (itBoard->gtBoardId())
               << " in the record ( " << m_totalBxInEvent
               << " ) \n is smaller than the number of bunch crosses requested to be unpacked (" << m_unpackBxInEvent
               << " )!!! \n         Unpacking only " << m_totalBxInEvent << " bunch crosses.\n"
               << std::endl;
         }
  
         m_lowSkipBxInEvent = 0;
         m_uppSkipBxInEvent = m_totalBxInEvent;
  
       } else if (m_unpackBxInEvent < 0) {
         m_lowSkipBxInEvent = 0;
         m_uppSkipBxInEvent = m_totalBxInEvent;
  
         if (m_verbosity) {
           LogDebug("L1GlobalTriggerEvmRawToDigi")
               << "\nUnpacking all " << m_totalBxInEvent << " bunch crosses available."
               << "\n"
               << std::endl;
         }
  
       } else if (m_unpackBxInEvent == 0) {
         m_lowSkipBxInEvent = m_totalBxInEvent;
         m_uppSkipBxInEvent = m_totalBxInEvent;
  
         if (m_verbosity) {
           LogDebug("L1GlobalTriggerEvmRawToDigi")
               << "\nNo bxInEvent required to be unpacked from " << m_totalBxInEvent << " bunch crosses available."
               << "\n"
               << std::endl;
         }
  
         // change RecordLength
         // cast int to cms_uint16_t (there are normally 3 or 5 BxInEvent)
         m_gtfeWord->setRecordLength(static_cast<cms_uint16_t>(m_unpackBxInEvent));
         m_gtfeWord->setRecordLength1(static_cast<cms_uint16_t>(m_unpackBxInEvent));
  
       } else {
         m_lowSkipBxInEvent = (m_totalBxInEvent - m_unpackBxInEvent) / 2;
         m_uppSkipBxInEvent = m_totalBxInEvent - m_lowSkipBxInEvent;
  
         if (m_verbosity) {
           LogDebug("L1GlobalTriggerEvmRawToDigi") << "\nUnpacking " << m_unpackBxInEvent << " bunch crosses from "
                                                   << m_totalBxInEvent << " bunch crosses available."
                                                   << "\n"
                                                   << std::endl;
         }
  
         // change RecordLength
         // cast int to cms_uint16_t (there are normally 3 or 5 BxInEvent)
         m_gtfeWord->setRecordLength(static_cast<cms_uint16_t>(m_unpackBxInEvent));
         m_gtfeWord->setRecordLength1(static_cast<cms_uint16_t>(m_unpackBxInEvent));
       }
  
     } else {
       // board not in the ActiveBoards for the record
       continue;
     }
  
     if (!activeBoardInitial) {
       if (m_verbosity) {
         LogDebug("L1GlobalTriggerEvmRawToDigi") << "\nBoard of type " << itBoard->gtBoardName() << " with index "
                                                 << itBoard->gtBoardIndex() << " not active initially in raw data.\n"
                                                 << std::endl;
       }
       continue;
     }
  
     // active board initially, could unpack it
     switch (itBoard->gtBoardType()) {
       case TCS: {
         // if pointer after TCS payload is greater than pointer at
         // the end of GT payload, produce empty products and quit unpacking
         if ((ptrGt + m_tcsWord->getSize()) > endPtrGt) {
           edm::LogError("L1GlobalTriggerEvmRawToDigi") << "\nError: Pointer after TCS "
                                                        << " greater than end pointer."
                                                        << "\n Put empty products in the event!"
                                                        << "\n Quit unpacking this event." << std::endl;
  
           produceEmptyProducts(iEvent);
  
           return;
         }
  
         // unpack only if requested, otherwise skip it
         if (activeBoardToUnpack) {
           m_tcsWord->unpack(ptrGt);
  
           // add 1 to the GT luminosity number to use the same convention as
           // offline, where LS number starts with 1;
           // in GT hardware, LS starts with 0
           cms_uint16_t lsNr = m_tcsWord->luminositySegmentNr() + 1;
           m_tcsWord->setLuminositySegmentNr(lsNr);
  
           // add TCS block to GT EVM readout record
           gtReadoutRecord->setTcsWord(*m_tcsWord);
  
           if (m_verbosity && m_isDebugEnabled) {
             std::ostringstream myCoutStream;
             m_tcsWord->print(myCoutStream);
             LogTrace("L1GlobalTriggerEvmRawToDigi") << myCoutStream.str() << "\n" << std::endl;
           }
  
           // ... and reset it
           m_tcsWord->reset();
         }
  
         ptrGt += m_tcsWord->getSize();  // advance with TCS block size
  
       } break;
       case FDL: {
         for (int iFdl = 0; iFdl < m_totalBxInEvent; ++iFdl) {
           // if pointer after FDL payload is greater than pointer at
           // the end of GT payload, produce empty products and quit unpacking
           if ((ptrGt + m_gtFdlWord->getSize()) > endPtrGt) {
             edm::LogError("L1GlobalTriggerEvmRawToDigi")
                 << "\nError: Pointer after FDL " << iFdl << " greater than end pointer."
                 << "\n Put empty products in the event!"
                 << "\n Quit unpacking this event." << std::endl;
  
             produceEmptyProducts(iEvent);
  
             return;
           }
  
           // unpack only if requested, otherwise skip it
           if (activeBoardToUnpack) {
             // unpack only bxInEvent requested, otherwise skip it
             if ((iFdl >= m_lowSkipBxInEvent) && (iFdl < m_uppSkipBxInEvent)) {
               m_gtFdlWord->unpack(ptrGt);
  
               // add 1 to the GT luminosity number to use the same convention as
               // offline, where LS number starts with 1;
               // in GT hardware, LS starts with 0
               cms_uint16_t lsNr = m_gtFdlWord->lumiSegmentNr() + 1;
               m_gtFdlWord->setLumiSegmentNr(lsNr);
  
               // add FDL block to GT readout record
               gtReadoutRecord->setGtFdlWord(*m_gtFdlWord);
  
               if (m_verbosity && m_isDebugEnabled) {
                 std::ostringstream myCoutStream;
                 m_gtFdlWord->print(myCoutStream);
                 LogTrace("L1GlobalTriggerEvmRawToDigi") << myCoutStream.str() << "\n" << std::endl;
               }
  
               // ... and reset it
               m_gtFdlWord->reset();
             }
           }
  
           ptrGt += m_gtFdlWord->getSize();  // advance with FDL block size
         }
       }
  
       break;
       default: {
         // do nothing, all blocks are given in GtBoardType enum
         if (m_verbosity) {
           LogDebug("L1GlobalTriggerEvmRawToDigi")
               << "\nBoard of type " << itBoard->gtBoardType() << " not expected  in record.\n"
               << std::endl;
         }
       } break;
     }
   }
  
   // add GTFE block to GT readout record, after updating active boards and record length
  
   gtReadoutRecord->setGtfeWord(*m_gtfeWord);
  
   // ... and reset it
   m_gtfeWord->reset();
  
   // unpack trailer
  
   int trailerSize = 8;
  
   // if pointer after trailer is greater than pointer at
   // the end of GT payload, produce empty products and quit unpacking
   if ((ptrGt + trailerSize) > endPtrGt) {
     edm::LogError("L1GlobalTriggerEvmRawToDigi") << "\nError: Pointer after trailer "
                                                  << " greater than end pointer."
                                                  << "\n Put empty products in the event!"
                                                  << "\n Quit unpacking this event." << std::endl;
  
     produceEmptyProducts(iEvent);
  
     return;
   }
  
   unpackTrailer(ptrGt, cmsTrailer);
  
   if (m_verbosity && m_isDebugEnabled) {
     std::ostringstream myCoutStream;
     gtReadoutRecord->print(myCoutStream);
     LogTrace("L1GlobalTriggerEvmRawToDigi") << "\n The following L1 GT EVM readout record was unpacked.\n"
                                             << myCoutStream.str() << "\n"
                                             << std::endl;
   }
  
   // put records into event
   iEvent.put(std::move(gtReadoutRecord));
 }

References L1GtfeWord::activeBoards(), L1GtfeWord::altNrBxBoard(), FEDRawData::data(), TauDecayModes::dec, dumpFedRawData(), FDL, edm::EventSetup::get(), get, L1GtfeExtWord::getSize(), L1TcsWord::getSize(), L1GtFdlWord::getSize(), GMT, L1GtBoardMaps::gtBoardMaps(), L1GtParameters::gtBstLengthBytes(), GTFE, iEvent, edm::HandleBase::isValid(), LogDebug, LogTrace, L1TcsWord::luminositySegmentNr(), L1GtFdlWord::lumiSegmentNr(), m_activeBoardsMaskGt, m_bstLengthBytes, m_evmGtFedId, m_evmGtInputTag, m_gtFdlWord, m_gtfeWord, m_isDebugEnabled, m_lowSkipBxInEvent, m_recordLength0, m_recordLength1, m_tcsWord, m_totalBxInEvent, m_unpackBxInEvent, m_uppSkipBxInEvent, m_verbosity, SiStripPI::max, eostools::move(), L1GtfeExtWord::print(), L1TcsWord::print(), L1GtFdlWord::print(), produceEmptyProducts(), edm::Handle< T >::product(), edm::ESHandle< T >::product(), PSB, L1GtfeWord::recordLength(), L1GtfeWord::recordLength1(), L1GtfeExtWord::reset(), L1TcsWord::reset(), L1GtFdlWord::reset(), L1GtfeExtWord::resize(), L1GtfeWord::setActiveBoards(), L1TcsWord::setLuminositySegmentNr(), L1GtFdlWord::setLumiSegmentNr(), L1GtfeWord::setRecordLength(), L1GtfeWord::setRecordLength1(), FEDRawData::size(), TCS, TIM, L1GtfeExtWord::unpack(), L1TcsWord::unpack(), L1GtFdlWord::unpack(), unpackHeader(), and unpackTrailer().

◆ produceEmptyProducts()

void L1GlobalTriggerEvmRawToDigi::produceEmptyProducts ( edm::Event & iEvent )

private

produce empty products in case of problems

Definition at line 730 of file L1GlobaTriggerEvmRawToDigi.cc.

                                                                        {
   std::unique_ptr<L1GlobalTriggerEvmReadoutRecord> gtReadoutRecord(new L1GlobalTriggerEvmReadoutRecord());
  
   // put empty records into event
  
   iEvent.put(std::move(gtReadoutRecord));
 }

References iEvent, and eostools::move().

Referenced by produce().

◆ unpackHeader()

void L1GlobalTriggerEvmRawToDigi::unpackHeader	(	const unsigned char *	gtPtr,
		FEDHeader &	cmsHeader
	)

private

block unpackers

unpack header

Definition at line 643 of file L1GlobaTriggerEvmRawToDigi.cc.

                                                                                                {
   // TODO  if needed in another format
  
   // print the header info
   if (edm::isDebugEnabled()) {
     const cms_uint64_t* payload = reinterpret_cast<cms_uint64_t*>(const_cast<unsigned char*>(gtPtr));
  
     std::ostringstream myCoutStream;
  
     // one word only
     int iWord = 0;
  
     myCoutStream << std::setw(4) << iWord << "  " << std::hex << std::setfill('0') << std::setw(16) << payload[iWord]
                  << std::dec << std::setfill(' ') << "\n"
                  << std::endl;
  
     myCoutStream << "  Event_type:  " << std::hex << " hex: "
                  << "     " << std::setw(1) << std::setfill('0') << cmsHeader.triggerType() << std::setfill(' ')
                  << std::dec << " dec: " << cmsHeader.triggerType() << std::endl;
  
     myCoutStream << "  LVL1_Id:     " << std::hex << " hex: "
                  << "" << std::setw(6) << std::setfill('0') << cmsHeader.lvl1ID() << std::setfill(' ') << std::dec
                  << " dec: " << cmsHeader.lvl1ID() << std::endl;
  
     myCoutStream << "  BX_Id:       " << std::hex << " hex: "
                  << "   " << std::setw(3) << std::setfill('0') << cmsHeader.bxID() << std::setfill(' ') << std::dec
                  << " dec: " << cmsHeader.bxID() << std::endl;
  
     myCoutStream << "  Source_Id:   " << std::hex << " hex: "
                  << "   " << std::setw(3) << std::setfill('0') << cmsHeader.sourceID() << std::setfill(' ') << std::dec
                  << " dec: " << cmsHeader.sourceID() << std::endl;
  
     myCoutStream << "  FOV:         " << std::hex << " hex: "
                  << "     " << std::setw(1) << std::setfill('0') << cmsHeader.version() << std::setfill(' ') << std::dec
                  << " dec: " << cmsHeader.version() << std::endl;
  
     myCoutStream << "  H:           " << std::hex << " hex: "
                  << "     " << std::setw(1) << std::setfill('0') << cmsHeader.moreHeaders() << std::setfill(' ')
                  << std::dec << " dec: " << cmsHeader.moreHeaders() << std::endl;
  
     LogDebug("L1GlobalTriggerEvmRawToDigi") << "\n CMS Header \n" << myCoutStream.str() << "\n" << std::endl;
   }
 }

References FEDHeader::bxID(), TauDecayModes::dec, edm::isDebugEnabled(), LogDebug, FEDHeader::lvl1ID(), FEDHeader::moreHeaders(), jets_cff::payload, FEDHeader::sourceID(), FEDHeader::triggerType(), and FEDHeader::version().

Referenced by produce().

◆ unpackTrailer()

void L1GlobalTriggerEvmRawToDigi::unpackTrailer	(	const unsigned char *	trlPtr,
		FEDTrailer &	cmsTrailer
	)

private

unpack trailer word

Definition at line 689 of file L1GlobaTriggerEvmRawToDigi.cc.

                                                                                                    {
   // TODO  if needed in another format
  
   // print the trailer info
   if (m_verbosity && m_isDebugEnabled) {
     const cms_uint64_t* payload = reinterpret_cast<cms_uint64_t*>(const_cast<unsigned char*>(trlPtr));
  
     std::ostringstream myCoutStream;
  
     // one word only
     int iWord = 0;
  
     myCoutStream << std::setw(4) << iWord << "  " << std::hex << std::setfill('0') << std::setw(16) << payload[iWord]
                  << std::dec << std::setfill(' ') << "\n"
                  << std::endl;
  
     myCoutStream << "  Event_length:  " << std::hex << " hex: "
                  << "" << std::setw(6) << std::setfill('0') << cmsTrailer.fragmentLength() << std::setfill(' ')
                  << std::dec << " dec: " << cmsTrailer.fragmentLength() << std::endl;
  
     myCoutStream << "  CRC:           " << std::hex << " hex: "
                  << "  " << std::setw(4) << std::setfill('0') << cmsTrailer.crc() << std::setfill(' ') << std::dec
                  << " dec: " << cmsTrailer.crc() << std::endl;
  
     myCoutStream << "  Event_status:  " << std::hex << " hex: "
                  << "    " << std::setw(2) << std::setfill('0') << cmsTrailer.evtStatus() << std::setfill(' ')
                  << std::dec << " dec: " << cmsTrailer.evtStatus() << std::endl;
  
     myCoutStream << "  TTS_bits:      " << std::hex << " hex: "
                  << "     " << std::setw(1) << std::setfill('0') << cmsTrailer.ttsBits() << std::setfill(' ')
                  << std::dec << " dec: " << cmsTrailer.ttsBits() << std::endl;
  
     myCoutStream << "  More trailers: " << std::hex << " hex: "
                  << "     " << std::setw(1) << std::setfill('0') << cmsTrailer.moreTrailers() << std::setfill(' ')
                  << std::dec << " dec: " << cmsTrailer.moreTrailers() << std::endl;
  
     LogDebug("L1GlobalTriggerEvmRawToDigi") << "\n CMS Trailer \n" << myCoutStream.str() << "\n" << std::endl;
   }
 }