#include <L1TSync_Offline.h>

Inheritance diagram for L1TSync_Offline:

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::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
	L1TSync_Offline (const edm::ParameterSet &ps)

virtual	~L1TSync_Offline ()

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

virtual void	beginStream (edm::StreamID id) final

	DQMEDAnalyzer (void)

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

virtual 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

virtual	~EDAnalyzerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Protected Member Functions
void	analyze (const edm::Event &e, const edm::EventSetup &c)

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

virtual void	bookHistograms (DQMStore::IBooker &ibooker, const edm::Run &, const edm::EventSetup &) override
	BeginRun. More...

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

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	getBeamConfOffline (const edm::Event &)

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

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

Description: offline DQM module for L1Trigger/bunchStructure synchronization

Implementation: <TODO: enter implementation details>

Author: : Pietro Vischia - LIP Lisbon pietr.nosp@m.o.vi.nosp@m.schia.nosp@m.@gma.nosp@m.il.co.nosp@m.m

Changelog: 2012/08/10 11:01:01: First creation. Dummy module with actual code commented.

Todo:

implement the module in offline
check if there are user includes specific for offline/online that should be changed

Definition at line 63 of file L1TSync_Offline.h.

Member Enumeration Documentation

enum L1TSync_Offline::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 67 of file L1TSync_Offline.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_Offline::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 91 of file L1TSync_Offline.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_Offline::L1TSync_Offline ( const edm::ParameterSet & ps )

Definition at line 61 of file L1TSync_Offline.cc.

References 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, 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.size() != 0) {
     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_Offline::~L1TSync_Offline ( )

virtual

Definition at line 217 of file L1TSync_Offline.cc.

217 {}

Member Function Documentation

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

protectedvirtual

Implements edm::stream::EDAnalyzerBase.

Definition at line 312 of file L1TSync_Offline.cc.

References a, funct::abs(), L1TBeamConfiguration::beam1, L1TBeamConfiguration::beam2, L1GtfeExtWord::beamMode(), L1TBeamConfiguration::bxConfig(), gather_cfg::cout, ERROR_UNABLE_RETRIVE_PRODUCT, getBeamConfOffline(), edm::Event::getByToken(), MonitorElement::getTH1(), i, L1TBeamConfiguration::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_Offline] Called analyze." << endl;}
 
   // We only start analyzing if current LS is still valid
   if(m_currentLSValid){
   
     if(m_verbose){cout << "[L1TSync_Offline] -> 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
 
     //I AM HERE
     getBeamConfOffline(iEvent);                       // Getting Beam Configuration from OMDS
     // no OMDS //
     /* (Savannah ticket https://savannah.cern.ch/task/?31857 )
       Purged the OMDS helper from the module, since apparently we don't have access to that information from Offline.
       The comparison with the closest BPTX trigger will be performed via conditions objects which are being implemented by Joao Pela.
       In the meantime, for being able to test the module, he suggested to pass the correct bunch structure by hand for the specific run which is run during the test.
       The idea of the temporary fix is setting the vector variable that stores the bunch structure either by hand or filling it with the BPTX fires (that is check for the event the BX's where tech0 fired and set those as true in the vector.
     */
     // no OMDS //    m_beamConfig = myOMDSHelper.getBeamConfiguration(m_lhcFill,errorRetrieve); Yuhuuu!!!OB asked Joao Pela how to fetch that
 
 
     
     
       }
 
       if(lhcBeamMode != STABLE){m_currentLSValid = false;
     if(m_verbose){cout << "[L1TSync_Offline] -> m_currentLSValid=" << m_currentLSValid << "because beams mode not stable, being " << lhcBeamMode << endl;}
       } // 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_Offline] -> m_currentLSValid=" << m_currentLSValid << endl;}
   }
 
   // Commenting out un-necessary  print outs (S.Dutta)
   /*  for(size_t l=0; l<m_beamConfig.beam1.size(); l++){
     cout << "Beam 1: element " << l << " is in state " << m_beamConfig.beam1[l] << " --- Beam 2: element " << l << " is in state " << m_beamConfig.beam2[l] << 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
           unsigned int  eventBx = ~0;      
 
           // 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.size() > eventBx && m_beamConfig.beam2.size() > eventBx) {
         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_Offline::beginLuminosityBlock	(	edm::LuminosityBlock const &	lumiBlock,
		edm::EventSetup const &	c
	)

protectedvirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 303 of file L1TSync_Offline.cc.

References gather_cfg::cout, m_currentLSValid, and m_verbose.

                                                                                                  {
  
    if (m_verbose){cout << "[L1TSync_Offline] Called beginLuminosityBlock." << endl;}
  
    m_currentLSValid = true; 
  
  }

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

overrideprotectedvirtual

BeginRun.

Implements DQMEDAnalyzer.

Definition at line 227 of file L1TSync_Offline.cc.

References ecalcalib_dqm_sourceclient-live_cfg::algo, DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), gather_cfg::cout, ERROR_LSBLOCK_NOTVALID, ERROR_TRIGGERALIAS_NOTVALID, ERROR_UNABLE_RETRIVE_PRODUCT, edm::EventSetup::get(), L1TMenuHelper::getLUSOTrigger(), L1GtTriggerMenu::gtAlgorithmAliasMap(), 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, m_verbose, relval_steps::menu, edm::ESHandle< class >::product(), L1GtUtils::retrieveL1EventSetup(), MonitorElement::setBinLabel(), DQMStore::IBooker::setCurrentFolder(), L1TMenuHelper::testAlgos(), UNKNOWN, WARNING_DB_CONN_FAILED, WARNING_DB_INCORRECT_NBUNCHES, and WARNING_DB_QUERY_FAILED.

                                                                                                              {
 
   if (m_verbose){cout << "[L1TSync_Offline] Called beginRun." << endl;}
 
   // 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_Offline::dqmBeginRun	(	const edm::Run &	,
		const edm::EventSetup &
	)

protectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 221 of file L1TSync_Offline.cc.

                                                                     {
 
 }

void L1TSync_Offline::getBeamConfOffline ( const edm::Event & iEvent )

private

Definition at line 445 of file L1TSync_Offline.cc.

References a, L1TBeamConfiguration::beam1, L1TBeamConfiguration::beam2, edm::Event::getByToken(), edm::HandleBase::isValid(), m_algoBit, m_beamConfig, m_l1GtDataDaqInputTag, m_selectedTriggers, and L1TBeamConfiguration::m_valid.

Referenced by analyze().

                                                            {
 
   //Getting connection parameters
   //  [11:21:35] Pietro Vischia: pathCondDB and oracleDB are available in offline?
   //  [11:21:51] Joao Pela: no
   //  [11:21:56] Pietro Vischia: cool
   //  [11:21:58] Pietro Vischia: tks
   //  [11:22:00] Joao Pela: well
   //  [11:22:02] Joao Pela: maybe
   //  [11:22:05] Joao Pela: but assume no
   //  [11:22:22] Joao Pela: definitely assume no
   // *** UPDATE: now we have a DB for Rate parameters, it would be useful to have s.th also for L1TSync
 
   // string oracleDB   = m_parameters.getParameter<string>("oracleDB");
   // string pathCondDB = m_parameters.getParameter<string>("pathCondDB");
   
   //  m_beamConfig = myOMDSHelper.getBeamConfiguration(m_lhcFill,errorRetrieve);
   //  m_lhcFill -> lhcFillNumber
   //  errorRetrieve -> error
   // m_beamConfig -> bConfig
   
 
   // No error codes at the moment. Taking info from BPTX fires
   //  int errorRetrieve = 0; // NO_ERROR;
   m_beamConfig.m_valid = true;
 
 
 
   //  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 BPTX (temporary fix Savannah ticket https://savannah.cern.ch/task/?31857 )
   // 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();
     
     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[ m_selectedTriggers["BPTX"] ] ]){firedAlgo = true;}
       }
       
       // Fill beam status with BPTX fires
       if(firedAlgo){
     m_beamConfig.beam1.push_back(true);
     m_beamConfig.beam2.push_back(true);
       }
       else {
     m_beamConfig.beam1.push_back(false);
     m_beamConfig.beam2.push_back(false);
       }
       // End fill beam status with BPTX fires
     } // End loop on FDL
   } // End if readout is valid  
   
 }