#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 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 DQMEDAnalyzer
void	accumulate (edm::Event const &ev, edm::EventSetup const &es) final

virtual void	analyze (edm::Event const &, edm::EventSetup const &)

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) override

void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final

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

	DQMEDAnalyzer ()

	DQMEDAnalyzer (DQMEDAnalyzer const &)=delete

	DQMEDAnalyzer (DQMEDAnalyzer &&)=delete

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

void	endLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup) final

void	endRun (edm::Run const &run, edm::EventSetup const &setup) override

void	endRunProduce (edm::Run &run, edm::EventSetup const &setup) override

	~DQMEDAnalyzer () override=default

Public Member Functions inherited from edm::one::EDProducer< edm::Accumulator, edm::EndLuminosityBlockProducer, edm::EndRunProducer, edm::one::WatchLuminosityBlocks, edm::one::WatchRuns >
	EDProducer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInLumis () const final

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

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)

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 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 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 DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_

edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

Definition at line 47 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 51 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 75 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 TagProbeFitTreeAnalyzer_cfi::Categories, gather_cfg::cout, 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 198 of file L1TSync.cc.

198 {}

Member Function Documentation

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

overrideprotected

Definition at line 384 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(), 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 283 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 208 of file L1TSync.cc.

References patPFMETCorrections_cff::algo, DQMStore::IBooker::book1D(), 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, edm::ESHandle< T >::product(), L1GtUtils::retrieveL1EventSetup(), MonitorElement::setBinLabel(), 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 687 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 576 of file L1TSync.cc.

References a, certifyLSBlock(), gather_cfg::cout, ERROR_LSBLOCK_NOTVALID, ERROR_TRIGGERALIAS_NOTVALID, hcaldqm::quantity::fLS, dedxEstimators_cff::fraction, edm::ParameterSet::getParameter(), 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 DQMEDAnalyzer.

Definition at line 203 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 319 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 496 of file L1TSync.cc.

References gather_cfg::cout, edm::ParameterSet::getParameter(), MonitorElement::getTH1(), m_beamConfig, m_ErrorMonitor, m_lhcFill, m_parameters, BeamConfiguration::m_valid, m_verbose, BeamConfiguration::nCollidingBunches, L1TOMDSHelper::NO_ERROR, 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);
     }
 
   }
 
 }