L1TBPTX Class Reference

#include <L1TBPTX.h>

Inheritance diagram for L1TBPTX:

Public Types
enum	BeamMode {   NOMODE = 1, SETUP = 2, INJPILOT = 3, INJINTR = 4,   INJNOMN = 5, PRERAMP = 6, RAMP = 7, FLATTOP = 8,   SQUEEZE = 9, ADJUST = 10, STABLE = 11, UNSTABLE = 12,   BEAMDUMP = 13, RAMPDOWN = 14, RECOVERY = 15, INJDUMP = 16,   CIRCDUMP = 17, ABORT = 18, CYCLING = 19, WBDUMP = 20,   NOBEAM = 21 }
enum	Errors {   UNKNOWN = 1, WARNING_DB_CONN_FAILED = 2, WARNING_DB_QUERY_FAILED = 3, WARNING_DB_INCORRECT_NBUNCHES = 4,   ERROR_UNABLE_RETRIVE_PRODUCT = 5, ERROR_TRIGGERALIAS_NOTVALID = 6, ERROR_LSBLOCK_NOTVALID = 7 }
Public Types inherited from DQMOneEDAnalyzer< edm::one::WatchLuminosityBlocks >
typedef dqm::reco::DQMStore	DQMStore
typedef dqm::reco::MonitorElement	MonitorElement
Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType
Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const *, const char *, edm::ProductResolverIndex >>
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Public Member Functions
	L1TBPTX (const edm::ParameterSet &ps)
	~L1TBPTX () override
Public Member Functions inherited from DQMOneEDAnalyzer< edm::one::WatchLuminosityBlocks >
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) override
void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final
	DQMOneEDAnalyzer ()
void	endRun (edm::Run const &, edm::EventSetup const &) final
void	endRunProduce (edm::Run &run, edm::EventSetup const &setup) final
virtual bool	getCanSaveByLumi ()
Public Member Functions inherited from edm::one::EDProducer< edm::EndRunProducer, edm::one::WatchRuns, edm::Accumulator, Args...>
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
SerialTaskQueue *	globalLuminosityBlocksQueue () final
SerialTaskQueue *	globalRunsQueue () final
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
bool	wantsGlobalLuminosityBlocks () const final
bool	wantsGlobalRuns () const final
bool	wantsInputProcessBlocks () const final
bool	wantsProcessBlocks () const final
Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()
ModuleDescription const &	moduleDescription () const
bool	wantsStreamLuminosityBlocks () const
bool	wantsStreamRuns () const
	~EDProducerBase () override
Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
std::vector < edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const
	ProducerBase ()
std::vector < edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const
void	registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...
void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)
	~ProducerBase () noexcept(false) override
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...
	EDConsumerBase ()
	EDConsumerBase (EDConsumerBase const &)=delete
	EDConsumerBase (EDConsumerBase &&)=default
ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const
std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const
std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector < ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const * > *, NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
EDConsumerBase &	operator= (EDConsumerBase &&)=default
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)
virtual	~EDConsumerBase () noexcept(false)

Protected Member Functions
void	analyze (const edm::Event &e, const edm::EventSetup &c) override
void	beginLuminosityBlock (edm::LuminosityBlock const &lumiBlock, edm::EventSetup const &c) override
void	bookHistograms (DQMStore::IBooker &ibooker, const edm::Run &, const edm::EventSetup &) override
	BeginRun. More...
void	dqmBeginRun (const edm::Run &, const edm::EventSetup &) override
void	endLuminosityBlock (edm::LuminosityBlock const &lumiBlock, edm::EventSetup const &c) override
Protected Member Functions inherited from DQMOneEDAnalyzer< edm::one::WatchLuminosityBlocks >
virtual void	dqmEndRun (edm::Run const &, edm::EventSetup const &)
Protected Member Functions inherited from edm::ProducerBase
ProducesCollector	producesCollector ()
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()
template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)
template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
void	resetItemsToGetFrom (BranchType iType)

Private Member Functions
void	certifyLSBlock (std::string iTrigger, int iInitLs, int iEndLs, float iValue)
void	doFractionInSync (bool iForce=false, bool iBad=false)
void	getBeamConfOMDS ()

Private Attributes
edm::ESGetToken < L1GtTriggerMenu, L1GtTriggerMenuRcd >	l1gtMenuToken_
edm::ESGetToken < L1GtPrescaleFactors, L1GtPrescaleFactorsAlgoTrigRcd >	l1GtPfAlgoToken_
edm::ESGetToken < L1GtPrescaleFactors, L1GtPrescaleFactorsTechTrigRcd >	l1GtPfTechToken_
std::map< int, TString >	m_algoBit_Alias
BeamConfiguration	m_beamConfig
unsigned int	m_currentGTLS
unsigned int	m_currentLS
bool	m_currentLSValid
int	m_currentPrescalesIndex
std::map< TString, int >	m_effDenominator
std::map< TString, int >	m_effNumerator
MonitorElement *	m_ErrorMonitor
edm::EDGetTokenT < L1GlobalTriggerReadoutRecord >	m_l1GtDataDaqInputTag
edm::EDGetTokenT < L1GlobalTriggerEvmReadoutRecord >	m_l1GtEvmSource
std::map< std::pair< bool, int > , double >	m_l1Rate
unsigned int	m_lhcFill
std::map< TString, MonitorElement * >	m_meAlgoEfficiency
std::map< TString, MonitorElement * >	m_meAlgoMissFire
std::map< std::pair< bool, int > , MonitorElement * >	m_meRate
std::map< TString, MonitorElement * >	m_meTechEfficiency
std::map< TString, MonitorElement * >	m_meTechMissFire
std::map< TString, int >	m_missFireDenominator
std::map< TString, int >	m_missFireNumerator
std::vector< edm::ParameterSet >	m_monitorBits
std::vector< edm::ParameterSet >	m_monitorRates
std::string	m_outputFile
edm::ParameterSet	m_parameters
const std::vector< std::vector < int > > *	m_prescaleFactorsAlgoTrig
const std::vector< std::vector < int > > *	m_prescaleFactorsTechTrig
bool *	m_processedLS
int	m_refPrescaleSet
edm::EDGetTokenT < Level1TriggerScalersCollection >	m_scalersSource
std::vector< std::pair< int, int > >	m_selAlgoBit
std::vector< std::pair< int, int > >	m_selTechBit
std::map< int, TString >	m_techBit_Alias
bool	m_verbose

Additional Inherited Members
Static Public Member Functions inherited from edm::one::EDProducerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Attributes inherited from DQMOneEDAnalyzer< edm::one::WatchLuminosityBlocks >
edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

Definition at line 75 of file L1TBPTX.h.

Member Enumeration Documentation

enum L1TBPTX::BeamMode

Enumerator
NOMODE
SETUP
INJPILOT
INJINTR
INJNOMN
PRERAMP
RAMP
FLATTOP
SQUEEZE
ADJUST
STABLE
UNSTABLE
BEAMDUMP
RAMPDOWN
RECOVERY
INJDUMP
CIRCDUMP
ABORT
CYCLING
WBDUMP
NOBEAM

Definition at line 77 of file L1TBPTX.h.

                {
    NOMODE = 1,
    SETUP = 2,
    INJPILOT = 3,
    INJINTR = 4,
    INJNOMN = 5,
    PRERAMP = 6,
    RAMP = 7,
    FLATTOP = 8,
    SQUEEZE = 9,
    ADJUST = 10,
    STABLE = 11,
    UNSTABLE = 12,
    BEAMDUMP = 13,
    RAMPDOWN = 14,
    RECOVERY = 15,
    INJDUMP = 16,
    CIRCDUMP = 17,
    ABORT = 18,
    CYCLING = 19,
    WBDUMP = 20,
    NOBEAM = 21
  };

enum L1TBPTX::Errors

Enumerator
UNKNOWN
WARNING_DB_CONN_FAILED
WARNING_DB_QUERY_FAILED
WARNING_DB_INCORRECT_NBUNCHES
ERROR_UNABLE_RETRIVE_PRODUCT
ERROR_TRIGGERALIAS_NOTVALID
ERROR_LSBLOCK_NOTVALID

Definition at line 101 of file L1TBPTX.h.

              {
    UNKNOWN = 1,
    WARNING_DB_CONN_FAILED = 2,
    WARNING_DB_QUERY_FAILED = 3,
    WARNING_DB_INCORRECT_NBUNCHES = 4,
    ERROR_UNABLE_RETRIVE_PRODUCT = 5,
    ERROR_TRIGGERALIAS_NOTVALID = 6,
    ERROR_LSBLOCK_NOTVALID = 7
  };

Constructor & Destructor Documentation

L1TBPTX::L1TBPTX

(

const edm::ParameterSet &

ps

)

Definition at line 33 of file L1TBPTX.cc.

References edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), mps_fire::i, m_verbose(), hltrates_dqm_sourceclient-live_cfg::offset, and TrackValidation_cff::pset.

                                         {
  m_parameters = pset;

  // Mapping parameter input variables
  m_scalersSource = consumes<Level1TriggerScalersCollection>(pset.getParameter<InputTag>("inputTagScalersResults"));
  m_l1GtDataDaqInputTag = consumes<L1GlobalTriggerReadoutRecord>(pset.getParameter<InputTag>("inputTagL1GtDataDaq"));
  m_l1GtEvmSource = consumes<L1GlobalTriggerEvmReadoutRecord>(pset.getParameter<InputTag>("inputTagtEvmSource"));
  l1gtMenuToken_ = esConsumes<edm::Transition::BeginRun>();
  l1GtPfAlgoToken_ = esConsumes<edm::Transition::BeginRun>();
  l1GtPfTechToken_ = esConsumes<edm::Transition::BeginRun>();
  m_verbose = pset.getUntrackedParameter<bool>("verbose", false);
  //  m_refPrescaleSet      = pset.getParameter         <int>     ("refPrescaleSet");

  m_monitorBits = pset.getParameter<vector<ParameterSet> >("MonitorBits");

  for (unsigned i = 0; i < m_monitorBits.size(); i++) {
    // Algorithms
    if (m_monitorBits[i].getParameter<bool>("bitType")) {
      int bit = m_monitorBits[i].getParameter<int>("bitNumber");
      int offset = m_monitorBits[i].getParameter<int>("bitOffset");
      m_selAlgoBit.push_back(pair<int, int>(bit, offset));
    }
    // Tech
    else {
      int bit = m_monitorBits[i].getParameter<int>("bitNumber");
      int offset = m_monitorBits[i].getParameter<int>("bitOffset");
      m_selTechBit.push_back(pair<int, int>(bit, offset));
    }
  }

  m_monitorRates = pset.getParameter<vector<ParameterSet> >("MonitorRates");
}

L1TBPTX::~L1TBPTX ( )

override

Definition at line 68 of file L1TBPTX.cc.

{}

Member Function Documentation

void L1TBPTX::analyze ( const edm::Event &  e, const edm::EventSetup &  c  )

overrideprotectedvirtual

Reimplemented from DQMOneEDAnalyzer< edm::one::WatchLuminosityBlocks >.

Definition at line 325 of file L1TBPTX.cc.

References a, L1GtfeExtWord::beamMode(), gather_cfg::cout, edm::Event::getByToken(), Level1TriggerRates::gtAlgoCountsRate(), mps_fire::i, edm::EventBase::id(), edm::HandleBase::isValid(), L1GtfeExtWord::lhcFillNumber(), m_verbose(), hltrates_dqm_sourceclient-live_cfg::offset, edm::EventID::run(), and cond::impl::to_string().

                                                                       {
  if (m_verbose) {
    cout << "[L1TBPTX] Called analyze." << endl;
  }

  // We only start analyzing if current LS is still valid
  if (m_currentLSValid) {
    if (m_verbose) {
      cout << "[L1TBPTX] -> m_currentLSValid=" << m_currentLSValid << endl;
    }

    // Retriving information from GT
    edm::Handle<L1GlobalTriggerEvmReadoutRecord> gtEvmReadoutRecord;
    iEvent.getByToken(m_l1GtEvmSource, gtEvmReadoutRecord);

    // Determining beam mode and fill number
    if (gtEvmReadoutRecord.isValid()) {
      const L1GtfeExtWord& gtfeEvmWord = gtEvmReadoutRecord->gtfeWord();
      unsigned int lhcBeamMode = gtfeEvmWord.beamMode();  // Updating beam mode

      if (m_verbose) {
        cout << "[L1TBPTX] Beam mode: " << lhcBeamMode << endl;
      }

      if (lhcBeamMode == RAMP || lhcBeamMode == FLATTOP || lhcBeamMode == SQUEEZE || lhcBeamMode == ADJUST ||
          lhcBeamMode == STABLE) {
        if (m_lhcFill == 0) {
          if (m_verbose) {
            cout << "[L1TBPTX] No valid bunch structure yet retrived. Attemptting to retrive..." << endl;
          }

          m_lhcFill = gtfeEvmWord.lhcFillNumber();  // Getting LHC Fill Number from GT

          getBeamConfOMDS();  // Getting Beam Configuration from OMDS

          // We are between RAMP and STABLE so there should be some colliding bunches
          // in the machine. If 0 colliding bunched are found might be due to a delay
          // of the update of the database. So we declare this LS as invalid and try
          // again on the next one.
          if (m_beamConfig.nCollidingBunches <= 0) {
            m_lhcFill = 0;
            m_currentLSValid = false;
          }
        }
      } else {
        m_currentLSValid = false;
      }

    } else {
      int eCount = m_ErrorMonitor->getTH1()->GetBinContent(ERROR_UNABLE_RETRIVE_PRODUCT);
      eCount++;
      m_ErrorMonitor->getTH1()->SetBinContent(ERROR_UNABLE_RETRIVE_PRODUCT, eCount);
    }
  }

  //______________________________________________________________________________
  // If current LS is valid and Beam Configuration is Valid we analyse this event
  //______________________________________________________________________________
  if (m_currentLSValid && m_beamConfig.isValid()) {
    if (m_verbose) {
      cout << "Current event in valid LS and beam config" << endl;
    }

    // Getting Final Decision Logic (FDL) Data from GT
    edm::Handle<L1GlobalTriggerReadoutRecord> gtReadoutRecordData;
    iEvent.getByToken(m_l1GtDataDaqInputTag, gtReadoutRecordData);

    if (gtReadoutRecordData.isValid()) {
      const vector<L1GtFdlWord>& gtFdlVectorData = gtReadoutRecordData->gtFdlVector();

      // Getting the index for the fdl data for this event
      int eventFDL = 0;
      for (unsigned int i = 0; i < gtFdlVectorData.size(); i++) {
        if (gtFdlVectorData[i].bxInEvent() == 0) {
          eventFDL = i;
          break;
        }
      }

      m_currentPrescalesIndex = gtFdlVectorData[eventFDL].gtPrescaleFactorIndexAlgo();

      for (unsigned i = 0; i < m_monitorBits.size(); i++) {
        TString triggerName = "";
        bool isAlgo = m_monitorBits[i].getParameter<bool>("bitType");
        int bit = m_monitorBits[i].getParameter<int>("bitNumber");
        int offset = m_monitorBits[i].getParameter<int>("bitOffset");

        if (isAlgo) {
          triggerName = "algo_" + std::to_string(bit);
        } else {
          triggerName = "tech_" + std::to_string(bit);
        }

        for (unsigned a = 0; a < gtFdlVectorData.size(); a++) {
          int testBx = gtFdlVectorData[a].localBxNr() - offset;
          bool lhcBxFilled = m_beamConfig.beam1[testBx] && m_beamConfig.beam2[testBx];
          bool algoFired = false;

          if (isAlgo) {
            if (gtFdlVectorData[a].gtDecisionWord()[bit])
              algoFired = true;

          } else {
            if (gtFdlVectorData[a].gtTechnicalTriggerWord()[bit])
              algoFired = true;
          }

          if (lhcBxFilled) {
            m_effDenominator[triggerName]++;
            if (algoFired)
              m_effNumerator[triggerName]++;
          }
          if (algoFired) {
            m_missFireDenominator[triggerName]++;
            if (!lhcBxFilled)
              m_missFireNumerator[triggerName]++;
          }
        }
      }
    }
  }

  //______________________________________________________________________________
  // Rate calculation
  //______________________________________________________________________________
  edm::Handle<Level1TriggerScalersCollection> triggerScalers;
  iEvent.getByToken(m_scalersSource, triggerScalers);

  if (triggerScalers.isValid()) {
    Level1TriggerScalersCollection::const_iterator itL1TScalers = triggerScalers->begin();
    Level1TriggerRates trigRates(*itL1TScalers, iEvent.id().run());

    m_currentGTLS = (*itL1TScalers).lumiSegmentNr();

    for (unsigned i = 0; i < m_monitorRates.size(); i++) {
      bool isAlgo = m_monitorRates[i].getParameter<bool>("bitType");
      int bit = m_monitorRates[i].getParameter<int>("bitNumber");

      pair<bool, int> refTrig = pair<bool, int>(isAlgo, bit);

      if (isAlgo) {
        m_l1Rate[refTrig] = trigRates.gtAlgoCountsRate()[bit];
      } else {
        m_l1Rate[refTrig] = trigRates.gtTechCountsRate()[bit];
      }
    }
  }
}

void L1TBPTX::beginLuminosityBlock ( edm::LuminosityBlock const &  lumiBlock, edm::EventSetup const &  c  )

overrideprotected

Definition at line 214 of file L1TBPTX.cc.

References gather_cfg::cout, mps_fire::i, edm::LuminosityBlockBase::id(), edm::LuminosityBlockID::luminosityBlock(), m_verbose(), and cond::impl::to_string().

                                                                                        {
  if (m_verbose) {
    cout << "[L1TBPTX] Called beginLuminosityBlock." << endl;
  }

  // Updating current LS number
  m_currentLS = lumiBlock.id().luminosityBlock();

  // A LS will be valid if BeamMode==STABLE for all events monitored
  m_currentLSValid = true;

  for (unsigned i = 0; i < m_monitorBits.size(); i++) {
    TString triggerName = "";
    if (m_monitorBits[i].getParameter<bool>("bitType")) {
      triggerName = "algo_" + std::to_string(m_monitorBits[i].getParameter<int>("bitNumber"));
    } else {
      triggerName = "tech_" + std::to_string(m_monitorBits[i].getParameter<int>("bitNumber"));
    }

    m_effNumerator[triggerName] = 0;
    m_effDenominator[triggerName] = 0;
    m_missFireNumerator[triggerName] = 0;
    m_missFireDenominator[triggerName] = 0;
  }
}

void L1TBPTX::bookHistograms ( DQMStore::IBooker &  ibooker, const edm::Run &  iRun, const edm::EventSetup &  iSetup  )

overrideprotectedvirtual

BeginRun.

Implements DQMOneEDAnalyzer< edm::one::WatchLuminosityBlocks >.

Definition at line 73 of file L1TBPTX.cc.

References dqm::implementation::IBooker::book1D(), gather_cfg::cout, edm::EventSetup::getData(), edm::EventSetup::getHandle(), L1GtTriggerMenu::gtAlgorithmAliasMap(), L1GtPrescaleFactors::gtPrescaleFactors(), L1GtTriggerMenu::gtTechnicalTriggerMap(), mps_fire::i, m_verbose(), relval_steps::menu, dqm::impl::MonitorElement::setAxisTitle(), dqm::impl::MonitorElement::setBinLabel(), dqm::implementation::NavigatorBase::setCurrentFolder(), cond::impl::to_string(), and SiStripSubdetector::UNKNOWN.

                                                                                                      {
  if (m_verbose) {
    cout << "[L1TBPTX] Called beginRun." << endl;
  }

  ibooker.setCurrentFolder("L1T/L1TBPTX");

  // Initializing variables
  int maxNbins = 2501;

  // Reseting run dependent variables
  m_lhcFill = 0;
  m_currentLS = 0;

  // Getting Trigger menu from GT
  const L1GtTriggerMenu* menu = &iSetup.getData(l1gtMenuToken_);

  // Filling Alias-Bit Map
  for (CItAlgo algo = menu->gtAlgorithmAliasMap().begin(); algo != menu->gtAlgorithmAliasMap().end(); ++algo) {
    m_algoBit_Alias[(algo->second).algoBitNumber()] = (algo->second).algoAlias();
  }

  for (CItAlgo algo = menu->gtTechnicalTriggerMap().begin(); algo != menu->gtTechnicalTriggerMap().end(); ++algo) {
    m_techBit_Alias[(algo->second).algoBitNumber()] = (algo->second).algoName();
  }

  // Initializing DQM Monitor Elements
  ibooker.setCurrentFolder("L1T/L1TBPTX");
  m_ErrorMonitor = ibooker.book1D("ErrorMonitor", "ErrorMonitor", 7, 0, 7);
  m_ErrorMonitor->setBinLabel(UNKNOWN, "UNKNOWN");
  m_ErrorMonitor->setBinLabel(WARNING_DB_CONN_FAILED, "WARNING_DB_CONN_FAILED");    // Errors from L1TOMDSHelper
  m_ErrorMonitor->setBinLabel(WARNING_DB_QUERY_FAILED, "WARNING_DB_QUERY_FAILED");  // Errors from L1TOMDSHelper
  m_ErrorMonitor->setBinLabel(WARNING_DB_INCORRECT_NBUNCHES,
                              "WARNING_DB_INCORRECT_NBUNCHES");  // Errors from L1TOMDSHelper
  m_ErrorMonitor->setBinLabel(ERROR_UNABLE_RETRIVE_PRODUCT, "ERROR_UNABLE_RETRIVE_PRODUCT");
  m_ErrorMonitor->setBinLabel(ERROR_TRIGGERALIAS_NOTVALID, "ERROR_TRIGGERALIAS_NOTVALID");
  m_ErrorMonitor->setBinLabel(ERROR_LSBLOCK_NOTVALID, "ERROR_LSBLOCK_NOTVALID");

  for (unsigned i = 0; i < m_monitorBits.size(); i++) {
    bool isAlgo = m_monitorBits[i].getParameter<bool>("bitType");
    TString testName = m_monitorBits[i].getParameter<string>("testName");
    int bit = m_monitorBits[i].getParameter<int>("bitNumber");

    TString meTitle = "";
    ibooker.setCurrentFolder("L1T/L1TBPTX/Efficiency/");
    if (isAlgo) {
      meTitle = "Algo ";
      meTitle += bit;
      meTitle += " - ";
      meTitle += m_algoBit_Alias[bit];
      meTitle += " Efficiency";
      m_meAlgoEfficiency[bit] = ibooker.book1D(testName, meTitle, maxNbins, -0.5, double(maxNbins) - 0.5);
      m_meAlgoEfficiency[bit]->setAxisTitle("Lumi Section", 1);
    } else {
      meTitle = "Tech ";
      meTitle += bit;
      meTitle += " - ";
      meTitle += m_techBit_Alias[bit];
      meTitle += " Efficiency";
      m_meTechEfficiency[bit] = ibooker.book1D(testName, meTitle, maxNbins, -0.5, double(maxNbins) - 0.5);
      m_meTechEfficiency[bit]->setAxisTitle("Lumi Section", 1);
    }

    meTitle = "";
    ibooker.setCurrentFolder("L1T/L1TBPTX/MissFire/");
    if (isAlgo) {
      meTitle = "Algo ";
      meTitle += bit;
      meTitle += " - ";
      meTitle += m_algoBit_Alias[bit];
      meTitle += "(1 - Miss Fire Rate)";
      m_meAlgoMissFire[bit] = ibooker.book1D(testName, meTitle, maxNbins, -0.5, double(maxNbins) - 0.5);
      m_meAlgoMissFire[bit]->setAxisTitle("Lumi Section", 1);
      m_meAlgoMissFire[bit]->setAxisTitle("1 - Miss Fire Rate", 2);
    } else {
      meTitle = "Tech ";
      meTitle += bit;
      meTitle += " - ";
      meTitle += m_techBit_Alias[bit];
      meTitle += "(1 - Miss Fire Rate)";
      m_meTechMissFire[bit] = ibooker.book1D(testName, meTitle, maxNbins, -0.5, double(maxNbins) - 0.5);
      m_meTechMissFire[bit]->setAxisTitle("Lumi Section", 1);
      m_meTechMissFire[bit]->setAxisTitle("1 - Miss Fire Rate", 2);
    }
  }

  for (unsigned i = 0; i < m_monitorRates.size(); i++) {
    TString testName = m_monitorRates[i].getParameter<string>("testName");
    bool isAlgo = m_monitorRates[i].getParameter<bool>("bitType");
    int bit = m_monitorRates[i].getParameter<int>("bitNumber");

    pair<bool, int> refME = pair<bool, int>(isAlgo, bit);

    TString meTitle = "";
    ibooker.setCurrentFolder("L1T/L1TBPTX/Rate/");
    if (isAlgo) {
      meTitle = "Algo " + std::to_string(bit);
      meTitle += " - ";
      meTitle += m_algoBit_Alias[bit];
      meTitle += " Rate";
      m_meRate[refME] = ibooker.book1D(testName, meTitle, maxNbins, -0.5, double(maxNbins) - 0.5);
      m_meRate[refME]->setAxisTitle("Lumi Section", 1);
      m_meRate[refME]->setAxisTitle("Rate (unprescaled) [Hz]", 2);
    } else {
      meTitle = "Tech " + std::to_string(bit);
      meTitle += " - ";
      meTitle += m_techBit_Alias[bit];
      meTitle += " Rate";
      m_meRate[refME] = ibooker.book1D(testName, meTitle, maxNbins, -0.5, double(maxNbins) - 0.5);
      m_meRate[refME]->setAxisTitle("Lumi Section", 1);
      m_meRate[refME]->setAxisTitle("Rate (unprescaled) [Hz]", 2);
    }
  }

  //_____________________________________________________________________
  // Getting the prescale columns definition for this run
  const auto& l1GtPfAlgo = iSetup.getHandle(l1GtPfAlgoToken_);
  const auto& l1GtPfTech = iSetup.getHandle(l1GtPfTechToken_);

  if (l1GtPfAlgo.isValid()) {
    const L1GtPrescaleFactors* m_l1GtPfAlgo = l1GtPfAlgo.product();
    m_prescaleFactorsAlgoTrig = &(m_l1GtPfAlgo->gtPrescaleFactors());
  } else {
    //TODO: Some error handling
  }

  if (l1GtPfAlgo.isValid()) {
    const L1GtPrescaleFactors* m_l1GtPfTech = l1GtPfTech.product();
    m_prescaleFactorsTechTrig = &(m_l1GtPfTech->gtPrescaleFactors());
  } else {
    //TODO: Some error handling
  }
}

void L1TBPTX::certifyLSBlock ( std::string  iTrigger, int  iInitLs, int  iEndLs, float  iValue  )

private

Definition at line 568 of file L1TBPTX.cc.

{}

void L1TBPTX::doFractionInSync ( bool  iForce = false, bool  iBad = false  )

private

Definition at line 558 of file L1TBPTX.cc.

{}

void L1TBPTX::dqmBeginRun ( const edm::Run &  , const edm::EventSetup &    )

overrideprotectedvirtual

Reimplemented from DQMOneEDAnalyzer< edm::one::WatchLuminosityBlocks >.

Definition at line 207 of file L1TBPTX.cc.

                                                             {
  //empty
}

void L1TBPTX::endLuminosityBlock ( edm::LuminosityBlock const &  lumiBlock, edm::EventSetup const &  c  )

overrideprotected

Definition at line 244 of file L1TBPTX.cc.

References newFWLiteAna::bin, gather_cfg::cout, mps_fire::i, m_verbose(), and cond::impl::to_string().

                                                                                      {
  //______________________________________________________________________________
  // Monitoring efficiencies
  //______________________________________________________________________________
  if (m_verbose) {
    cout << "[L1TBPTX] Called endLuminosityBlock." << endl;
  }

  // If this LS is valid (i.e. all events recorded with stable beams)
  if (m_currentLSValid && m_beamConfig.isValid()) {
    for (unsigned i = 0; i < m_monitorBits.size(); i++) {
      bool isAlgo = m_monitorBits[i].getParameter<bool>("bitType");
      TString testName = m_monitorBits[i].getParameter<string>("testName");
      int bit = m_monitorBits[i].getParameter<int>("bitNumber");

      TString triggerName;
      if (isAlgo) {
        triggerName = "algo_" + std::to_string(bit);
      } else {
        triggerName = "tech_" + std::to_string(bit);
      }

      double valEff;
      double valMiss;
      if (m_effDenominator[triggerName] != 0) {
        valEff = (double)m_effNumerator[triggerName] / m_effDenominator[triggerName];
      } else {
        valEff = 0;
      }
      if (m_missFireDenominator[triggerName] != 0) {
        valMiss = (double)m_missFireNumerator[triggerName] / m_missFireDenominator[triggerName];
      } else {
        valMiss = 0;
      }

      if (isAlgo) {
        int bin = m_meAlgoEfficiency[bit]->getTH1()->FindBin(m_currentLS);
        m_meAlgoEfficiency[bit]->setBinContent(bin, valEff);
        m_meAlgoMissFire[bit]->setBinContent(bin, 1 - valMiss);
      } else {
        int bin = m_meTechEfficiency[bit]->getTH1()->FindBin(m_currentLS);
        m_meTechEfficiency[bit]->setBinContent(bin, valEff);
        m_meTechMissFire[bit]->setBinContent(bin, 1 - valMiss);
      }
    }
  }

  //______________________________________________________________________________
  // Monitoring rates
  //______________________________________________________________________________
  // We are only interested in monitoring lumisections where the the LHC state is
  // RAMP, FLATTOP, SQUEEZE, ADJUST or STABLE since the bunch configuration and
  // therefore the BPTX rate will not change.

  if (m_currentLSValid) {
    const vector<int>& currentPFAlgo = (*m_prescaleFactorsAlgoTrig).at(m_currentPrescalesIndex);
    const vector<int>& currentPFTech = (*m_prescaleFactorsTechTrig).at(m_currentPrescalesIndex);

    for (unsigned i = 0; i < m_monitorRates.size(); i++) {
      bool isAlgo = m_monitorRates[i].getParameter<bool>("bitType");
      int bit = m_monitorRates[i].getParameter<int>("bitNumber");

      pair<bool, int> refME = pair<bool, int>(isAlgo, bit);

      if (isAlgo) {
        int bin = m_meRate[refME]->getTH1()->FindBin(m_currentGTLS);
        int trigPS = currentPFAlgo[bit];
        double trigRate = (double)trigPS * m_l1Rate[refME];
        m_meRate[refME]->setBinContent(bin, trigRate);

      } else {
        int bin = m_meRate[refME]->getTH1()->FindBin(m_currentGTLS);
        int trigPS = currentPFTech[bit];
        double trigRate = (double)trigPS * m_l1Rate[refME];
        m_meRate[refME]->setBinContent(bin, trigRate);
      }
    }
  }
}

void L1TBPTX::getBeamConfOMDS ( )

private

Definition at line 479 of file L1TBPTX.cc.

References gather_cfg::cout, m_verbose(), L1TOMDSHelper::NO_ERROR, SiStripSubdetector::UNKNOWN, L1TOMDSHelper::WARNING_DB_CONN_FAILED, L1TOMDSHelper::WARNING_DB_INCORRECT_NBUNCHES, and L1TOMDSHelper::WARNING_DB_QUERY_FAILED.

                              {
  if (m_verbose) {
    cout << "[L1TBPTX] Called getBeamConfOMDS()" << endl;
  }

  //Getting connection paremeters
  string oracleDB = m_parameters.getParameter<string>("oracleDB");
  string pathCondDB = m_parameters.getParameter<string>("pathCondDB");

  // Connecting to OMDS
  L1TOMDSHelper myOMDSHelper = L1TOMDSHelper();
  int conError;
  myOMDSHelper.connect(oracleDB, pathCondDB, conError);

  if (conError == L1TOMDSHelper::NO_ERROR) {
    if (m_verbose) {
      cout << "[L1TBPTX] Connected to DB with no error." << endl;
    }

    int errorRetrive;
    m_beamConfig = myOMDSHelper.getBeamConfiguration(m_lhcFill, errorRetrive);

    if (errorRetrive == L1TOMDSHelper::NO_ERROR) {
      if (m_verbose) {
        cout << "[L1TBPTX] Retriving LHC Bunch Structure: NO_ERROR" << endl;
        cout << "[L1TSync] -> LHC Bunch Structure valid=" << m_beamConfig.m_valid
             << " nBunches=" << m_beamConfig.nCollidingBunches << endl;
      }
    } else if (errorRetrive == L1TOMDSHelper::WARNING_DB_QUERY_FAILED) {
      if (m_verbose) {
        cout << "[L1TBPTX] Retriving LHC Bunch Structure: WARNING_DB_QUERY_FAILED" << endl;
      }

      int eCount = m_ErrorMonitor->getTH1()->GetBinContent(WARNING_DB_QUERY_FAILED);
      eCount++;
      m_ErrorMonitor->getTH1()->SetBinContent(WARNING_DB_QUERY_FAILED, eCount);
    } else if (errorRetrive == L1TOMDSHelper::WARNING_DB_INCORRECT_NBUNCHES) {
      if (m_verbose) {
        cout << "[L1TBPTX] Retriving LHC Bunch Structure: WARNING_DB_INCORRECT_NBUNCHES" << endl;
      }

      int eCount = m_ErrorMonitor->getTH1()->GetBinContent(WARNING_DB_INCORRECT_NBUNCHES);
      eCount++;
      m_ErrorMonitor->getTH1()->SetBinContent(WARNING_DB_INCORRECT_NBUNCHES, eCount);
    } else {
      if (m_verbose) {
        cout << "[L1TBPTX] Retriving LHC Bunch Structure: UNKNOWN" << endl;
      }
      int eCount = m_ErrorMonitor->getTH1()->GetBinContent(UNKNOWN);
      eCount++;
      m_ErrorMonitor->getTH1()->SetBinContent(UNKNOWN, eCount);
    }

  } else if (conError == L1TOMDSHelper::WARNING_DB_CONN_FAILED) {
    if (m_verbose) {
      cout << "[L1TBPTX] Connection to DB: WARNING_DB_CONN_FAILED" << endl;
    }
    int eCount = m_ErrorMonitor->getTH1()->GetBinContent(WARNING_DB_CONN_FAILED);
    eCount++;
    m_ErrorMonitor->getTH1()->SetBinContent(WARNING_DB_CONN_FAILED, eCount);
  } else {
    if (m_verbose) {
      cout << "[L1TBPTX] Connection to DB: UNKNOWN" << endl;
    }
    int eCount = m_ErrorMonitor->getTH1()->GetBinContent(UNKNOWN);
    eCount++;
    m_ErrorMonitor->getTH1()->SetBinContent(UNKNOWN, eCount);
  }
}

Member Data Documentation

edm::ESGetToken<L1GtTriggerMenu, L1GtTriggerMenuRcd> L1TBPTX::l1gtMenuToken_

private

Definition at line 182 of file L1TBPTX.h.

edm::ESGetToken<L1GtPrescaleFactors, L1GtPrescaleFactorsAlgoTrigRcd> L1TBPTX::l1GtPfAlgoToken_

private

Definition at line 183 of file L1TBPTX.h.

edm::ESGetToken<L1GtPrescaleFactors, L1GtPrescaleFactorsTechTrigRcd> L1TBPTX::l1GtPfTechToken_

private

Definition at line 184 of file L1TBPTX.h.

std::map<int, TString> L1TBPTX::m_algoBit_Alias

private

Definition at line 164 of file L1TBPTX.h.

BeamConfiguration L1TBPTX::m_beamConfig

private

Definition at line 155 of file L1TBPTX.h.

unsigned int L1TBPTX::m_currentGTLS

private

Definition at line 150 of file L1TBPTX.h.

unsigned int L1TBPTX::m_currentLS

private

Definition at line 149 of file L1TBPTX.h.

bool L1TBPTX::m_currentLSValid

private

Definition at line 138 of file L1TBPTX.h.

int L1TBPTX::m_currentPrescalesIndex

private

Definition at line 148 of file L1TBPTX.h.

std::map<TString, int> L1TBPTX::m_effDenominator

private

Definition at line 143 of file L1TBPTX.h.

std::map<TString, int> L1TBPTX::m_effNumerator

private

Definition at line 142 of file L1TBPTX.h.

MonitorElement* L1TBPTX::m_ErrorMonitor

private

Definition at line 176 of file L1TBPTX.h.

edm::EDGetTokenT<L1GlobalTriggerReadoutRecord> L1TBPTX::m_l1GtDataDaqInputTag

private

Definition at line 181 of file L1TBPTX.h.

edm::EDGetTokenT<L1GlobalTriggerEvmReadoutRecord> L1TBPTX::m_l1GtEvmSource

private

Definition at line 180 of file L1TBPTX.h.

std::map<std::pair<bool, int>, double> L1TBPTX::m_l1Rate

private

Definition at line 173 of file L1TBPTX.h.

unsigned int L1TBPTX::m_lhcFill

private

Definition at line 152 of file L1TBPTX.h.

std::map<TString, MonitorElement*> L1TBPTX::m_meAlgoEfficiency

private

Definition at line 167 of file L1TBPTX.h.

std::map<TString, MonitorElement*> L1TBPTX::m_meAlgoMissFire

private

Definition at line 168 of file L1TBPTX.h.

std::map<std::pair<bool, int>, MonitorElement*> L1TBPTX::m_meRate

private

Definition at line 172 of file L1TBPTX.h.

std::map<TString, MonitorElement*> L1TBPTX::m_meTechEfficiency

private

Definition at line 169 of file L1TBPTX.h.

std::map<TString, MonitorElement*> L1TBPTX::m_meTechMissFire

private

Definition at line 170 of file L1TBPTX.h.

std::map<TString, int> L1TBPTX::m_missFireDenominator

private

Definition at line 145 of file L1TBPTX.h.

std::map<TString, int> L1TBPTX::m_missFireNumerator

private

Definition at line 144 of file L1TBPTX.h.

std::vector<edm::ParameterSet> L1TBPTX::m_monitorBits

private

Definition at line 132 of file L1TBPTX.h.

std::vector<edm::ParameterSet> L1TBPTX::m_monitorRates

private

Definition at line 133 of file L1TBPTX.h.

std::string L1TBPTX::m_outputFile

private

Definition at line 134 of file L1TBPTX.h.

edm::ParameterSet L1TBPTX::m_parameters

private

Definition at line 131 of file L1TBPTX.h.

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

private

Definition at line 160 of file L1TBPTX.h.

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

private

Definition at line 161 of file L1TBPTX.h.

bool* L1TBPTX::m_processedLS

private

Definition at line 139 of file L1TBPTX.h.

int L1TBPTX::m_refPrescaleSet

private

Definition at line 147 of file L1TBPTX.h.

edm::EDGetTokenT<Level1TriggerScalersCollection> L1TBPTX::m_scalersSource

private

Definition at line 179 of file L1TBPTX.h.

std::vector<std::pair<int, int> > L1TBPTX::m_selAlgoBit

private

Definition at line 156 of file L1TBPTX.h.

std::vector<std::pair<int, int> > L1TBPTX::m_selTechBit

private

Definition at line 157 of file L1TBPTX.h.

std::map<int, TString> L1TBPTX::m_techBit_Alias

private

Definition at line 165 of file L1TBPTX.h.

bool L1TBPTX::m_verbose

private

Definition at line 137 of file L1TBPTX.h.