#include <HLTMuonPlotter.h>

Classes
struct	matchesByDescendingPt

struct	MatchStruct

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

void	beginJob ()

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

	HLTMuonPlotter (const edm::ParameterSet &, std::string, const std::vector< std::string > &, const std::vector< std::string > &, const boost::tuple< edm::EDGetTokenT< trigger::TriggerEventWithRefs >, edm::EDGetTokenT< reco::GenParticleCollection >, edm::EDGetTokenT< reco::MuonCollection > > &)

Static Public Member Functions
static boost::tuple < edm::EDGetTokenT < trigger::TriggerEventWithRefs > , edm::EDGetTokenT < reco::GenParticleCollection > , edm::EDGetTokenT < reco::MuonCollection > >	getTokens (const edm::ParameterSet &, edm::ConsumesCollector &&)

Private Member Functions
void	analyzePath (const edm::Event &, const std::string &, const std::string &, const std::vector< MatchStruct > &, edm::Handle< trigger::TriggerEventWithRefs >)

void	bookHist (DQMStore::IBooker &, std::string, std::string, std::string, std::string)

void	findMatches (std::vector< MatchStruct > &, const std::vector< l1extra::L1MuonParticleRef > &, const std::vector< std::vector< const reco::RecoChargedCandidate * > > &)

Private Attributes
double	cutMaxEta_

double	cutMinPt_

unsigned int	cutMotherId_

std::vector< double >	cutsDr_

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

std::string	genMuonCut_

StringCutObjectSelector < reco::GenParticle > *	genMuonSelector_

edm::EDGetTokenT < reco::GenParticleCollection >	genParticleLabel_

std::string	hltPath_

std::string	hltProcessName_

edm::EDGetTokenT < trigger::TriggerEventWithRefs >	hltTriggerSummaryRAW_

L1MuonMatcherAlgo	l1Matcher_

std::vector< std::string >	moduleLabels_

std::vector< double >	parametersEta_

std::vector< double >	parametersPhi_

std::vector< double >	parametersTurnOn_

std::string	recMuonCut_

edm::EDGetTokenT < reco::MuonCollection >	recMuonLabel_

StringCutObjectSelector < reco::Muon > *	recMuonSelector_

std::vector< std::string >	stepLabels_

Detailed Description

Generate histograms for muon trigger efficiencies Documentation available on the CMS TWiki: https://twiki.cern.ch/twiki/bin/view/CMS/MuonHLTOfflinePerformance

Author: J. Klukas, M. Vander Donckt, J. Alcaraz

Definition at line 58 of file HLTMuonPlotter.h.

Constructor & Destructor Documentation

HLTMuonPlotter::HLTMuonPlotter	(	const edm::ParameterSet &	,
		std::string	,
		const std::vector< std::string > &	,
		const std::vector< std::string > &	,
		const boost::tuple< edm::EDGetTokenT< trigger::TriggerEventWithRefs >, edm::EDGetTokenT< reco::GenParticleCollection >, edm::EDGetTokenT< reco::MuonCollection > > &
	)

Definition at line 36 of file HLTMuonPlotter.cc.

References cutsDr_, genMuonCut_, genMuonSelector_, genParticleLabel_, edm::ParameterSet::getParameter(), hltPath_, hltProcessName_, hltTriggerSummaryRAW_, moduleLabels_, parametersEta_, parametersPhi_, parametersTurnOn_, recMuonCut_, recMuonLabel_, recMuonSelector_, and stepLabels_.

                      :
                    
   l1Matcher_(pset)
 {
 
   hltPath_ = hltPath;
   moduleLabels_ = moduleLabels;
   stepLabels_ = stepLabels;
   hltProcessName_  = pset.getParameter<string>("hltProcessName");
 
   cutsDr_      = pset.getParameter< vector<double> >("cutsDr"     );
 
   parametersEta_    = pset.getParameter< vector<double> >("parametersEta");
   parametersPhi_    = pset.getParameter< vector<double> >("parametersPhi");
   parametersTurnOn_ = pset.getParameter< vector<double> >("parametersTurnOn");
 
   genMuonCut_ = pset.getParameter<string>("genMuonCut");
   recMuonCut_ = pset.getParameter<string>("recMuonCut");
 
   genMuonSelector_ = 0;
   recMuonSelector_ = 0;
 
   //set tokens
   hltTriggerSummaryRAW_ = tokens.get<0>();
   genParticleLabel_ = tokens.get<1>();
   recMuonLabel_ = tokens.get<2>();
 
 }

Member Function Documentation

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

Definition at line 137 of file HLTMuonPlotter.cc.

References prof2calltree::count, cutMaxEta_, cutMinPt_, elements_, eta(), edm::HandleBase::failedToGet(), HcalObjRepresent::Fill(), spr::find(), findMatches(), genMuonCut_, genMuonSelector_, genParticleLabel_, genParticleCandidates2GenParticles_cfi::genParticles, edm::Event::getByToken(), hltPath_, hltProcessName_, hltTriggerSummaryRAW_, i, edm::HandleBase::isValid(), j, testEve_cfg::level, LogTrace, moduleLabels_, phi, EnergyCorrector::pt, recMuonCut_, recMuonLabel_, recMuonSelector_, findQualityFiles::size, python.multivaluedict::sort(), source, relval_parameters_module::step, stepLabels_, GlobalPosition_Frontier_DevDB_cff::tag, trigger::TriggerL1Mu, and trigger::TriggerMuon.

 {
 
   static int eventNumber = 0;
   eventNumber++;
   LogTrace("HLTMuonVal") << "In HLTMuonPlotter::analyze,  " 
                          << "Event: " << eventNumber;
 
   // cout << hltPath_ << endl;
   // for (size_t i = 0; i < moduleLabels_.size(); i++)
   //   cout << "    " << moduleLabels_[i] << endl;
 
   Handle<          TriggerEventWithRefs> rawTriggerEvent;
   Handle<                MuonCollection> recMuons;
   Handle<         GenParticleCollection> genParticles;
 
   iEvent.getByToken(hltTriggerSummaryRAW_, rawTriggerEvent);
   if (rawTriggerEvent.failedToGet())
     {LogError("HLTMuonVal") << "No trigger summary found"; return;}
   iEvent.getByToken(recMuonLabel_, recMuons);
   iEvent.getByToken(genParticleLabel_, genParticles );
 
   vector<string> sources;
   if (genParticles.isValid()) sources.push_back("gen");
   if (    recMuons.isValid()) sources.push_back("rec");
 
   for (size_t sourceNo = 0; sourceNo < sources.size(); sourceNo++) {
 
     string source = sources[sourceNo];
     
     // If this is the first event, initialize selectors
     if (!genMuonSelector_) genMuonSelector_ =
       new StringCutObjectSelector<reco::GenParticle>(genMuonCut_);
     if (!recMuonSelector_) recMuonSelector_ =
       new StringCutObjectSelector<reco::Muon       >(recMuonCut_);
 
     // Make each good gen/rec muon into the base cand for a MatchStruct
     vector<MatchStruct> matches;
     if (source == "gen" && genParticles.isValid())
       for (size_t i = 0; i < genParticles->size(); i++)
         if ((*genMuonSelector_)(genParticles->at(i)))
           matches.push_back(MatchStruct(& genParticles->at(i)));
     if (source == "rec" && recMuons.isValid())
       for (size_t i = 0; i < recMuons->size(); i++)
         if ((*recMuonSelector_)(recMuons->at(i)))
           matches.push_back(MatchStruct(& recMuons->at(i)));
     
     // Sort the MatchStructs by pT for later filling of turn-on curve
     sort(matches.begin(), matches.end(), matchesByDescendingPt());
 
     const bool isDoubleMuonPath = (hltPath_.find("Double") != string::npos);
     const size_t nFilters   = moduleLabels_.size();
     const size_t nSteps     = stepLabels_.size();
     const size_t nStepsHlt  = nSteps - 2;
     const int nObjectsToPassPath = (isDoubleMuonPath) ? 2 : 1;
     vector< L1MuonParticleRef > candsL1;
     vector< vector< RecoChargedCandidateRef      > > refsHlt(nStepsHlt);
     vector< vector< const RecoChargedCandidate * > > candsHlt(nStepsHlt);
     
     for (size_t i = 0; i < nFilters; i++) {
       const int hltStep = i - 1;
       InputTag tag = InputTag(moduleLabels_[i], "", hltProcessName_);
       size_t iFilter = rawTriggerEvent->filterIndex(tag);
       if (iFilter < rawTriggerEvent->size()) {
         if (i == 0)
           rawTriggerEvent->getObjects(iFilter, TriggerL1Mu, candsL1);
         else
           rawTriggerEvent->getObjects(iFilter, TriggerMuon, 
                                       refsHlt[hltStep]);
       }
       else LogTrace("HLTMuonVal") << "No collection with label " << tag;
     }
     for (size_t i = 0; i < nStepsHlt; i++)
       for (size_t j = 0; j < refsHlt[i].size(); j++)
         if (refsHlt[i][j].isAvailable()) {
           candsHlt[i].push_back(& * refsHlt[i][j]);
         } else {
           LogWarning("HLTMuonPlotter")
             << "Ref refsHlt[i][j]: product not available "
             << i << " " << j;
         }
     
     // Add trigger objects to the MatchStructs
     findMatches(matches, candsL1, candsHlt);
     
     vector<size_t> matchesInEtaRange;
     vector<bool> hasMatch(matches.size(), true);
     
     for (size_t step = 0; step < nSteps; step++) {
       
       const size_t hltStep = (step >= 2) ? step - 2 : 0;
       size_t level = 0;
       if ((stepLabels_[step].find("L3") != string::npos)||(stepLabels_[step].find("Tk") != string::npos)) level = 3;
       else if (stepLabels_[step].find("L2") != string::npos) level = 2;
       else if (stepLabels_[step].find("L1") != string::npos) level = 1;
       
       for (size_t j = 0; j < matches.size(); j++) {
         if (level == 0) {
           if (fabs(matches[j].candBase->eta()) < cutMaxEta_)
             matchesInEtaRange.push_back(j);
         }
         else if (level == 1) {
           if (matches[j].candL1 == 0)
             hasMatch[j] = false;
         }
         else if (level >= 2) {
           if (matches[j].candHlt[hltStep] == 0)
             hasMatch[j] = false;
           else if (!hasMatch[j]) {
             LogTrace("HLTMuonVal") << "Match found for HLT step " << hltStep
                                    << " of " << nStepsHlt 
                                    << " without previous match!";
             break;
           }
         }
       }
       
       if (std::count(hasMatch.begin(), hasMatch.end(), true) <
           nObjectsToPassPath) 
         break;
       
       string pre  = source + "Pass";
       string post = "_" + stepLabels_[step];
       
       for (size_t j = 0; j < matches.size(); j++) {
         float pt  = matches[j].candBase->pt();
         float eta = matches[j].candBase->eta();
         float phi = matches[j].candBase->phi();
         if (hasMatch[j]) { 
           if (matchesInEtaRange.size() >= 1 && j == matchesInEtaRange[0])
             elements_[pre + "MaxPt1" + post]->Fill(pt);
           if (matchesInEtaRange.size() >= 2 && j == matchesInEtaRange[1])
             elements_[pre + "MaxPt2" + post]->Fill(pt);
           if (pt > cutMinPt_) {
             elements_[pre + "Eta" + post]->Fill(eta);
             if (fabs(eta) < cutMaxEta_)
               elements_[pre + "Phi" + post]->Fill(phi);
           }
         }
       }
       
     }
     
     
     
   } // End loop over sources
   
 }

void HLTMuonPlotter::analyzePath	(	const edm::Event &	,
		const std::string &	,
		const std::string &	,
		const std::vector< MatchStruct > &	,
		edm::Handle< trigger::TriggerEventWithRefs >
	)

private

void HLTMuonPlotter::beginJob ( void )

Definition at line 75 of file HLTMuonPlotter.cc.

 {
 
 }

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

Definition at line 83 of file HLTMuonPlotter.cc.

References DQMStore::IBooker::bookFloat(), bookHist(), cutMaxEta_, cutMinPt_, elements_, hltPath_, i, L1MuonMatcherAlgo::init(), j, l1Matcher_, convertSQLiteXML::runNumber, DQMStore::IBooker::setCurrentFolder(), source, stepLabels_, and dtDQMClient_cfg::threshold.

 {
 
   static int runNumber = 0;
   runNumber++;
 
   l1Matcher_.init(iSetup);
 
   cutMaxEta_ = 2.4;
   if (hltPath_.find("eta2p1") != string::npos) 
     cutMaxEta_ = 2.1;
 
   // Choose a pT cut for gen/rec muons based on the pT cut in the hltPath_
   unsigned int threshold = 0;
   TPRegexp ptRegexp("Mu([0-9]+)");
   TObjArray * regexArray = ptRegexp.MatchS(hltPath_);
   if (regexArray->GetEntriesFast() == 2) {
     threshold = atoi(((TObjString *)regexArray->At(1))->GetString());
   }
   delete regexArray;
   // We select a whole number min pT cut slightly above the hltPath_'s final 
   // pt threshold, then subtract a bit to let through particle gun muons with
   // exact integer pT:
   cutMinPt_ = ceil(threshold * 1.1) - 0.01;
   if (cutMinPt_ < 0.) cutMinPt_ = 0.;
   
   string baseDir = "HLT/Muon/Distributions/";
   iBooker.setCurrentFolder(baseDir + hltPath_);
 
   vector<string> sources(2);
   sources[0] = "gen";
   sources[1] = "rec";
 
   elements_["CutMinPt" ] = iBooker.bookFloat("CutMinPt" );
   elements_["CutMaxEta"] = iBooker.bookFloat("CutMaxEta");
   elements_["CutMinPt" ]->Fill(cutMinPt_);
   elements_["CutMaxEta"]->Fill(cutMaxEta_);
 
   for (size_t i = 0; i < sources.size(); i++) {
     string source = sources[i];
     for (size_t j = 0; j < stepLabels_.size(); j++) {
       bookHist(iBooker, hltPath_, stepLabels_[j], source, "Eta");
       bookHist(iBooker, hltPath_, stepLabels_[j], source, "Phi");
       bookHist(iBooker, hltPath_, stepLabels_[j], source, "MaxPt1");
       bookHist(iBooker, hltPath_, stepLabels_[j], source, "MaxPt2");
     }
   }
 
 }

void HLTMuonPlotter::bookHist	(	DQMStore::IBooker &	,
		std::string	,
		std::string	,
		std::string	,
		std::string
	)

private

Definition at line 394 of file HLTMuonPlotter.cc.

References DQMStore::IBooker::book1D(), prof2calltree::edges, elements_, h, i, diffTwoXMLs::label, bookConverter::max, min(), mergeVDriftHistosByStation::name, parametersEta_, parametersPhi_, parametersTurnOn_, source, and indexGen::title.

Referenced by beginRun().

 {
 
   string sourceUpper = source; 
   sourceUpper[0] = toupper(sourceUpper[0]);
   string name = source + "Pass" + type + "_" + label;
   TH1F * h;
 
   if (type.find("MaxPt") != string::npos) {
     string desc = (type == "MaxPt1") ? "Leading" : "Next-to-Leading";
     string title = "pT of " + desc + " " + sourceUpper + " Muon "+
                    "matched to " + label;
     const size_t nBins = parametersTurnOn_.size() - 1;
     float * edges = new float[nBins + 1];
     for (size_t i = 0; i < nBins + 1; i++) edges[i] = parametersTurnOn_[i];
     h = new TH1F(name.c_str(), title.c_str(), nBins, edges);
   }
 
   else {
     string symbol = (type == "Eta") ? "#eta" : "#phi";
     string title  = symbol + " of " + sourceUpper + " Muons " +
                     "matched to " + label;
     vector<double> params = (type == "Eta") ? parametersEta_ : parametersPhi_; 
     int    nBins = (int)params[0];
     double min   = params[1];
     double max   = params[2];
     h = new TH1F(name.c_str(), title.c_str(), nBins, min, max);
   }
 
   h->Sumw2();
   elements_[name] = iBooker.book1D(name, h);
   delete h;
 
 }

void HLTMuonPlotter::findMatches	(	std::vector< MatchStruct > &	matches,
		const std::vector< l1extra::L1MuonParticleRef > &	candsL1,
		const std::vector< std::vector< const reco::RecoChargedCandidate * > > &	candsHlt
	)

private

Definition at line 309 of file HLTMuonPlotter.cc.

References begin, deltar::bestMatch(), cutsDr_, deltaR(), PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, reco::Candidate::eta(), i, edm::eventsetup::heterocontainer::insert(), j, kNull, testEve_cfg::level, and reco::Candidate::phi().

Referenced by analyze().

 {
 
   set<size_t>::iterator it;
 
   set<size_t> indicesL1;
   for (size_t i = 0; i < candsL1.size(); i++) 
     indicesL1.insert(i);
 
   vector< set<size_t> > indicesHlt(candsHlt.size());
   for (size_t i = 0; i < candsHlt.size(); i++)
     for (size_t j = 0; j < candsHlt[i].size(); j++)
       indicesHlt[i].insert(j);
 
   for (size_t i = 0; i < matches.size(); i++) {
 
     const Candidate * cand = matches[i].candBase;
 
     double bestDeltaR = cutsDr_[0];
     size_t bestMatch = kNull;
     for (it = indicesL1.begin(); it != indicesL1.end(); it++) {
      if (candsL1[*it].isAvailable()) {
       double dR = deltaR(cand->eta(), cand->phi(),
                          candsL1[*it]->eta(), candsL1[*it]->phi());
       if (dR < bestDeltaR) {
         bestMatch = *it;
         bestDeltaR = dR;
       }
       // TrajectoryStateOnSurface propagated;
       // float dR = 999., dPhi = 999.;
       // bool isValid = l1Matcher_.match(* cand, * candsL1[*it], 
       //                                 dR, dPhi, propagated);
       // if (isValid && dR < bestDeltaR) {
       //   bestMatch = *it;
       //   bestDeltaR = dR;
       // }
      } else {
        LogWarning("HLTMuonPlotter")
      << "Ref candsL1[*it]: product not available "
      << *it;
      }
     }
     if (bestMatch != kNull)
       matches[i].candL1 = & * candsL1[bestMatch];
     indicesL1.erase(bestMatch);
 
     matches[i].candHlt.assign(candsHlt.size(), 0);
     for (size_t j = 0; j < candsHlt.size(); j++) {
       size_t level = (candsHlt.size() == 4) ? (j < 2) ? 2 : 3 :
                      (candsHlt.size() == 2) ? (j < 1) ? 2 : 3 :
                      2;
       bestDeltaR = cutsDr_[level - 2];
       bestMatch = kNull;
       for (it = indicesHlt[j].begin(); it != indicesHlt[j].end(); it++) {
         double dR = deltaR(cand->eta(), cand->phi(),
                            candsHlt[j][*it]->eta(), candsHlt[j][*it]->phi());
         if (dR < bestDeltaR) {
           bestMatch = *it;
           bestDeltaR = dR;
         }
       }
       if (bestMatch != kNull)
         matches[i].candHlt[j] = candsHlt[j][bestMatch];
       indicesHlt[j].erase(bestMatch);
     }
 
 //     cout << "    Muon: " << cand->eta() << ", ";
 //     if (matches[i].candL1) cout << matches[i].candL1->eta() << ", ";
 //     else cout << "none, ";
 //     for (size_t j = 0; j < candsHlt.size(); j++) 
 //       if (matches[i].candHlt[j]) cout << matches[i].candHlt[j]->eta() << ", ";
 //       else cout << "none, ";
 //     cout << endl;
 
   }
 
 }

boost::tuple< edm::EDGetTokenT< trigger::TriggerEventWithRefs >, edm::EDGetTokenT< reco::GenParticleCollection >, edm::EDGetTokenT< reco::MuonCollection > > HLTMuonPlotter::getTokens	(	const edm::ParameterSet &	pset,
		edm::ConsumesCollector &&	iC
	)

static

Definition at line 291 of file HLTMuonPlotter.cc.

References edm::ParameterSet::getParameter().

Referenced by HLTMuonValidator::HLTMuonValidator().

 {
 
   edm::EDGetTokenT<trigger::TriggerEventWithRefs> _hltTriggerSummaryRAW = iC.consumes<TriggerEventWithRefs>(edm::InputTag("hltTriggerSummaryRAW"));
   edm::EDGetTokenT<reco::GenParticleCollection> _genParticleLabel = iC.consumes<GenParticleCollection>(pset.getParameter<string>("genParticleLabel"));
   edm::EDGetTokenT<reco::MuonCollection> _recMuonLabel = iC.consumes<MuonCollection>(pset.getParameter<string>("recMuonLabel"));
 
   boost::tuple<
     edm::EDGetTokenT<trigger::TriggerEventWithRefs>,
     edm::EDGetTokenT<reco::GenParticleCollection>,
     edm::EDGetTokenT<reco::MuonCollection> > myTuple(_hltTriggerSummaryRAW,_genParticleLabel,_recMuonLabel);
 
   return (myTuple);
 }