#include <L1TSync.h>

Inheritance diagram for L1TSync:

Public Types
enum	BeamMode { NOMODE = 1, SETUP = 2, INJPILOT = 3, INJINTR = 4, INJNOMN = 5, PRERAMP = 6, RAMP = 7, FLATTOP = 8, QUEEZE = 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
	L1TSync (const edm::ParameterSet &ps)

	~L1TSync () override

Public Member Functions inherited from DQMOneEDAnalyzer< edm::one::WatchLuminosityBlocks >
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final

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

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () 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

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::vector< ModuleDescription const * > &modules, 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

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

void	dqmBeginRun (edm::Run const &, edm::EventSetup const &) override
	BeginRun. More...

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

Protected Member Functions inherited from DQMOneEDAnalyzer< edm::one::WatchLuminosityBlocks >
virtual void	analyze (edm::Event const &, edm::EventSetup const &)

virtual void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &)=0

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)

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

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
const std::vector< std::vector< int > > *	ListsPrescaleFactors

std::map< std::string, bool >	m_algoAutoSelect

std::map< TString, int >	m_algoBit

std::map< TString, MonitorElement * >	m_algoCertification

std::map< TString, MonitorElement * >	m_algoVsBunchStructure

BeamConfiguration	m_beamConfig

std::map< TString, unsigned int >	m_certFirstLS

std::map< TString, unsigned int >	m_certLastLS

unsigned int	m_currentLS

bool	m_currentLSValid

MonitorElement *	m_ErrorMonitor

edm::EDGetTokenT< L1GlobalTriggerReadoutRecord >	m_l1GtDataDaqInputTag

edm::EDGetTokenT< L1GlobalTriggerEvmReadoutRecord >	m_l1GtEvmSource

L1GtUtils	m_l1GtUtils

unsigned int	m_lhcFill

std::string	m_outputFile

edm::ParameterSet	m_parameters

bool *	m_processedLS

int	m_refPrescaleSet

std::map< std::string, std::string >	m_selectedTriggers

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 46 of file L1TSync.h.

Member Enumeration Documentation

enum L1TSync::BeamMode

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

Definition at line 48 of file L1TSync.h.

                 {
     NOMODE = 1,
     SETUP = 2,
     INJPILOT = 3,
     INJINTR = 4,
     INJNOMN = 5,
     PRERAMP = 6,
     RAMP = 7,
     FLATTOP = 8,
     QUEEZE = 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 L1TSync::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 72 of file L1TSync.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

L1TSync::L1TSync ( const edm::ParameterSet & ps )

Definition at line 40 of file L1TSync.cc.

References L1TSync_cfi::Categories, gather_cfg::cout, L1TSync_cfi::doGlobalAutoSelection, L1TSync_cfi::forceGlobalParameters, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), m_algoAutoSelect, m_l1GtDataDaqInputTag, m_l1GtEvmSource, m_outputFile, m_parameters, m_refPrescaleSet, m_selectedTriggers, m_verbose, muonDTDigis_cfi::pset, and AlCaHLTBitMon_QueryRunRegistry::string.

                                          : m_l1GtUtils(pset, consumesCollector(), false, *this) {
   m_parameters = pset;
 
   // Mapping parameter input variables
   m_l1GtDataDaqInputTag = consumes<L1GlobalTriggerReadoutRecord>(pset.getParameter<InputTag>("inputTagL1GtDataDaq"));
   m_l1GtEvmSource = consumes<L1GlobalTriggerEvmReadoutRecord>(pset.getParameter<InputTag>("inputTagtEvmSource"));
   m_verbose = pset.getUntrackedParameter<bool>("verbose", false);
   m_refPrescaleSet = pset.getParameter<int>("refPrescaleSet");
 
   // Getting which categories to monitor
   ParameterSet Categories = pset.getParameter<ParameterSet>("Categories");
 
   bool forceGlobalParameters = Categories.getParameter<bool>("forceGlobalParameters");
   bool doGlobalAutoSelection = Categories.getParameter<bool>("doGlobalAutoSelection");
 
   ParameterSet CatBPTX = Categories.getParameter<ParameterSet>("BPTX");
   ParameterSet CatMu = Categories.getParameter<ParameterSet>("Mu");
   ParameterSet CatEG = Categories.getParameter<ParameterSet>("EG");
   ParameterSet CatIsoEG = Categories.getParameter<ParameterSet>("IsoEG");
   ParameterSet CatJet = Categories.getParameter<ParameterSet>("Jet");
   ParameterSet CatCenJet = Categories.getParameter<ParameterSet>("CenJet");
   ParameterSet CatForJet = Categories.getParameter<ParameterSet>("ForJet");
   ParameterSet CatTauJet = Categories.getParameter<ParameterSet>("TauJet");
   ParameterSet CatETM = Categories.getParameter<ParameterSet>("ETT");
   ParameterSet CatETT = Categories.getParameter<ParameterSet>("ETM");
   ParameterSet CatHTT = Categories.getParameter<ParameterSet>("HTT");
   ParameterSet CatHTM = Categories.getParameter<ParameterSet>("HTM");
 
   // --> Setting parameters related to which algos to monitor
   // If global parameters are forced they take precedence over algo-by-algo parameters
   if (forceGlobalParameters) {
     // If global automatic selection if enable all categories set to be monitored will have
     // their algos auto selected (the lowest prescale algo will be selected)
     if (doGlobalAutoSelection) {
       if (CatMu.getParameter<bool>("monitor")) {
         m_algoAutoSelect["Mu"] = true;
       } else {
         m_algoAutoSelect["Mu"] = false;
       }
       if (CatEG.getParameter<bool>("monitor")) {
         m_algoAutoSelect["EG"] = true;
       } else {
         m_algoAutoSelect["EG"] = false;
       }
       if (CatIsoEG.getParameter<bool>("monitor")) {
         m_algoAutoSelect["IsoEG"] = true;
       } else {
         m_algoAutoSelect["IsoEG"] = false;
       }
       if (CatJet.getParameter<bool>("monitor")) {
         m_algoAutoSelect["Jet"] = true;
       } else {
         m_algoAutoSelect["Jet"] = false;
       }
       if (CatCenJet.getParameter<bool>("monitor")) {
         m_algoAutoSelect["CenJet"] = true;
       } else {
         m_algoAutoSelect["CenJet"] = false;
       }
       if (CatForJet.getParameter<bool>("monitor")) {
         m_algoAutoSelect["ForJet"] = true;
       } else {
         m_algoAutoSelect["ForJet"] = false;
       }
       if (CatTauJet.getParameter<bool>("monitor")) {
         m_algoAutoSelect["TauJet"] = true;
       } else {
         m_algoAutoSelect["TauJet"] = false;
       }
       if (CatETM.getParameter<bool>("monitor")) {
         m_algoAutoSelect["ETM"] = true;
       } else {
         m_algoAutoSelect["ETM"] = false;
       }
       if (CatETT.getParameter<bool>("monitor")) {
         m_algoAutoSelect["ETT"] = true;
       } else {
         m_algoAutoSelect["ETT"] = false;
       }
       if (CatHTM.getParameter<bool>("monitor")) {
         m_algoAutoSelect["HTM"] = true;
       } else {
         m_algoAutoSelect["HTM"] = false;
       }
       if (CatHTT.getParameter<bool>("monitor")) {
         m_algoAutoSelect["HTT"] = true;
       } else {
         m_algoAutoSelect["HTT"] = false;
       }
 
       // If global non-automatic selection is enable all categories set to be monitored will use
       // user defined algos
     } else {
       m_algoAutoSelect["Mu"] = false;
       m_algoAutoSelect["EG"] = false;
       m_algoAutoSelect["IsoEG"] = false;
       m_algoAutoSelect["Jet"] = false;
       m_algoAutoSelect["CenJet"] = false;
       m_algoAutoSelect["ForJet"] = false;
       m_algoAutoSelect["TauJet"] = false;
       m_algoAutoSelect["ETM"] = false;
       m_algoAutoSelect["ETT"] = false;
       m_algoAutoSelect["HTM"] = false;
       m_algoAutoSelect["HTT"] = false;
 
       if (CatMu.getParameter<bool>("monitor")) {
         m_selectedTriggers["Mu"] = CatMu.getParameter<string>("algo");
       }
       if (CatEG.getParameter<bool>("monitor")) {
         m_selectedTriggers["EG"] = CatEG.getParameter<string>("algo");
       }
       if (CatIsoEG.getParameter<bool>("monitor")) {
         m_selectedTriggers["IsoEG"] = CatIsoEG.getParameter<string>("algo");
       }
       if (CatJet.getParameter<bool>("monitor")) {
         m_selectedTriggers["Jet"] = CatJet.getParameter<string>("algo");
       }
       if (CatCenJet.getParameter<bool>("monitor")) {
         m_selectedTriggers["CenJet"] = CatCenJet.getParameter<string>("algo");
       }
       if (CatForJet.getParameter<bool>("monitor")) {
         m_selectedTriggers["CatForJet"] = CatForJet.getParameter<string>("algo");
       }
       if (CatTauJet.getParameter<bool>("monitor")) {
         m_selectedTriggers["TauJet"] = CatTauJet.getParameter<string>("algo");
       }
       if (CatETM.getParameter<bool>("monitor")) {
         m_selectedTriggers["ETM"] = CatETM.getParameter<string>("algo");
       }
       if (CatETT.getParameter<bool>("monitor")) {
         m_selectedTriggers["ETT"] = CatETT.getParameter<string>("algo");
       }
       if (CatHTM.getParameter<bool>("monitor")) {
         m_selectedTriggers["HTM"] = CatHTM.getParameter<string>("algo");
       }
       if (CatHTT.getParameter<bool>("monitor")) {
         m_selectedTriggers["HTT"] = CatHTT.getParameter<string>("algo");
       }
     }
 
     // If we are using algo-by-algo parametes we get them and set what is needed
   } else {
     if (CatBPTX.getParameter<bool>("monitor")) {
       m_selectedTriggers["BPTX"] = CatBPTX.getParameter<string>("algo");
     }
 
     if (CatMu.getParameter<bool>("monitor")) {
       m_algoAutoSelect["Mu"] = CatMu.getParameter<bool>("doAutoSelection");
       if (!m_algoAutoSelect["Mu"]) {
         m_selectedTriggers["Mu"] = CatMu.getParameter<string>("algo");
       }
     } else {
       m_algoAutoSelect["Mu"] = false;
     }
 
     if (CatEG.getParameter<bool>("monitor")) {
       m_algoAutoSelect["EG"] = CatEG.getParameter<bool>("doAutoSelection");
       if (!m_algoAutoSelect["EG"]) {
         m_selectedTriggers["EG"] = CatEG.getParameter<string>("algo");
       }
     } else {
       m_algoAutoSelect["EG"] = false;
     }
 
     if (CatIsoEG.getParameter<bool>("monitor")) {
       m_algoAutoSelect["IsoEG"] = CatIsoEG.getParameter<bool>("doAutoSelection");
       if (!m_algoAutoSelect["IsoEG"]) {
         m_selectedTriggers["IsoEG"] = CatIsoEG.getParameter<string>("algo");
       }
     } else {
       m_algoAutoSelect["IsoEG"] = false;
     }
 
     if (CatJet.getParameter<bool>("monitor")) {
       m_algoAutoSelect["Jet"] = CatJet.getParameter<bool>("doAutoSelection");
       if (!m_algoAutoSelect["Jet"]) {
         m_selectedTriggers["Jet"] = CatJet.getParameter<string>("algo");
       }
     } else {
       m_algoAutoSelect["Jet"] = false;
     }
 
     if (CatCenJet.getParameter<bool>("monitor")) {
       m_algoAutoSelect["CenJet"] = CatCenJet.getParameter<bool>("doAutoSelection");
       if (!m_algoAutoSelect["CenJet"]) {
         m_selectedTriggers["CenJet"] = CatCenJet.getParameter<string>("algo");
       }
     } else {
       m_algoAutoSelect["CenJet"] = false;
     }
 
     if (CatForJet.getParameter<bool>("monitor")) {
       m_algoAutoSelect["CatForJet"] = CatForJet.getParameter<bool>("doAutoSelection");
       if (!m_algoAutoSelect["CatForJet"]) {
         m_selectedTriggers["CatForJet"] = CatForJet.getParameter<string>("algo");
       }
     } else {
       m_algoAutoSelect["CatForJet"] = false;
     }
 
     if (CatTauJet.getParameter<bool>("monitor")) {
       m_algoAutoSelect["TauJet"] = CatTauJet.getParameter<bool>("doAutoSelection");
       if (!m_algoAutoSelect["TauJet"]) {
         m_selectedTriggers["TauJet"] = CatTauJet.getParameter<string>("algo");
       }
     } else {
       m_algoAutoSelect["TauJet"] = false;
     }
 
     if (CatETM.getParameter<bool>("monitor")) {
       m_algoAutoSelect["ETM"] = CatETM.getParameter<bool>("doAutoSelection");
       if (!m_algoAutoSelect["ETM"]) {
         m_selectedTriggers["ETM"] = CatETM.getParameter<string>("algo");
       }
     } else {
       m_algoAutoSelect["ETM"] = false;
     }
 
     if (CatETT.getParameter<bool>("monitor")) {
       m_algoAutoSelect["ETT"] = CatETT.getParameter<bool>("doAutoSelection");
       if (!m_algoAutoSelect["ETT"]) {
         m_selectedTriggers["ETT"] = CatETT.getParameter<string>("algo");
       }
     } else {
       m_algoAutoSelect["ETT"] = false;
     }
 
     if (CatHTM.getParameter<bool>("monitor")) {
       m_algoAutoSelect["HTM"] = CatHTM.getParameter<bool>("doAutoSelection");
       if (!m_algoAutoSelect["HTM"]) {
         m_selectedTriggers["HTM"] = CatHTM.getParameter<string>("algo");
       }
     } else {
       m_algoAutoSelect["HTM"] = false;
     }
 
     if (CatHTT.getParameter<bool>("monitor")) {
       m_algoAutoSelect["HTT"] = CatHTT.getParameter<bool>("doAutoSelection");
       if (!m_algoAutoSelect["HTT"]) {
         m_selectedTriggers["HTT"] = CatHTT.getParameter<string>("algo");
       }
     } else {
       m_algoAutoSelect["HTT"] = false;
     }
   }
 
   m_outputFile = pset.getUntrackedParameter<std::string>("outputFile", "");
 
   if (!m_outputFile.empty()) {
     std::cout << "L1T Monitoring histograms will be saved to " << m_outputFile.c_str() << std::endl;
   }
 
   bool disable = pset.getUntrackedParameter<bool>("disableROOToutput", false);
   if (disable) {
     m_outputFile = "";
   }
 }

L1TSync::~L1TSync ( )

override

Definition at line 300 of file L1TSync.cc.

300 {}

Member Function Documentation

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

overrideprotected

Definition at line 482 of file L1TSync.cc.

References a, funct::abs(), BeamConfiguration::beam1, BeamConfiguration::beam2, L1GtfeExtWord::beamMode(), BeamConfiguration::bxConfig(), gather_cfg::cout, ERROR_UNABLE_RETRIVE_PRODUCT, getBeamConfOMDS(), edm::Event::getByToken(), dqm::impl::MonitorElement::getTH1(), L1GlobalTriggerReadoutRecord::gtFdlVector(), L1GlobalTriggerEvmReadoutRecord::gtfeWord(), mps_fire::i, BeamConfiguration::isValid(), edm::HandleBase::isValid(), L1GtfeExtWord::lhcFillNumber(), m_algoBit, m_algoVsBunchStructure, m_beamConfig, m_currentLS, m_currentLSValid, m_ErrorMonitor, m_l1GtDataDaqInputTag, m_l1GtEvmSource, m_lhcFill, m_selectedTriggers, m_verbose, and STABLE.

                                                                        {
   if (m_verbose) {
     cout << "[L1TSync] Called analyze." << endl;
   }
 
   // We only start analyzing if current LS is still valid
   if (m_currentLSValid) {
     if (m_verbose) {
       cout << "[L1TSync] -> 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_lhcFill == 0) {
         m_lhcFill = gtfeEvmWord.lhcFillNumber();  // Getting LHC Fill Number from GT
         getBeamConfOMDS();                        // Getting Beam Configuration from OMDS
       }
 
       if (lhcBeamMode != STABLE) {
         m_currentLSValid = false;
       }  // If Beams are not stable we invalidate this LS
 
     } else {
       int eCount = m_ErrorMonitor->getTH1()->GetBinContent(ERROR_UNABLE_RETRIVE_PRODUCT);
       eCount++;
       m_ErrorMonitor->getTH1()->SetBinContent(ERROR_UNABLE_RETRIVE_PRODUCT, eCount);
     }
   } else {
     if (m_verbose) {
       cout << "[L1TSync] -> m_currentLSValid=" << m_currentLSValid << endl;
     }
   }
 
   //------------------------------------------------------------------------------
   // If current LS is valid and Beam Configuration is Valid we analyse this event
   //------------------------------------------------------------------------------
   if (m_currentLSValid && m_beamConfig.isValid()) {
     // 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();
 
       // Running over selected triggers
       for (map<string, string>::const_iterator i = m_selectedTriggers.begin(); i != m_selectedTriggers.end(); i++) {
         string tTrigger = (*i).second;
 
         // Analyse only defined triggers
         if (tTrigger != "Undefined" && tTrigger != "Undefined (Wrong Name)") {
           bool beamSingleConfig = false;  // Single beam configured for this event
           bool firedAlgo = false;         // Algo fired in this event
           int eventBx = -1;
 
           // Running over FDL results to get which bits fired
           for (unsigned int a = 0; a < gtFdlVectorData.size(); a++) {
             // Selecting the FDL that triggered
             if (gtFdlVectorData[a].bxInEvent() == 0) {
               eventBx = gtFdlVectorData[a].localBxNr();
               if (gtFdlVectorData[a].gtDecisionWord()[m_algoBit[tTrigger]]) {
                 firedAlgo = true;
               }
             }
           }
 
           // Checking beam configuration
           if (m_beamConfig.beam1[eventBx] && !m_beamConfig.beam2[eventBx]) {
             beamSingleConfig = true;
           }
           if (!m_beamConfig.beam1[eventBx] && m_beamConfig.beam2[eventBx]) {
             beamSingleConfig = true;
           }
 
           // Analyse only if this trigger fired in this event
           // NOTE: Veto cases where a single beam is configured since
           //       for this cases this could be a real-satelite bunch collision
           // -> Calculate the minimum bx diference between this event and a configured bx
           if (firedAlgo && !beamSingleConfig) {
             int DifAlgoVsBunchStructure = 9999;  // Majorated
 
             for (unsigned int a = 0; a < gtFdlVectorData.size(); a++) {
               int bxFDL = gtFdlVectorData[a].localBxNr();
               int bxInEvent = gtFdlVectorData[a].bxInEvent();
 
               if (m_beamConfig.bxConfig(bxFDL) && abs(bxInEvent) < abs(DifAlgoVsBunchStructure)) {
                 DifAlgoVsBunchStructure = -1 * bxInEvent;
               }
             }
 
             m_algoVsBunchStructure[tTrigger]->Fill(m_currentLS, DifAlgoVsBunchStructure);
           }
         }
       }
     } else {
       int eCount = m_ErrorMonitor->getTH1()->GetBinContent(ERROR_UNABLE_RETRIVE_PRODUCT);
       eCount++;
       m_ErrorMonitor->getTH1()->SetBinContent(ERROR_UNABLE_RETRIVE_PRODUCT, eCount);
     }
   }
 }

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

overrideprotected

Definition at line 385 of file L1TSync.cc.

References gather_cfg::cout, doFractionInSync(), mps_fire::i, edm::LuminosityBlockBase::id(), edm::LuminosityBlockID::luminosityBlock(), m_certFirstLS, m_currentLS, m_currentLSValid, m_selectedTriggers, and m_verbose.

                                                                                         {
   if (m_verbose) {
     cout << "[L1TSync] Called beginLuminosityBlock." << endl;
   }
 
   // If this LS is not the next to last one force closing of current LS blocks
   // for certification
   if (m_currentLS != 0 && m_currentLS + 1 != lumiBlock.id().luminosityBlock()) {
     if (m_verbose) {
       cout << "[L1TSync] None consecutive: doFractionInSync() - LAST=" << m_currentLS
            << " CURRENT=" << lumiBlock.id().luminosityBlock() << endl;
     }
     doFractionInSync(true, false);
   }
 
   // Updating current LS number
   m_currentLS = lumiBlock.id().luminosityBlock();
 
   // If this is the fist valid LS update first LS for certification
   for (map<string, string>::const_iterator i = m_selectedTriggers.begin(); i != m_selectedTriggers.end(); i++) {
     string theTriggerAlias = (*i).second;
     if (m_certFirstLS[theTriggerAlias] == 0) {
       m_certFirstLS[theTriggerAlias] = m_currentLS;
     }
   }
 
   // A LS will be valid if:
   //   * BeamMode == STABLE for all events monitored
   m_currentLSValid = true;
 }

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

overrideprotected

Definition at line 311 of file L1TSync.cc.

References ecalcalib_dqm_sourceclient-live_cfg::algo, dqm::dqmstoreimpl::DQMStore::IBooker::book1D(), dqm::dqmstoreimpl::DQMStore::IBooker::book2D(), ERROR_LSBLOCK_NOTVALID, ERROR_TRIGGERALIAS_NOTVALID, ERROR_UNABLE_RETRIVE_PRODUCT, edm::EventSetup::get(), L1TMenuHelper::getLUSOTrigger(), L1GtTriggerMenu::gtAlgorithmAliasMap(), mps_fire::i, m_algoAutoSelect, m_algoBit, m_algoCertification, m_algoVsBunchStructure, m_certFirstLS, m_certLastLS, m_currentLS, m_ErrorMonitor, m_l1GtUtils, m_lhcFill, m_refPrescaleSet, m_selectedTriggers, optionsL1T::menu, edm::ESHandle< T >::product(), L1GtUtils::retrieveL1EventSetup(), dqm::impl::MonitorElement::setBinLabel(), dqm::dqmstoreimpl::DQMStore::IBooker::setCurrentFolder(), L1TMenuHelper::testAlgos(), UNKNOWN, WARNING_DB_CONN_FAILED, WARNING_DB_INCORRECT_NBUNCHES, and WARNING_DB_QUERY_FAILED.

                                                                                                  {
   // Initializing variables
   int maxNbins = 2501;
 
   // Reseting run dependent variables
   m_lhcFill = 0;
   m_currentLS = 0;
   m_certFirstLS.clear();
   m_certLastLS.clear();
 
   // Getting Trigger menu from GT
   ESHandle<L1GtTriggerMenu> menuRcd;
   iSetup.get<L1GtTriggerMenuRcd>().get(menuRcd);
   const L1GtTriggerMenu* menu = menuRcd.product();
 
   // Filling Alias-Bit Map
   for (CItAlgo algo = menu->gtAlgorithmAliasMap().begin(); algo != menu->gtAlgorithmAliasMap().end(); ++algo) {
     m_algoBit[(algo->second).algoAlias()] = (algo->second).algoBitNumber();
   }
 
   // Getting fill number for this run
   //Handle<ConditionsInRunBlock> runConditions;
   //iRun.getByType(runConditions);
   //int lhcFillNumber = runConditions->lhcFillNumber;
 
   //ESHandle<L1GtPrescaleFactors> l1GtPfAlgo;
   //iSetup.get<L1GtPrescaleFactorsAlgoTrigRcd>().get(l1GtPfAlgo);
   //const L1GtPrescaleFactors* m_l1GtPfAlgo = l1GtPfAlgo.product();
 
   L1TMenuHelper myMenuHelper = L1TMenuHelper(iSetup);
 
   m_selectedTriggers = myMenuHelper.testAlgos(m_selectedTriggers);
 
   m_l1GtUtils.retrieveL1EventSetup(iSetup);
   map<string, string> tAutoSelTrig = myMenuHelper.getLUSOTrigger(m_algoAutoSelect, m_refPrescaleSet, m_l1GtUtils);
   m_selectedTriggers.insert(tAutoSelTrig.begin(), tAutoSelTrig.end());
 
   // Initializing DQM Monitor Elements
   ibooker.setCurrentFolder("L1T/L1TSync");
   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");
 
   // Looping over selected triggers
   for (map<string, string>::const_iterator i = m_selectedTriggers.begin(); i != m_selectedTriggers.end(); i++) {
     string tCategory = (*i).first;
     string tTrigger = (*i).second;
 
     // Initializing LS blocks for certification
     m_certFirstLS[(*i).second] = 0;
     m_certLastLS[(*i).second] = 0;
 
     // Initializing DQM Monitors
     ibooker.setCurrentFolder("L1T/L1TSync/AlgoVsBunchStructure/");
     m_algoVsBunchStructure[tTrigger] = ibooker.book2D(
         tCategory, "min #Delta(" + tTrigger + ",Bunch)", maxNbins, -0.5, double(maxNbins) - 0.5, 5, -2.5, 2.5);
     m_algoVsBunchStructure[tTrigger]->setAxisTitle("Lumi Section", 1);
 
     ibooker.setCurrentFolder("L1T/L1TSync/Certification/");
     m_algoCertification[tTrigger] =
         ibooker.book1D(tCategory, "fraction of in sync: " + tTrigger, maxNbins, -0.5, double(maxNbins) - 0.5);
     m_algoCertification[tTrigger]->setAxisTitle("Lumi Section", 1);
   }
 }

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

private

Definition at line 778 of file L1TSync.cc.

References eostools::ls(), and m_algoCertification.

Referenced by doFractionInSync().

                                                                                    {
   // Finding correct bins in the histogram for this block
   int binInit = m_algoCertification[iTrigger]->getTH1()->FindBin(iInitLs);
   int binEnd = m_algoCertification[iTrigger]->getTH1()->FindBin(iEndLs);
 
   for (int ls = binInit; ls <= binEnd; ls++) {
     m_algoCertification[iTrigger]->setBinContent(ls, iValue);
   }
 }

void L1TSync::doFractionInSync	(	bool	iForce = `false`,
		bool	iBad = `false`
	)

private

Definition at line 675 of file L1TSync.cc.

References a, certifyLSBlock(), gather_cfg::cout, ERROR_LSBLOCK_NOTVALID, ERROR_TRIGGERALIAS_NOTVALID, hcaldqm::quantity::fLS, HLT_2018_cff::fraction, edm::ParameterSet::getParameter(), dqm::impl::MonitorElement::getTH1(), mps_fire::i, eostools::ls(), m_algoVsBunchStructure, m_certFirstLS, m_certLastLS, m_ErrorMonitor, m_parameters, m_selectedTriggers, and m_verbose.

Referenced by beginLuminosityBlock(), and endLuminosityBlock().

                                                      {
   for (map<string, string>::const_iterator i = m_selectedTriggers.begin(); i != m_selectedTriggers.end(); i++) {
     string theCategory = (*i).first;
     string theTriggerAlias = (*i).second;
 
     // Caching frequently used values from maps
     unsigned int fLS = m_certFirstLS[theTriggerAlias];
     unsigned int lLS = m_certLastLS[theTriggerAlias];
 
     // Checking validity of the trigger alias and of the LS block
     bool triggerAlias_isValid = theTriggerAlias != "Undefined" && theTriggerAlias != "Undefined (Wrong Name)";
     bool lsBlock_exists = !(fLS == 0 && lLS == 0);
     bool lsBlock_isValid = fLS <= lLS && fLS > 0 && lLS > 0;
 
     if (triggerAlias_isValid && lsBlock_exists && lsBlock_isValid) {
       // If we are forced to close blocks and mark them bad
       if (iForce && iBad) {
         certifyLSBlock(theTriggerAlias, fLS, lLS, -1);
         m_certFirstLS[theTriggerAlias] = 0;
         m_certLastLS[theTriggerAlias] = 0;
       }
 
       // If we are not forced to mark bad, we check if we have enough statistics
       else {
         // Getting events with 0 bx difference between BPTX and Algo for current LS
         double CountSync = 0;
         double CountAll = 0;
 
         // Adding all entries for current LS block
         for (unsigned int ls = fLS; ls <= lLS; ls++) {
           CountSync += m_algoVsBunchStructure[theTriggerAlias]->getBinContent(ls + 1, 3);
           for (int a = 1; a < 6; a++) {
             CountAll += m_algoVsBunchStructure[theTriggerAlias]->getBinContent(ls + 1, a);
           }
         }
 
         if (m_verbose) {
           cout << "Alias = " << theTriggerAlias << " InitLS=" << fLS << " EndLS=" << lLS << " Events=" << CountAll;
         }
 
         if (iForce || CountAll >= m_parameters.getParameter<ParameterSet>("Categories")
                                       .getParameter<ParameterSet>(theCategory)
                                       .getParameter<int>("CertMinEvents")) {
           if (m_verbose) {
             cout << " <--------------- Enough Statistics: ";
           }
 
           // Calculating fraction of in time
           double fraction = 0;
           if (CountAll > 0) {
             fraction = CountSync / CountAll;
           }
 
           // This is to avoid having an entry equal to zero and thus
           // disregarded by the automatic tests
           if (fraction == 0) {
             fraction = 0.000001;
           }
 
           certifyLSBlock(theTriggerAlias, fLS, lLS, fraction);
           m_certFirstLS[theTriggerAlias] = 0;
           m_certLastLS[theTriggerAlias] = 0;
         }
 
         if (m_verbose) {
           cout << endl;
         }
       }
     }
 
     // A problem was found. We report it and set a not physical vale (-1) to the certification plot
     else {
       // If trigger alias is not valid report it to m_ErrorMonitor
       if (!triggerAlias_isValid) {
         int eCount = m_ErrorMonitor->getTH1()->GetBinContent(ERROR_TRIGGERALIAS_NOTVALID);
         eCount++;
         m_ErrorMonitor->getTH1()->SetBinContent(ERROR_TRIGGERALIAS_NOTVALID, eCount);
         certifyLSBlock(theTriggerAlias, fLS, lLS, -1);
         m_certFirstLS[theTriggerAlias] = 0;
         m_certLastLS[theTriggerAlias] = 0;
       }
 
       // If LS Block is not valid report it to m_ErrorMonitor
       if (lsBlock_exists && !lsBlock_isValid) {
         int eCount = m_ErrorMonitor->getTH1()->GetBinContent(ERROR_LSBLOCK_NOTVALID);
         eCount++;
         m_ErrorMonitor->getTH1()->SetBinContent(ERROR_LSBLOCK_NOTVALID, eCount);
         certifyLSBlock(theTriggerAlias, fLS, lLS, -1);
         m_certFirstLS[theTriggerAlias] = 0;
         m_certLastLS[theTriggerAlias] = 0;
       }
     }
   }
 }

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

overrideprotectedvirtual

BeginRun.

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

Definition at line 304 of file L1TSync.cc.

References gather_cfg::cout, and m_verbose.

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

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

overrideprotected

Definition at line 420 of file L1TSync.cc.

References gather_cfg::cout, doFractionInSync(), mps_fire::i, BeamConfiguration::isValid(), m_beamConfig, m_certFirstLS, m_certLastLS, m_currentLS, m_currentLSValid, m_selectedTriggers, and m_verbose.

                                                                                       {
   if (m_verbose) {
     cout << "[L1TSync] Called endLuminosityBlock." << endl;
   }
 
   if (m_verbose) {
     cout << "[L1TSync] m_currentLSValid      : " << m_currentLSValid << endl;
     cout << "[L1TSync] m_beamConfig.isValid(): " << m_beamConfig.isValid() << endl;
   }
 
   for (map<string, string>::const_iterator i = m_selectedTriggers.begin(); i != m_selectedTriggers.end(); i++) {
     // Update last LS for certification
     string theTriggerAlias = (*i).second;
     m_certLastLS[theTriggerAlias] = m_currentLS;
   }
 
   // If this LS is valid (i.e. all events recorded with stable beams)
   if (m_currentLSValid && m_beamConfig.isValid()) {
     if (m_verbose) {
       cout << "[L1TSync] Regular call: doFractionInSync()" << endl;
     }
     doFractionInSync(false, false);
 
   }
   // If this LS is not valid it can be in the following context:
   //  * We still hadn't stable beam (no need to certify nothing
   //  * Beam just got unstable or dumped (we may have a complete block of data do certify)
   else {
     //-> First we close all blocks from certFirstLS[] to m_currentLS-1
     for (map<string, string>::const_iterator i = m_selectedTriggers.begin(); i != m_selectedTriggers.end(); i++) {
       string theTriggerAlias = (*i).second;
 
       int fLs = m_certFirstLS[theTriggerAlias];
       int lLS = m_certLastLS[theTriggerAlias];
 
       // If this is a single LS block we do nothing (in this step)
       if (fLs == lLS) {
         m_certFirstLS[theTriggerAlias] = 0;
         m_certLastLS[theTriggerAlias] = 0;
       }
       // If block is multi LS then we remove the current LS
       else {
         m_certLastLS[theTriggerAlias] = m_currentLS - 1;
       }
     }
     doFractionInSync(true, false);
 
     //-> Second we mark this single LS bad for all triggers
     for (map<string, string>::const_iterator i = m_selectedTriggers.begin(); i != m_selectedTriggers.end(); i++) {
       string theTriggerAlias = (*i).second;
       m_certFirstLS[theTriggerAlias] = m_currentLS;
       m_certLastLS[theTriggerAlias] = m_currentLS;
     }
     doFractionInSync(true, true);
 
     if (m_verbose) {
       cout << "[L1TSync] Error call: doFractionInSync()" << endl;
     }
   }
 }

void L1TSync::getBeamConfOMDS ( )

private

Definition at line 595 of file L1TSync.cc.

References gather_cfg::cout, edm::ParameterSet::getParameter(), dqm::impl::MonitorElement::getTH1(), m_beamConfig, m_ErrorMonitor, m_lhcFill, m_parameters, BeamConfiguration::m_valid, m_verbose, BeamConfiguration::nCollidingBunches, L1TOMDSHelper::NO_ERROR, L1TBPTX_cfi::oracleDB, L1TBPTX_cfi::pathCondDB, UNKNOWN, L1TOMDSHelper::WARNING_DB_CONN_FAILED, WARNING_DB_CONN_FAILED, WARNING_DB_INCORRECT_NBUNCHES, L1TOMDSHelper::WARNING_DB_QUERY_FAILED, and WARNING_DB_QUERY_FAILED.

Referenced by analyze().

                               {
   //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 << "[L1TSync] 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 << "[L1TSync] 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_CONN_FAILED) {
       if (m_verbose) {
         cout << "[L1TSync] Retriving LHC Bunch Structure: WARNING_DB_CONN_FAILED" << endl;
       }
 
       int eCount = m_ErrorMonitor->getTH1()->GetBinContent(WARNING_DB_INCORRECT_NBUNCHES);
       eCount++;
       m_ErrorMonitor->getTH1()->SetBinContent(WARNING_DB_INCORRECT_NBUNCHES, eCount);
     } else if (errorRetrive == L1TOMDSHelper::WARNING_DB_QUERY_FAILED) {
       if (m_verbose) {
         cout << "[L1TSync] 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 (m_verbose) {
         cout << "[L1TSync] 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 << "[L1TSync] Connect 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 << "[L1TSync] Connect to DB: UNKNOWN" << endl;
       }
 
       int eCount = m_ErrorMonitor->getTH1()->GetBinContent(UNKNOWN);
       eCount++;
       m_ErrorMonitor->getTH1()->SetBinContent(UNKNOWN, eCount);
     }
   }
 }