#include <HLTMuonMatchAndPlot.h>

Public Types
typedef dqm::legacy::DQMStore	DQMStore

typedef dqm::legacy::MonitorElement	MonitorElement

Public Member Functions
void	analyze (edm::Handle< reco::MuonCollection > &, edm::Handle< reco::BeamSpot > &, edm::Handle< reco::VertexCollection > &, edm::Handle< trigger::TriggerEvent > &, edm::Handle< edm::TriggerResults > &, const edm::TriggerNames &)

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

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

bool	fillEdges (size_t &nBins, float *&edges, const std::vector< double > &binning)

template<class T >
void	fillMapFromPSet (std::map< std::string, T > &, const edm::ParameterSet &, const std::string &)

template<class T >
void	fillMapFromPSet (map< string, T > &m, const ParameterSet &pset, const string &target)

	HLTMuonMatchAndPlot (const edm::ParameterSet &, std::string, std::string, bool)
	Constructor. More...

template<class T1 , class T2 >
std::vector< size_t >	matchByDeltaR (const std::vector< T1 > &, const std::vector< T2 > &, const double maxDeltaR=NOMATCH)

template<class T1 , class T2 >
vector< size_t >	matchByDeltaR (const vector< T1 > &collection1, const vector< T2 > &collection2, const double maxDeltaR)

Private Member Functions
void	book1D (DQMStore::IBooker &, std::string, const std::string &, std::string)

void	book2D (DQMStore::IBooker &, const std::string &, const std::string &, const std::string &, const std::string &)

reco::MuonCollection	selectedMuons (const reco::MuonCollection &, const reco::BeamSpot &, bool)

trigger::TriggerObjectCollection	selectedTriggerObjects (const trigger::TriggerObjectCollection &, const trigger::TriggerEvent &)

Private Attributes
std::map< std::string, std::vector< double > >	binParams_

unsigned int	cutMinPt_

std::string	destination_

std::map< std::string, MonitorElement * >	hists_

std::string	hltPath_

std::string	hltProcessName_

bool	isLastFilter_

std::string	moduleLabel_

std::map< std::string, double >	plotCuts_

double	probeD0Cut_

bool	probeIsMuonGlb_

double	probeMuonEtaMax_

double	probeMuonEtaMin_

edm::ParameterSet	probeParams_

double	probeZ0Cut_

std::vector< std::string >	requiredTriggers_

double	targetD0Cut_

bool	targetIsMuonGlb_

double	targetMuonEtaMax_

double	targetMuonEtaMin_

edm::ParameterSet	targetParams_

double	targetptCutJpsi_

double	targetptCutZ_

double	targetZ0Cut_

double	triggerEtaMaxCut_

double	triggerEtaMinCut_

std::string	triggerLevel_

Detailed Description

Match reconstructed muons to HLT objects and plot efficiencies.

Note that this is not a true EDAnalyzer;

Documentation available on the CMS TWiki: https://twiki.cern.ch/twiki/bin/view/CMS/MuonHLTOfflinePerformance

Author: J. Slaunwhite, Jeff Klukas

Contanier class to handle vector of reconstructed muons matched to HLT objects used to plot efficiencies.

Note that this is not a true EDAnalyzer; rather, the intent is that one EDAnalyzer would call an instance of HLTMuonMatchAndPlotContainer

Documentation available on the CMS TWiki: https://twiki.cern.ch/twiki/bin/view/CMS/MuonHLTOfflinePerformance

Author: C. Battilana

Definition at line 55 of file HLTMuonMatchAndPlot.h.

Member Typedef Documentation

◆ DQMStore

typedef dqm::legacy::DQMStore HLTMuonMatchAndPlot::DQMStore

Definition at line 57 of file HLTMuonMatchAndPlot.h.

◆ MonitorElement

typedef dqm::legacy::MonitorElement HLTMuonMatchAndPlot::MonitorElement

Definition at line 58 of file HLTMuonMatchAndPlot.h.

Constructor & Destructor Documentation

◆ HLTMuonMatchAndPlot()

HLTMuonMatchAndPlot::HLTMuonMatchAndPlot	(	const edm::ParameterSet &	,
		std::string	,
		std::string	,
		bool
	)

Constructor.

Definition at line 37 of file HLTMuonMatchAndPlot.cc.

References binParams_, reco::ceil(), cutMinPt_, fillMapFromPSet(), hltPath_, moduleLabel_, plotCuts_, muonDTDigis_cfi::pset, and triggerLevel_.

     : hltProcessName_(pset.getParameter<string>("hltProcessName")),
       destination_(pset.getUntrackedParameter<string>("destination")),
       requiredTriggers_(pset.getUntrackedParameter<vstring>("requiredTriggers")),
       targetParams_(pset.getParameterSet("targetParams")),
       probeParams_(pset.getParameterSet("probeParams")),
       hltPath_(std::move(hltPath)),
       moduleLabel_(std::move(moduleLabel)),
       isLastFilter_(islastfilter),
       targetMuonEtaMax_(targetParams_.getUntrackedParameter<double>("recoMaxEtaCut", 0.)),
       targetMuonEtaMin_(targetParams_.getUntrackedParameter<double>("recoMinEtaCut", 0.)),
       targetIsMuonGlb_(targetParams_.getUntrackedParameter<bool>("recoGlbMuCut", false)),
       targetZ0Cut_(targetParams_.getUntrackedParameter<double>("z0Cut", 0.)),
       targetD0Cut_(targetParams_.getUntrackedParameter<double>("d0Cut", 0.)),
       targetptCutZ_(targetParams_.getUntrackedParameter<double>("ptCut_Z", 20.)),
       targetptCutJpsi_(targetParams_.getUntrackedParameter<double>("ptCut_Jpsi", 20.)),
       probeMuonEtaMax_(probeParams_.getUntrackedParameter<double>("recoMaxEtaCut", 0.)),
       probeMuonEtaMin_(probeParams_.getUntrackedParameter<double>("recoMinEtaCut", 0.)),
       probeIsMuonGlb_(probeParams_.getUntrackedParameter<bool>("recoGlbMuCut", false)),
       probeZ0Cut_(probeParams_.getUntrackedParameter<double>("z0Cut", 0.)),
       probeD0Cut_(probeParams_.getUntrackedParameter<double>("d0Cut", 0.)),
       triggerEtaMaxCut_(targetParams_.getUntrackedParameter<double>("hltMaxEtaCut", 0.)),
       triggerEtaMinCut_(targetParams_.getUntrackedParameter<double>("hltMinEtaCut", 0.)) {
   // Create std::map<string, T> from ParameterSets.
   fillMapFromPSet(binParams_, pset, "binParams");
   fillMapFromPSet(plotCuts_, pset, "plotCuts");
 
   // Get the trigger level.
   triggerLevel_ = "L3";
   TPRegexp levelRegexp("L[1-3]");
   //  size_t nModules = moduleLabels_.size();
   //  cout << moduleLabel_ << " " << hltPath_ << endl;
   TObjArray* levelArray = levelRegexp.MatchS(moduleLabel_);
   if (levelArray->GetEntriesFast() > 0) {
     triggerLevel_ = static_cast<const char*>(((TObjString*)levelArray->At(0))->GetString());
   }
   delete levelArray;
 
   // Get the pT cut by parsing the name of the HLT path.
   cutMinPt_ = 3;
   TPRegexp ptRegexp("Mu([0-9]*)");
   TObjArray* objArray = ptRegexp.MatchS(hltPath_);
   if (objArray->GetEntriesFast() >= 2) {
     auto* ptCutString = (TObjString*)objArray->At(1);
     cutMinPt_ = atoi(ptCutString->GetString());
     cutMinPt_ = ceil(cutMinPt_ * plotCuts_["minPtFactor"]);
   }
   delete objArray;
 }

Member Function Documentation

◆ analyze()

void HLTMuonMatchAndPlot::analyze	(	edm::Handle< reco::MuonCollection > &	allMuons,
		edm::Handle< reco::BeamSpot > &	beamSpot,
		edm::Handle< reco::VertexCollection > &	vertices,
		edm::Handle< trigger::TriggerEvent > &	triggerSummary,
		edm::Handle< edm::TriggerResults > &	triggerResults,
		const edm::TriggerNames &	trigNames
	)

Definition at line 132 of file HLTMuonMatchAndPlot.cc.

References allMuons_cfi::allMuons, pwdgSkimBPark_cfi::beamSpot, cutMinPt_, reco::TrackBase::dz(), EFFICIENCY_SUFFIXES, hists_, HLT_2024v13_cff::hltMuons, hltPath_, mps_fire::i, isLastFilter_, matchByDeltaR(), oniaPATMuonsWithTrigger_cff::matches, plotCuts_, selectedMuons(), selectedTriggerObjects(), makePlotsFromDump::suffix, HLT_2024v13_cff::track, triggerLevel_, triggerResults, HLTMuonOfflineAnalyzer_cfi::triggerSummary, trigNames, and AlignmentTracksFromVertexSelector_cfi::vertices.

                                                                     {
   /*
   if(gen != 0) {
     for(g_part = gen->begin(); g_part != gen->end(); g_part++){
       if( abs(g_part->pdgId()) ==  13) {
         if(!( g_part->status() ==1 || (g_part->status() ==2 && abs(g_part->pdgId())==5))) continue;
         bool GenMomExists  (true);
         bool GenGrMomExists(true);
         if( g_part->pt() < 10.0 )  continue;
         if( fabs(g_part->eta()) > 2.4 ) continue;
         int gen_id= g_part->pdgId();
         const GenParticle* gen_lept = &(*g_part);
         // get mother of gen_lept
         const GenParticle* gen_mom = static_cast<const GenParticle*> (gen_lept->mother());
         if(gen_mom==NULL) GenMomExists=false;
         int m_id=-999;
         if(GenMomExists) m_id = gen_mom->pdgId();
         if(m_id != gen_id || !GenMomExists);
         else{
           int id= m_id;
           while(id == gen_id && GenMomExists){
             gen_mom = static_cast<const GenParticle*> (gen_mom->mother());
             if(gen_mom==NULL){
               GenMomExists=false;
             }
             if(GenMomExists) id=gen_mom->pdgId();
           }
         }
         if(GenMomExists) m_id = gen_mom->pdgId();
         gen_leptsp.push_back(gen_lept);
         gen_momsp.push_back(gen_mom);
       }
     }
   }
   std::vector<GenParticle> gen_lepts;
   for(size_t i = 0; i < gen_leptsp.size(); i++) {
     gen_lepts.push_back(*gen_leptsp[i]);
   }
   */
 
   // Select objects based on the configuration.
   MuonCollection targetMuons = selectedMuons(*allMuons, *beamSpot, true);
   MuonCollection probeMuons = selectedMuons(*allMuons, *beamSpot, false);
   TriggerObjectCollection allTriggerObjects = triggerSummary->getObjects();
   TriggerObjectCollection hltMuons = selectedTriggerObjects(allTriggerObjects, *triggerSummary);
   // Fill plots for HLT muons.
 
   // Find the best trigger object matches for the targetMuons.
   vector<size_t> matches = matchByDeltaR(targetMuons, hltMuons, plotCuts_[triggerLevel_ + "DeltaR"]);
 
   // Fill plots for matched muons.
   for (size_t i = 0; i < targetMuons.size(); i++) {
     Muon& muon = targetMuons[i];
 
     // Fill numerators and denominators for efficiency plots.
     for (const auto& suffix : EFFICIENCY_SUFFIXES) {
       // If no match was found, then the numerator plots don't get filled.
       if (suffix == "numer" && matches[i] >= targetMuons.size())
         continue;
 
       if (muon.pt() > cutMinPt_) {
         hists_["efficiencyEta_" + suffix]->Fill(muon.eta());
       }
 
       if (fabs(muon.eta()) < plotCuts_["maxEta"]) {
         hists_["efficiencyTurnOn_" + suffix]->Fill(muon.pt());
       }
 
       if (muon.pt() > cutMinPt_ && fabs(muon.eta()) < plotCuts_["maxEta"]) {
         const Track* track = nullptr;
         if (muon.isTrackerMuon())
           track = &*muon.innerTrack();
         else if (muon.isStandAloneMuon())
           track = &*muon.outerTrack();
         if (track) {
           hists_["efficiencyNVertex_" + suffix]->Fill(vertices->size());
           hists_["efficiencyPhi_" + suffix]->Fill(muon.phi());
 
           if (isLastFilter_) {
             hists_["efficiencyZ0_" + suffix]->Fill(track->dz(beamSpot->position()));
             hists_["efficiencyCharge_" + suffix]->Fill(muon.charge());
           }
         }
       }
     }  // finish loop numerator / denominator...
 
     if (!isLastFilter_)
       continue;
     // Fill plots for tag and probe
     // Muon cannot be a tag because doesn't match an hlt muon
     if (matches[i] >= targetMuons.size())
       continue;
   }  // End loop over targetMuons.
 
   // fill eff histograms for reference trigger method
   // Denominator: events passing reference trigger and two target muons
   // Numerator:   events in the denominator with two target muons
   // matched to hlt muons
   if (!isLastFilter_)
     return;
   unsigned int numTriggers = trigNames.size();
 
   int nMatched = 0;
   for (unsigned long matche : matches) {
     if (matche < targetMuons.size())
       nMatched++;
   }
 
   string nonDZPath = hltPath_;
   bool dzPath = false;
   if (nonDZPath.rfind("_DZ") < nonDZPath.length()) {
     dzPath = true;
     nonDZPath = boost::replace_all_copy<string>(nonDZPath, "_DZ", "");
     nonDZPath = nonDZPath.substr(0, nonDZPath.rfind("_v") + 2);
   }
   bool passTriggerDZ = false;
 
   if (dzPath) {
     for (unsigned int hltIndex = 0; hltIndex < numTriggers; ++hltIndex) {
       passTriggerDZ = passTriggerDZ || (trigNames.triggerName(hltIndex).find(nonDZPath) != std::string::npos &&
                                         triggerResults->wasrun(hltIndex) && triggerResults->accept(hltIndex));
     }
   }
   if (dzPath && targetMuons.size() > 1 && passTriggerDZ) {
     const Track* track0 = nullptr;
     const Track* track1 = nullptr;
     if (targetMuons.at(0).isTrackerMuon())
       track0 = &*targetMuons.at(0).innerTrack();
     else if (targetMuons.at(0).isStandAloneMuon())
       track0 = &*targetMuons.at(0).outerTrack();
     if (targetMuons.at(1).isTrackerMuon())
       track1 = &*targetMuons.at(1).innerTrack();
     else if (targetMuons.at(1).isStandAloneMuon())
       track1 = &*targetMuons.at(1).outerTrack();
 
     if (track0 && track1) {
       hists_["efficiency_DZ_Mu_denom"]->Fill(track0->dz(beamSpot->position()) - track1->dz(beamSpot->position()));
       if (nMatched > 1) {
         hists_["efficiency_DZ_Mu_numer"]->Fill(track0->dz(beamSpot->position()) - track1->dz(beamSpot->position()));
       }
     }
   }
 
 }  // End analyze() method.

◆ beginRun()

void HLTMuonMatchAndPlot::beginRun	(	DQMStore::IBooker &	iBooker,
		const edm::Run &	iRun,
		const edm::EventSetup &	iSetup
	)

Definition at line 87 of file HLTMuonMatchAndPlot.cc.

References ALCARECODTCalibSynchDQM_cff::baseDir, book1D(), destination_, EFFICIENCY_SUFFIXES, hltPath_, isLastFilter_, moduleLabel_, dqm::implementation::NavigatorBase::setCurrentFolder(), and makePlotsFromDump::suffix.

                                                                                                             {
   TPRegexp suffixPtCut("Mu[0-9]+$");
 
   string baseDir = destination_;
   if (baseDir[baseDir.size() - 1] != '/')
     baseDir += '/';
   string pathSansSuffix = hltPath_;
   if (hltPath_.rfind("_v") < hltPath_.length())
     pathSansSuffix = hltPath_.substr(0, hltPath_.rfind("_v"));
 
   if (isLastFilter_)
     iBooker.setCurrentFolder(baseDir + pathSansSuffix);
   else
     iBooker.setCurrentFolder(baseDir + pathSansSuffix + "/" + moduleLabel_);
 
   // Form is book1D(name, binningType, title) where 'binningType' is used
   // to fetch the bin settings from binParams_.
 
   for (const auto& suffix : EFFICIENCY_SUFFIXES) {
     if (isLastFilter_)
       iBooker.setCurrentFolder(baseDir + pathSansSuffix);
     else
       iBooker.setCurrentFolder(baseDir + pathSansSuffix + "/" + moduleLabel_);
 
     book1D(iBooker, "efficiencyEta_" + suffix, "eta", ";#eta;");
     book1D(iBooker, "efficiencyPhi_" + suffix, "phi", ";#phi;");
     book1D(iBooker, "efficiencyTurnOn_" + suffix, "pt", ";p_{T};");
     book1D(iBooker, "efficiencyNVertex_" + suffix, "NVertex", ";NVertex;");
 
     if (isLastFilter_)
       iBooker.setCurrentFolder(baseDir + pathSansSuffix);
     else
       iBooker.setCurrentFolder(baseDir + pathSansSuffix + "/" + moduleLabel_);
 
     if (!isLastFilter_)
       continue;  //this will be plotted only for the last filter
 
     book1D(iBooker, "efficiencyCharge_" + suffix, "charge", ";charge;");
     book1D(iBooker, "efficiencyZ0_" + suffix, "z0", ";z0;");
     book1D(iBooker, "efficiency_DZ_Mu_" + suffix, "z0", ";z0;");
   }
 }

◆ book1D()

void HLTMuonMatchAndPlot::book1D	(	DQMStore::IBooker &	,
		std::string	,
		const std::string &	,
		std::string
	)

private

Definition at line 418 of file HLTMuonMatchAndPlot.cc.

References binParams_, dqm::implementation::IBooker::book1D(), SelectiveReadoutTask_cfi::edges, fillEdges(), hists_, Skims_PA_cff::name, seedmultiplicitymonitor_newtracking_cfi::nBins, and runGCPTkAlMap::title.

Referenced by beginRun().

                                                                                                                {
   /* Properly delete the array of floats that has been allocated on
    * the heap by fillEdges.  Avoid multiple copies and internal ROOT
    * clones by simply creating the histograms directly in the DQMStore
    * using the appropriate book1D method to handle the variable bins
    * case. */
 
   size_t nBins;
   float* edges = nullptr;
   bool bookhist = fillEdges(nBins, edges, binParams_[binningType]);
   if (bookhist) {
     hists_[name] = iBooker.book1D(name, title, nBins, edges);
     if (hists_[name]->getTH1F()->GetSumw2N())
       hists_[name]->enableSumw2();
 
     delete[] edges;
   }
 }

◆ book2D()

void HLTMuonMatchAndPlot::book2D	(	DQMStore::IBooker &	,
		const std::string &	,
		const std::string &	,
		const std::string &	,
		const std::string &
	)

private

Definition at line 437 of file HLTMuonMatchAndPlot.cc.

References binParams_, dqm::implementation::IBooker::book2D(), fillEdges(), hists_, Skims_PA_cff::name, and runGCPTkAlMap::title.

                                                       {
   /* Properly delete the arrays of floats that have been allocated on
    * the heap by fillEdges.  Avoid multiple copies and internal ROOT
    * clones by simply creating the histograms directly in the DQMStore
    * using the appropriate book2D method to handle the variable bins
    * case. */
 
   size_t nBinsX;
   float* edgesX = nullptr;
   bool bookhist = fillEdges(nBinsX, edgesX, binParams_[binningTypeX]);
 
   size_t nBinsY;
   float* edgesY = nullptr;
   bookhist &= fillEdges(nBinsY, edgesY, binParams_[binningTypeY]);
   if (bookhist) {
     hists_[name] = iBooker.book2D(name.c_str(), title.c_str(), nBinsX, edgesX, nBinsY, edgesY);
     if (hists_[name]->getTH2F()->GetSumw2N())
       hists_[name]->enableSumw2();
 
     delete[] edgesX;
     delete[] edgesY;
   }
 }

◆ endRun()

void HLTMuonMatchAndPlot::endRun	(	const edm::Run &	iRun,
		const edm::EventSetup &	iSetup
	)

Definition at line 130 of file HLTMuonMatchAndPlot.cc.

130 {}

◆ fillEdges()

bool HLTMuonMatchAndPlot::fillEdges	(	size_t &	nBins,
		float *&	edges,
		const std::vector< double > &	binning
	)

Definition at line 283 of file HLTMuonMatchAndPlot.cc.

References pileupCalc::binning, SelectiveReadoutTask_cfi::edges, mps_fire::i, SiStripPI::min, and seedmultiplicitymonitor_newtracking_cfi::nBins.

Referenced by book1D(), and book2D().

                                                                                                {
   if (binning.size() < 3) {
     LogWarning("HLTMuonVal") << "Invalid binning parameters!";
     return false;
   }
 
   // Fixed-width binning.
   if (binning.size() == 3) {
     nBins = binning[0];
     edges = new float[nBins + 1];
     const double min = binning[1];
     const double binwidth = (binning[2] - binning[1]) / nBins;
     for (size_t i = 0; i <= nBins; i++)
       edges[i] = min + (binwidth * i);
   }
 
   // Variable-width binning.
   else {
     nBins = binning.size() - 1;
     edges = new float[nBins + 1];
     for (size_t i = 0; i <= nBins; i++)
       edges[i] = binning[i];
   }
   return true;
 }

◆ fillMapFromPSet() [1/2]

template<class T >

void HLTMuonMatchAndPlot::fillMapFromPSet	(	std::map< std::string, T > &	,
		const edm::ParameterSet &	,
		const std::string &
	)

Referenced by HLTMuonMatchAndPlot().

◆ fillMapFromPSet() [2/2]

template<class T >

void HLTMuonMatchAndPlot::fillMapFromPSet	(	map< string, T > &	m,
		const ParameterSet &	pset,
		const string &	target
	)

Definition at line 313 of file HLTMuonMatchAndPlot.cc.

References edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNames(), edm::ParameterSet::getUntrackedParameter(), visualization-live-secondInstance_cfg::m, names, muonDTDigis_cfi::pset, and filterCSVwithJSON::target.

                                                                                                            {
   // Get the ParameterSet with name 'target' from 'pset'
   ParameterSet targetPset;
   if (pset.existsAs<ParameterSet>(target, true))  // target is tracked
     targetPset = pset.getParameterSet(target);
   else if (pset.existsAs<ParameterSet>(target, false))  // target is untracked
     targetPset = pset.getUntrackedParameterSet(target);
 
   // Get the parameter names from targetPset
   vector<string> names = targetPset.getParameterNames();
   vector<string>::const_iterator iter;
 
   for (iter = names.begin(); iter != names.end(); ++iter) {
     if (targetPset.existsAs<T>(*iter, true))  // target is tracked
       m[*iter] = targetPset.getParameter<T>(*iter);
     else if (targetPset.existsAs<T>(*iter, false))  // target is untracked
       m[*iter] = targetPset.getUntrackedParameter<T>(*iter);
   }
 }

◆ matchByDeltaR() [1/2]

template<class T1 , class T2 >

std::vector<size_t> HLTMuonMatchAndPlot::matchByDeltaR	(	const std::vector< T1 > &	,
		const std::vector< T2 > &	,
		const double	maxDeltaR = `NOMATCH`
	)

Referenced by analyze().

◆ matchByDeltaR() [2/2]

template<class T1 , class T2 >

vector<size_t> HLTMuonMatchAndPlot::matchByDeltaR	(	const vector< T1 > &	collection1,
		const vector< T2 > &	collection2,
		const double	maxDeltaR
	)

Definition at line 335 of file HLTMuonMatchAndPlot.cc.

References l1tGTMenu_BTagSeeds_cff::collection1, l1tGTMenu_BTagSeeds_cff::collection2, PbPb_ZMuSkimMuonDPG_cff::deltaR, mps_fire::i, dqmiolumiharvest::j, dqmdumpme::k, ewkMuLumiMonitorDQM_cfi::maxDeltaR, HLT_2024v13_cff::minDeltaR, NOMATCH, and mps_fire::result.

                                                                           {
   const size_t n1 = collection1.size();
   const size_t n2 = collection2.size();
 
   vector<size_t> result(n1, -1);
   vector<vector<double> > deltaRMatrix(n1, vector<double>(n2, NOMATCH));
 
   for (size_t i = 0; i < n1; i++)
     for (size_t j = 0; j < n2; j++) {
       deltaRMatrix[i][j] = deltaR(collection1[i], collection2[j]);
     }
 
   // Run through the matrix n1 times to make sure we've found all matches.
   for (size_t k = 0; k < n1; k++) {
     size_t i_min = -1;
     size_t j_min = -1;
     double minDeltaR = maxDeltaR;
     // find the smallest deltaR
     for (size_t i = 0; i < n1; i++)
       for (size_t j = 0; j < n2; j++)
         if (deltaRMatrix[i][j] < minDeltaR) {
           i_min = i;
           j_min = j;
           minDeltaR = deltaRMatrix[i][j];
         }
     // If a match has been made, save it and make those candidates unavailable.
     if (minDeltaR < maxDeltaR) {
       result[i_min] = j_min;
       deltaRMatrix[i_min] = vector<double>(n2, NOMATCH);
       for (size_t i = 0; i < n1; i++)
         deltaRMatrix[i][j_min] = NOMATCH;
     }
   }
 
   return result;
 }

◆ selectedMuons()

MuonCollection HLTMuonMatchAndPlot::selectedMuons	(	const reco::MuonCollection &	allMuons,
		const reco::BeamSpot &	beamSpot,
		bool	isTargetMuons
	)

private

Definition at line 374 of file HLTMuonMatchAndPlot.cc.

References funct::abs(), allMuons_cfi::allMuons, pwdgSkimBPark_cfi::beamSpot, TrackSplittingMonitor_cfi::d0Cut, amptDefaultParameters_cff::mu, probeD0Cut_, probeIsMuonGlb_, probeMuonEtaMax_, probeMuonEtaMin_, probeZ0Cut_, targetD0Cut_, targetIsMuonGlb_, targetMuonEtaMax_, targetMuonEtaMin_, targetZ0Cut_, HLT_2024v13_cff::track, and HLTMuonOfflineAnalyzer_cff::z0Cut.

Referenced by analyze().

                                                                       {
   MuonCollection reducedMuons;
   double RecoMuonEtaMax = isTargetMuons ? targetMuonEtaMax_ : probeMuonEtaMax_;
   double RecoMuonEtaMin = isTargetMuons ? targetMuonEtaMin_ : probeMuonEtaMin_;
   bool IsMuonGlb = isTargetMuons ? targetIsMuonGlb_ : probeIsMuonGlb_;
   double d0Cut = isTargetMuons ? targetD0Cut_ : probeD0Cut_;
   double z0Cut = isTargetMuons ? targetZ0Cut_ : probeZ0Cut_;
 
   for (auto const& mu : allMuons) {
     const Track* track = nullptr;
     if (mu.isTrackerMuon())
       track = &*mu.innerTrack();
     else if (mu.isStandAloneMuon())
       track = &*mu.outerTrack();
     // minimun ID (requested for cosmics) is being a StandAlone muon
     bool muID = IsMuonGlb ? mu.isGlobalMuon() : mu.isStandAloneMuon();
     if (track && muID && abs(mu.eta()) < RecoMuonEtaMax && abs(mu.eta()) >= RecoMuonEtaMin &&
         fabs(track->dxy(beamSpot.position())) < d0Cut && fabs(track->dz(beamSpot.position())) < z0Cut)
       reducedMuons.push_back(mu);
   }
 
   return reducedMuons;
 }

◆ selectedTriggerObjects()

TriggerObjectCollection HLTMuonMatchAndPlot::selectedTriggerObjects	(	const trigger::TriggerObjectCollection &	triggerObjects,
		const trigger::TriggerEvent &	triggerSummary
	)

private

Definition at line 400 of file HLTMuonMatchAndPlot.cc.

References funct::abs(), trigger::TriggerObject::eta(), hltProcessName_, submitPVResolutionJobs::key, relativeConstraints::keys, moduleLabel_, triggerEtaMaxCut_, triggerEtaMinCut_, triggerMatchMonitor_cfi::triggerObjects, and HLTMuonOfflineAnalyzer_cfi::triggerSummary.

Referenced by analyze().

                                                                                                         {
   InputTag filterTag(moduleLabel_, "", hltProcessName_);
   size_t filterIndex = triggerSummary.filterIndex(filterTag);
 
   TriggerObjectCollection selectedObjects;
   if (filterIndex < triggerSummary.sizeFilters()) {
     const Keys& keys = triggerSummary.filterKeys(filterIndex);
     for (unsigned short key : keys) {
       TriggerObject foundObject = triggerObjects[key];
       if (abs(foundObject.eta()) < triggerEtaMaxCut_ && abs(foundObject.eta()) >= triggerEtaMinCut_)
         selectedObjects.push_back(foundObject);
     }
   }
 
   return selectedObjects;
 }

Member Data Documentation

◆ binParams_

std::map<std::string, std::vector<double> > HLTMuonMatchAndPlot::binParams_

private

Definition at line 92 of file HLTMuonMatchAndPlot.h.

Referenced by book1D(), book2D(), and HLTMuonMatchAndPlot().

◆ cutMinPt_

unsigned int HLTMuonMatchAndPlot::cutMinPt_

private

Definition at line 99 of file HLTMuonMatchAndPlot.h.

Referenced by analyze(), and HLTMuonMatchAndPlot().

◆ destination_

std::string HLTMuonMatchAndPlot::destination_

private

Definition at line 90 of file HLTMuonMatchAndPlot.h.

Referenced by beginRun().

◆ hists_

std::map<std::string, MonitorElement *> HLTMuonMatchAndPlot::hists_

private

Definition at line 103 of file HLTMuonMatchAndPlot.h.

Referenced by analyze(), book1D(), and book2D().

◆ hltPath_

std::string HLTMuonMatchAndPlot::hltPath_

private

Definition at line 100 of file HLTMuonMatchAndPlot.h.

Referenced by analyze(), beginRun(), and HLTMuonMatchAndPlot().

◆ hltProcessName_

std::string HLTMuonMatchAndPlot::hltProcessName_

private

Definition at line 89 of file HLTMuonMatchAndPlot.h.

Referenced by selectedTriggerObjects().

◆ isLastFilter_

bool HLTMuonMatchAndPlot::isLastFilter_

private

Definition at line 102 of file HLTMuonMatchAndPlot.h.

Referenced by analyze(), and beginRun().

◆ moduleLabel_

std::string HLTMuonMatchAndPlot::moduleLabel_

private

Definition at line 101 of file HLTMuonMatchAndPlot.h.

Referenced by beginRun(), HLTMuonMatchAndPlot(), ExternalGeneratorFilter.ExternalGeneratorFilter::insertInto(), Modules.SwitchProducer::insertInto(), Mixins._TypedParameterizable::insertInto(), Modules.ESSource::nameInProcessDesc_(), Modules.ESProducer::nameInProcessDesc_(), and selectedTriggerObjects().

◆ plotCuts_

std::map<std::string, double> HLTMuonMatchAndPlot::plotCuts_

private

Definition at line 93 of file HLTMuonMatchAndPlot.h.

Referenced by analyze(), and HLTMuonMatchAndPlot().

◆ probeD0Cut_

double HLTMuonMatchAndPlot::probeD0Cut_

private

Definition at line 116 of file HLTMuonMatchAndPlot.h.

Referenced by selectedMuons().

◆ probeIsMuonGlb_

bool HLTMuonMatchAndPlot::probeIsMuonGlb_

private

Definition at line 114 of file HLTMuonMatchAndPlot.h.

Referenced by selectedMuons().

◆ probeMuonEtaMax_

double HLTMuonMatchAndPlot::probeMuonEtaMax_

private

Definition at line 112 of file HLTMuonMatchAndPlot.h.

Referenced by selectedMuons().

◆ probeMuonEtaMin_

double HLTMuonMatchAndPlot::probeMuonEtaMin_

private

Definition at line 113 of file HLTMuonMatchAndPlot.h.

Referenced by selectedMuons().

◆ probeParams_

edm::ParameterSet HLTMuonMatchAndPlot::probeParams_

private

Definition at line 95 of file HLTMuonMatchAndPlot.h.

◆ probeZ0Cut_

double HLTMuonMatchAndPlot::probeZ0Cut_

private

Definition at line 115 of file HLTMuonMatchAndPlot.h.

Referenced by selectedMuons().

◆ requiredTriggers_

std::vector<std::string> HLTMuonMatchAndPlot::requiredTriggers_

private

Definition at line 91 of file HLTMuonMatchAndPlot.h.

◆ targetD0Cut_

double HLTMuonMatchAndPlot::targetD0Cut_

private

Definition at line 109 of file HLTMuonMatchAndPlot.h.

Referenced by selectedMuons().

◆ targetIsMuonGlb_

bool HLTMuonMatchAndPlot::targetIsMuonGlb_

private

Definition at line 107 of file HLTMuonMatchAndPlot.h.

Referenced by selectedMuons().

◆ targetMuonEtaMax_

double HLTMuonMatchAndPlot::targetMuonEtaMax_

private

Definition at line 105 of file HLTMuonMatchAndPlot.h.

Referenced by selectedMuons().

◆ targetMuonEtaMin_

double HLTMuonMatchAndPlot::targetMuonEtaMin_

private

Definition at line 106 of file HLTMuonMatchAndPlot.h.

Referenced by selectedMuons().

◆ targetParams_

edm::ParameterSet HLTMuonMatchAndPlot::targetParams_

private

Definition at line 94 of file HLTMuonMatchAndPlot.h.

◆ targetptCutJpsi_

double HLTMuonMatchAndPlot::targetptCutJpsi_

private

Definition at line 111 of file HLTMuonMatchAndPlot.h.

◆ targetptCutZ_

double HLTMuonMatchAndPlot::targetptCutZ_

private

Definition at line 110 of file HLTMuonMatchAndPlot.h.

◆ targetZ0Cut_

double HLTMuonMatchAndPlot::targetZ0Cut_

private

Definition at line 108 of file HLTMuonMatchAndPlot.h.

Referenced by selectedMuons().

◆ triggerEtaMaxCut_

double HLTMuonMatchAndPlot::triggerEtaMaxCut_

private

Definition at line 117 of file HLTMuonMatchAndPlot.h.

Referenced by selectedTriggerObjects().

◆ triggerEtaMinCut_

double HLTMuonMatchAndPlot::triggerEtaMinCut_

private

Definition at line 118 of file HLTMuonMatchAndPlot.h.

Referenced by selectedTriggerObjects().

◆ triggerLevel_

std::string HLTMuonMatchAndPlot::triggerLevel_

private

Definition at line 98 of file HLTMuonMatchAndPlot.h.

Referenced by analyze(), and HLTMuonMatchAndPlot().

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ DQMStore

◆ MonitorElement

Constructor & Destructor Documentation

◆ HLTMuonMatchAndPlot()

Member Function Documentation

◆ analyze()

◆ beginRun()

◆ book1D()

◆ book2D()

◆ endRun()

◆ fillEdges()

◆ fillMapFromPSet() [1/2]

◆ fillMapFromPSet() [2/2]

◆ matchByDeltaR() [1/2]

◆ matchByDeltaR() [2/2]

◆ selectedMuons()

◆ selectedTriggerObjects()

Member Data Documentation

◆ binParams_

◆ cutMinPt_

◆ destination_

◆ hists_

◆ hltPath_

◆ hltProcessName_

◆ isLastFilter_

◆ moduleLabel_

◆ plotCuts_

◆ probeD0Cut_

◆ probeIsMuonGlb_

◆ probeMuonEtaMax_

◆ probeMuonEtaMin_

◆ probeParams_

◆ probeZ0Cut_

◆ requiredTriggers_

◆ targetD0Cut_

◆ targetIsMuonGlb_

◆ targetMuonEtaMax_

◆ targetMuonEtaMin_

◆ targetParams_

◆ targetptCutJpsi_

◆ targetptCutZ_

◆ targetZ0Cut_

◆ triggerEtaMaxCut_

◆ triggerEtaMinCut_

◆ triggerLevel_