#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 DQMOneEDAnalyzer< edm::LuminosityBlockCache< ltso::LSValid > >
typedef dqm::reco::DQMStore	DQMStore

typedef dqm::reco::MonitorElement	MonitorElement

Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
template<typename T >
using	BranchAliasSetterT = ProductRegistryHelper::BranchAliasSetterT< T >

using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex > >

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

	~L1TSync_Offline () override

Public Member Functions inherited from DQMOneEDAnalyzer< edm::LuminosityBlockCache< ltso::LSValid > >
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) override

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

	DQMOneEDAnalyzer ()

void	endRun (edm::Run const &, edm::EventSetup const &) final

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

virtual bool	getCanSaveByLumi ()

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

	EDProducer (const EDProducer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

bool	wantsGlobalLuminosityBlocks () const noexcept final

bool	wantsGlobalRuns () const noexcept final

bool	wantsInputProcessBlocks () const noexcept final

bool	wantsProcessBlocks () const noexcept final

Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const noexcept

bool	wantsStreamRuns () const noexcept

	~EDProducerBase () override

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

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

std::vector< bool > const &	recordProvenanceList () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~ProducerBase () noexcept(false) override

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESResolverIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESResolverIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

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

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

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

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, 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

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Protected Member Functions
void	analyze (const edm::Event &e, const edm::EventSetup &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

std::shared_ptr< ltso::LSValid >	globalBeginLuminosityBlock (edm::LuminosityBlock const &lumiBlock, edm::EventSetup const &c) const final

void	globalEndLuminosityBlock (edm::LuminosityBlock const &lumiBlock, edm::EventSetup const &c) final

Protected Member Functions inherited from DQMOneEDAnalyzer< edm::LuminosityBlockCache< ltso::LSValid > >
virtual void	dqmEndRun (edm::Run const &, edm::EventSetup const &)

Protected Member Functions inherited from edm::ProducerBase
template<Transition Tr = Transition::Event>
auto	produces (std::string instanceName) noexcept
	declare what type of product will make and with which optional label More...

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

template<Transition Tr = Transition::Event>
auto	produces () noexcept

ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

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)

void	resetItemsToGetFrom (BranchType iType)

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

MonitorElement *	m_ErrorMonitor

L1TMenuHelper::Tokens	m_helperTokens

edm::EDGetTokenT< L1GlobalTriggerReadoutRecord >	m_l1GtDataDaqInputTag

edm::EDGetTokenT< L1GlobalTriggerEvmReadoutRecord >	m_l1GtEvmSource

L1GtUtils	m_l1GtUtils

unsigned int	m_lhcFill

const edm::ESGetToken< L1GtTriggerMenu, L1GtTriggerMenuRcd >	m_menuToken

edm::ParameterSet	m_parameters

int	m_refPrescaleSet

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

bool	m_verbose

Additional Inherited Members
Static Public Member Functions inherited from edm::one::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Attributes inherited from DQMOneEDAnalyzer< edm::LuminosityBlockCache< ltso::LSValid > >
edm::EDPutTokenT< DQMToken >	runToken_

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 66 of file L1TSync_Offline.h.

Member Enumeration Documentation

◆ BeamMode

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 68 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
   };

◆ Errors

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

Definition at line 60 of file L1TSync_Offline.cc.

References L1TSync_cfi::Categories, L1TSync_cfi::doGlobalAutoSelection, L1TSync_cfi::forceGlobalParameters, m_algoAutoSelect, m_l1GtDataDaqInputTag, m_l1GtEvmSource, m_parameters, m_refPrescaleSet, m_selectedTriggers, m_verbose, and muonDTDigis_cfi::pset.

     : m_menuToken(esConsumes<edm::Transition::BeginRun>()),
       m_helperTokens(L1TMenuHelper::consumes<edm::Transition::BeginRun>(consumesCollector())),
       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;
     }
   }
 }

◆ ~L1TSync_Offline()

L1TSync_Offline::~L1TSync_Offline ( )

override

Definition at line 312 of file L1TSync_Offline.cc.

312 {}

Member Function Documentation

◆ analyze()

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

overrideprotectedvirtual

Reimplemented from DQMOneEDAnalyzer< edm::LuminosityBlockCache< ltso::LSValid > >.

Definition at line 405 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(), dqm::impl::MonitorElement::getTH1(), L1GlobalTriggerReadoutRecord::gtFdlVector(), L1GlobalTriggerEvmReadoutRecord::gtfeWord(), mps_fire::i, iEvent, L1TBeamConfiguration::isValid(), edm::HandleBase::isValid(), L1GtfeExtWord::lhcFillNumber(), m_algoBit, m_algoVsBunchStructure, m_beamConfig, 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
   auto& currentLSValid = luminosityBlockCache(iEvent.getLuminosityBlock().index())->lsIsValid;
   if (currentLSValid) {
     if (m_verbose) {
       cout << "[L1TSync_Offline] -> currentLSValid=" << 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) {
         currentLSValid = false;
         if (m_verbose) {
           cout << "[L1TSync_Offline] -> currentLSValid=" << 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] -> currentLSValid=" << 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 (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(0 /*m_currentLS*/, DifAlgoVsBunchStructure);
           }
         }
       }
     } else {
       int eCount = m_ErrorMonitor->getTH1()->GetBinContent(ERROR_UNABLE_RETRIVE_PRODUCT);
       eCount++;
       m_ErrorMonitor->getTH1()->SetBinContent(ERROR_UNABLE_RETRIVE_PRODUCT, eCount);
     }
   }
 }

◆ bookHistograms()

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

overrideprotectedvirtual

BeginRun.

Implements DQMOneEDAnalyzer< edm::LuminosityBlockCache< ltso::LSValid > >.

Definition at line 320 of file L1TSync_Offline.cc.

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), gather_cfg::cout, ERROR_LSBLOCK_NOTVALID, ERROR_TRIGGERALIAS_NOTVALID, ERROR_UNABLE_RETRIVE_PRODUCT, edm::EventSetup::getData(), L1TMenuHelper::getLUSOTrigger(), mps_fire::i, m_algoAutoSelect, m_algoBit, m_algoCertification, m_algoVsBunchStructure, m_certFirstLS, m_certLastLS, m_ErrorMonitor, m_helperTokens, m_l1GtUtils, m_lhcFill, m_menuToken, m_refPrescaleSet, m_selectedTriggers, m_verbose, relval_steps::menu, L1GtUtils::retrieveL1EventSetup(), dqm::impl::MonitorElement::setBinLabel(), dqm::implementation::NavigatorBase::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_certFirstLS.clear();
   m_certLastLS.clear();
 
   // Getting Trigger menu from GT
   const L1GtTriggerMenu& menu = iSetup.getData(m_menuToken);
 
   // Filling Alias-Bit Map
   for (const auto& algo : menu.gtAlgorithmAliasMap()) {
     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_helperTokens);
 
   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);
   }
 }

◆ dqmBeginRun()

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

overrideprotectedvirtual

Reimplemented from DQMOneEDAnalyzer< edm::LuminosityBlockCache< ltso::LSValid > >.

Definition at line 316 of file L1TSync_Offline.cc.

316 {}

◆ getBeamConfOffline()

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

private

Definition at line 537 of file L1TSync_Offline.cc.

References a, L1TBeamConfiguration::beam1, L1TBeamConfiguration::beam2, L1GlobalTriggerReadoutRecord::gtFdlVector(), iEvent, 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
 }

◆ globalBeginLuminosityBlock()

std::shared_ptr< ltso::LSValid > L1TSync_Offline::globalBeginLuminosityBlock	(	edm::LuminosityBlock const &	lumiBlock,
		edm::EventSetup const &	c
	)		const

finalprotected

Definition at line 395 of file L1TSync_Offline.cc.

References gather_cfg::cout, and m_verbose.

                                                                                                       {
   if (m_verbose) {
     cout << "[L1TSync_Offline] Called beginLuminosityBlock." << endl;
   }
 
   return std::make_shared<ltso::LSValid>();
 }