#include <METplusTrackMonitor.h>

Inheritance diagram for METplusTrackMonitor:

Public Member Functions
	METplusTrackMonitor (const edm::ParameterSet &)

	~METplusTrackMonitor ()(true) override

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

void	beginStream (edm::StreamID id) final

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

	DQMEDAnalyzer (void)

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

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

uint32_t	streamId () const

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

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

	~EDAnalyzerBase () override

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

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

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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

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

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

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

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

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

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

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

virtual	~EDConsumerBase () noexcept(false)

Public Member Functions inherited from TriggerDQMBase
	TriggerDQMBase ()=default

virtual	~TriggerDQMBase ()=default

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

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)

Static Public Member Functions inherited from TriggerDQMBase
static void	fillHistoLSPSetDescription (edm::ParameterSetDescription &pset)

static void	fillHistoPSetDescription (edm::ParameterSetDescription &pset)

static MEbinning	getHistoLSPSet (const edm::ParameterSet &pset)

static MEbinning	getHistoPSet (const edm::ParameterSet &pset)

Protected Member Functions
void	analyze (edm::Event const &iEvent, edm::EventSetup const &iSetup) override

void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override

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

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

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

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Protected Member Functions inherited from TriggerDQMBase
void	bookME (DQMStore::IBooker &, ObjME &me, const std::string &histname, const std::string &histtitle, unsigned nbins, double xmin, double xmax)

void	bookME (DQMStore::IBooker &, ObjME &me, const std::string &histname, const std::string &histtitle, const std::vector< double > &binningX)

void	bookME (DQMStore::IBooker &, ObjME &me, const std::string &histname, const std::string &histtitle, unsigned nbinsX, double xmin, double xmax, double ymin, double ymax)

void	bookME (DQMStore::IBooker &, ObjME &me, const std::string &histname, const std::string &histtitle, unsigned nbinsX, double xmin, double xmax, unsigned nbinsY, double ymin, double ymax)

void	bookME (DQMStore::IBooker &, ObjME &me, const std::string &histname, const std::string &histtitle, const std::vector< double > &binningX, const std::vector< double > &binningY)

void	setMETitle (ObjME &me, const std::string &titleX, const std::string &titleY)

Private Member Functions
bool	getHLTObj (const edm::Handle< trigger::TriggerEvent > &trigSummary, const edm::InputTag &filterTag, trigger::TriggerObject &obj) const

Private Attributes
ObjME	deltaphimetj1ME_

ObjME	deltaphimetmuonME_

std::unique_ptr< GenericTriggerEventFlag >	den_genTriggerEventFlag_

MEbinning	eta_binning_

std::string	folderName_

std::string	histoSuffix_

edm::InputTag	hltMetCleanTag_

edm::InputTag	hltMetTag_

StringCutObjectSelector< reco::PFJet, true >	jetSelection_

edm::EDGetTokenT< reco::PFJetCollection >	jetToken_

double	leadJetEtaCut_

MEbinning	ls_binning_

double	maxMatchDeltaR_

MEbinning	met_binning_

std::vector< double >	met_variable_binning_

ObjME	metME_variableBinning_

ObjME	metPhiME_

StringCutObjectSelector< reco::CaloMET, true >	metSelection_

edm::EDGetTokenT< reco::CaloMETCollection >	metToken_

ObjME	metVsHltMet_

ObjME	metVsHltMetClean_

ObjME	metVsLS_

ObjME	muonEtaME_

ObjME	muonEtaVsPhi_

std::vector< double >	muonPt_variable_binning_

ObjME	muonPtME_variableBinning_

ObjME	muonPtVsLS_

StringCutObjectSelector< reco::Muon, true >	muonSelection_

edm::EDGetTokenT< reco::MuonCollection >	muonToken_

unsigned	njets_

unsigned	nmuons_

std::unique_ptr< GenericTriggerEventFlag >	num_genTriggerEventFlag_

MEbinning	phi_binning_

MEbinning	pt_binning_

bool	requireLeadMatched_

edm::EDGetTokenT< trigger::TriggerEvent >	theTrigSummary_

edm::InputTag	trackLegFilterTag_

StringCutObjectSelector< reco::Vertex, true >	vtxSelection_

edm::EDGetTokenT< reco::VertexCollection >	vtxToken_

Additional Inherited Members
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

Detailed Description

Definition at line 50 of file METplusTrackMonitor.h.

Constructor & Destructor Documentation

METplusTrackMonitor::METplusTrackMonitor ( const edm::ParameterSet & iConfig )

Definition at line 16 of file METplusTrackMonitor.cc.

References deltaphimetj1ME_, deltaphimetmuonME_, TriggerDQMBase::ObjME::denominator, metME_variableBinning_, metPhiME_, metVsHltMet_, metVsHltMetClean_, metVsLS_, muonEtaVsPhi_, muonPtME_variableBinning_, muonPtVsLS_, and TriggerDQMBase::ObjME::numerator.

                                                                          :
   folderName_             ( iConfig.getParameter<std::string>("FolderName") )
   , metToken_             ( consumes<reco::CaloMETCollection>      (iConfig.getParameter<edm::InputTag>("met")            ) )
   , muonToken_            ( consumes<reco::MuonCollection>         (iConfig.getParameter<edm::InputTag>("muons")          ) )
   , jetToken_             ( consumes<reco::PFJetCollection>        (iConfig.getParameter<edm::InputTag>("jets")           ) )
   , vtxToken_             ( consumes<reco::VertexCollection>       (iConfig.getParameter<edm::InputTag>("vertices")       ) )
   , theTrigSummary_       ( consumes<trigger::TriggerEvent>        (iConfig.getParameter<edm::InputTag>("trigSummary")    ) )
   , hltMetTag_               ( iConfig.getParameter<edm::InputTag>("hltMetFilter")         )
   , hltMetCleanTag_          ( iConfig.getParameter<edm::InputTag>("hltMetCleanFilter")    )
   , trackLegFilterTag_       ( iConfig.getParameter<edm::InputTag>("trackLegFilter") )
   , met_variable_binning_    ( iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("metBinning") )
   , muonPt_variable_binning_ ( iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("ptBinning")  )
   , met_binning_          ( getHistoPSet   (iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("metPSet")    ) )
   , ls_binning_           ( getHistoPSet (iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("lsPSet")     ) )
   , pt_binning_           ( getHistoPSet   (iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("ptPSet")     ) )
   , eta_binning_          ( getHistoPSet   (iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("etaPSet")    ) )
   , phi_binning_          ( getHistoPSet   (iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("phiPSet")    ) )
   , num_genTriggerEventFlag_(new GenericTriggerEventFlag(iConfig.getParameter<edm::ParameterSet>("numGenericTriggerEventPSet"), consumesCollector(), *this))
   , den_genTriggerEventFlag_(new GenericTriggerEventFlag(iConfig.getParameter<edm::ParameterSet>("denGenericTriggerEventPSet"), consumesCollector(), *this))
   , metSelection_         ( iConfig.getParameter<std::string>("metSelection")         )
   , muonSelection_        ( iConfig.getParameter<std::string>("muonSelection")        )
   , jetSelection_         ( iConfig.getParameter<std::string>("jetSelection")         )
   , vtxSelection_         ( iConfig.getParameter<std::string>("vtxSelection")         )
   , nmuons_          ( iConfig.getParameter<unsigned>("nmuons") )
   , njets_           ( iConfig.getParameter<unsigned>("njets") )
   , leadJetEtaCut_   ( iConfig.getParameter<double>("leadJetEtaCut") )
   , requireLeadMatched_ ( iConfig.getParameter<bool>("requireLeadMatched") )
   , maxMatchDeltaR_     ( iConfig.getParameter<double>("maxMatchDeltaR") )
 {
 
   metME_variableBinning_.numerator   = nullptr;
   metME_variableBinning_.denominator = nullptr;
   metVsLS_.numerator   = nullptr;
   metVsLS_.denominator = nullptr;
   metPhiME_.numerator   = nullptr;
   metPhiME_.denominator = nullptr;
   deltaphimetj1ME_.numerator   = nullptr;
   deltaphimetj1ME_.denominator = nullptr;
   metVsHltMet_.numerator = nullptr;      // numerator only, only available from passed filter
   metVsHltMetClean_.numerator = nullptr; // numerator only, only available from passed filter
 
   muonPtME_variableBinning_.numerator   = nullptr;
   muonPtME_variableBinning_.denominator = nullptr;
   muonPtVsLS_.numerator   = nullptr;
   muonPtVsLS_.denominator = nullptr;
   deltaphimetmuonME_.numerator = nullptr;
   deltaphimetmuonME_.denominator = nullptr;
   muonEtaVsPhi_.numerator = nullptr;
   muonEtaVsPhi_.denominator = nullptr;
 
 }

METplusTrackMonitor::~METplusTrackMonitor ( )

inlineoverride

Definition at line 55 of file METplusTrackMonitor.h.

References analyze(), bookHistograms(), fillDescriptions(), getHLTObj(), iEvent, and MuonAssociatorByHits_cfi::obj.

55 { }

Member Function Documentation

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

overrideprotectedvirtual

Implements edm::stream::EDAnalyzerBase.

Definition at line 131 of file METplusTrackMonitor.cc.

References CaloMET_cfi::caloMet, hiPixelPairStep_cff::deltaPhi, deltaphimetj1ME_, deltaphimetmuonME_, deltaR(), den_genTriggerEventFlag_, TriggerDQMBase::ObjME::denominator, PVValHelper::eta, MonitorElement::Fill(), edm::Event::getByToken(), getHLTObj(), hltMetCleanTag_, hltMetTag_, edm::EventBase::id(), muon::isTightMuon(), edm::HandleBase::isValid(), fwrapper::jets, jetSelection_, jetToken_, leadJetEtaCut_, eostools::ls(), edm::EventID::luminosityBlock(), funct::m, maxMatchDeltaR_, RazorAnalyzer::met, metME_variableBinning_, metPhiME_, metSelection_, metToken_, metVsHltMet_, metVsHltMetClean_, metVsLS_, reco::HitPattern::MISSING_INNER_HITS, muonEtaME_, muonEtaVsPhi_, muonPtME_variableBinning_, muonPtVsLS_, nano_cff::muons, muonSelection_, muonToken_, njets_, nmuons_, num_genTriggerEventFlag_, TriggerDQMBase::ObjME::numerator, phi, reco::LeafCandidate::phi(), jets_cff::primaryVertices, EnergyCorrector::pt, trigger::TriggerObject::pt(), reco::LeafCandidate::pt(), MetAnalyzer::pv(), requireLeadMatched_, theTrigSummary_, reco::HitPattern::TRACK_HITS, trackLegFilterTag_, findQualityFiles::v, vtxSelection_, and vtxToken_.

Referenced by ~METplusTrackMonitor().

  {
 
    // Filter out events if Trigger Filtering is requested
   if(den_genTriggerEventFlag_->on() && !den_genTriggerEventFlag_->accept(iEvent, iSetup)) return;
 
   edm::Handle<reco::CaloMETCollection> metHandle;
   iEvent.getByToken(metToken_, metHandle);
   reco::CaloMET caloMet = metHandle->front();
   if(!metSelection_(caloMet)) return;
 
   float met = caloMet.pt();
   float metPhi = caloMet.phi();
 
   edm::Handle<reco::PFJetCollection> jetsHandle;
   iEvent.getByToken(jetToken_, jetsHandle);
   if(jetsHandle->size() < njets_) return;
   std::vector<reco::PFJet> jets;
   for(auto const & j : *jetsHandle) {
     if(jetSelection_(j)) jets.push_back(j);
   }
   if(jets.size() < njets_) return;
   if(njets_ > 0 && !(jets.empty()) && fabs(jets[0].eta()) > leadJetEtaCut_) return;
   float deltaphi_metjet1 = !(jets.empty()) ? fabs(deltaPhi(caloMet.phi(), jets[0].phi())) : 10.0;
 
   edm::Handle<reco::VertexCollection> primaryVertices;
   iEvent.getByToken(vtxToken_, primaryVertices);
   if(primaryVertices->empty()) return;
   const reco::Vertex* pv = nullptr;
   for(auto const& v: *primaryVertices) {
     if (!vtxSelection_(v)) continue;
     pv = &v;
     break;
   }
   if(pv == nullptr) return;
 
   edm::Handle<reco::MuonCollection> muonHandle;
   iEvent.getByToken(muonToken_, muonHandle);
   if(muonHandle->size() < nmuons_) return;
   std::vector<reco::Muon> muons;
   for(auto const & m : *muonHandle) {
     bool passTightID = muon::isTightMuon(m, *pv) &&
                        m.innerTrack()->hitPattern().trackerLayersWithoutMeasurement(reco::HitPattern::MISSING_INNER_HITS) == 0 &&
                        m.innerTrack()->hitPattern().trackerLayersWithoutMeasurement(reco::HitPattern::TRACK_HITS) == 0;
     if(muonSelection_(m) && passTightID) muons.push_back(m);
   }
   if(muons.size() < nmuons_) return;
 
   // Filling MET leg histograms (denominator)
   metME_variableBinning_.denominator->Fill(met);
   metPhiME_.denominator->Fill(metPhi);
   deltaphimetj1ME_.denominator->Fill(deltaphi_metjet1);
 
   int ls = iEvent.id().luminosityBlock();
   metVsLS_.denominator->Fill(ls, met);
 
   // Apply the selection for the MET leg numerator
   edm::Handle<trigger::TriggerEvent> triggerSummary;
   iEvent.getByToken(theTrigSummary_, triggerSummary);
   if(!triggerSummary.isValid()) {
     edm::LogError("METplusTrackMonitor") << "Invalid collection: TriggerSummary" << "\n";
     return;
   }
 
   trigger::TriggerObject hltMet, hltMetClean;
   bool passesHltMetFilter = getHLTObj(triggerSummary, hltMetTag_, hltMet);
   bool passesHltMetCleanFilter = getHLTObj(triggerSummary, hltMetCleanTag_, hltMetClean);
 
   if(!passesHltMetFilter || !passesHltMetCleanFilter) return;
 
   // Filling MET leg histograms (numerator)
   metME_variableBinning_.numerator->Fill(met);
   metPhiME_.numerator->Fill(metPhi);
   deltaphimetj1ME_.numerator->Fill(deltaphi_metjet1);
   metVsLS_.numerator->Fill(ls, met);
   metVsHltMet_.numerator->Fill(hltMet.pt(), met);
   metVsHltMetClean_.numerator->Fill(hltMetClean.pt(), met);
 
   // Filling track leg histograms (denominator)
   double leadMuonPt      = !(muons.empty()) ? muons[0].pt()  : -1.0;
   double leadMuonEta     = !(muons.empty()) ? muons[0].eta() : 10.0;
   double leadMuonPhi     = !(muons.empty()) ? muons[0].phi() : 10.0;
   float deltaphi_metmuon = !(muons.empty()) ? fabs(deltaPhi(caloMet.phi(), muons[0].phi())) : 10.0;
 
   muonPtME_variableBinning_.denominator->Fill(leadMuonPt);
   muonPtVsLS_.denominator->Fill(ls, leadMuonPt);
   muonEtaME_.denominator->Fill(leadMuonEta);
   deltaphimetmuonME_.denominator->Fill(deltaphi_metmuon);
   muonEtaVsPhi_.denominator->Fill(leadMuonPhi, leadMuonEta);
 
   // Apply the selection for the track leg numerator
   trigger::TriggerObject isoTrk;
   bool passesTrackLegFilter = getHLTObj(triggerSummary, trackLegFilterTag_, isoTrk);
 
   // require track leg filter
   if(!passesTrackLegFilter) return;
 
   // if requested, require lead selected muon is matched to the track leg filter object
   if(requireLeadMatched_ && !(muons.empty()) && deltaR(muons[0], isoTrk) < maxMatchDeltaR_) return;
 
   // require the full HLT path is fired
   if(num_genTriggerEventFlag_->on() && !num_genTriggerEventFlag_->accept(iEvent, iSetup)) return;
 
   // Filling track leg histograms (denominator)
   muonPtME_variableBinning_.numerator->Fill(leadMuonPt);
   muonPtVsLS_.numerator->Fill(ls, leadMuonPt);
   muonEtaME_.numerator->Fill(leadMuonEta);
   deltaphimetmuonME_.numerator->Fill(deltaphi_metmuon);
   muonEtaVsPhi_.numerator->Fill(leadMuonPhi, leadMuonEta);
 
 }

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

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 68 of file METplusTrackMonitor.cc.

References TriggerDQMBase::bookME(), deltaphimetj1ME_, deltaphimetmuonME_, den_genTriggerEventFlag_, eta_binning_, folderName_, ls_binning_, met_binning_, met_variable_binning_, metME_variableBinning_, metPhiME_, metVsHltMet_, metVsHltMetClean_, metVsLS_, muonEtaME_, muonEtaVsPhi_, muonPt_variable_binning_, muonPtME_variableBinning_, muonPtVsLS_, TriggerDQMBase::MEbinning::nbins, num_genTriggerEventFlag_, phi_binning_, pt_binning_, DQMStore::IBooker::setCurrentFolder(), TriggerDQMBase::setMETitle(), AlCaHLTBitMon_QueryRunRegistry::string, TriggerDQMBase::MEbinning::xmax, and TriggerDQMBase::MEbinning::xmin.

Referenced by ~METplusTrackMonitor().

  {
    std::string histname, histtitle;
 
    std::string currentFolder = folderName_;
    ibooker.setCurrentFolder(currentFolder);
 
    // MET leg histograms
 
    histname = "met_variable"; histtitle = "CaloMET";
    bookME(ibooker, metME_variableBinning_, histname, histtitle, met_variable_binning_);
    setMETitle(metME_variableBinning_, "CaloMET [GeV]", "events / [GeV]");
 
    histname = "metVsLS"; histtitle = "CaloMET vs LS";
    bookME(ibooker, metVsLS_, histname, histtitle, ls_binning_.nbins, ls_binning_.xmin, ls_binning_.xmax, met_binning_.xmin, met_binning_.xmax);
    setMETitle(metVsLS_, "LS", "CaloMET [GeV]");
 
    histname = "metPhi"; histtitle = "CaloMET phi";
    bookME(ibooker, metPhiME_, histname, histtitle, phi_binning_.nbins, phi_binning_.xmin, phi_binning_.xmax);
    setMETitle(metPhiME_, "CaloMET #phi","events / 0.2 rad");
 
    histname = "deltaphi_metjet1"; histtitle = "dPhi(CaloMET, jet1)";
    bookME(ibooker, deltaphimetj1ME_, histname, histtitle, phi_binning_.nbins, 0, phi_binning_.xmax);
    setMETitle(deltaphimetj1ME_, "#Delta#phi (CaloMET, j1)", "events / 0.1 rad");
 
    histname = "metVsHltMet"; histtitle = "CaloMET vs hltMet";
    bookME(ibooker, metVsHltMet_, histname, histtitle, met_binning_.nbins, met_binning_.xmin, met_binning_.xmax, met_binning_.nbins, met_binning_.xmin, met_binning_.xmax);
    setMETitle(metVsHltMet_, "hltMet (online) [GeV]", "CaloMET (offline) [GeV]");
 
    histname = "metVsHltMetClean"; histtitle = "CaloMET vs hltMetClean";
    bookME(ibooker, metVsHltMetClean_, histname, histtitle, met_binning_.nbins, met_binning_.xmin, met_binning_.xmax, met_binning_.nbins, met_binning_.xmin, met_binning_.xmax);
    setMETitle(metVsHltMetClean_, "hltMetClean (online) [GeV]", "CaloMET (offline) [GeV]");
 
    // Track leg histograms
 
    histname = "muonPt_variable"; histtitle = "Muon PT";
    bookME(ibooker, muonPtME_variableBinning_, histname, histtitle, muonPt_variable_binning_);
    setMETitle(muonPtME_variableBinning_, "Muon p_{T} [GeV]", "events / [GeV]");
 
    histname = "muonEta"; histtitle = "Muon eta";
    bookME(ibooker, muonEtaME_, histname, histtitle, eta_binning_.nbins, eta_binning_.xmin, eta_binning_.xmax);
    setMETitle(muonEtaME_, "Muon #eta", "events / 0.2");
 
    histname = "deltaphi_muonmet"; histtitle = "dPhi(Muon, CaloMET)";
    bookME(ibooker, deltaphimetmuonME_, histname, histtitle, phi_binning_.nbins, 0, phi_binning_.xmax);
    setMETitle(deltaphimetmuonME_, "#Delta#phi (Muon, CaloMET)", "events / 0.1 rad");
 
    histname = "muonEtaVsPhi"; histtitle = "Muon eta vs phi";
    bookME(ibooker, muonEtaVsPhi_, histname, histtitle, phi_binning_.nbins, phi_binning_.xmin, phi_binning_.xmax, eta_binning_.nbins, eta_binning_.xmin, eta_binning_.xmax);
    setMETitle(muonEtaVsPhi_, "Muon #phi", "Muon #eta");
 
    histname = "muonPtVsLS"; histtitle = "Muon PT vs LS";
    bookME(ibooker, muonPtVsLS_, histname, histtitle, ls_binning_.nbins, ls_binning_.xmin, ls_binning_.xmax, pt_binning_.xmin, pt_binning_.xmax);
    setMETitle(muonPtVsLS_, "LS", "Muon p_{T} [GeV]");
 
    // Initialize the GenericTriggerEventFlag
   if(num_genTriggerEventFlag_ && num_genTriggerEventFlag_->on()) num_genTriggerEventFlag_->initRun(iRun, iSetup);
   if(den_genTriggerEventFlag_ && den_genTriggerEventFlag_->on()) den_genTriggerEventFlag_->initRun(iRun, iSetup);
 
  }

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

static

Definition at line 243 of file METplusTrackMonitor.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), create_public_pileup_plots::bins, TriggerDQMBase::fillHistoLSPSetDescription(), TriggerDQMBase::fillHistoPSetDescription(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by ~METplusTrackMonitor().

 {
   edm::ParameterSetDescription desc;
   desc.add<std::string>  ( "FolderName", "HLT/MET" );
 
   desc.add<edm::InputTag>( "met",               edm::InputTag("caloMet") );
   desc.add<edm::InputTag>( "jets",              edm::InputTag("ak4PFJetsCHS") );
   desc.add<edm::InputTag>( "electrons",         edm::InputTag("gedGsfElectrons") );
   desc.add<edm::InputTag>( "muons",             edm::InputTag("muons") );
   desc.add<edm::InputTag>( "vertices",          edm::InputTag("offlinePrimaryVertices") );
   desc.add<edm::InputTag>( "trigSummary",       edm::InputTag("hltTriggerSummaryAOD") );
   desc.add<edm::InputTag>( "hltMetFilter",      edm::InputTag("hltMET105", "", "HLT") );
   desc.add<edm::InputTag>( "hltMetCleanFilter", edm::InputTag("hltMETClean65", "", "HLT") );
   desc.add<edm::InputTag>( "trackLegFilter",    edm::InputTag("hltTrk50Filter", "", "HLT") );
 
   desc.add<std::string>("metSelection", "pt > 0");
   desc.add<std::string>("jetSelection", "pt > 0");
   desc.add<std::string>("muonSelection", "pt > 0");
   desc.add<std::string>("vtxSelection",  "!isFake");
   desc.add<unsigned>("njets",  0);
   desc.add<unsigned>("nmuons", 0);
   desc.add<double>("leadJetEtaCut", 2.4);
   desc.add<bool>("requireLeadMatched", true);
   desc.add<double>("maxMatchDeltaR", 0.1);
 
   edm::ParameterSetDescription genericTriggerEventPSet;
   genericTriggerEventPSet.add<bool>("andOr");
   genericTriggerEventPSet.add<edm::InputTag>("dcsInputTag", edm::InputTag("scalersRawToDigi") );
   genericTriggerEventPSet.add<std::vector<int> >("dcsPartitions", {});
   genericTriggerEventPSet.add<bool>("andOrDcs", false);
   genericTriggerEventPSet.add<bool>("errorReplyDcs", true);
   genericTriggerEventPSet.add<std::string>("dbLabel", "");
   genericTriggerEventPSet.add<bool>("andOrHlt", true);
   genericTriggerEventPSet.add<edm::InputTag>("hltInputTag", edm::InputTag("TriggerResults::HLT") );
   genericTriggerEventPSet.add<std::vector<std::string> >("hltPaths", {});
   genericTriggerEventPSet.add<std::string>("hltDBKey", "");
   genericTriggerEventPSet.add<bool>("errorReplyHlt", false);
   genericTriggerEventPSet.add<unsigned int>("verbosityLevel", 1);
 
   desc.add<edm::ParameterSetDescription>("numGenericTriggerEventPSet", genericTriggerEventPSet);
   desc.add<edm::ParameterSetDescription>("denGenericTriggerEventPSet", genericTriggerEventPSet);
 
   edm::ParameterSetDescription histoPSet;
   edm::ParameterSetDescription metPSet;
   edm::ParameterSetDescription phiPSet;
   edm::ParameterSetDescription ptPSet;
   edm::ParameterSetDescription etaPSet;
 
   fillHistoPSetDescription(metPSet);
   fillHistoPSetDescription(phiPSet);
   fillHistoPSetDescription(ptPSet);
   fillHistoPSetDescription(etaPSet);
 
   histoPSet.add<edm::ParameterSetDescription>("metPSet", metPSet);
   histoPSet.add<edm::ParameterSetDescription>("phiPSet", phiPSet);
   histoPSet.add<edm::ParameterSetDescription>("ptPSet",  ptPSet);
   histoPSet.add<edm::ParameterSetDescription>("etaPSet", etaPSet);
 
   std::vector<double> bins = {0.,20.,40.,60.,80.,90.,100.,110.,120.,130.,140.,150.,160.,170.,180.,190.,200.,220.,240.,260.,280.,300.,350.,400.,450.,1000.};
 
   histoPSet.add<std::vector<double> >("metBinning", bins);
   histoPSet.add<std::vector<double> >("ptBinning",  bins);
 
   edm::ParameterSetDescription lsPSet;
   fillHistoLSPSetDescription(lsPSet);
   histoPSet.add<edm::ParameterSetDescription>("lsPSet", lsPSet);
 
   desc.add<edm::ParameterSetDescription>("histoPSet", histoPSet);
 
   descriptions.add("metPlusTrackMonitoring", desc);
 }

bool METplusTrackMonitor::getHLTObj	(	const edm::Handle< trigger::TriggerEvent > &	trigSummary,
		const edm::InputTag &	filterTag,
		trigger::TriggerObject &	obj
	)		const

private

Definition at line 315 of file METplusTrackMonitor.cc.

References DEFINE_FWK_MODULE, trigger::TriggerEvent::filterIndex(), trigger::TriggerEvent::filterKeys(), trigger::TriggerEvent::getObjects(), crabWrapper::key, relativeConstraints::keys, trigger::TriggerObject::pt(), trigger::TriggerEvent::sizeFilters(), and TriggerAnalyzer::triggerObjects.

Referenced by analyze(), and ~METplusTrackMonitor().

 {
 
  double leadingPt = -1.0;
 
  size_t filterIndex = trigSummary->filterIndex( filterTag );
  trigger::TriggerObjectCollection triggerObjects = trigSummary->getObjects();
 
  if( !(filterIndex >= trigSummary->sizeFilters()) ) {
    const trigger::Keys& keys = trigSummary->filterKeys( filterIndex );
    for(unsigned short key : keys) {
      trigger::TriggerObject foundObject = triggerObjects[key];
      if(foundObject.pt() > leadingPt) {
        obj = foundObject;
        leadingPt = obj.pt();
      }
    }
  }
 
  return (leadingPt > 0.0);
 }