L1GlobalTrigger.cc

Go to the documentation of this file.

// this class header
#include "L1GlobalTrigger.h"

// system include files
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <memory>

#include <boost/cstdint.hpp>

// user include files
//#include
//"DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutSetupFwd.h"
#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerEvmReadoutRecord.h"
#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerObjectMapRecord.h"
#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutRecord.h"

#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerObjectMap.h"

#include "DataFormats/L1GlobalMuonTrigger/interface/L1MuGMTCand.h"
#include "DataFormats/L1GlobalMuonTrigger/interface/L1MuGMTExtendedCand.h"
#include "DataFormats/L1GlobalMuonTrigger/interface/L1MuGMTReadoutCollection.h"

#include "DataFormats/L1GlobalCaloTrigger/interface/L1GctEmCand.h"
#include "DataFormats/L1GlobalCaloTrigger/interface/L1GctEtSums.h"
#include "DataFormats/L1GlobalCaloTrigger/interface/L1GctHFBitCounts.h"
#include "DataFormats/L1GlobalCaloTrigger/interface/L1GctHFRingEtSums.h"
#include "DataFormats/L1GlobalCaloTrigger/interface/L1GctJetCand.h"
#include "DataFormats/L1GlobalCaloTrigger/interface/L1GctJetCounts.h"

#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/MakerMacros.h"

#include "CondFormats/DataRecord/interface/L1GtStableParametersRcd.h"
#include "CondFormats/L1TObjects/interface/L1GtStableParameters.h"

#include "CondFormats/DataRecord/interface/L1GtParametersRcd.h"
#include "CondFormats/L1TObjects/interface/L1GtParameters.h"

#include "CondFormats/DataRecord/interface/L1GtBoardMapsRcd.h"
#include "CondFormats/L1TObjects/interface/L1GtBoard.h"
#include "CondFormats/L1TObjects/interface/L1GtBoardMaps.h"
#include "CondFormats/L1TObjects/interface/L1GtFwd.h"

#include "CondFormats/DataRecord/interface/L1GtPrescaleFactorsAlgoTrigRcd.h"
#include "CondFormats/DataRecord/interface/L1GtPrescaleFactorsTechTrigRcd.h"
#include "CondFormats/L1TObjects/interface/L1GtPrescaleFactors.h"

#include "CondFormats/DataRecord/interface/L1GtTriggerMaskAlgoTrigRcd.h"
#include "CondFormats/DataRecord/interface/L1GtTriggerMaskTechTrigRcd.h"
#include "CondFormats/L1TObjects/interface/L1GtTriggerMask.h"

#include "CondFormats/DataRecord/interface/L1GtTriggerMaskVetoAlgoTrigRcd.h"
#include "CondFormats/DataRecord/interface/L1GtTriggerMaskVetoTechTrigRcd.h"

#include "L1Trigger/GlobalTrigger/interface/L1GlobalTriggerFDL.h"
#include "L1Trigger/GlobalTrigger/interface/L1GlobalTriggerGTL.h"
#include "L1Trigger/GlobalTrigger/interface/L1GlobalTriggerPSB.h"

#include "DataFormats/L1GlobalTrigger/interface/L1GtfeExtWord.h"
#include "DataFormats/L1GlobalTrigger/interface/L1GtfeWord.h"
#include "DataFormats/L1GlobalTrigger/interface/L1TcsWord.h"

#include "DataFormats/Common/interface/RefProd.h"
#include "FWCore/Utilities/interface/InputTag.h"

#include "FWCore/MessageLogger/interface/MessageDrop.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

// constructors

L1GlobalTrigger::L1GlobalTrigger(const edm::ParameterSet &parSet)
    : 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())

{

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

// destructor
L1GlobalTrigger::~L1GlobalTrigger() {

  delete m_gtPSB;
  delete m_gtGTL;
  delete m_gtFDL;
}

// member functions

// method called to produce the data
void L1GlobalTrigger::produce(edm::Event &iEvent,
                              const edm::EventSetup &evSetup) {

  // 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.get<L1GtStableParametersRcd>().get(l1GtStablePar);
    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.get<L1GtParametersRcd>().get(l1GtPar);
    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.get<L1GtBoardMapsRcd>().get(l1GtBM);
    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.get<L1GtPrescaleFactorsAlgoTrigRcd>().get(l1GtPfAlgo);
    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.get<L1GtPrescaleFactorsTechTrigRcd>().get(l1GtPfTech);
    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.get<L1GtTriggerMaskAlgoTrigRcd>().get(l1GtTmAlgo);
    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.get<L1GtTriggerMaskTechTrigRcd>().get(l1GtTmTech);
    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.get<L1GtTriggerMaskVetoAlgoTrigRcd>().get(l1GtTmVetoAlgo);
    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.get<L1GtTriggerMaskVetoTechTrigRcd>().get(l1GtTmVetoTech);
    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();
  boost::uint16_t bxCrossHw = 0;
  if ((bxCross & 0xFFF) == bxCross) {
    bxCrossHw = static_cast<boost::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 boost::uint16_t
            // there are normally 3 or 5 BxInEvent
            gtfeWordValue.setRecordLength(
                static_cast<boost::uint16_t>(recordLength0));

            gtfeWordValue.setRecordLength1(
                static_cast<boost::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<boost::uint16_t>(m_alternativeNrBxBoardDaq));

            // set the TOTAL_TRIGNR as read from iEvent
            // TODO check again - PTC stuff

            gtfeWordValue.setTotalTriggerNr(
                static_cast<boost::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 boost::uint16_t
            // there are normally 3 or 5 BxInEvent
            gtfeWordValue.setRecordLength(
                static_cast<boost::uint16_t>(recordLength0));

            gtfeWordValue.setRecordLength1(
                static_cast<boost::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<boost::uint16_t>(m_alternativeNrBxBoardEvm));

            // set the TOTAL_TRIGNR as read from iEvent
            // TODO check again - PTC stuff

            gtfeWordValue.setTotalTriggerNr(
                static_cast<boost::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
            boost::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);

            boost::uint16_t trigType = 0x5; // 0101 simulated event
            tcsWordValue.setTriggerType(trigType);

            // luminosity segment number
            tcsWordValue.setLuminositySegmentNr(
                static_cast<boost::uint16_t>(iEvent.luminosityBlock()));

            // set the Event_Nr as read from iEvent
            tcsWordValue.setEventNr(
                static_cast<boost::uint32_t>(iEvent.id().event()));

            // orbit number
            tcsWordValue.setOrbitNr(
                static_cast<boost::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));
  }
}

// static data members

DEFINE_FWK_MODULE(L1GlobalTrigger);