L1GtTriggerMenuLiteProducer.cc

Go to the documentation of this file.

 
// this class header
#include "EventFilter/L1GlobalTriggerRawToDigi/interface/L1GtTriggerMenuLiteProducer.h"
 
// system include files
#include <iostream>
 
// user include files
#include "DataFormats/L1GlobalTrigger/interface/L1GtTriggerMenuLite.h"
 
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/InputTag.h"
 
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/Run.h"
 
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/MessageLogger/interface/MessageDrop.h"
 
// constructor(s)
L1GtTriggerMenuLiteProducer::L1GtTriggerMenuLiteProducer(const edm::ParameterSet& parSet)
    : m_l1GtStableParCacheID(0ULL),
      m_numberPhysTriggers(0),
 
      m_numberTechnicalTriggers(0),
 
      m_l1GtMenuCacheID(0ULL),
 
      m_l1GtTmAlgoCacheID(0ULL),
      m_l1GtTmTechCacheID(0ULL),
 
      m_l1GtPfAlgoCacheID(0ULL),
      m_l1GtPfTechCacheID(0ULL),
 
      m_l1GtStableParamToken(esConsumes<L1GtStableParameters, L1GtStableParametersRcd, edm::Transition::BeginRun>()),
      m_l1GtPfAlgoToken(esConsumes<L1GtPrescaleFactors, L1GtPrescaleFactorsAlgoTrigRcd, edm::Transition::BeginRun>()),
      m_l1GtPfTechToken(esConsumes<L1GtPrescaleFactors, L1GtPrescaleFactorsTechTrigRcd, edm::Transition::BeginRun>()),
      m_l1GtTmAlgoToken(esConsumes<L1GtTriggerMask, L1GtTriggerMaskAlgoTrigRcd, edm::Transition::BeginRun>()),
      m_l1GtTmTechToken(esConsumes<L1GtTriggerMask, L1GtTriggerMaskTechTrigRcd, edm::Transition::BeginRun>()),
      m_l1GtMenuToken(esConsumes<L1GtTriggerMenu, L1GtTriggerMenuRcd, edm::Transition::BeginRun>()),
      m_physicsDaqPartition(0) {
  // EDM product in Run Data
  produces<L1GtTriggerMenuLite, edm::Transition::BeginRun>();
}
 
// destructor
L1GtTriggerMenuLiteProducer::~L1GtTriggerMenuLiteProducer() {
  // empty
}
 
void L1GtTriggerMenuLiteProducer::retrieveL1EventSetup(const edm::EventSetup& evSetup) {
  // 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_l1GtStableParamToken);
    m_l1GtStablePar = l1GtStablePar.product();
 
    // number of physics triggers
    m_numberPhysTriggers = m_l1GtStablePar->gtNumberPhysTriggers();
 
    // number of technical triggers
    m_numberTechnicalTriggers = m_l1GtStablePar->gtNumberTechnicalTriggers();
 
    //
    m_l1GtStableParCacheID = l1GtStableParCacheID;
  }
 
  // 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;
  }
 
  // get / update the trigger menu from the EventSetup
  // local cache & check on cacheIdentifier
 
  unsigned long long l1GtMenuCacheID = evSetup.get<L1GtTriggerMenuRcd>().cacheIdentifier();
 
  if (m_l1GtMenuCacheID != l1GtMenuCacheID) {
    edm::ESHandle<L1GtTriggerMenu> l1GtMenu = evSetup.getHandle(m_l1GtMenuToken);
    m_l1GtMenu = l1GtMenu.product();
 
    m_algorithmMap = &(m_l1GtMenu->gtAlgorithmMap());
    m_algorithmAliasMap = &(m_l1GtMenu->gtAlgorithmAliasMap());
 
    m_technicalTriggerMap = &(m_l1GtMenu->gtTechnicalTriggerMap());
 
    m_l1GtMenuCacheID = l1GtMenuCacheID;
  }
}
 
// member functions
 
void L1GtTriggerMenuLiteProducer::beginJob() {
  // empty
}
 
void L1GtTriggerMenuLiteProducer::beginRunProduce(edm::Run& iRun, const edm::EventSetup& evSetup) {
  //
 
  retrieveL1EventSetup(evSetup);
 
  // produce the L1GtTriggerMenuLite
  std::unique_ptr<L1GtTriggerMenuLite> gtTriggerMenuLite(new L1GtTriggerMenuLite());
 
  // lite L1 trigger menu
 
  gtTriggerMenuLite->setGtTriggerMenuInterface(m_l1GtMenu->gtTriggerMenuInterface());
  gtTriggerMenuLite->setGtTriggerMenuName(m_l1GtMenu->gtTriggerMenuName());
  gtTriggerMenuLite->setGtTriggerMenuImplementation(m_l1GtMenu->gtTriggerMenuImplementation());
 
  gtTriggerMenuLite->setGtScaleDbKey(m_l1GtMenu->gtScaleDbKey());
 
  //
  L1GtTriggerMenuLite::L1TriggerMap algMap;
  for (CItAlgo itAlgo = m_algorithmMap->begin(); itAlgo != m_algorithmMap->end(); itAlgo++) {
    unsigned int bitNumber = (itAlgo->second).algoBitNumber();
    algMap[bitNumber] = itAlgo->first;
  }
 
  gtTriggerMenuLite->setGtAlgorithmMap(algMap);
 
  //
  L1GtTriggerMenuLite::L1TriggerMap algAliasMap;
  for (CItAlgo itAlgo = m_algorithmAliasMap->begin(); itAlgo != m_algorithmAliasMap->end(); itAlgo++) {
    unsigned int bitNumber = (itAlgo->second).algoBitNumber();
    algAliasMap[bitNumber] = itAlgo->first;
  }
 
  gtTriggerMenuLite->setGtAlgorithmAliasMap(algAliasMap);
 
  //
  L1GtTriggerMenuLite::L1TriggerMap techMap;
  for (CItAlgo itAlgo = m_technicalTriggerMap->begin(); itAlgo != m_technicalTriggerMap->end(); itAlgo++) {
    unsigned int bitNumber = (itAlgo->second).algoBitNumber();
    techMap[bitNumber] = itAlgo->first;
  }
 
  gtTriggerMenuLite->setGtTechnicalTriggerMap(techMap);
 
  // trigger masks
  std::vector<unsigned int> triggerMaskAlgoTrig(m_numberPhysTriggers, 0);
  int iBit = -1;
 
  for (std::vector<unsigned int>::const_iterator itBit = m_triggerMaskAlgoTrig->begin();
       itBit != m_triggerMaskAlgoTrig->end();
       itBit++) {
    iBit++;
    triggerMaskAlgoTrig[iBit] = (*itBit) & (1 << m_physicsDaqPartition);
  }
  gtTriggerMenuLite->setGtTriggerMaskAlgoTrig(triggerMaskAlgoTrig);
 
  //
  std::vector<unsigned int> triggerMaskTechTrig(m_numberTechnicalTriggers, 0);
  iBit = -1;
 
  for (std::vector<unsigned int>::const_iterator itBit = m_triggerMaskTechTrig->begin();
       itBit != m_triggerMaskTechTrig->end();
       itBit++) {
    iBit++;
    triggerMaskTechTrig[iBit] = (*itBit) & (1 << m_physicsDaqPartition);
  }
  gtTriggerMenuLite->setGtTriggerMaskTechTrig(triggerMaskTechTrig);
 
  //
  gtTriggerMenuLite->setGtPrescaleFactorsAlgoTrig(*m_prescaleFactorsAlgoTrig);
  gtTriggerMenuLite->setGtPrescaleFactorsTechTrig(*m_prescaleFactorsTechTrig);
 
  // print menu, trigger masks and prescale factors
  if (edm::isDebugEnabled()) {
    LogDebug("L1GtTriggerMenuLiteProducer") << *gtTriggerMenuLite;
  }
 
  // put records into event
  iRun.put(std::move(gtTriggerMenuLite));
}
 
void L1GtTriggerMenuLiteProducer::produce(edm::Event& iEvent, const edm::EventSetup& evSetup) {}
 
//
void L1GtTriggerMenuLiteProducer::endJob() {
  // empty now
}
 
// static class members
 
//define this as a plug-in
DEFINE_FWK_MODULE(L1GtTriggerMenuLiteProducer);