#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 Member Functions
	L1TBPTX (const edm::ParameterSet &ps)

	~L1TBPTX () override

Public Member Functions inherited from one::DQMEDAnalyzer< T >
	DQMEDAnalyzer ()=default

	DQMEDAnalyzer (DQMEDAnalyzer< T... > const &)=delete

	DQMEDAnalyzer (DQMEDAnalyzer< T... > &&)=delete

	~DQMEDAnalyzer () override=default

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

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

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 33 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 69 of file L1TBPTX.cc.

69 {}

Member Function Documentation

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

overrideprotected

Definition at line 313 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_"+std::to_string(bit);}
         else      {triggerName = "tech_"+std::to_string(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
	)

overrideprotected

Definition at line 204 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_"+std::to_string(m_monitorBits[i].getParameter<int>("bitNumber"));
     }else{
       triggerName = "tech_"+std::to_string(m_monitorBits[i].getParameter<int>("bitNumber"));
     }
 
     m_effNumerator       [triggerName] = 0;
     m_effDenominator     [triggerName] = 0;
     m_missFireNumerator  [triggerName] = 0;
     m_missFireDenominator[triggerName] = 0;
 
   }
 
 }

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

overrideprotected

BeginRun.

Definition at line 74 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 "+std::to_string(bit); meTitle+=" - "; meTitle+=m_algoBit_Alias[bit]; meTitle+=" Rate";
       m_meRate[refME] = ibooker.book1D(testName,meTitle,maxNbins,-0.5,double(maxNbins)-0.5);
       m_meRate[refME]->setAxisTitle("Lumi Section"           ,1);
       m_meRate[refME]->setAxisTitle("Rate (unprescaled) [Hz]",2);
     }
     else{
       meTitle="Tech "+std::to_string(bit); meTitle+=" - "; meTitle+=m_techBit_Alias[bit]; meTitle+=" Rate";
       m_meRate[refME] = ibooker.book1D(testName,meTitle,maxNbins,-0.5,double(maxNbins)-0.5);
       m_meRate[refME]->setAxisTitle("Lumi Section" ,1);
       m_meRate[refME]->setAxisTitle("Rate (unprescaled) [Hz]",2);
     }   
   }
     
     
     
   //_____________________________________________________________________
   // Getting the prescale columns definition for this run
   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 542 of file L1TBPTX.cc.

                                                                                   {
 
 }

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

private

Definition at line 529 of file L1TBPTX.cc.

                                                    {
 
 }

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

overrideprotected

Definition at line 197 of file L1TBPTX.cc.

                                                             {
   //empty
 }

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

overrideprotected

Definition at line 236 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_"+std::to_string(bit);}
       else      {triggerName = "tech_"+std::to_string(bit);}
 
       double valEff;
       double valMiss;
       if(m_effDenominator[triggerName]!=0)     {valEff  = (double)m_effNumerator[triggerName]/m_effDenominator[triggerName];}
       else                                     {valEff  = 0;}
       if(m_missFireDenominator[triggerName]!=0){valMiss = (double)m_missFireNumerator[triggerName]/m_missFireDenominator[triggerName];}
       else                                     {valMiss = 0;}
 
       if(isAlgo){
         int bin = m_meAlgoEfficiency[bit]->getTH1()->FindBin(m_currentLS);
         m_meAlgoEfficiency[bit]->setBinContent(bin,valEff);
         m_meAlgoMissFire[bit]  ->setBinContent(bin,1-valMiss);
       }
       else{
         int bin = m_meTechEfficiency[bit]->getTH1()->FindBin(m_currentLS);
         m_meTechEfficiency[bit]->setBinContent(bin,valEff);
         m_meTechMissFire[bit]  ->setBinContent(bin,1-valMiss);
       }
     }
   }
   
   //______________________________________________________________________________
   // Monitoring rates
   //______________________________________________________________________________  
   // We are only interested in monitoring lumisections where the the LHC state is
   // RAMP, FLATTOP, SQUEEZE, ADJUST or STABLE since the bunch configuration and 
   // therefore the BPTX rate will not change.
   
   if(m_currentLSValid){
   
     const vector<int>& currentPFAlgo = (*m_prescaleFactorsAlgoTrig).at(m_currentPrescalesIndex);
     const vector<int>& currentPFTech = (*m_prescaleFactorsTechTrig).at(m_currentPrescalesIndex);
     
     for(unsigned i=0; i<m_monitorRates.size(); i++){
    
       bool isAlgo = m_monitorRates[i].getParameter<bool>  ("bitType");
       int  bit    = m_monitorRates[i].getParameter<int>   ("bitNumber");
   
       pair<bool,int> refME = pair<bool,int>(isAlgo,bit);
     
       if(isAlgo){
         int    bin      = m_meRate[refME]->getTH1()->FindBin(m_currentGTLS);
         int    trigPS   = currentPFAlgo[bit];
         double trigRate = (double) trigPS*m_l1Rate[refME];
         m_meRate[refME]->setBinContent(bin,trigRate);
       
       }else{
         int    bin      = m_meRate[refME]->getTH1()->FindBin(m_currentGTLS);
         int    trigPS   = currentPFTech[bit];
         double trigRate = (double) trigPS*m_l1Rate[refME];
         m_meRate[refME]->setBinContent(bin,trigRate);
       }
     }
   }
 }

void L1TBPTX::getBeamConfOMDS ( )

private

Definition at line 458 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

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation