#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 edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Public Member Functions
	L1TBPTX (const edm::ParameterSet &ps)

	~L1TBPTX () override

Public Member Functions inherited from DQMEDAnalyzer
void	beginRun (edm::Run const &, edm::EventSetup const &) final

void	beginStream (edm::StreamID id) final

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

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

	DQMEDAnalyzer (void)

void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

uint32_t	streamId () const

Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default

Public Member Functions inherited from edm::stream::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

	~EDAnalyzerBase () 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

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
	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 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
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 DQMEDAnalyzer
static std::shared_ptr< dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)

static std::shared_ptr< dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)

static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const , dqmDetails::NoCache )

static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const , dqmDetails::NoCache )

Static Public Member Functions inherited from edm::stream::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Detailed Description

Definition at line 72 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 76 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 100 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 32 of file L1TBPTX.cc.

References edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), mps_fire::i, PFRecoTauDiscriminationByIsolation_cfi::offset, and muonDTDigis_cfi::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"));
   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.

68 {}

Member Function Documentation

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

overrideprotected

Definition at line 312 of file L1TBPTX.cc.

References a, L1GtfeExtWord::beamMode(), gather_cfg::cout, edm::Event::getByToken(), Level1TriggerRates::gtAlgoCountsRate(), L1GlobalTriggerReadoutRecord::gtFdlVector(), L1GlobalTriggerEvmReadoutRecord::gtfeWord(), mps_fire::i, edm::EventBase::id(), edm::HandleBase::isValid(), L1GtfeExtWord::lhcFillNumber(), PFRecoTauDiscriminationByIsolation_cfi::offset, and edm::EventID::run().

                                                                         {
 
   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_"+bit;}
         else      {triggerName = "tech_"+bit;}
 
         int evBxStart = -2;
         int evBxEnd   =  2;
 
         if(offset<0){evBxStart+=-1*offset;}
         if(offset>0){evBxEnd  +=-1*offset;}
 
         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(lhcBxFilled && algoFired){m_effNumerator  [triggerName]++;}
 
           if(algoFired)                {m_missFireNumerator[triggerName]++;}
           if(algoFired && !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
	)

overrideprotectedvirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 203 of file L1TBPTX.cc.

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

                                                                                         {
 
   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_"+m_monitorBits[i].getParameter<int>("bitNumber");
     }else{
       triggerName = "tech_"+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
	)

overrideprotected

BeginRun.

Definition at line 73 of file L1TBPTX.cc.

References patPFMETCorrections_cff::algo, HIPAlignmentAlgorithm_cfi::algoName, DQMStore::IBooker::book1D(), gather_cfg::cout, edm::EventSetup::get(), L1GtTriggerMenu::gtAlgorithmAliasMap(), L1GtPrescaleFactors::gtPrescaleFactors(), L1GtTriggerMenu::gtTechnicalTriggerMap(), mps_fire::i, edm::ESHandleBase::isValid(), edm::ESHandle< T >::product(), MonitorElement::setAxisTitle(), MonitorElement::setBinLabel(), DQMStore::IBooker::setCurrentFolder(), and pat::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
   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_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 "+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 "+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
   ESHandle<L1GtPrescaleFactors> l1GtPfAlgo;
   ESHandle<L1GtPrescaleFactors> l1GtPfTech;
 
   iSetup.get<L1GtPrescaleFactorsAlgoTrigRcd>().get(l1GtPfAlgo);
   iSetup.get<L1GtPrescaleFactorsTechTrigRcd>().get(l1GtPfTech);
    
   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 541 of file L1TBPTX.cc.

                                                                                   {
 
 }

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

private

Definition at line 528 of file L1TBPTX.cc.

                                                    {
 
 }

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

overrideprotected

Definition at line 196 of file L1TBPTX.cc.

                                                             {
   //empty
 }

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

overrideprotectedvirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 235 of file L1TBPTX.cc.

References stringResolutionProvider_cfi::bin, gather_cfg::cout, and mps_fire::i.

                                                                                       {
   
   //______________________________________________________________________________
   // 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_"+bit;}
       else      {triggerName = "tech_"+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 457 of file L1TBPTX.cc.

References gather_cfg::cout, L1TOMDSHelper::NO_ERROR, pat::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

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

private

Definition at line 168 of file L1TBPTX.h.

BeamConfiguration L1TBPTX::m_beamConfig

private

Definition at line 159 of file L1TBPTX.h.

unsigned int L1TBPTX::m_currentGTLS

private

Definition at line 154 of file L1TBPTX.h.

unsigned int L1TBPTX::m_currentLS

private

Definition at line 153 of file L1TBPTX.h.

bool L1TBPTX::m_currentLSValid

private

Definition at line 142 of file L1TBPTX.h.

int L1TBPTX::m_currentPrescalesIndex

private

Definition at line 152 of file L1TBPTX.h.

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

private

Definition at line 147 of file L1TBPTX.h.

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

private

Definition at line 146 of file L1TBPTX.h.

MonitorElement* L1TBPTX::m_ErrorMonitor

private

Definition at line 182 of file L1TBPTX.h.

edm::EDGetTokenT<L1GlobalTriggerReadoutRecord> L1TBPTX::m_l1GtDataDaqInputTag

private

Definition at line 187 of file L1TBPTX.h.

edm::EDGetTokenT<L1GlobalTriggerEvmReadoutRecord> L1TBPTX::m_l1GtEvmSource

private

Definition at line 186 of file L1TBPTX.h.

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

private

Definition at line 179 of file L1TBPTX.h.

unsigned int L1TBPTX::m_lhcFill

private

Definition at line 156 of file L1TBPTX.h.

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

private

Definition at line 172 of file L1TBPTX.h.

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

private

Definition at line 173 of file L1TBPTX.h.

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

private

Definition at line 178 of file L1TBPTX.h.

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

private

Definition at line 174 of file L1TBPTX.h.

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

private

Definition at line 175 of file L1TBPTX.h.

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

private

Definition at line 149 of file L1TBPTX.h.

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

private

Definition at line 148 of file L1TBPTX.h.

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

private

Definition at line 136 of file L1TBPTX.h.

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

private

Definition at line 137 of file L1TBPTX.h.

std::string L1TBPTX::m_outputFile

private

Definition at line 138 of file L1TBPTX.h.

edm::ParameterSet L1TBPTX::m_parameters

private

Definition at line 135 of file L1TBPTX.h.

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

private

Definition at line 164 of file L1TBPTX.h.

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

private

Definition at line 165 of file L1TBPTX.h.

bool* L1TBPTX::m_processedLS

private

Definition at line 143 of file L1TBPTX.h.

int L1TBPTX::m_refPrescaleSet

private

Definition at line 151 of file L1TBPTX.h.

edm::EDGetTokenT<Level1TriggerScalersCollection> L1TBPTX::m_scalersSource

private

Definition at line 185 of file L1TBPTX.h.

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

private

Definition at line 160 of file L1TBPTX.h.

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

private

Definition at line 161 of file L1TBPTX.h.

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

private

Definition at line 169 of file L1TBPTX.h.

bool L1TBPTX::m_verbose

private

Definition at line 141 of file L1TBPTX.h.

Public Types

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation