#include <HLTEventAnalyzerRAW.h>

Inheritance diagram for HLTEventAnalyzerRAW:

Public Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

virtual void	analyzeTrigger (const edm::Event &, const edm::EventSetup &, const std::string &triggerName)

void	beginRun (edm::Run const &, edm::EventSetup const &) override

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

	HLTEventAnalyzerRAW (const edm::ParameterSet &)

template<>
void	showObject (LOG &log, trigger::VRl1hfrings::value_type const &ref) const

	~HLTEventAnalyzerRAW () override=default

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

	EDAnalyzer ()=default

	EDAnalyzer (const EDAnalyzer &)=delete

const EDAnalyzer &	operator= (const EDAnalyzer &)=delete

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

	EDAnalyzerBase ()

	EDAnalyzerBase (const EDAnalyzerBase &)=delete

ModuleDescription const &	moduleDescription () const

const EDAnalyzerBase &	operator= (const EDAnalyzerBase &)=delete

	~EDAnalyzerBase () override

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

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

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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

std::vector< ESProxyIndex > 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

bool	registeredToConsumeMany (TypeID const &, 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::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Types
using	LOG = edm::LogVerbatim

Private Member Functions
template<class TREF >
void	showObject (LOG &log, TREF const &ref) const

template<class TVID , class TVREF >
void	showObjects (TVID const &vids, TVREF const &vrefs, std::string const &name) const

Private Attributes
trigger::Vids	basemetIds_

trigger::VRbasemet	basemetRefs_

trigger::Vids	calometIds_

trigger::VRcalomet	calometRefs_

trigger::Vids	compositeIds_

trigger::VRcomposite	compositeRefs_

trigger::Vids	electronIds_

trigger::VRelectron	electronRefs_

HLTConfigProvider	hltConfig_

trigger::Vids	jetIds_

trigger::VRjet	jetRefs_

trigger::Vids	l1emIds_

trigger::VRl1em	l1emRefs_

trigger::Vids	l1etmissIds_

trigger::VRl1etmiss	l1etmissRefs_

trigger::Vids	l1hfringsIds_

trigger::VRl1hfrings	l1hfringsRefs_

trigger::Vids	l1jetIds_

trigger::VRl1jet	l1jetRefs_

trigger::Vids	l1muonIds_

trigger::VRl1muon	l1muonRefs_

trigger::Vids	l1tegammaIds_

trigger::VRl1tegamma	l1tegammaRefs_

trigger::Vids	l1tetsumIds_

trigger::VRl1tetsum	l1tetsumRefs_

trigger::Vids	l1thpspftauIds_

trigger::VRl1thpspftau	l1thpspftauRefs_

trigger::Vids	l1tjetIds_

trigger::VRl1tjet	l1tjetRefs_

trigger::Vids	l1tmuonIds_

trigger::VRl1tmuon	l1tmuonRefs_

trigger::Vids	l1tmuonShowerIds_

trigger::VRl1tmuonShower	l1tmuonShowerRefs_

trigger::Vids	l1tpfjetIds_

trigger::VRl1tpfjet	l1tpfjetRefs_

trigger::Vids	l1tpftauIds_

trigger::VRl1tpftau	l1tpftauRefs_

trigger::Vids	l1tpftrackIds_

trigger::VRl1tpftrack	l1tpftrackRefs_

trigger::Vids	l1ttauIds_

trigger::VRl1ttau	l1ttauRefs_

trigger::Vids	l1ttkeleIds_

trigger::VRl1ttkele	l1ttkeleRefs_

trigger::Vids	l1ttkemIds_

trigger::VRl1ttkem	l1ttkemRefs_

trigger::Vids	l1ttkmuIds_
	Phase 2. More...

trigger::VRl1ttkmuon	l1ttkmuRefs_

trigger::Vids	muonIds_

trigger::VRmuon	muonRefs_

bool const	permissive_

trigger::Vids	pfjetIds_

trigger::VRpfjet	pfjetRefs_

trigger::Vids	pfmetIds_

trigger::VRpfmet	pfmetRefs_

trigger::Vids	pftauIds_

trigger::VRpftau	pftauRefs_

trigger::Vids	photonIds_
	payload extracted from TriggerEventWithRefs More...

trigger::VRphoton	photonRefs_

trigger::Vids	pixtrackIds_

trigger::VRpixtrack	pixtrackRefs_

const std::string	processName_
	module config parameters More...

edm::Handle< trigger::TriggerEventWithRefs >	triggerEventWithRefsHandle_

const edm::InputTag	triggerEventWithRefsTag_

const edm::EDGetTokenT< trigger::TriggerEventWithRefs >	triggerEventWithRefsToken_

const std::string	triggerName_

edm::Handle< edm::TriggerResults >	triggerResultsHandle_

const edm::InputTag	triggerResultsTag_

const edm::EDGetTokenT< edm::TriggerResults >	triggerResultsToken_

bool const	verbose_
	additional class data members More...

Static Private Attributes
static constexpr const char *	logMsgType_ = "HLTEventAnalyzerRAW"

Additional Inherited Members
Public Types inherited from edm::stream::EDAnalyzer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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 ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

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)

Detailed Description

This class is an EDAnalyzer analyzing the combined HLT information for RAW

Author: Martin Grunewald

See header file for documentation

Author: Martin Grunewald

Definition at line 29 of file HLTEventAnalyzerRAW.h.

Member Typedef Documentation

◆ LOG

using HLTEventAnalyzerRAW::LOG = edm::LogVerbatim

private

Definition at line 43 of file HLTEventAnalyzerRAW.h.

Constructor & Destructor Documentation

◆ HLTEventAnalyzerRAW()

HLTEventAnalyzerRAW::HLTEventAnalyzerRAW ( const edm::ParameterSet & ps )

explicit

Definition at line 54 of file HLTEventAnalyzerRAW.cc.

References edm::InputTag::encode(), logMsgType_, processName_, triggerEventWithRefsTag_, triggerName_, and triggerResultsTag_.

     : processName_(ps.getParameter<std::string>("processName")),
       triggerName_(ps.getParameter<std::string>("triggerName")),
       triggerResultsTag_(ps.getParameter<edm::InputTag>("triggerResults")),
       triggerResultsToken_(consumes<edm::TriggerResults>(triggerResultsTag_)),
       triggerEventWithRefsTag_(ps.getParameter<edm::InputTag>("triggerEventWithRefs")),
       triggerEventWithRefsToken_(consumes<trigger::TriggerEventWithRefs>(triggerEventWithRefsTag_)),
       verbose_(ps.getParameter<bool>("verbose")),
       permissive_(ps.getParameter<bool>("permissive")) {
   LOG(logMsgType_) << logMsgType_ << " configuration:\n"
                    << "   ProcessName = " << processName_ << "\n"
                    << "   TriggerName = " << triggerName_ << "\n"
                    << "   TriggerResultsTag = " << triggerResultsTag_.encode() << "\n"
                    << "   TriggerEventWithRefsTag = " << triggerEventWithRefsTag_.encode();
 }

◆ ~HLTEventAnalyzerRAW()

HLTEventAnalyzerRAW::~HLTEventAnalyzerRAW ( )

overridedefault

Member Function Documentation

◆ analyze()

void HLTEventAnalyzerRAW::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overridevirtual

Implements edm::stream::EDAnalyzerBase.

Definition at line 117 of file HLTEventAnalyzerRAW.cc.

References analyzeTrigger(), cms::cuda::assert(), hltConfig_, mps_fire::i, iEvent, edm::HandleBase::isValid(), logMsgType_, dqmiodumpmetadata::n, edm::HLTGlobalStatus::size(), HLTConfigProvider::size(), triggerEventWithRefsHandle_, triggerEventWithRefsToken_, HLTConfigProvider::triggerName(), triggerName_, triggerResultsHandle_, and triggerResultsToken_.

                                                                                      {
   // get event products
   triggerResultsHandle_ = iEvent.getHandle(triggerResultsToken_);
   if (not triggerResultsHandle_.isValid()) {
     LOG(logMsgType_) << logMsgType_ << "::analyze: Error in getting TriggerResults product from Event!";
     return;
   }
   triggerEventWithRefsHandle_ = iEvent.getHandle(triggerEventWithRefsToken_);
   if (not triggerEventWithRefsHandle_.isValid()) {
     LOG(logMsgType_) << logMsgType_ << "::analyze: Error in getting TriggerEventWithRefs product from Event!";
     return;
   }
 
   // sanity check
   assert(triggerResultsHandle_->size() == hltConfig_.size());
 
   // analyze this event for the triggers requested
   if (triggerName_ == "@") {
     const unsigned int n(hltConfig_.size());
     for (unsigned int i = 0; i != n; ++i) {
       analyzeTrigger(iEvent, iSetup, hltConfig_.triggerName(i));
     }
   } else {
     analyzeTrigger(iEvent, iSetup, triggerName_);
   }
 
   return;
 }

◆ analyzeTrigger()

void HLTEventAnalyzerRAW::analyzeTrigger	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		const std::string &	triggerName
	)

virtual

Phase 2

Definition at line 146 of file HLTEventAnalyzerRAW.cc.

References edm::HLTGlobalStatus::accept(), cms::cuda::assert(), basemetIds_, basemetRefs_, calometIds_, calometRefs_, compositeIds_, compositeRefs_, electronIds_, electronRefs_, edm::HLTGlobalStatus::error(), trigger::TriggerEventWithRefs::filterIndex(), trigger::TriggerEventWithRefs::getObjects(), hltConfig_, iEvent, edm::HLTGlobalStatus::index(), dqmiolumiharvest::j, jetIds_, jetRefs_, l1emIds_, l1emRefs_, l1etmissIds_, l1etmissRefs_, l1hfringsIds_, l1hfringsRefs_, l1jetIds_, l1jetRefs_, l1muonIds_, l1muonRefs_, l1tegammaIds_, l1tegammaRefs_, l1tetsumIds_, l1tetsumRefs_, l1thpspftauIds_, l1thpspftauRefs_, l1tjetIds_, l1tjetRefs_, l1tmuonIds_, l1tmuonRefs_, l1tmuonShowerIds_, l1tmuonShowerRefs_, l1tpfjetIds_, l1tpfjetRefs_, l1tpftauIds_, l1tpftauRefs_, l1tpftrackIds_, l1tpftrackRefs_, l1ttauIds_, l1ttauRefs_, l1ttkeleIds_, l1ttkeleRefs_, l1ttkemIds_, l1ttkemRefs_, l1ttkmuIds_, l1ttkmuRefs_, logMsgType_, visualization-live-secondInstance_cfg::m, HerwigMaxPtPartonFilter_cfi::moduleLabel, HLTConfigProvider::moduleLabels(), HLTConfigProvider::moduleType(), muonIds_, muonRefs_, dqmiodumpmetadata::n, pfjetIds_, pfjetRefs_, pfmetIds_, pfmetRefs_, pftauIds_, pftauRefs_, photonIds_, photonRefs_, pixtrackIds_, pixtrackRefs_, processName_, showObjects(), HLTConfigProvider::size(), findQualityFiles::size, AlCaHLTBitMon_QueryRunRegistry::string, triggerEventWithRefsHandle_, HLTConfigProvider::triggerIndex(), PDWG_DiPhoton_SD_cff::triggerName, triggerResultsHandle_, and edm::HLTGlobalStatus::wasrun().

Referenced by analyze().

                                                                        {
   const unsigned int n(hltConfig_.size());
   const unsigned int triggerIndex(hltConfig_.triggerIndex(triggerName));
   assert(triggerIndex == iEvent.triggerNames(*triggerResultsHandle_).triggerIndex(triggerName));
 
   // abort on invalid trigger name
   if (triggerIndex >= n) {
     LOG(logMsgType_) << logMsgType_ << "::analyzeTrigger: path " << triggerName << " - not found!";
     return;
   }
 
   LOG(logMsgType_) << logMsgType_ << "::analyzeTrigger: path " << triggerName << " [" << triggerIndex << "]";
 
   // results from TriggerResults product
   LOG(logMsgType_) << " Trigger path status:"
                    << " WasRun=" << triggerResultsHandle_->wasrun(triggerIndex)
                    << " Accept=" << triggerResultsHandle_->accept(triggerIndex)
                    << " Error=" << triggerResultsHandle_->error(triggerIndex);
 
   // modules on this trigger path
   const unsigned int m(hltConfig_.size(triggerIndex));
   const std::vector<std::string>& moduleLabels(hltConfig_.moduleLabels(triggerIndex));
   assert(m == moduleLabels.size());
 
   // skip empty Path
   if (m == 0) {
     LOG(logMsgType_) << logMsgType_ << "::analyzeTrigger: path " << triggerName << " [" << triggerIndex
                      << "] is empty!";
     return;
   }
 
   // index of last module executed in this Path
   const unsigned int moduleIndex(triggerResultsHandle_->index(triggerIndex));
   assert(moduleIndex < m);
 
   LOG(logMsgType_) << " Last active module - label/type: " << moduleLabels[moduleIndex] << "/"
                    << hltConfig_.moduleType(moduleLabels[moduleIndex]) << " [" << moduleIndex << " out of 0-" << (m - 1)
                    << " on this path]";
 
   // results from TriggerEventWithRefs product
   photonIds_.clear();
   photonRefs_.clear();
   electronIds_.clear();
   electronRefs_.clear();
   muonIds_.clear();
   muonRefs_.clear();
   jetIds_.clear();
   jetRefs_.clear();
   compositeIds_.clear();
   compositeRefs_.clear();
   basemetIds_.clear();
   basemetRefs_.clear();
   calometIds_.clear();
   calometRefs_.clear();
   pixtrackIds_.clear();
   pixtrackRefs_.clear();
 
   l1emIds_.clear();
   l1emRefs_.clear();
   l1muonIds_.clear();
   l1muonRefs_.clear();
   l1jetIds_.clear();
   l1jetRefs_.clear();
   l1etmissIds_.clear();
   l1etmissRefs_.clear();
   l1hfringsIds_.clear();
   l1hfringsRefs_.clear();
 
   l1tmuonIds_.clear();
   l1tmuonRefs_.clear();
   l1tmuonShowerIds_.clear();
   l1tmuonShowerRefs_.clear();
   l1tegammaIds_.clear();
   l1tegammaRefs_.clear();
   l1tjetIds_.clear();
   l1tjetRefs_.clear();
   l1ttauIds_.clear();
   l1ttauRefs_.clear();
   l1tetsumIds_.clear();
   l1tetsumRefs_.clear();
 
   l1ttkmuIds_.clear();
   l1ttkmuRefs_.clear();
   l1ttkeleIds_.clear();
   l1ttkeleRefs_.clear();
   l1ttkemIds_.clear();
   l1ttkemRefs_.clear();
   l1tpfjetIds_.clear();
   l1tpfjetRefs_.clear();
   l1tpftauIds_.clear();
   l1tpftauRefs_.clear();
   l1thpspftauIds_.clear();
   l1thpspftauRefs_.clear();
   l1tpftrackIds_.clear();
   l1tpftrackRefs_.clear();
 
   pfjetIds_.clear();
   pfjetRefs_.clear();
   pftauIds_.clear();
   pftauRefs_.clear();
   pfmetIds_.clear();
   pfmetRefs_.clear();
 
   // Attention: must look only for modules actually run in this path for this event!
   for (unsigned int j = 0; j <= moduleIndex; ++j) {
     const std::string& moduleLabel(moduleLabels[j]);
     const std::string moduleType(hltConfig_.moduleType(moduleLabel));
     // check whether the module is packed up in TriggerEventWithRefs product
     const unsigned int filterIndex(
         triggerEventWithRefsHandle_->filterIndex(edm::InputTag(moduleLabel, "", processName_)));
     if (filterIndex < triggerEventWithRefsHandle_->size()) {
       LOG(logMsgType_) << " Filter in slot " << j << " - label/type " << moduleLabel << "/" << moduleType;
       LOG(logMsgType_) << " Filter packed up at: " << filterIndex;
       LOG(logMsgType_) << "  Accepted objects:";
 
       // Photons
       triggerEventWithRefsHandle_->getObjects(filterIndex, photonIds_, photonRefs_);
       showObjects(photonIds_, photonRefs_, "Photons");
 
       // Electrons
       triggerEventWithRefsHandle_->getObjects(filterIndex, electronIds_, electronRefs_);
       showObjects(electronIds_, electronRefs_, "Electrons");
 
       // Muons
       triggerEventWithRefsHandle_->getObjects(filterIndex, muonIds_, muonRefs_);
       showObjects(muonIds_, muonRefs_, "Muons");
 
       // Jets
       triggerEventWithRefsHandle_->getObjects(filterIndex, jetIds_, jetRefs_);
       showObjects(jetIds_, jetRefs_, "Jets");
 
       // Composites
       triggerEventWithRefsHandle_->getObjects(filterIndex, compositeIds_, compositeRefs_);
       showObjects(compositeIds_, compositeRefs_, "Composites");
 
       // BaseMETs
       triggerEventWithRefsHandle_->getObjects(filterIndex, basemetIds_, basemetRefs_);
       showObjects(basemetIds_, basemetRefs_, "BaseMETs");
 
       // CaloMETs
       triggerEventWithRefsHandle_->getObjects(filterIndex, calometIds_, calometRefs_);
       showObjects(calometIds_, calometRefs_, "CaloMETs");
 
       // PixTracks
       triggerEventWithRefsHandle_->getObjects(filterIndex, pixtrackIds_, pixtrackRefs_);
       showObjects(pixtrackIds_, pixtrackRefs_, "PixTracks");
 
       // L1EMs
       triggerEventWithRefsHandle_->getObjects(filterIndex, l1emIds_, l1emRefs_);
       showObjects(l1emIds_, l1emRefs_, "L1EMs");
 
       // L1Muons
       triggerEventWithRefsHandle_->getObjects(filterIndex, l1muonIds_, l1muonRefs_);
       showObjects(l1muonIds_, l1muonRefs_, "L1Muons");
 
       // L1Jets
       triggerEventWithRefsHandle_->getObjects(filterIndex, l1jetIds_, l1jetRefs_);
       showObjects(l1jetIds_, l1jetRefs_, "L1Jets");
 
       // L1EtMiss
       triggerEventWithRefsHandle_->getObjects(filterIndex, l1etmissIds_, l1etmissRefs_);
       showObjects(l1etmissIds_, l1etmissRefs_, "L1EtMiss");
 
       // L1HFRings
       triggerEventWithRefsHandle_->getObjects(filterIndex, l1hfringsIds_, l1hfringsRefs_);
       showObjects(l1hfringsIds_, l1hfringsRefs_, "L1HFRings");
 
       // L1TMuons
       triggerEventWithRefsHandle_->getObjects(filterIndex, l1tmuonIds_, l1tmuonRefs_);
       showObjects(l1tmuonIds_, l1tmuonRefs_, "L1TMuons");
 
       // L1TMuonShowers
       triggerEventWithRefsHandle_->getObjects(filterIndex, l1tmuonShowerIds_, l1tmuonShowerRefs_);
       showObjects(l1tmuonShowerIds_, l1tmuonShowerRefs_, "L1TMuonShowers");
 
       // L1TEGammas
       triggerEventWithRefsHandle_->getObjects(filterIndex, l1tegammaIds_, l1tegammaRefs_);
       showObjects(l1tegammaIds_, l1tegammaRefs_, "L1TEGammas");
 
       // L1TJets
       triggerEventWithRefsHandle_->getObjects(filterIndex, l1tjetIds_, l1tjetRefs_);
       showObjects(l1tjetIds_, l1tjetRefs_, "L1TJets");
 
       // L1TTaus
       triggerEventWithRefsHandle_->getObjects(filterIndex, l1ttauIds_, l1ttauRefs_);
       showObjects(l1ttauIds_, l1ttauRefs_, "L1TTaus");
 
       // L1TEtSums
       triggerEventWithRefsHandle_->getObjects(filterIndex, l1tetsumIds_, l1tetsumRefs_);
       showObjects(l1tetsumIds_, l1tetsumRefs_, "L1TEtSum");
 
 
       // L1TTkMuons
       triggerEventWithRefsHandle_->getObjects(filterIndex, l1ttkmuIds_, l1ttkmuRefs_);
       showObjects(l1ttkmuIds_, l1ttkmuRefs_, "L1TTkMuons");
 
       // L1TTkElectrons
       triggerEventWithRefsHandle_->getObjects(filterIndex, l1ttkeleIds_, l1ttkeleRefs_);
       showObjects(l1ttkeleIds_, l1ttkeleRefs_, "L1TTkElectrons");
 
       // L1TTkEMs
       triggerEventWithRefsHandle_->getObjects(filterIndex, l1ttkemIds_, l1ttkemRefs_);
       showObjects(l1ttkemIds_, l1ttkemRefs_, "L1TTkEMs");
 
       // L1TPFJets
       triggerEventWithRefsHandle_->getObjects(filterIndex, l1tpfjetIds_, l1tpfjetRefs_);
       showObjects(l1tpfjetIds_, l1tpfjetRefs_, "L1TPFJets");
 
       // L1TPFTaus
       triggerEventWithRefsHandle_->getObjects(filterIndex, l1tpftauIds_, l1tpftauRefs_);
       showObjects(l1tpftauIds_, l1tpftauRefs_, "L1TPFTaus");
 
       // L1THPSPFTaus
       triggerEventWithRefsHandle_->getObjects(filterIndex, l1thpspftauIds_, l1thpspftauRefs_);
       showObjects(l1thpspftauIds_, l1thpspftauRefs_, "L1THPSPFTaus");
 
       // L1TPFTracks
       triggerEventWithRefsHandle_->getObjects(filterIndex, l1tpftrackIds_, l1tpftrackRefs_);
       showObjects(l1tpftrackIds_, l1tpftrackRefs_, "L1TPFTracks");
 
       // PFJets
       triggerEventWithRefsHandle_->getObjects(filterIndex, pfjetIds_, pfjetRefs_);
       showObjects(pfjetIds_, pfjetRefs_, "PFJets");
 
       // PFTaus
       triggerEventWithRefsHandle_->getObjects(filterIndex, pftauIds_, pftauRefs_);
       showObjects(pftauIds_, pftauRefs_, "PFTaus");
 
       // PFMETs
       triggerEventWithRefsHandle_->getObjects(filterIndex, pfmetIds_, pfmetRefs_);
       showObjects(pfmetIds_, pfmetRefs_, "PFMETs");
     }
   }
 
   return;
 }

◆ beginRun()

void HLTEventAnalyzerRAW::beginRun	(	edm::Run const &	iRun,
		edm::EventSetup const &	iSetup
	)

overridevirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 86 of file HLTEventAnalyzerRAW.cc.

References HLTConfigProvider::dump(), hltConfig_, HLTConfigProvider::init(), logMsgType_, dqmiodumpmetadata::n, processName_, HLTConfigProvider::size(), HLTConfigProvider::triggerIndex(), triggerName_, and verbose_.

                                                                                   {
   bool changed(true);
   if (hltConfig_.init(iRun, iSetup, processName_, changed)) {
     if (changed) {
       // check if trigger name in (new) config
       if (triggerName_ != "@") {  // "@" means: analyze all triggers in config
         const unsigned int n(hltConfig_.size());
         const unsigned int triggerIndex(hltConfig_.triggerIndex(triggerName_));
         if (triggerIndex >= n) {
           LOG(logMsgType_) << logMsgType_ << "::beginRun: TriggerName " << triggerName_
                            << " not available in (new) config!";
           LOG(logMsgType_) << "Available TriggerNames are: ";
           hltConfig_.dump("Triggers");
         }
       }
       // in verbose mode, print process info to stdout
       if (verbose_) {
         hltConfig_.dump("ProcessName");
         hltConfig_.dump("GlobalTag");
         hltConfig_.dump("TableName");
         hltConfig_.dump("Streams");
         hltConfig_.dump("Datasets");
         hltConfig_.dump("PrescaleTable");
         hltConfig_.dump("ProcessPSet");
       }
     }
   } else {
     LOG(logMsgType_) << logMsgType_ << "::beginRun: config extraction failure with process name " << processName_;
   }
 }

◆ endRun()

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

inlineoverridevirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 36 of file HLTEventAnalyzerRAW.h.

36 {}

◆ fillDescriptions()

void HLTEventAnalyzerRAW::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 73 of file HLTEventAnalyzerRAW.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, HLT_2022v15_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                      {
   edm::ParameterSetDescription desc;
   desc.add<std::string>("processName", "HLT");
   desc.add<std::string>("triggerName", "@")
       ->setComment("name of trigger Path to consider (use \"@\" to consider all Paths)");
   desc.add<edm::InputTag>("triggerResults", edm::InputTag("TriggerResults", "", "HLT"));
   desc.add<edm::InputTag>("triggerEventWithRefs", edm::InputTag("hltTriggerSummaryRAW", "", "HLT"));
   desc.add<bool>("verbose", false)->setComment("enable verbose mode");
   desc.add<bool>("permissive", false)
       ->setComment("if true, exceptions due to Refs pointing to unavailable collections are bypassed");
   descriptions.add("hltEventAnalyzerRAW", desc);
 }

◆ showObject() [1/2]

template<class TREF >

void HLTEventAnalyzerRAW::showObject	(	LOG &	log,
		TREF const &	ref
	)		const

private

Definition at line 159 of file HLTEventAnalyzerRAW.h.

References dqm-mbProfile::log.

Referenced by showObjects().

                                                                     {
   log << "pt=" << ref->pt() << " eta=" << ref->eta() << " phi=" << ref->phi() << " mass=" << ref->mass();
 }

◆ showObject() [2/2]

void HLTEventAnalyzerRAW::showObject	(	LOG &	log,
		trigger::VRl1hfrings::value_type const &	ref
	)		const

Definition at line 387 of file HLTEventAnalyzerRAW.cc.

References l1extra::L1HFRings::kRing1NegEta, l1extra::L1HFRings::kRing1PosEta, l1extra::L1HFRings::kRing2NegEta, l1extra::L1HFRings::kRing2PosEta, and dqm-mbProfile::log.

                                                                                             {
   log << "hfEtSum(ring1PosEta)=" << ref->hfEtSum(l1extra::L1HFRings::kRing1PosEta)
       << " hfEtSum(ring1NegEta)=" << ref->hfEtSum(l1extra::L1HFRings::kRing1NegEta)
       << " hfEtSum(ring2PosEta)=" << ref->hfEtSum(l1extra::L1HFRings::kRing2PosEta)
       << " hfEtSum(ring2NegEta)=" << ref->hfEtSum(l1extra::L1HFRings::kRing2NegEta)
       << " hfBitCount(ring1PosEta)=" << ref->hfBitCount(l1extra::L1HFRings::kRing1PosEta)
       << " hfBitCount(ring1NegEta)=" << ref->hfBitCount(l1extra::L1HFRings::kRing1NegEta)
       << " hfBitCount(ring2PosEta)=" << ref->hfBitCount(l1extra::L1HFRings::kRing2PosEta)
       << " hfBitCount(ring2NegEta)=" << ref->hfBitCount(l1extra::L1HFRings::kRing2NegEta);
 }

◆ showObjects()

template<class TVID , class TVREF >

void HLTEventAnalyzerRAW::showObjects	(	TVID const &	vids,
		TVREF const &	vrefs,
		std::string const &	name
	)		const

private

Definition at line 137 of file HLTEventAnalyzerRAW.h.

References cms::cuda::assert(), heavyIonCSV_trainingSettings::idx, dqm-mbProfile::log, logMsgType_, Skims_PA_cff::name, permissive_, showObject(), and findQualityFiles::size.

Referenced by analyzeTrigger().

                                                                                                        {
   size_t const size = vids.size();
   assert(size == vrefs.size());
 
   if (size == 0) {
     return;
   }
 
   LOG(logMsgType_) << "   " << name << ": size=" << size;
   for (size_t idx = 0; idx < size; ++idx) {
     LOG log(logMsgType_);
     log << "    [" << idx << "] id=" << vids[idx] << " ";
     auto const& ref = vrefs[idx];
     if (permissive_ and not ref.isAvailable()) {
       log << "(Ref with id=" << ref.id() << " not available)";
     } else {
       showObject(log, ref);
     }
   }
 }