#include <MuonPFAnalyzer.h>

Inheritance diagram for MuonPFAnalyzer:

Public Types
typedef std::vector< RecoGenPair >	RecoGenCollection

typedef std::pair< const reco::Muon , const reco::GenParticle >	RecoGenPair

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

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

	MuonPFAnalyzer (const edm::ParameterSet &)
	Constructor. More...

	~MuonPFAnalyzer () override
	Destructor. More...

Public Member Functions inherited from one::DQMEDAnalyzer< T >
	DQMEDAnalyzer ()=default

	DQMEDAnalyzer (DQMEDAnalyzer< T... > const &)=delete

	DQMEDAnalyzer (DQMEDAnalyzer< T... > &&)=delete

	~DQMEDAnalyzer () override=default

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

float	combRelIso (const reco::Muon *muon)

float	fDeltaPhi (float phi1, float phi2)

void	fillInRange (MonitorElement *plot, int nAxis, double x, double y=0)

MonitorElement *	getPlot (const std::string &group, const std::string &type)

const reco::Vertex	getPrimaryVertex (edm::Handle< reco::VertexCollection > &vertex, edm::Handle< reco::BeamSpot > &beamSpot)

int	muonTrackType (const reco::Muon *muon, bool usePF)

void	recoToGenMatch (edm::Handle< reco::MuonCollection > &reco, edm::Handle< reco::GenParticleCollection > &gen)

void	setCodeLabels (MonitorElement *plot, int nAxis)

Private Attributes
edm::EDGetTokenT< reco::BeamSpot >	theBeamSpotLabel_

std::string	theFolder

edm::EDGetTokenT< reco::GenParticleCollection >	theGenLabel_

double	theHighPtTh

double	theIsoCut

std::vector< std::string >	theMuonKinds

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

RecoGenCollection	theRecoGen

double	theRecoGenR

edm::EDGetTokenT< reco::MuonCollection >	theRecoLabel_

bool	theRunOnMC

edm::EDGetTokenT< reco::VertexCollection >	theVertexLabel_

Detailed Description

Definition at line 34 of file MuonPFAnalyzer.h.

Member Typedef Documentation

typedef std::vector<RecoGenPair> MuonPFAnalyzer::RecoGenCollection

Definition at line 39 of file MuonPFAnalyzer.h.

typedef std::pair<const reco::Muon*, const reco::GenParticle*> MuonPFAnalyzer::RecoGenPair

Definition at line 38 of file MuonPFAnalyzer.h.

Constructor & Destructor Documentation

MuonPFAnalyzer::MuonPFAnalyzer ( const edm::ParameterSet & pSet )

explicit

Constructor.

Definition at line 42 of file MuonPFAnalyzer.cc.

References edm::ParameterSet::getParameter(), and LogTrace.

                                                       {
   
   LogTrace("MuonPFAnalyzer") << "[MuonPFAnalyzer] Initializing configuration from parameterset.\n";
   
   theGenLabel_      = consumes<GenParticleCollection>(pSet.getParameter<InputTag>("inputTagGenParticles"));  
   theRecoLabel_     = consumes<MuonCollection>       (pSet.getParameter<InputTag>("inputTagMuonReco"));  
   theVertexLabel_   = consumes<VertexCollection>     (pSet.getParameter<InputTag>("inputTagVertex"));  
   theBeamSpotLabel_ = consumes<BeamSpot>             (pSet.getParameter<InputTag>("inputTagBeamSpot"));  
   
   theHighPtTh   = pSet.getParameter<double>("highPtThreshold");
   theRecoGenR   = pSet.getParameter<double>("recoGenDeltaR");
   theIsoCut     = pSet.getParameter<double>("relCombIsoCut");
   theRunOnMC    = pSet.getParameter<bool>("runOnMC");
   
   theFolder = pSet.getParameter<string>("folder");
   
   theMuonKinds.push_back("");          // all TUNEP/PF muons
   theMuonKinds.push_back("Tight");     // tight TUNEP/PF muons
   theMuonKinds.push_back("TightIso");  // tight/iso TUNEP/PF muons
  
 
 }

MuonPFAnalyzer::~MuonPFAnalyzer ( )

override

Destructor.

Definition at line 66 of file MuonPFAnalyzer.cc.

References LogTrace.

                                 {
   LogTrace("MuonPFAnalyzer") << "[MuonPFAnalyzer] Destructor called.\n";
 }

Member Function Documentation

void MuonPFAnalyzer::analyze	(	const edm::Event &	event,
		const edm::EventSetup &	context
	)

override

Definition at line 92 of file MuonPFAnalyzer.cc.

References ecalDrivenElectronSeedsParameters_cff::beamSpot, PVValHelper::eta, dataDML::fillInRange(), runTauDisplay::genMuons, PFJetFilter_cfi::genPt, edmIntegrityCheck::group, reco::Muon::innerTrack(), edm::Ref< C, T, F >::isNull(), reco::Muon::isPFMuon(), muon::isTightMuon(), callgraph::kind, extraflags_cff::muons, reco::LeafCandidate::p4(), impactParameterTagInfos_cfi::primaryVertex, EnergyCorrector::pt, reco::LeafCandidate::pt(), and reco::Muon::tunePMuonBestTrack().

 {
   
   Handle<reco::MuonCollection> muons;
   event.getByToken(theRecoLabel_, muons);
 
   Handle<GenParticleCollection> genMuons;
   event.getByToken(theGenLabel_, genMuons);
 
   Handle<BeamSpot> beamSpot;
   event.getByToken(theBeamSpotLabel_, beamSpot);
 
   Handle<VertexCollection> vertex;
   event.getByToken(theVertexLabel_, vertex);
 
   const Vertex primaryVertex = getPrimaryVertex(vertex, beamSpot);
 
   recoToGenMatch(muons, genMuons);
  
   RecoGenCollection::const_iterator recoGenIt  = theRecoGen.begin();
   RecoGenCollection::const_iterator recoGenEnd = theRecoGen.end();
     
   for (;recoGenIt!=recoGenEnd;++recoGenIt) 
     {
     
       const Muon *muon = recoGenIt->first;
       TrackRef tunePTrack = muon->tunePMuonBestTrack();
 
      const GenParticle *genMuon = recoGenIt->second;
       
       vector<string>::const_iterator kindIt  = theMuonKinds.begin();
       vector<string>::const_iterator kindEnd = theMuonKinds.end();
 
       for (;kindIt!=kindEnd;++kindIt) 
     { 
 
       const string & kind = (*kindIt);
 
       if (kind.find("Tight") != string::npos && 
           !muon::isTightMuon((*muon), primaryVertex)) continue;
       
       if (kind.find("Iso") != string::npos &&
           combRelIso(muon) > theIsoCut) continue;
       
       if (theRunOnMC && genMuon && !muon->innerTrack().isNull() ) // has matched gen muon
         {
 
           if (!tunePTrack.isNull())
         { 
 
           string group = "TUNEP" + kind;
 
           float pt  = tunePTrack->pt();
           float phi = tunePTrack->phi();
           float eta = tunePTrack->eta();
 
           float genPt  = genMuon->pt();
           float genPhi = genMuon->p4().phi();
           float genEta = genMuon->p4().eta();
 
           float dPtOverPt = (pt / genPt) - 1;
           
           if (pt < theHighPtTh)
             {
 
               fillInRange(getPlot(group,"code"),1,muonTrackType(muon, false));
               fillInRange(getPlot(group,"deltaPtOverPt"),1,dPtOverPt);
             }
           else
             {
               fillInRange(getPlot(group,"codeHighPt"),1,muonTrackType(muon, false));
               fillInRange(getPlot(group,"deltaPtOverPtHighPt"),1,dPtOverPt);
             }
     
           fillInRange(getPlot(group,"deltaPt"),1,(pt - genPt));
           fillInRange(getPlot(group,"deltaPhi"),1,fDeltaPhi(genPhi,phi));
           fillInRange(getPlot(group,"deltaEta"),1,genEta - eta);
       
         }
           
           if (muon->isPFMuon()) 
         {
           
           string group = "PF" + kind;
           
           // Assumes that default in muon is PF
           float pt  = muon->pt();
           float phi = muon->p4().phi();
           float eta = muon->p4().eta();
           
           float genPt  = genMuon->pt();
           float genPhi = genMuon->p4().phi();
           float genEta = genMuon->p4().eta();
 
           float dPtOverPt = (pt / genPt) - 1;
           
           if (pt < theHighPtTh)
             {
               fillInRange(getPlot(group,"code"),1,muonTrackType(muon, true));
               fillInRange(getPlot(group,"deltaPtOverPt"),1,dPtOverPt);
             }
           else
             { 
               fillInRange(getPlot(group,"codeHighPt"),1,muonTrackType(muon, true));
               fillInRange(getPlot(group,"deltaPtOverPtHighPt"),1,dPtOverPt);
             }
           
           
           fillInRange(getPlot(group,"deltaPt"),1,pt - genPt);
           fillInRange(getPlot(group,"deltaPhi"),1,fDeltaPhi(genPhi,phi));
           fillInRange(getPlot(group,"deltaEta"),1,genEta - eta);
           
         }
         
         }
 
     
 
         if (muon->isPFMuon() && !tunePTrack.isNull() &&          
         !muon->innerTrack().isNull()) // Compare PF with TuneP + Tracker 
           {                               // No gen matching needed
     
           string group = "PFvsTUNEP" + kind;
 
           float pt  = tunePTrack->pt();
           float phi = tunePTrack->phi();
           float eta = tunePTrack->eta();
           
           // Assumes that default in muon is PF
           float pfPt  = muon->pt();
           float pfPhi = muon->p4().phi();
           float pfEta = muon->p4().eta();
           float dPtOverPt = (pfPt / pt) - 1; // TUNEP vs PF pt used as denum.
          
 
           if (pt < theHighPtTh) 
         {
           fillInRange(getPlot(group,"code"),2,
                   muonTrackType(muon, false),muonTrackType(muon, true));
           fillInRange(getPlot(group,"deltaPtOverPt"),1,dPtOverPt);
         }
           else 
         {
           fillInRange(getPlot(group,"codeHighPt"),
                   2,muonTrackType(muon, false),muonTrackType(muon, true));
           fillInRange(getPlot(group,"deltaPtOverPtHighPt"),1,dPtOverPt);
         }
           
           fillInRange(getPlot(group,"deltaPt"),1,pfPt - pt);
           fillInRange(getPlot(group,"deltaPhi"),1,fDeltaPhi(pfPhi,phi));
           fillInRange(getPlot(group,"deltaEta"),1,pfEta - eta);
           
 
           if (theRunOnMC && genMuon) // has a matched gen muon
         
         {
           
           float genPt     = genMuon->pt();
           float dPtOverPtGen = (pt / genPt) - 1;
           float dPtOverPtGenPF = (pfPt / genPt) - 1;
           
           if (pt < theHighPtTh) 
             {
               fillInRange(getPlot(group,"deltaPtOverPtPFvsTUNEP"),
                   2,dPtOverPtGen,dPtOverPtGenPF);
             }
           else 
             {
               fillInRange(getPlot(group,"deltaPtOverPtHighPtPFvsTUNEP"),
                   2,dPtOverPtGen,dPtOverPtGenPF);
             }
         }         
           
           }
         
     }
       
     }
 
 }

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

override

Definition at line 71 of file MuonPFAnalyzer.cc.

References bookHistos().

                                            {
   
   if(theRunOnMC)
     {
       bookHistos(ibooker, "PF");
       bookHistos(ibooker, "PFTight");
       bookHistos(ibooker, "PFTightIso");
       bookHistos(ibooker, "TUNEP");
       bookHistos(ibooker, "TUNEPTight");
       bookHistos(ibooker, "TUNEPTightIso");
     }
  
     bookHistos(ibooker,"PFvsTUNEP");
     bookHistos(ibooker,"PFvsTUNEPTight");
     bookHistos(ibooker,"PFvsTUNEPTightIso");
   
 
 }

void MuonPFAnalyzer::bookHistos	(	DQMStore::IBooker &	,
		const std::string &
	)

private

Definition at line 277 of file MuonPFAnalyzer.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), edmIntegrityCheck::group, LogTrace, plotFactory::plot, and DQMStore::IBooker::setCurrentFolder().

                                       { 
 
   
 
   LogTrace("MuonPFAnalyzer") << "[MuonPFAnalyzer] Booking histos for group :"
                  << group << "\n";
 
   ibooker.setCurrentFolder(string(theFolder) + group);
  
 
     bool isPFvsTUNEP = group.find("PFvsTUNEP") != string::npos;
     
     string hName;
     
       
     hName  = "deltaPtOverPt" + group;
     thePlots[group]["deltaPtOverPt"] = ibooker.book1D(hName.c_str(),hName.c_str(),101,-1.01,1.01);
     
     hName = "deltaPtOverPtHighPt" + group;
     thePlots[group]["deltaPtOverPtHighPt"] = ibooker.book1D(hName.c_str(),hName.c_str(),101,-1.01,1.01);
     
     hName = "deltaPt" + group;
     thePlots[group]["deltaPt"] = ibooker.book1D(hName.c_str(),hName.c_str(),201.,-10.25,10.25);
     
     hName = "deltaPhi"+group;
     thePlots[group]["deltaPhi"] = ibooker.book1D(hName.c_str(),hName.c_str(),51.,0,.0102);
     
     hName = "deltaEta"+group;
     thePlots[group]["deltaEta"] = ibooker.book1D(hName.c_str(),hName.c_str(),101.,-.00505,.00505);
     
 
 
     if (isPFvsTUNEP) {
 
      
       hName = "code"+group;
       MonitorElement * plot = ibooker.book2D(hName.c_str(),hName.c_str(),7,-.5,6.5,7,-.5,6.5);
       thePlots[group]["code"] = plot;
       setCodeLabels(plot,1);
       setCodeLabels(plot,2);
       
       hName = "codeHighPt"+group;
       plot = ibooker.book2D(hName.c_str(),hName.c_str(),7,-.5,6.5,7,-.5,6.5);
       thePlots[group]["codeHighPt"] = plot; 
       setCodeLabels(plot,1);
       setCodeLabels(plot,2);
     
 
       if (theRunOnMC)
     {   
       hName = "deltaPtOverPtPFvsTUNEP" + group;
       thePlots[group]["deltaPtOverPtPFvsTUNEP"] =  
         ibooker.book2D(hName.c_str(),hName.c_str(),
                101,-1.01,1.01,101,-1.01,1.01);
 
       hName = "deltaPtOverPtHighPtPFvsTUNEP" + group;
       thePlots[group]["deltaPtOverPtHighPtPFvsTUNEP"] =  
         ibooker.book2D(hName.c_str(),hName.c_str(),
                101,-1.01,1.01,101,-1.01,1.01);
     }
     } else {
       hName = "code"+group;
       MonitorElement * plot = ibooker.book1D(hName.c_str(),hName.c_str(),7,-.5,6.5);
       thePlots[group]["code"] = plot;
       setCodeLabels(plot,1);
 
       hName = "codeHighPt"+group;
       plot = ibooker.book1D(hName.c_str(),hName.c_str(),7,-.5,6.5);
       thePlots[group]["codeHighPt"] = plot;  
       setCodeLabels(plot,1);
     }
   
 }

float MuonPFAnalyzer::combRelIso ( const reco::Muon * muon )

inlineprivate

Definition at line 376 of file MuonPFAnalyzer.cc.

References reco::MuonIsolation::emEt, reco::MuonIsolation::hadEt, reco::Muon::isolationR03(), reco::LeafCandidate::pt(), and reco::MuonIsolation::sumPt.

 {
   
   MuonIsolation iso = muon->isolationR03();
   float combRelIso = (iso.emEt + iso.hadEt + iso.sumPt) / muon->pt();  
 
   return combRelIso;
   
 }

float MuonPFAnalyzer::fDeltaPhi	(	float	phi1,
		float	phi2
	)

inlineprivate

Definition at line 387 of file MuonPFAnalyzer.cc.

References funct::cos().

                                                              {
   
   float fPhiDiff = fabs(acos(cos(phi1-phi2)));
   return fPhiDiff;
   
 }

void MuonPFAnalyzer::fillInRange	(	MonitorElement *	plot,
		int	nAxis,
		double	x,
		double	y = `0`
	)

private

Definition at line 421 of file MuonPFAnalyzer.cc.

References MonitorElement::Fill(), MonitorElement::getTH1(), trackerHits::histo, mps_fire::i, edm::max(), and edm::min().

 {
 
   TH1 * histo =  plot->getTH1();
   
   TAxis *axis[2] = {nullptr, nullptr};
   axis[0] = histo->GetXaxis();
   if (nAxis == 2)
     axis[1] = histo->GetYaxis();
 
   double value[2] = {0, 0};
   value[0] = x;
   value[1] = y;
 
   for (int i = 0;i<nAxis;++i)
     {
       double min = axis[i]->GetXmin();
       double max = axis[i]->GetXmax();
 
       if (value[i] <= min)
     value[i] = axis[i]->GetBinCenter(1);
 
       if (value[i] >= max)
     value[i] = axis[i]->GetBinCenter(axis[i]->GetNbins());
     }
 
   if (nAxis == 2)
     plot->Fill(value[0],value[1]);
   else
     plot->Fill(value[0]);
   
 }

MonitorElement * MuonPFAnalyzer::getPlot	(	const std::string &	group,
		const std::string &	type
	)

private

Definition at line 353 of file MuonPFAnalyzer.cc.

References LogTrace.

                                           {
 
   map<string,map<string,MonitorElement *> >::iterator groupIt = thePlots.find(group);
   if (groupIt == thePlots.end()) {
     LogTrace("MuonPFAnalyzer") << "[MuonPFAnalyzer] GROUP : " << group 
                    << " is not a valid plot group. Returning 0.\n";
     return nullptr;
   }
   
   map<string,MonitorElement *>::iterator typeIt = groupIt->second.find(type);
   if (typeIt == groupIt->second.end()) {
     LogTrace("MuonPFAnalyzer") << "[MuonPFAnalyzer] TYPE : " << type 
                    << " is not a valid type for GROUP : " << group 
                    << ". Returning 0.\n";
     return nullptr;
   }
   
   return typeIt->second;
 
 } 

const reco::Vertex MuonPFAnalyzer::getPrimaryVertex	(	edm::Handle< reco::VertexCollection > &	vertex,
		edm::Handle< reco::BeamSpot > &	beamSpot
	)

private

Definition at line 536 of file MuonPFAnalyzer.cc.

References reco::BeamSpot::BeamWidthX(), reco::BeamSpot::BeamWidthY(), DEFINE_FWK_MODULE, edm::HandleBase::isValid(), reco::BeamSpot::position(), impactParameterTagInfos_cfi::primaryVertex, and reco::BeamSpot::sigmaZ().

 {
 
   Vertex::Point posVtx;
   Vertex::Error errVtx;
 
   bool hasPrimaryVertex = false;
 
   if (vertex.isValid())
     {
 
       vector<Vertex>::const_iterator vertexIt  = vertex->begin();
       vector<Vertex>::const_iterator vertexEnd = vertex->end();
 
       for (;vertexIt!=vertexEnd;++vertexIt) 
     {
       if (vertexIt->isValid() && 
           !vertexIt->isFake()) 
         {
           posVtx = vertexIt->position();
           errVtx = vertexIt->error();
           hasPrimaryVertex = true;        
           break;
         }
     }
     }
 
   if ( !hasPrimaryVertex ) {
 
     LogInfo("MuonPFAnalyzer") << 
       "[MuonPFAnalyzer] PrimaryVertex not found, use BeamSpot position instead.\n";
 
     posVtx = beamSpot->position();
     errVtx(0,0) = beamSpot->BeamWidthX();
     errVtx(1,1) = beamSpot->BeamWidthY();
     errVtx(2,2) = beamSpot->sigmaZ();
     
   }
 
   const Vertex primaryVertex(posVtx,errVtx);
 
   return primaryVertex;
 
 }

int MuonPFAnalyzer::muonTrackType	(	const reco::Muon *	muon,
		bool	usePF
	)

private

Definition at line 455 of file MuonPFAnalyzer.cc.

References reco::Muon::muonBestTrackType(), None, and reco::Muon::tunePMuonBestTrackType().

                                                                {
 
   switch ( usePF ? muon->muonBestTrackType() : muon->tunePMuonBestTrackType() ) {
   case Muon::InnerTrack :
     return 0;
   case Muon::OuterTrack :
     return 1;
   case Muon::CombinedTrack :
     return 2;
   case Muon::TPFMS :
     return 3;
   case Muon::Picky :
     return 4;
   case Muon::DYT :
     return 5;
   case Muon::None :
     return 6;
   }
 
   return 6;
 
 }

void MuonPFAnalyzer::recoToGenMatch	(	edm::Handle< reco::MuonCollection > &	reco,
		edm::Handle< reco::GenParticleCollection > &	gen
	)

private

Definition at line 479 of file MuonPFAnalyzer.cc.

References funct::abs(), boostedElectronIsolation_cff::deltaR, PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, edm::HandleBase::isValid(), PatBasicFWLiteAnalyzer::muonEta, and PatBasicFWLiteAnalyzer::muonPhi.

 {
 
   theRecoGen.clear();  
 
   if (muons.isValid())
     {
 
       MuonCollection::const_iterator muonIt  = muons->begin();
       MuonCollection::const_iterator muonEnd = muons->end();
 
       for(; muonIt!=muonEnd; ++muonIt) 
     {
       
       float bestDR = 999.;
       const GenParticle *bestGen = nullptr;
 
       if (theRunOnMC && gens.isValid()) 
         {
       
           GenParticleCollection::const_iterator genIt  = gens->begin();
           GenParticleCollection::const_iterator genEnd = gens->end();
       
           for(; genIt!=genEnd; ++genIt) 
         {
       
           if (abs(genIt->pdgId()) == 13 ) 
             {
           
               float muonPhi = muonIt->phi();
               float muonEta = muonIt->eta();
           
               float genPhi = genIt->phi();
               float genEta = genIt->eta();
           
               float dR = deltaR(muonEta,muonPhi,
                     genEta,genPhi);
           
               if (dR < theRecoGenR && dR < bestDR) 
             {
               bestDR = dR;
               bestGen = &(*genIt);
             }
               
             }   
           
         }
         }
       
       theRecoGen.push_back(RecoGenPair(&(*muonIt), bestGen));
 
     }
     }
   
 }

void MuonPFAnalyzer::setCodeLabels	(	MonitorElement *	plot,
		int	nAxis
	)

private

Definition at line 395 of file MuonPFAnalyzer.cc.

References MonitorElement::getTH1(), and trackerHits::histo.

 {
 
   TAxis *axis = nullptr;
   
   TH1 * histo = plot->getTH1();
   if(!histo) return;
   
   if (nAxis==1) 
     axis =histo->GetXaxis();
   else if (nAxis == 2)
     axis =histo->GetYaxis();
 
   if(!axis) return;
 
   axis->SetBinLabel(1,"Inner Track");
   axis->SetBinLabel(2,"Outer Track");
   axis->SetBinLabel(3,"Combined");
   axis->SetBinLabel(4,"TPFMS");
   axis->SetBinLabel(5,"Picky");
   axis->SetBinLabel(6,"DYT");
   axis->SetBinLabel(7,"None");
 
 }

Member Data Documentation

edm::EDGetTokenT<reco::BeamSpot> MuonPFAnalyzer::theBeamSpotLabel_

private

Definition at line 85 of file MuonPFAnalyzer.h.

std::string MuonPFAnalyzer::theFolder

private

Definition at line 99 of file MuonPFAnalyzer.h.

edm::EDGetTokenT<reco::GenParticleCollection> MuonPFAnalyzer::theGenLabel_

private

Definition at line 82 of file MuonPFAnalyzer.h.

double MuonPFAnalyzer::theHighPtTh

private

Definition at line 93 of file MuonPFAnalyzer.h.

double MuonPFAnalyzer::theIsoCut

private

Definition at line 95 of file MuonPFAnalyzer.h.

std::vector<std::string> MuonPFAnalyzer::theMuonKinds

private

Definition at line 87 of file MuonPFAnalyzer.h.

std::map<std::string,std::map<std::string,MonitorElement*> > MuonPFAnalyzer::thePlots

private

Definition at line 90 of file MuonPFAnalyzer.h.

RecoGenCollection MuonPFAnalyzer::theRecoGen

private

Definition at line 91 of file MuonPFAnalyzer.h.

double MuonPFAnalyzer::theRecoGenR

private

Definition at line 94 of file MuonPFAnalyzer.h.

edm::EDGetTokenT<reco::MuonCollection> MuonPFAnalyzer::theRecoLabel_

private

Definition at line 83 of file MuonPFAnalyzer.h.

bool MuonPFAnalyzer::theRunOnMC

private

Definition at line 97 of file MuonPFAnalyzer.h.

edm::EDGetTokenT<reco::VertexCollection> MuonPFAnalyzer::theVertexLabel_

private

Definition at line 84 of file MuonPFAnalyzer.h.

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation