#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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

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

const edm::ESGetToken< L1GtBoardMaps, L1GtBoardMapsRcd >	m_l1GtBMToken
	EventSetup Token for L1GtBoardMaps. More...

edm::ESGetToken< L1GtParameters, L1GtParametersRcd >	m_l1GtParamToken
	EventSetup Token for L1GtParameters. More...

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<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::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 49 of file L1GlobalTriggerEvmRawToDigi.h.

Constructor & Destructor Documentation

◆ L1GlobalTriggerEvmRawToDigi()

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

explicit

constructor(s)

EventSetup Token for L1GtParameters

Definition at line 50 of file L1GlobaTriggerEvmRawToDigi.cc.

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

     :
 
       // 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)),
 
       m_l1GtBMToken(esConsumes<L1GtBoardMaps, L1GtBoardMapsRcd>()),
 
       // 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);
 
   if (m_bstLengthBytes < 0) {
     m_l1GtParamToken = esConsumes<L1GtParameters, L1GtParametersRcd>();
   }
 }

◆ ~L1GlobalTriggerEvmRawToDigi()

L1GlobalTriggerEvmRawToDigi::~L1GlobalTriggerEvmRawToDigi ( )

override

destructor

Definition at line 125 of file L1GlobaTriggerEvmRawToDigi.cc.

References m_gtFdlWord, m_gtfeWord, and m_tcsWord.

                                                           {
   delete m_gtfeWord;
   delete m_tcsWord;
   delete m_gtFdlWord;
 }

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.

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

Referenced by produce().

                                                                                                            {
   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;
   }
 }

◆ produce()

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

overrideprivate

Definition at line 134 of file L1GlobaTriggerEvmRawToDigi.cc.

References L1GtfeWord::activeBoards(), L1GtfeWord::altNrBxBoard(), FEDRawData::data(), TauDecayModes::dec, dumpFedRawData(), FDL, edm::EventSetup::getHandle(), 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_l1GtBMToken, m_l1GtParamToken, 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().

                                                                                         {
   // get records from EventSetup
 
   //  board maps
   edm::ESHandle<L1GtBoardMaps> l1GtBM = evSetup.getHandle(m_l1GtBMToken);
 
   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.getHandle(m_l1GtParamToken);
     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));
 }

◆ produceEmptyProducts()

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

private

produce empty products in case of problems

Definition at line 730 of file L1GlobaTriggerEvmRawToDigi.cc.

References iEvent, and eostools::move().

Referenced by produce().

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

◆ unpackHeader()

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

private

block unpackers

unpack header

Definition at line 643 of file L1GlobaTriggerEvmRawToDigi.cc.

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

Referenced by produce().

                                                                                                {
   // 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;
   }
 }

◆ unpackTrailer()

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

private

unpack trailer word

Definition at line 689 of file L1GlobaTriggerEvmRawToDigi.cc.

References FEDTrailer::crc(), TauDecayModes::dec, FEDTrailer::evtStatus(), FEDTrailer::fragmentLength(), LogDebug, m_isDebugEnabled, m_verbosity, FEDTrailer::moreTrailers(), jetsAK4_Puppi_cff::payload, and FEDTrailer::ttsBits().

Referenced by produce().

                                                                                                    {
   // 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;
   }
 }