#include <L1GlobalTrigger.h>

Inheritance diagram for L1GlobalTrigger:

Public Member Functions
const L1GlobalTriggerFDL *	gtFDL () const

const L1GlobalTriggerGTL *	gtGTL () const

const L1GlobalTriggerPSB *	gtPSB () const

	L1GlobalTrigger (const edm::ParameterSet &)

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

	~L1GlobalTrigger () override

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 Attributes
uint16_t	m_activeBoardsGtDaq
	active boards in L1 GT DAQ record and in L1 GT EVM record More...

uint16_t	m_activeBoardsGtEvm

const bool	m_algorithmTriggersUnmasked

const bool	m_algorithmTriggersUnprescaled

const unsigned int	m_alternativeNrBxBoardDaq

const unsigned int	m_alternativeNrBxBoardEvm

unsigned int	m_bstLengthBytes
	length of BST record (in bytes) from event setup More...

const edm::InputTag	m_caloGctInputTag
	input tag for calorimeter collections from GCT More...

const edm::InputTag	m_castorInputTag
	input tag for CASTOR record More...

int	m_emulateBxInEvent

L1GlobalTriggerFDL *	m_gtFDL

L1GlobalTriggerGTL *	m_gtGTL

L1GlobalTriggerPSB *	m_gtPSB

int	m_ifCaloEtaNumberBits

int	m_ifMuEtaNumberBits

const bool	m_isDebugEnabled

const L1GtBoardMaps *	m_l1GtBM
	board maps - cache only the record More...

unsigned long long	m_l1GtBMCacheID

edm::ESGetToken< L1GtBoardMaps, L1GtBoardMapsRcd >	m_l1GtBMToken

const L1GtParameters *	m_l1GtPar
	parameters More...

unsigned long long	m_l1GtParCacheID

edm::ESGetToken< L1GtParameters, L1GtParametersRcd >	m_l1GtParToken

const L1GtPrescaleFactors *	m_l1GtPfAlgo
	prescale factors More...

unsigned long long	m_l1GtPfAlgoCacheID

edm::ESGetToken< L1GtPrescaleFactors, L1GtPrescaleFactorsAlgoTrigRcd >	m_l1GtPfAlgoToken

const L1GtPrescaleFactors *	m_l1GtPfTech

unsigned long long	m_l1GtPfTechCacheID

edm::ESGetToken< L1GtPrescaleFactors, L1GtPrescaleFactorsTechTrigRcd >	m_l1GtPfTechToken

const L1GtStableParameters *	m_l1GtStablePar
	cached stuff More...

unsigned long long	m_l1GtStableParCacheID

edm::ESGetToken< L1GtStableParameters, L1GtStableParametersRcd >	m_l1GtStableParToken
	EventSetup Tokens. More...

const L1GtTriggerMask *	m_l1GtTmAlgo
	trigger masks & veto masks More...

unsigned long long	m_l1GtTmAlgoCacheID

edm::ESGetToken< L1GtTriggerMask, L1GtTriggerMaskAlgoTrigRcd >	m_l1GtTmAlgoToken

const L1GtTriggerMask *	m_l1GtTmTech

unsigned long long	m_l1GtTmTechCacheID

edm::ESGetToken< L1GtTriggerMask, L1GtTriggerMaskTechTrigRcd >	m_l1GtTmTechToken

const L1GtTriggerMask *	m_l1GtTmVetoAlgo

unsigned long long	m_l1GtTmVetoAlgoCacheID

edm::ESGetToken< L1GtTriggerMask, L1GtTriggerMaskVetoAlgoTrigRcd >	m_l1GtTmVetoAlgoToken

const L1GtTriggerMask *	m_l1GtTmVetoTech

unsigned long long	m_l1GtTmVetoTechCacheID

edm::ESGetToken< L1GtTriggerMask, L1GtTriggerMaskVetoTechTrigRcd >	m_l1GtTmVetoTechToken

const edm::InputTag	m_muGmtInputTag
	input tag for muon collection from GMT More...

int	m_nrL1CenJet

int	m_nrL1ForJet

int	m_nrL1IsoEG

int	m_nrL1JetCounts

int	m_nrL1Mu

int	m_nrL1NoIsoEG

int	m_nrL1TauJet

unsigned int	m_numberDaqPartitions
	number of DAQ partitions More...

unsigned int	m_numberPhysTriggers
	number of physics triggers More...

unsigned int	m_numberTechnicalTriggers
	number of technical triggers More...

const std::vector< std::vector< int > > *	m_prescaleFactorsAlgoTrig

const std::vector< std::vector< int > > *	m_prescaleFactorsTechTrig

const bool	m_produceL1GtDaqRecord
	logical flag to produce the L1 GT DAQ readout record More...

const bool	m_produceL1GtEvmRecord
	logical flag to produce the L1 GT EVM readout record More...

const bool	m_produceL1GtObjectMapRecord
	logical flag to produce the L1 GT object map record More...

const int	m_psBstLengthBytes
	length of BST record (in bytes) from parameter set More...

const bool	m_readTechnicalTriggerRecords
	logical flag to read the technical trigger records More...

const std::vector< int >	m_recordLength

const std::vector< edm::InputTag >	m_technicalTriggersInputTags
	input tag for technical triggers More...

const bool	m_technicalTriggersUnmasked

const bool	m_technicalTriggersUnprescaled

const bool	m_technicalTriggersVetoUnmasked

int	m_totalBxInEvent
	total number of Bx's in the event coming from EventSetup More...

std::vector< unsigned int >	m_triggerMaskAlgoTrig

std::vector< unsigned int >	m_triggerMaskTechTrig

std::vector< unsigned int >	m_triggerMaskVetoAlgoTrig

std::vector< unsigned int >	m_triggerMaskVetoTechTrig

const int	m_verbosity
	verbosity level More...

const bool	m_writePsbL1GtDaqRecord
	logical flag to write the PSB content in the L1 GT DAQ record 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: see header file.

Implementation: <TODO: enter implementation details>

Author: : Vasile Mihai Ghete - HEPHY Vienna

Description: L1 Global Trigger producer.

Implementation: <TODO: enter implementation details>

Author: : Vasile Mihai Ghete - HEPHY Vienna

The CMSSW implementation of the L1 Global Trigger emulator uses concepts and code from the ORCA L1 Global Trigger simulation, authors: N. Neumeister, M. Fierro, M. Eder - HEPHY Vienna.

Definition at line 78 of file L1GlobalTrigger.h.

Constructor & Destructor Documentation

◆ L1GlobalTrigger()

L1GlobalTrigger::L1GlobalTrigger ( const edm::ParameterSet & parSet )

explicit

Definition at line 66 of file L1GlobalTrigger.cc.

References TauDecayModes::dec, LogDebug, LogTrace, m_activeBoardsGtDaq, m_activeBoardsGtEvm, m_algorithmTriggersUnmasked, m_algorithmTriggersUnprescaled, m_alternativeNrBxBoardDaq, m_alternativeNrBxBoardEvm, m_bstLengthBytes, m_caloGctInputTag, m_castorInputTag, m_emulateBxInEvent, m_gtFDL, m_gtGTL, m_gtPSB, m_ifCaloEtaNumberBits, m_ifMuEtaNumberBits, m_l1GtBMCacheID, m_l1GtParCacheID, m_l1GtPfAlgoCacheID, m_l1GtPfTechCacheID, m_l1GtStableParCacheID, m_l1GtTmAlgoCacheID, m_l1GtTmTechCacheID, m_l1GtTmVetoAlgoCacheID, m_l1GtTmVetoTechCacheID, m_muGmtInputTag, m_nrL1CenJet, m_nrL1ForJet, m_nrL1IsoEG, m_nrL1JetCounts, m_nrL1Mu, m_nrL1NoIsoEG, m_nrL1TauJet, m_numberDaqPartitions, m_numberPhysTriggers, m_numberTechnicalTriggers, m_produceL1GtDaqRecord, m_produceL1GtEvmRecord, m_produceL1GtObjectMapRecord, m_psBstLengthBytes, m_readTechnicalTriggerRecords, m_recordLength, m_technicalTriggersInputTags, m_technicalTriggersUnmasked, m_technicalTriggersUnprescaled, m_totalBxInEvent, m_verbosity, m_writePsbL1GtDaqRecord, SiStripPI::max, L1GlobalTriggerFDL::setVerbosity(), L1GlobalTriggerGTL::setVerbosity(), and L1GlobalTriggerPSB::setVerbosity().

     : m_muGmtInputTag(parSet.getParameter<edm::InputTag>("GmtInputTag")),
       m_caloGctInputTag(parSet.getParameter<edm::InputTag>("GctInputTag")),
       m_castorInputTag(parSet.getParameter<edm::InputTag>("CastorInputTag")),
       m_technicalTriggersInputTags(parSet.getParameter<std::vector<edm::InputTag>>("TechnicalTriggersInputTags")),
       m_produceL1GtDaqRecord(parSet.getParameter<bool>("ProduceL1GtDaqRecord")),
       m_produceL1GtEvmRecord(parSet.getParameter<bool>("ProduceL1GtEvmRecord")),
       m_produceL1GtObjectMapRecord(parSet.getParameter<bool>("ProduceL1GtObjectMapRecord")),
       m_writePsbL1GtDaqRecord(parSet.getParameter<bool>("WritePsbL1GtDaqRecord")),
       m_readTechnicalTriggerRecords(parSet.getParameter<bool>("ReadTechnicalTriggerRecords")),
       m_emulateBxInEvent(parSet.getParameter<int>("EmulateBxInEvent")),
       m_recordLength(parSet.getParameter<std::vector<int>>("RecordLength")),
       m_alternativeNrBxBoardDaq(parSet.getParameter<unsigned int>("AlternativeNrBxBoardDaq")),
       m_alternativeNrBxBoardEvm(parSet.getParameter<unsigned int>("AlternativeNrBxBoardEvm")),
       m_psBstLengthBytes(parSet.getParameter<int>("BstLengthBytes")),
       m_algorithmTriggersUnprescaled(parSet.getParameter<bool>("AlgorithmTriggersUnprescaled")),
       m_algorithmTriggersUnmasked(parSet.getParameter<bool>("AlgorithmTriggersUnmasked")),
       m_technicalTriggersUnprescaled(parSet.getParameter<bool>("TechnicalTriggersUnprescaled")),
       m_technicalTriggersUnmasked(parSet.getParameter<bool>("TechnicalTriggersUnmasked")),
       m_technicalTriggersVetoUnmasked(parSet.getParameter<bool>("TechnicalTriggersVetoUnmasked")),
       m_verbosity(parSet.getUntrackedParameter<int>("Verbosity", 0)),
       m_isDebugEnabled(edm::isDebugEnabled()),
       m_l1GtStableParToken(esConsumes<L1GtStableParameters, L1GtStableParametersRcd>()),
       m_l1GtParToken(esConsumes<L1GtParameters, L1GtParametersRcd>()),
       m_l1GtBMToken(esConsumes<L1GtBoardMaps, L1GtBoardMapsRcd>()),
       m_l1GtPfAlgoToken(esConsumes<L1GtPrescaleFactors, L1GtPrescaleFactorsAlgoTrigRcd>()),
       m_l1GtPfTechToken(esConsumes<L1GtPrescaleFactors, L1GtPrescaleFactorsTechTrigRcd>()),
       m_l1GtTmAlgoToken(esConsumes<L1GtTriggerMask, L1GtTriggerMaskAlgoTrigRcd>()),
       m_l1GtTmTechToken(esConsumes<L1GtTriggerMask, L1GtTriggerMaskTechTrigRcd>()),
       m_l1GtTmVetoAlgoToken(esConsumes<L1GtTriggerMask, L1GtTriggerMaskVetoAlgoTrigRcd>()),
       m_l1GtTmVetoTechToken(esConsumes<L1GtTriggerMask, L1GtTriggerMaskVetoTechTrigRcd>()) {
   if (m_verbosity) {
     LogDebug("L1GlobalTrigger") << std::endl;
 
     LogTrace("L1GlobalTrigger") << "\nInput tag for muon collection from GMT:         " << m_muGmtInputTag
                                 << "\nInput tag for calorimeter collections from GCT: " << m_caloGctInputTag
                                 << "\nInput tag for CASTOR record:                    " << m_castorInputTag
                                 << "\nInput tag for technical triggers:               " << std::endl;
 
     // loop over all producers of technical trigger records
     for (std::vector<edm::InputTag>::const_iterator it = m_technicalTriggersInputTags.begin();
          it != m_technicalTriggersInputTags.end();
          it++) {
       LogTrace("L1GlobalTrigger") << "\n  " << (*it) << std::endl;
     }
 
     LogTrace("L1GlobalTrigger")
         << "\nProduce the L1 GT DAQ readout record:           " << m_produceL1GtDaqRecord
         << "\nProduce the L1 GT EVM readout record:           " << m_produceL1GtEvmRecord
         << "\nProduce the L1 GT Object Map record:            " << m_produceL1GtObjectMapRecord << " \n"
         << "\nWrite Psb content to L1 GT DAQ Record:          " << m_writePsbL1GtDaqRecord << " \n"
         << "\nRead technical trigger records:                 " << m_readTechnicalTriggerRecords << " \n"
         << "\nNumber of BxInEvent to be emulated:             " << m_emulateBxInEvent
         << "\nNumber of BXs corresponding to alternative 0:   " << m_recordLength.at(0)
         << "\nNumber of BXs corresponding to alternative 1:   " << m_recordLength.at(1) << " \n"
         << "\nAlternative for number of BX in GT DAQ record:   0x" << std::hex << m_alternativeNrBxBoardDaq
         << "\nAlternative for number of BX in GT EVM record:   0x" << std::hex << m_alternativeNrBxBoardEvm << std::dec
         << " \n"
         << "\nLength of BST message [bytes]:                  " << m_psBstLengthBytes << "\n"
         << "\nRun algorithm triggers unprescaled:             " << m_algorithmTriggersUnprescaled
         << "\nRun algorithm triggers unmasked (all enabled):  " << m_algorithmTriggersUnmasked << "\n"
         << "\nRun technical triggers unprescaled:             " << m_technicalTriggersUnprescaled
         << "\nRun technical triggers unmasked (all enabled):  " << m_technicalTriggersUnmasked
         << "\nRun technical triggers veto unmasked (no veto): " << m_technicalTriggersUnmasked << "\n"
         << std::endl;
   }
 
   if ((m_emulateBxInEvent > 0) && ((m_emulateBxInEvent % 2) == 0)) {
     m_emulateBxInEvent = m_emulateBxInEvent - 1;
 
     if (m_verbosity) {
       edm::LogWarning("L1GlobalTrigger") << "\nWARNING: Number of bunch crossing to be emulated rounded to: "
                                          << m_emulateBxInEvent << "\n         The number must be an odd number!\n"
                                          << std::endl;
     }
   }
 
   int requiredRecordLength = std::max(m_recordLength.at(0), m_recordLength.at(1));
   if ((m_emulateBxInEvent >= 0) && (m_emulateBxInEvent < requiredRecordLength)) {
     m_emulateBxInEvent = requiredRecordLength;
 
     if (m_verbosity) {
       edm::LogWarning("L1GlobalTrigger") << "\nWARNING: Number of bunch crossing required to be emulated ( "
                                          << m_emulateBxInEvent << " BX) smaller as required in RecordLength:"
                                          << "\n  Number of BXs corresponding to alternative 0:   "
                                          << m_recordLength.at(0)
                                          << "\n  Number of BXs corresponding to alternative 1:   "
                                          << m_recordLength.at(1) << "\nEmulating " << requiredRecordLength << " BX!"
                                          << "\n"
                                          << std::endl;
     }
   }
 
   // register products
   if (m_produceL1GtDaqRecord) {
     produces<L1GlobalTriggerReadoutRecord>();
   }
 
   if (m_produceL1GtEvmRecord) {
     produces<L1GlobalTriggerEvmReadoutRecord>();
   }
 
   if (m_produceL1GtObjectMapRecord) {
     produces<L1GlobalTriggerObjectMapRecord>();
   }
 
   // create new PSBs
   m_gtPSB = new L1GlobalTriggerPSB(m_caloGctInputTag, m_technicalTriggersInputTags, consumesCollector());
   m_gtPSB->setVerbosity(m_verbosity);
 
   // create new GTL
   m_gtGTL = new L1GlobalTriggerGTL(m_muGmtInputTag, consumesCollector());
   m_gtGTL->setVerbosity(m_verbosity);
 
   // create new FDL
   m_gtFDL = new L1GlobalTriggerFDL();
   m_gtFDL->setVerbosity(m_verbosity);
 
   // initialize cached IDs
 
   //
   m_l1GtStableParCacheID = 0ULL;
 
   m_numberPhysTriggers = 0;
   m_numberTechnicalTriggers = 0;
   m_numberDaqPartitions = 0;
 
   m_nrL1Mu = 0;
 
   m_nrL1NoIsoEG = 0;
   m_nrL1IsoEG = 0;
 
   m_nrL1CenJet = 0;
   m_nrL1ForJet = 0;
   m_nrL1TauJet = 0;
 
   m_nrL1JetCounts = 0;
 
   m_ifMuEtaNumberBits = 0;
   m_ifCaloEtaNumberBits = 0;
 
   //
   m_l1GtParCacheID = 0ULL;
 
   m_totalBxInEvent = 0;
 
   m_activeBoardsGtDaq = 0;
   m_activeBoardsGtEvm = 0;
   m_bstLengthBytes = 0;
 
   //
   m_l1GtBMCacheID = 0ULL;
 
   //
   m_l1GtPfAlgoCacheID = 0ULL;
   m_l1GtPfTechCacheID = 0ULL;
 
   m_l1GtTmAlgoCacheID = 0ULL;
   m_l1GtTmTechCacheID = 0ULL;
 
   m_l1GtTmVetoAlgoCacheID = 0ULL;
   m_l1GtTmVetoTechCacheID = 0ULL;
 
   consumes<L1MuGMTReadoutCollection>(m_muGmtInputTag);
 }

◆ ~L1GlobalTrigger()

L1GlobalTrigger::~L1GlobalTrigger ( )

override

Definition at line 233 of file L1GlobalTrigger.cc.

References m_gtFDL, m_gtGTL, and m_gtPSB.

                                   {
   delete m_gtPSB;
   delete m_gtGTL;
   delete m_gtFDL;
 }

Member Function Documentation

◆ gtFDL()

const L1GlobalTriggerFDL* L1GlobalTrigger::gtFDL ( ) const

inline

Definition at line 92 of file L1GlobalTrigger.h.

References m_gtFDL.

92 { return m_gtFDL; }

L1GlobalTrigger::m_gtFDL

L1GlobalTriggerFDL * m_gtFDL

Definition: L1GlobalTrigger.h:178

◆ gtGTL()

const L1GlobalTriggerGTL* L1GlobalTrigger::gtGTL ( ) const

inline

Definition at line 89 of file L1GlobalTrigger.h.

References m_gtGTL.

89 { return m_gtGTL; }

L1GlobalTrigger::m_gtGTL

L1GlobalTriggerGTL * m_gtGTL

Definition: L1GlobalTrigger.h:177

◆ gtPSB()

const L1GlobalTriggerPSB* L1GlobalTrigger::gtPSB ( ) const

inline

Definition at line 86 of file L1GlobalTrigger.h.

References m_gtPSB.

86 { return m_gtPSB; }

L1GlobalTrigger::m_gtPSB

L1GlobalTriggerPSB * m_gtPSB

Definition: L1GlobalTrigger.h:176

◆ produce()

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

override

length of BST message (in bytes) for L1 GT EVM record

receive technical trigger

Definition at line 242 of file L1GlobalTrigger.cc.

                                                                             {
   // process event iEvent
 
   // get / update the stable parameters from the EventSetup
   // local cache & check on cacheIdentifier
 
   unsigned long long l1GtStableParCacheID = evSetup.get<L1GtStableParametersRcd>().cacheIdentifier();
 
   if (m_l1GtStableParCacheID != l1GtStableParCacheID) {
     edm::ESHandle<L1GtStableParameters> l1GtStablePar = evSetup.getHandle(m_l1GtStableParToken);
     m_l1GtStablePar = l1GtStablePar.product();
 
     // number of physics triggers
     m_numberPhysTriggers = m_l1GtStablePar->gtNumberPhysTriggers();
 
     // number of technical triggers
     m_numberTechnicalTriggers = m_l1GtStablePar->gtNumberTechnicalTriggers();
 
     // number of DAQ partitions
     m_numberDaqPartitions = 8;  // FIXME add it to stable parameters
 
     // number of objects of each type
     m_nrL1Mu = static_cast<int>(m_l1GtStablePar->gtNumberL1Mu());
 
     m_nrL1NoIsoEG = static_cast<int>(m_l1GtStablePar->gtNumberL1NoIsoEG());
     m_nrL1IsoEG = static_cast<int>(m_l1GtStablePar->gtNumberL1IsoEG());
 
     m_nrL1CenJet = static_cast<int>(m_l1GtStablePar->gtNumberL1CenJet());
     m_nrL1ForJet = static_cast<int>(m_l1GtStablePar->gtNumberL1ForJet());
     m_nrL1TauJet = static_cast<int>(m_l1GtStablePar->gtNumberL1TauJet());
 
     m_nrL1JetCounts = static_cast<int>(m_l1GtStablePar->gtNumberL1JetCounts());
 
     // ... the rest of the objects are global
 
     m_ifMuEtaNumberBits = static_cast<int>(m_l1GtStablePar->gtIfMuEtaNumberBits());
     m_ifCaloEtaNumberBits = static_cast<int>(m_l1GtStablePar->gtIfCaloEtaNumberBits());
 
     // (re)initialize L1GlobalTriggerGTL
     m_gtGTL->init(m_nrL1Mu, m_numberPhysTriggers);
 
     // (re)initialize L1GlobalTriggerPSB
     m_gtPSB->init(m_nrL1NoIsoEG, m_nrL1IsoEG, m_nrL1CenJet, m_nrL1ForJet, m_nrL1TauJet, m_numberTechnicalTriggers);
 
     //
     m_l1GtStableParCacheID = l1GtStableParCacheID;
   }
 
   // get / update the parameters from the EventSetup
   // local cache & check on cacheIdentifier
 
   unsigned long long l1GtParCacheID = evSetup.get<L1GtParametersRcd>().cacheIdentifier();
 
   if (m_l1GtParCacheID != l1GtParCacheID) {
     edm::ESHandle<L1GtParameters> l1GtPar = evSetup.getHandle(m_l1GtParToken);
     m_l1GtPar = l1GtPar.product();
 
     //    total number of Bx's in the event coming from EventSetup
     m_totalBxInEvent = m_l1GtPar->gtTotalBxInEvent();
 
     //    active boards in L1 GT DAQ record and in L1 GT EVM record
     m_activeBoardsGtDaq = m_l1GtPar->gtDaqActiveBoards();
     m_activeBoardsGtEvm = m_l1GtPar->gtEvmActiveBoards();
 
     m_bstLengthBytes = m_l1GtPar->gtBstLengthBytes();
 
     m_l1GtParCacheID = l1GtParCacheID;
   }
 
   // negative value: emulate TotalBxInEvent as given in EventSetup
   if (m_emulateBxInEvent < 0) {
     m_emulateBxInEvent = m_totalBxInEvent;
   }
 
   int minBxInEvent = (m_emulateBxInEvent + 1) / 2 - m_emulateBxInEvent;
   int maxBxInEvent = (m_emulateBxInEvent + 1) / 2 - 1;
 
   int recordLength0 = m_recordLength.at(0);
   int recordLength1 = m_recordLength.at(1);
 
   if ((recordLength0 < 0) || (recordLength1 < 0)) {
     // take them from event setup
     // FIXME implement later - temporary solution
 
     recordLength0 = m_emulateBxInEvent;
     recordLength1 = m_emulateBxInEvent;
   }
 
   if (m_verbosity) {
     LogDebug("L1GlobalTrigger") << "\nTotal number of BX to emulate in the GT readout record: " << m_emulateBxInEvent
                                 << " = "
                                 << "[" << minBxInEvent << ", " << maxBxInEvent << "] BX\n"
                                 << "\nNumber of BX for alternative 0:  " << recordLength0
                                 << "\nNumber of BX for alternative 1:  " << recordLength1
                                 << "\nActive boards in L1 GT DAQ record (hex format) = " << std::hex
                                 << std::setw(sizeof(m_activeBoardsGtDaq) * 2) << std::setfill('0')
                                 << m_activeBoardsGtDaq << std::dec << std::setfill(' ')
                                 << "\nActive boards in L1 GT EVM record (hex format) = " << std::hex
                                 << std::setw(sizeof(m_activeBoardsGtEvm) * 2) << std::setfill('0')
                                 << m_activeBoardsGtEvm << std::dec << std::setfill(' ') << "\n"
                                 << std::endl;
   }
 
   // get / update the board maps from the EventSetup
   // local cache & check on cacheIdentifier
 
   typedef std::vector<L1GtBoard>::const_iterator CItBoardMaps;
 
   unsigned long long l1GtBMCacheID = evSetup.get<L1GtBoardMapsRcd>().cacheIdentifier();
 
   if (m_l1GtBMCacheID != l1GtBMCacheID) {
     edm::ESHandle<L1GtBoardMaps> l1GtBM = evSetup.getHandle(m_l1GtBMToken);
     m_l1GtBM = l1GtBM.product();
 
     m_l1GtBMCacheID = l1GtBMCacheID;
   }
 
   // TODO need changes in CondFormats to cache the maps
   const std::vector<L1GtBoard> &boardMaps = m_l1GtBM->gtBoardMaps();
 
   // get / update the prescale factors from the EventSetup
   // local cache & check on cacheIdentifier
 
   unsigned long long l1GtPfAlgoCacheID = evSetup.get<L1GtPrescaleFactorsAlgoTrigRcd>().cacheIdentifier();
 
   if (m_l1GtPfAlgoCacheID != l1GtPfAlgoCacheID) {
     edm::ESHandle<L1GtPrescaleFactors> l1GtPfAlgo = evSetup.getHandle(m_l1GtPfAlgoToken);
     m_l1GtPfAlgo = l1GtPfAlgo.product();
 
     m_prescaleFactorsAlgoTrig = &(m_l1GtPfAlgo->gtPrescaleFactors());
 
     m_l1GtPfAlgoCacheID = l1GtPfAlgoCacheID;
   }
 
   unsigned long long l1GtPfTechCacheID = evSetup.get<L1GtPrescaleFactorsTechTrigRcd>().cacheIdentifier();
 
   if (m_l1GtPfTechCacheID != l1GtPfTechCacheID) {
     edm::ESHandle<L1GtPrescaleFactors> l1GtPfTech = evSetup.getHandle(m_l1GtPfTechToken);
     m_l1GtPfTech = l1GtPfTech.product();
 
     m_prescaleFactorsTechTrig = &(m_l1GtPfTech->gtPrescaleFactors());
 
     m_l1GtPfTechCacheID = l1GtPfTechCacheID;
   }
 
   // get / update the trigger mask from the EventSetup
   // local cache & check on cacheIdentifier
 
   unsigned long long l1GtTmAlgoCacheID = evSetup.get<L1GtTriggerMaskAlgoTrigRcd>().cacheIdentifier();
 
   if (m_l1GtTmAlgoCacheID != l1GtTmAlgoCacheID) {
     edm::ESHandle<L1GtTriggerMask> l1GtTmAlgo = evSetup.getHandle(m_l1GtTmAlgoToken);
     m_l1GtTmAlgo = l1GtTmAlgo.product();
 
     m_triggerMaskAlgoTrig = m_l1GtTmAlgo->gtTriggerMask();
 
     m_l1GtTmAlgoCacheID = l1GtTmAlgoCacheID;
   }
 
   unsigned long long l1GtTmTechCacheID = evSetup.get<L1GtTriggerMaskTechTrigRcd>().cacheIdentifier();
 
   if (m_l1GtTmTechCacheID != l1GtTmTechCacheID) {
     edm::ESHandle<L1GtTriggerMask> l1GtTmTech = evSetup.getHandle(m_l1GtTmTechToken);
     m_l1GtTmTech = l1GtTmTech.product();
 
     m_triggerMaskTechTrig = m_l1GtTmTech->gtTriggerMask();
 
     m_l1GtTmTechCacheID = l1GtTmTechCacheID;
   }
 
   unsigned long long l1GtTmVetoAlgoCacheID = evSetup.get<L1GtTriggerMaskVetoAlgoTrigRcd>().cacheIdentifier();
 
   if (m_l1GtTmVetoAlgoCacheID != l1GtTmVetoAlgoCacheID) {
     edm::ESHandle<L1GtTriggerMask> l1GtTmVetoAlgo = evSetup.getHandle(m_l1GtTmVetoAlgoToken);
     m_l1GtTmVetoAlgo = l1GtTmVetoAlgo.product();
 
     m_triggerMaskVetoAlgoTrig = m_l1GtTmVetoAlgo->gtTriggerMask();
 
     m_l1GtTmVetoAlgoCacheID = l1GtTmVetoAlgoCacheID;
   }
 
   unsigned long long l1GtTmVetoTechCacheID = evSetup.get<L1GtTriggerMaskVetoTechTrigRcd>().cacheIdentifier();
 
   if (m_l1GtTmVetoTechCacheID != l1GtTmVetoTechCacheID) {
     edm::ESHandle<L1GtTriggerMask> l1GtTmVetoTech = evSetup.getHandle(m_l1GtTmVetoTechToken);
     m_l1GtTmVetoTech = l1GtTmVetoTech.product();
 
     m_triggerMaskVetoTechTrig = m_l1GtTmVetoTech->gtTriggerMask();
 
     m_l1GtTmVetoTechCacheID = l1GtTmVetoTechCacheID;
   }
 
   // loop over blocks in the GT DAQ record receiving data, count them if they
   // are active all board type are defined in CondFormats/L1TObjects/L1GtFwd
   // enum L1GtBoardType { GTFE, FDL, PSB, GMT, TCS, TIM };
   // &
   // set the active flag for each object type received from GMT and GCT
   // all objects in the GT system are defined in enum L1GtObject from
   // DataFormats/L1Trigger/L1GlobalTriggerReadoutSetupFwd
 
   int daqNrGtfeBoards = 0;
 
   int daqNrFdlBoards = 0;
   int daqNrPsbBoards = 0;
   int daqNrGmtBoards = 0;
   int daqNrTcsBoards = 0;
   int daqNrTimBoards = 0;
 
   //
   bool receiveMu = false;
   bool receiveNoIsoEG = false;
   bool receiveIsoEG = false;
   bool receiveCenJet = false;
   bool receiveForJet = false;
   bool receiveTauJet = false;
   bool receiveETM = false;
   bool receiveETT = false;
   bool receiveHTT = false;
   bool receiveHTM = false;
   bool receiveJetCounts = false;
   bool receiveHfBitCounts = false;
   bool receiveHfRingEtSums = false;
 
   bool receiveExternal = false;
 
   bool receiveTechTr = false;
 
   for (CItBoardMaps itBoard = boardMaps.begin(); itBoard != boardMaps.end(); ++itBoard) {
     int iPosition = itBoard->gtPositionDaqRecord();
     if (iPosition > 0) {
       int iActiveBit = itBoard->gtBitDaqActiveBoards();
       bool activeBoard = false;
 
       if (iActiveBit >= 0) {
         activeBoard = m_activeBoardsGtDaq & (1 << iActiveBit);
       }
 
       // use board if: in the record, but not in ActiveBoardsMap (iActiveBit <
       // 0)
       //               in the record and ActiveBoardsMap, and active
       if ((iActiveBit < 0) || activeBoard) {
         switch (itBoard->gtBoardType()) {
           case GTFE: {
             daqNrGtfeBoards++;
           }
 
           break;
           case FDL: {
             daqNrFdlBoards++;
           }
 
           break;
           case PSB: {
             daqNrPsbBoards++;
 
             // get the objects coming to this PSB
             std::vector<L1GtPsbQuad> quadInPsb = itBoard->gtQuadInPsb();
             for (std::vector<L1GtPsbQuad>::const_iterator itQuad = quadInPsb.begin(); itQuad != quadInPsb.end();
                  ++itQuad) {
               switch (*itQuad) {
                 case TechTr: {
                   receiveTechTr = true;
                 }
 
                 break;
                 case NoIsoEGQ: {
                   receiveNoIsoEG = true;
                 }
 
                 break;
                 case IsoEGQ: {
                   receiveIsoEG = true;
                 }
 
                 break;
                 case CenJetQ: {
                   receiveCenJet = true;
                 }
 
                 break;
                 case ForJetQ: {
                   receiveForJet = true;
                 }
 
                 break;
                 case TauJetQ: {
                   receiveTauJet = true;
                 }
 
                 break;
                 case ESumsQ: {
                   receiveETM = true;
                   receiveETT = true;
                   receiveHTT = true;
                   receiveHTM = true;
                 }
 
                 break;
                 case JetCountsQ: {
                   receiveJetCounts = true;
                 }
 
                 break;
                 case CastorQ: {
                   // obsolete
                 }
 
                 break;
                 case BptxQ: {
                   // obsolete
                 }
 
                 break;
                 case GtExternalQ: {
                   receiveExternal = true;
                 }
 
                 break;
                 case HfQ: {
                   receiveHfBitCounts = true;
                   receiveHfRingEtSums = true;
                 }
 
                 break;
                   // FIXME add MIP/Iso bits
                 default: {
                   // do nothing
                 }
 
                 break;
               }
             }
 
           }
 
           break;
           case GMT: {
             daqNrGmtBoards++;
             receiveMu = true;
           }
 
           break;
           case TCS: {
             daqNrTcsBoards++;
           }
 
           break;
           case TIM: {
             daqNrTimBoards++;
           }
 
           break;
           default: {
             // do nothing, all blocks are given in GtBoardType enum
           }
 
           break;
         }
       }
     }
   }
 
   // produce the L1GlobalTriggerReadoutRecord now, after we found how many
   // BxInEvent the record has and how many boards are active
   std::unique_ptr<L1GlobalTriggerReadoutRecord> gtDaqReadoutRecord(
       new L1GlobalTriggerReadoutRecord(m_emulateBxInEvent, daqNrFdlBoards, daqNrPsbBoards));
 
   // * produce the L1GlobalTriggerEvmReadoutRecord
   std::unique_ptr<L1GlobalTriggerEvmReadoutRecord> gtEvmReadoutRecord(
       new L1GlobalTriggerEvmReadoutRecord(m_emulateBxInEvent, daqNrFdlBoards));
   // daqNrFdlBoards OK, just reserve memory at this point
 
   // * produce the L1GlobalTriggerObjectMapRecord
   std::unique_ptr<L1GlobalTriggerObjectMapRecord> gtObjectMapRecord(new L1GlobalTriggerObjectMapRecord());
 
   // fill the boards not depending on the BxInEvent in the L1 GT DAQ record
   // GMT, PSB and FDL depend on BxInEvent
 
   // fill in emulator the same bunch crossing (12 bits - hardwired number of
   // bits...) and the same local bunch crossing for all boards
   int bxCross = iEvent.bunchCrossing();
   uint16_t bxCrossHw = 0;
   if ((bxCross & 0xFFF) == bxCross) {
     bxCrossHw = static_cast<uint16_t>(bxCross);
   } else {
     bxCrossHw = 0;  // Bx number too large, set to 0!
     if (m_verbosity) {
       LogDebug("L1GlobalTrigger") << "\nBunch cross number [hex] = " << std::hex << bxCross
                                   << "\n  larger than 12 bits. Set to 0! \n"
                                   << std::dec << std::endl;
     }
   }
 
   if (m_produceL1GtDaqRecord) {
     for (CItBoardMaps itBoard = boardMaps.begin(); itBoard != boardMaps.end(); ++itBoard) {
       int iPosition = itBoard->gtPositionDaqRecord();
       if (iPosition > 0) {
         int iActiveBit = itBoard->gtBitDaqActiveBoards();
         bool activeBoard = false;
 
         if (iActiveBit >= 0) {
           activeBoard = m_activeBoardsGtDaq & (1 << iActiveBit);
         }
 
         // use board if: in the record, but not in ActiveBoardsMap (iActiveBit <
         // 0)
         //               in the record and ActiveBoardsMap, and active
         if ((iActiveBit < 0) || activeBoard) {
           switch (itBoard->gtBoardType()) {
             case GTFE: {
               L1GtfeWord gtfeWordValue;
 
               gtfeWordValue.setBoardId(itBoard->gtBoardId());
 
               // cast int to uint16_t
               // there are normally 3 or 5 BxInEvent
               gtfeWordValue.setRecordLength(static_cast<uint16_t>(recordLength0));
 
               gtfeWordValue.setRecordLength1(static_cast<uint16_t>(recordLength1));
 
               // bunch crossing
               gtfeWordValue.setBxNr(bxCrossHw);
 
               // set the list of active boards
               gtfeWordValue.setActiveBoards(m_activeBoardsGtDaq);
 
               // set alternative for number of BX per board
               gtfeWordValue.setAltNrBxBoard(static_cast<uint16_t>(m_alternativeNrBxBoardDaq));
 
               // set the TOTAL_TRIGNR as read from iEvent
               // TODO check again - PTC stuff
 
               gtfeWordValue.setTotalTriggerNr(static_cast<uint32_t>(iEvent.id().event()));
 
               // ** fill L1GtfeWord in GT DAQ record
 
               gtDaqReadoutRecord->setGtfeWord(gtfeWordValue);
             }
 
             break;
             case TCS: {
               // nothing
             }
 
             break;
             case TIM: {
               // nothing
             }
 
             break;
             default: {
               // do nothing, all blocks are given in GtBoardType enum
             }
 
             break;
           }
         }
       }
     }
   }
 
   // fill the boards not depending on the BxInEvent in the L1 GT EVM record
 
   int evmNrFdlBoards = 0;
 
   if (m_produceL1GtEvmRecord) {
     // get the length of the BST message from parameter set or from event setup
 
     int bstLengthBytes = 0;
 
     if (m_psBstLengthBytes < 0) {
       // length from event setup
       bstLengthBytes = static_cast<int>(m_bstLengthBytes);
 
     } else {
       // length from parameter set
       bstLengthBytes = m_psBstLengthBytes;
     }
 
     if (m_verbosity) {
       LogTrace("L1GlobalTrigger") << "\n Length of BST message (in bytes): " << bstLengthBytes << "\n" << std::endl;
     }
 
     for (CItBoardMaps itBoard = boardMaps.begin(); itBoard != boardMaps.end(); ++itBoard) {
       int iPosition = itBoard->gtPositionEvmRecord();
       if (iPosition > 0) {
         int iActiveBit = itBoard->gtBitEvmActiveBoards();
         bool activeBoard = false;
 
         if (iActiveBit >= 0) {
           activeBoard = m_activeBoardsGtEvm & (1 << iActiveBit);
         }
 
         // use board if: in the record, but not in ActiveBoardsMap (iActiveBit <
         // 0)
         //               in the record and ActiveBoardsMap, and active
         if ((iActiveBit < 0) || activeBoard) {
           switch (itBoard->gtBoardType()) {
             case GTFE: {
               L1GtfeExtWord gtfeWordValue(bstLengthBytes);
 
               gtfeWordValue.setBoardId(itBoard->gtBoardId());
 
               // cast int to uint16_t
               // there are normally 3 or 5 BxInEvent
               gtfeWordValue.setRecordLength(static_cast<uint16_t>(recordLength0));
 
               gtfeWordValue.setRecordLength1(static_cast<uint16_t>(recordLength1));
 
               // bunch crossing
               gtfeWordValue.setBxNr(bxCrossHw);
 
               // set the list of active boards
               gtfeWordValue.setActiveBoards(m_activeBoardsGtEvm);
 
               // set alternative for number of BX per board
               gtfeWordValue.setAltNrBxBoard(static_cast<uint16_t>(m_alternativeNrBxBoardEvm));
 
               // set the TOTAL_TRIGNR as read from iEvent
               // TODO check again - PTC stuff
 
               gtfeWordValue.setTotalTriggerNr(static_cast<uint32_t>(iEvent.id().event()));
 
               // set the GPS time to the value read from Timestamp
               edm::TimeValue_t evTime = iEvent.time().value();
 
               gtfeWordValue.setGpsTime(evTime);
 
               // LogDebug("L1GlobalTrigger")
               //<< "\nEvent timestamp value [hex] = " << std::hex << evTime
               //<< "\nBST retrieved value [hex]   = " << gtfeWordValue.gpsTime()
               //<< std::dec << std::endl;
 
               // source of BST message: DDDD simulated data
               uint16_t bstSourceVal = 0xDDDD;
               gtfeWordValue.setBstSource(bstSourceVal);
 
               // ** fill L1GtfeWord in GT EVM record
 
               gtEvmReadoutRecord->setGtfeWord(gtfeWordValue);
             }
 
             break;
             case FDL: {
               evmNrFdlBoards++;
             }
 
             break;
             case TCS: {
               L1TcsWord tcsWordValue;
 
               tcsWordValue.setBoardId(itBoard->gtBoardId());
 
               // bunch crossing
               tcsWordValue.setBxNr(bxCrossHw);
 
               uint16_t trigType = 0x5;  // 0101 simulated event
               tcsWordValue.setTriggerType(trigType);
 
               // luminosity segment number
               tcsWordValue.setLuminositySegmentNr(static_cast<uint16_t>(iEvent.luminosityBlock()));
 
               // set the Event_Nr as read from iEvent
               tcsWordValue.setEventNr(static_cast<uint32_t>(iEvent.id().event()));
 
               // orbit number
               tcsWordValue.setOrbitNr(static_cast<uint64_t>(iEvent.orbitNumber()));
 
               // ** fill L1TcsWord in the EVM record
 
               gtEvmReadoutRecord->setTcsWord(tcsWordValue);
 
             }
 
             break;
             case TIM: {
               // nothing
             }
 
             break;
             default: {
               // do nothing, all blocks are given in GtBoardType enum
             }
 
             break;
           }
         }
       }
     }
   }
 
   // get the prescale factor set used in the actual luminosity segment
   int pfAlgoSetIndex = 0;  // FIXME
   const std::vector<int> &prescaleFactorsAlgoTrig = (*m_prescaleFactorsAlgoTrig).at(pfAlgoSetIndex);
 
   int pfTechSetIndex = 0;  // FIXME
   const std::vector<int> &prescaleFactorsTechTrig = (*m_prescaleFactorsTechTrig).at(pfTechSetIndex);
 
   //
 
   // loop over BxInEvent
   for (int iBxInEvent = minBxInEvent; iBxInEvent <= maxBxInEvent; ++iBxInEvent) {
     // * receive GCT object data via PSBs
     // LogDebug("L1GlobalTrigger")
     //<< "\nL1GlobalTrigger : receiving PSB data for bx = " << iBxInEvent <<
     //"\n"
     //<< std::endl;
 
     m_gtPSB->receiveGctObjectData(iEvent,
                                   m_caloGctInputTag,
                                   iBxInEvent,
                                   receiveNoIsoEG,
                                   m_nrL1NoIsoEG,
                                   receiveIsoEG,
                                   m_nrL1IsoEG,
                                   receiveCenJet,
                                   m_nrL1CenJet,
                                   receiveForJet,
                                   m_nrL1ForJet,
                                   receiveTauJet,
                                   m_nrL1TauJet,
                                   receiveETM,
                                   receiveETT,
                                   receiveHTT,
                                   receiveHTM,
                                   receiveJetCounts,
                                   receiveHfBitCounts,
                                   receiveHfRingEtSums);
 
     if (m_readTechnicalTriggerRecords) {
       m_gtPSB->receiveTechnicalTriggers(
           iEvent, m_technicalTriggersInputTags, iBxInEvent, receiveTechTr, m_numberTechnicalTriggers);
     }
 
     if (receiveExternal) {
       // FIXME read the external conditions
     }
 
     if (m_produceL1GtDaqRecord && m_writePsbL1GtDaqRecord) {
       m_gtPSB->fillPsbBlock(iEvent,
                             m_activeBoardsGtDaq,
                             recordLength0,
                             recordLength1,
                             m_alternativeNrBxBoardDaq,
                             boardMaps,
                             iBxInEvent,
                             gtDaqReadoutRecord.get());
     }
 
     // * receive GMT object data via GTL
     // LogDebug("L1GlobalTrigger")
     //<< "\nL1GlobalTrigger : receiving GMT data for bx = " << iBxInEvent <<
     //"\n"
     //<< std::endl;
 
     m_gtGTL->receiveGmtObjectData(iEvent, m_muGmtInputTag, iBxInEvent, receiveMu, m_nrL1Mu);
 
     // * run GTL
     // LogDebug("L1GlobalTrigger")
     //<< "\nL1GlobalTrigger : running GTL for bx = " << iBxInEvent << "\n"
     //<< std::endl;
 
     m_gtGTL->run(iEvent,
                  evSetup,
                  m_gtPSB,
                  m_produceL1GtObjectMapRecord,
                  iBxInEvent,
                  gtObjectMapRecord.get(),
                  m_numberPhysTriggers,
                  m_nrL1Mu,
                  m_nrL1NoIsoEG,
                  m_nrL1IsoEG,
                  m_nrL1CenJet,
                  m_nrL1ForJet,
                  m_nrL1TauJet,
                  m_nrL1JetCounts,
                  m_ifMuEtaNumberBits,
                  m_ifCaloEtaNumberBits);
 
     // LogDebug("L1GlobalTrigger")
     //<< "\n AlgorithmOR\n" << m_gtGTL->getAlgorithmOR() << "\n"
     //<< std::endl;
 
     // * run FDL
     // LogDebug("L1GlobalTrigger")
     //<< "\nL1GlobalTrigger : running FDL for bx = " << iBxInEvent << "\n"
     //<< std::endl;
 
     m_gtFDL->run(iEvent,
                  prescaleFactorsAlgoTrig,
                  prescaleFactorsTechTrig,
                  m_triggerMaskAlgoTrig,
                  m_triggerMaskTechTrig,
                  m_triggerMaskVetoAlgoTrig,
                  m_triggerMaskVetoTechTrig,
                  boardMaps,
                  m_emulateBxInEvent,
                  iBxInEvent,
                  m_numberPhysTriggers,
                  m_numberTechnicalTriggers,
                  m_numberDaqPartitions,
                  m_gtGTL,
                  m_gtPSB,
                  pfAlgoSetIndex,
                  pfTechSetIndex,
                  m_algorithmTriggersUnprescaled,
                  m_algorithmTriggersUnmasked,
                  m_technicalTriggersUnprescaled,
                  m_technicalTriggersUnmasked,
                  m_technicalTriggersVetoUnmasked);
 
     if (m_produceL1GtDaqRecord && (daqNrFdlBoards > 0)) {
       m_gtFDL->fillDaqFdlBlock(iBxInEvent,
                                m_activeBoardsGtDaq,
                                recordLength0,
                                recordLength1,
                                m_alternativeNrBxBoardDaq,
                                boardMaps,
                                gtDaqReadoutRecord.get());
     }
 
     if (m_produceL1GtEvmRecord && (evmNrFdlBoards > 0)) {
       m_gtFDL->fillEvmFdlBlock(iBxInEvent,
                                m_activeBoardsGtEvm,
                                recordLength0,
                                recordLength1,
                                m_alternativeNrBxBoardEvm,
                                boardMaps,
                                gtEvmReadoutRecord.get());
     }
 
     // reset
     m_gtPSB->reset();
     m_gtGTL->reset();
     m_gtFDL->reset();
 
     // LogDebug("L1GlobalTrigger") << "\n Reset PSB, GTL, FDL\n" << std::endl;
   }
 
   if (receiveMu) {
     // LogDebug("L1GlobalTrigger")
     //<< "\n**** "
     //<< "\n  Persistent reference for L1MuGMTReadoutCollection with input tag:
     //"
     //<< m_muGmtInputTag
     //<< "\n**** \n"
     //<< std::endl;
 
     // get L1MuGMTReadoutCollection reference and set it in GT record
 
     edm::Handle<L1MuGMTReadoutCollection> gmtRcHandle;
     iEvent.getByLabel(m_muGmtInputTag, gmtRcHandle);
 
     if (!gmtRcHandle.isValid()) {
       if (m_verbosity) {
         edm::LogWarning("L1GlobalTrigger") << "\nWarning: L1MuGMTReadoutCollection with input tag " << m_muGmtInputTag
                                            << "\nrequested in configuration, but not found in the event.\n"
                                            << std::endl;
       }
     } else {
       gtDaqReadoutRecord->setMuCollectionRefProd(gmtRcHandle);
     }
   }
 
   if (m_verbosity && m_isDebugEnabled) {
     std::ostringstream myCoutStream;
     gtDaqReadoutRecord->print(myCoutStream);
     LogTrace("L1GlobalTrigger") << "\n The following L1 GT DAQ readout record was produced:\n"
                                 << myCoutStream.str() << "\n"
                                 << std::endl;
 
     myCoutStream.str("");
     myCoutStream.clear();
 
     gtEvmReadoutRecord->print(myCoutStream);
     LogTrace("L1GlobalTrigger") << "\n The following L1 GT EVM readout record was produced:\n"
                                 << myCoutStream.str() << "\n"
                                 << std::endl;
 
     myCoutStream.str("");
     myCoutStream.clear();
 
     const std::vector<L1GlobalTriggerObjectMap> objMapVec = gtObjectMapRecord->gtObjectMap();
 
     for (std::vector<L1GlobalTriggerObjectMap>::const_iterator it = objMapVec.begin(); it != objMapVec.end(); ++it) {
       (*it).print(myCoutStream);
     }
 
     LogDebug("L1GlobalTrigger") << "Test gtObjectMapRecord in L1GlobalTrigger \n\n"
                                 << myCoutStream.str() << "\n\n"
                                 << std::endl;
 
     myCoutStream.str("");
     myCoutStream.clear();
   }
 
   // **
   // register products
   if (m_produceL1GtDaqRecord) {
     iEvent.put(std::move(gtDaqReadoutRecord));
   }
 
   if (m_produceL1GtEvmRecord) {
     iEvent.put(std::move(gtEvmReadoutRecord));
   }
 
   if (m_produceL1GtObjectMapRecord) {
     iEvent.put(std::move(gtObjectMapRecord));
   }
 }

Member Data Documentation

◆ m_activeBoardsGtDaq

uint16_t L1GlobalTrigger::m_activeBoardsGtDaq

private

active boards in L1 GT DAQ record and in L1 GT EVM record

Definition at line 137 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_activeBoardsGtEvm

uint16_t L1GlobalTrigger::m_activeBoardsGtEvm

private

Definition at line 138 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_algorithmTriggersUnmasked

const bool L1GlobalTrigger::m_algorithmTriggersUnmasked

private

if true, unmasked - all enabled (all trigger masks set to 0) will overwrite the event setup

Definition at line 237 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_algorithmTriggersUnprescaled

const bool L1GlobalTrigger::m_algorithmTriggersUnprescaled

private

run algorithm triggers if true, unprescaled (all prescale factors 1) will overwrite the event setup

Definition at line 233 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_alternativeNrBxBoardDaq

const unsigned int L1GlobalTrigger::m_alternativeNrBxBoardDaq

private

alternative for number of BX per active board in GT DAQ record: 0 or 1 the position is identical with the active board bit

Definition at line 221 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_alternativeNrBxBoardEvm

const unsigned int L1GlobalTrigger::m_alternativeNrBxBoardEvm

private

alternative for number of BX per active board in GT EVM record: 0 or 1 the position is identical with the active board bit

Definition at line 225 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_bstLengthBytes

unsigned int L1GlobalTrigger::m_bstLengthBytes

private

length of BST record (in bytes) from event setup

Definition at line 141 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_caloGctInputTag

const edm::InputTag L1GlobalTrigger::m_caloGctInputTag

private

input tag for calorimeter collections from GCT

Definition at line 184 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_castorInputTag

const edm::InputTag L1GlobalTrigger::m_castorInputTag

private

input tag for CASTOR record

Definition at line 187 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger().

◆ m_emulateBxInEvent

int L1GlobalTrigger::m_emulateBxInEvent

private

number of "bunch crossing in the event" (BxInEvent) to be emulated symmetric around L1Accept (BxInEvent = 0): 1 (BxInEvent = 0); 3 (F 0 1) (standard record); 5 (E F 0 1 2) (debug record) even numbers (except 0) "rounded" to the nearest lower odd number

Definition at line 212 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_gtFDL

L1GlobalTriggerFDL* L1GlobalTrigger::m_gtFDL

private

Definition at line 178 of file L1GlobalTrigger.h.

Referenced by gtFDL(), L1GlobalTrigger(), produce(), and ~L1GlobalTrigger().

◆ m_gtGTL

L1GlobalTriggerGTL* L1GlobalTrigger::m_gtGTL

private

Definition at line 177 of file L1GlobalTrigger.h.

Referenced by gtGTL(), L1GlobalTrigger(), produce(), and ~L1GlobalTrigger().

◆ m_gtPSB

L1GlobalTriggerPSB* L1GlobalTrigger::m_gtPSB

private

Definition at line 176 of file L1GlobalTrigger.h.

Referenced by gtPSB(), L1GlobalTrigger(), produce(), and ~L1GlobalTrigger().

◆ m_ifCaloEtaNumberBits

int L1GlobalTrigger::m_ifCaloEtaNumberBits

private

Definition at line 127 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_ifMuEtaNumberBits

int L1GlobalTrigger::m_ifMuEtaNumberBits

private

Definition at line 126 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_isDebugEnabled

const bool L1GlobalTrigger::m_isDebugEnabled

private

Definition at line 254 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_l1GtBM

const L1GtBoardMaps* L1GlobalTrigger::m_l1GtBM

private

board maps - cache only the record

Definition at line 144 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_l1GtBMCacheID

unsigned long long L1GlobalTrigger::m_l1GtBMCacheID

private

Definition at line 145 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_l1GtBMToken

edm::ESGetToken<L1GtBoardMaps, L1GtBoardMapsRcd> L1GlobalTrigger::m_l1GtBMToken

private

Definition at line 259 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_l1GtPar

const L1GtParameters* L1GlobalTrigger::m_l1GtPar

private

parameters

Definition at line 130 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_l1GtParCacheID

unsigned long long L1GlobalTrigger::m_l1GtParCacheID

private

Definition at line 131 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_l1GtParToken

edm::ESGetToken<L1GtParameters, L1GtParametersRcd> L1GlobalTrigger::m_l1GtParToken

private

Definition at line 258 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_l1GtPfAlgo

const L1GtPrescaleFactors* L1GlobalTrigger::m_l1GtPfAlgo

private

prescale factors

Definition at line 148 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_l1GtPfAlgoCacheID

unsigned long long L1GlobalTrigger::m_l1GtPfAlgoCacheID

private

Definition at line 149 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_l1GtPfAlgoToken

edm::ESGetToken<L1GtPrescaleFactors, L1GtPrescaleFactorsAlgoTrigRcd> L1GlobalTrigger::m_l1GtPfAlgoToken

private

Definition at line 260 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_l1GtPfTech

const L1GtPrescaleFactors* L1GlobalTrigger::m_l1GtPfTech

private

Definition at line 151 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_l1GtPfTechCacheID

unsigned long long L1GlobalTrigger::m_l1GtPfTechCacheID

private

Definition at line 152 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_l1GtPfTechToken

edm::ESGetToken<L1GtPrescaleFactors, L1GtPrescaleFactorsTechTrigRcd> L1GlobalTrigger::m_l1GtPfTechToken

private

Definition at line 261 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_l1GtStablePar

const L1GtStableParameters* L1GlobalTrigger::m_l1GtStablePar

private

cached stuff

stable parameters

Definition at line 98 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_l1GtStableParCacheID

unsigned long long L1GlobalTrigger::m_l1GtStableParCacheID

private

Definition at line 99 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_l1GtStableParToken

edm::ESGetToken<L1GtStableParameters, L1GtStableParametersRcd> L1GlobalTrigger::m_l1GtStableParToken

private

EventSetup Tokens.

Definition at line 257 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_l1GtTmAlgo

const L1GtTriggerMask* L1GlobalTrigger::m_l1GtTmAlgo

private

trigger masks & veto masks

Definition at line 158 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_l1GtTmAlgoCacheID

unsigned long long L1GlobalTrigger::m_l1GtTmAlgoCacheID

private

Definition at line 159 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_l1GtTmAlgoToken

edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskAlgoTrigRcd> L1GlobalTrigger::m_l1GtTmAlgoToken

private

Definition at line 262 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_l1GtTmTech

const L1GtTriggerMask* L1GlobalTrigger::m_l1GtTmTech

private

Definition at line 161 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_l1GtTmTechCacheID

unsigned long long L1GlobalTrigger::m_l1GtTmTechCacheID

private

Definition at line 162 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_l1GtTmTechToken

edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskTechTrigRcd> L1GlobalTrigger::m_l1GtTmTechToken

private

Definition at line 263 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_l1GtTmVetoAlgo

const L1GtTriggerMask* L1GlobalTrigger::m_l1GtTmVetoAlgo

private

Definition at line 164 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_l1GtTmVetoAlgoCacheID

unsigned long long L1GlobalTrigger::m_l1GtTmVetoAlgoCacheID

private

Definition at line 165 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_l1GtTmVetoAlgoToken

edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskVetoAlgoTrigRcd> L1GlobalTrigger::m_l1GtTmVetoAlgoToken

private

Definition at line 264 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_l1GtTmVetoTech

const L1GtTriggerMask* L1GlobalTrigger::m_l1GtTmVetoTech

private

Definition at line 167 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_l1GtTmVetoTechCacheID

unsigned long long L1GlobalTrigger::m_l1GtTmVetoTechCacheID

private

Definition at line 168 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_l1GtTmVetoTechToken

edm::ESGetToken<L1GtTriggerMask, L1GtTriggerMaskVetoTechTrigRcd> L1GlobalTrigger::m_l1GtTmVetoTechToken

private

Definition at line 265 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_muGmtInputTag

const edm::InputTag L1GlobalTrigger::m_muGmtInputTag

private

input tag for muon collection from GMT

Definition at line 181 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_nrL1CenJet

int L1GlobalTrigger::m_nrL1CenJet

private

Definition at line 118 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_nrL1ForJet

int L1GlobalTrigger::m_nrL1ForJet

private

Definition at line 119 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_nrL1IsoEG

int L1GlobalTrigger::m_nrL1IsoEG

private

Definition at line 116 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_nrL1JetCounts

int L1GlobalTrigger::m_nrL1JetCounts

private

Definition at line 122 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_nrL1Mu

int L1GlobalTrigger::m_nrL1Mu

private

number of objects of each type { Mu, NoIsoEG, IsoEG, CenJet, ForJet, TauJet, ETM, ETT, HTT, JetCounts };

Definition at line 113 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_nrL1NoIsoEG

int L1GlobalTrigger::m_nrL1NoIsoEG

private

Definition at line 115 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_nrL1TauJet

int L1GlobalTrigger::m_nrL1TauJet

private

Definition at line 120 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_numberDaqPartitions

unsigned int L1GlobalTrigger::m_numberDaqPartitions

private

number of DAQ partitions

Definition at line 108 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_numberPhysTriggers

unsigned int L1GlobalTrigger::m_numberPhysTriggers

private

number of physics triggers

Definition at line 102 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_numberTechnicalTriggers

unsigned int L1GlobalTrigger::m_numberTechnicalTriggers

private

number of technical triggers

Definition at line 105 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_prescaleFactorsAlgoTrig

const std::vector<std::vector<int> >* L1GlobalTrigger::m_prescaleFactorsAlgoTrig

private

Definition at line 154 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_prescaleFactorsTechTrig

const std::vector<std::vector<int> >* L1GlobalTrigger::m_prescaleFactorsTechTrig

private

Definition at line 155 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_produceL1GtDaqRecord

const bool L1GlobalTrigger::m_produceL1GtDaqRecord

private

logical flag to produce the L1 GT DAQ readout record

Definition at line 193 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_produceL1GtEvmRecord

const bool L1GlobalTrigger::m_produceL1GtEvmRecord

private

logical flag to produce the L1 GT EVM readout record

Definition at line 196 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_produceL1GtObjectMapRecord

const bool L1GlobalTrigger::m_produceL1GtObjectMapRecord

private

logical flag to produce the L1 GT object map record

Definition at line 199 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_psBstLengthBytes

const int L1GlobalTrigger::m_psBstLengthBytes

private

length of BST record (in bytes) from parameter set

Definition at line 228 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_readTechnicalTriggerRecords

const bool L1GlobalTrigger::m_readTechnicalTriggerRecords

private

logical flag to read the technical trigger records

Definition at line 205 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_recordLength

const std::vector<int> L1GlobalTrigger::m_recordLength

private

number of BXs in the event corresponding to alternative 0 and 1 in altNrBxBoard() EmulateBxInEvent >= max(RecordLength[0], RecordLength[1]) negative values: take the numbers from event setup, from L1GtParameters

Definition at line 217 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_technicalTriggersInputTags

const std::vector<edm::InputTag> L1GlobalTrigger::m_technicalTriggersInputTags

private

input tag for technical triggers

Definition at line 190 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_technicalTriggersUnmasked

const bool L1GlobalTrigger::m_technicalTriggersUnmasked

private

if true, unmasked - all enabled (all trigger masks set to 0) will overwrite the event setup

Definition at line 246 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_technicalTriggersUnprescaled

const bool L1GlobalTrigger::m_technicalTriggersUnprescaled

private

run technical triggers if true, unprescaled (all prescale factors 1) will overwrite the event setup

Definition at line 242 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_technicalTriggersVetoUnmasked

const bool L1GlobalTrigger::m_technicalTriggersVetoUnmasked

private

if true, veto unmasked - all enabled (all trigger veto masks set to 0) will overwrite the event setup

Definition at line 250 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_totalBxInEvent

int L1GlobalTrigger::m_totalBxInEvent

private

total number of Bx's in the event coming from EventSetup

Definition at line 134 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_triggerMaskAlgoTrig

std::vector<unsigned int> L1GlobalTrigger::m_triggerMaskAlgoTrig

private

Definition at line 170 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_triggerMaskTechTrig

std::vector<unsigned int> L1GlobalTrigger::m_triggerMaskTechTrig

private

Definition at line 171 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_triggerMaskVetoAlgoTrig

std::vector<unsigned int> L1GlobalTrigger::m_triggerMaskVetoAlgoTrig

private

Definition at line 173 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_triggerMaskVetoTechTrig

std::vector<unsigned int> L1GlobalTrigger::m_triggerMaskVetoTechTrig

private

Definition at line 174 of file L1GlobalTrigger.h.

Referenced by produce().

◆ m_verbosity

const int L1GlobalTrigger::m_verbosity

private

verbosity level

Definition at line 253 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

◆ m_writePsbL1GtDaqRecord

const bool L1GlobalTrigger::m_writePsbL1GtDaqRecord

private

logical flag to write the PSB content in the L1 GT DAQ record

Definition at line 202 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ L1GlobalTrigger()

◆ ~L1GlobalTrigger()

Member Function Documentation

◆ gtFDL()

◆ gtGTL()

◆ gtPSB()

◆ produce()

Member Data Documentation

◆ m_activeBoardsGtDaq

◆ m_activeBoardsGtEvm

◆ m_algorithmTriggersUnmasked

◆ m_algorithmTriggersUnprescaled

◆ m_alternativeNrBxBoardDaq

◆ m_alternativeNrBxBoardEvm

◆ m_bstLengthBytes

◆ m_caloGctInputTag

◆ m_castorInputTag

◆ m_emulateBxInEvent

◆ m_gtFDL

◆ m_gtGTL

◆ m_gtPSB

◆ m_ifCaloEtaNumberBits

◆ m_ifMuEtaNumberBits

◆ m_isDebugEnabled

◆ m_l1GtBM

◆ m_l1GtBMCacheID

◆ m_l1GtBMToken

◆ m_l1GtPar

◆ m_l1GtParCacheID

◆ m_l1GtParToken

◆ m_l1GtPfAlgo

◆ m_l1GtPfAlgoCacheID

◆ m_l1GtPfAlgoToken

◆ m_l1GtPfTech

◆ m_l1GtPfTechCacheID

◆ m_l1GtPfTechToken

◆ m_l1GtStablePar

◆ m_l1GtStableParCacheID

◆ m_l1GtStableParToken

◆ m_l1GtTmAlgo

◆ m_l1GtTmAlgoCacheID

◆ m_l1GtTmAlgoToken

◆ m_l1GtTmTech

◆ m_l1GtTmTechCacheID

◆ m_l1GtTmTechToken

◆ m_l1GtTmVetoAlgo

◆ m_l1GtTmVetoAlgoCacheID

◆ m_l1GtTmVetoAlgoToken

◆ m_l1GtTmVetoTech

◆ m_l1GtTmVetoTechCacheID

◆ m_l1GtTmVetoTechToken

◆ m_muGmtInputTag

◆ m_nrL1CenJet

◆ m_nrL1ForJet

◆ m_nrL1IsoEG

◆ m_nrL1JetCounts

◆ m_nrL1Mu

◆ m_nrL1NoIsoEG

◆ m_nrL1TauJet

◆ m_numberDaqPartitions

◆ m_numberPhysTriggers

◆ m_numberTechnicalTriggers

◆ m_prescaleFactorsAlgoTrig

◆ m_prescaleFactorsTechTrig

◆ m_produceL1GtDaqRecord

◆ m_produceL1GtEvmRecord

◆ m_produceL1GtObjectMapRecord

◆ m_psBstLengthBytes

◆ m_readTechnicalTriggerRecords

◆ m_recordLength

◆ m_technicalTriggersInputTags

◆ m_technicalTriggersUnmasked

◆ m_technicalTriggersUnprescaled

◆ m_technicalTriggersVetoUnmasked

◆ m_totalBxInEvent