#include <RecoMuonValidator.h>

Inheritance diagram for RecoMuonValidator:

Classes
struct	CommonME

struct	HistoDimensions

struct	MuonME

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

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

virtual int	countMuonHits (const reco::Track &track) const

virtual int	countTrackerHits (const reco::Track &track) const

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

virtual void	endRun ()

	RecoMuonValidator (const edm::ParameterSet &pset)

	~RecoMuonValidator ()

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

virtual void	beginStream (edm::StreamID id) final

	DQMEDAnalyzer (void)

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

virtual 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

virtual	~EDAnalyzerBase ()

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

	EDConsumerBase ()

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

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

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

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Protected Attributes
edm::InputTag	beamspotLabel_

edm::EDGetTokenT< reco::BeamSpot >	beamspotToken_

CommonME *	commonME_

DQMStore *	dbe_

bool	doAbsEta_

bool	doAssoc_

HistoDimensions	hDim

edm::InputTag	muAssocLabel_

edm::EDGetTokenT < reco::MuonToTrackingParticleAssociator >	muAssocToken_

edm::InputTag	muonLabel_

MuonME *	muonME_

std::string	muonSelection_

edm::EDGetTokenT< edm::View < reco::Muon > >	muonToken_

std::string	outputFileName_

edm::InputTag	primvertexLabel_

edm::EDGetTokenT < reco::VertexCollection >	primvertexToken_

edm::ParameterSet	pset

edm::InputTag	simLabel_

edm::EDGetTokenT < TrackingParticleCollection >	simToken_

std::string	subDir_

std::string	subsystemname_

MuonServiceProxy *	theMuonService

TrackingParticleSelector	tpSelector_

reco::MuonTrackType	trackType_

bool	usePFMuon_

unsigned int	verbose_

Private Attributes
StringCutObjectSelector < reco::Muon >	selector_

bool	wantTightMuon_

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

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)

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)

Detailed Description

Definition at line 33 of file RecoMuonValidator.h.

Constructor & Destructor Documentation

RecoMuonValidator::RecoMuonValidator ( const edm::ParameterSet & pset )

Definition at line 416 of file RecoMuonValidator.cc.

                                                                :
     selector_(pset.getParameter<std::string>("selection"))
 {
 //  pset=ps;
   verbose_ = pset.getUntrackedParameter<unsigned int>("verbose", 0);
 
   outputFileName_ = pset.getUntrackedParameter<string>("outputFileName", "");
 
   wantTightMuon_ = pset.getParameter<bool>("wantTightMuon");
   beamspotLabel_ = pset.getParameter< edm::InputTag >("beamSpot");
   primvertexLabel_ = pset.getParameter< edm::InputTag >("primaryVertex");
   beamspotToken_ = consumes<reco::BeamSpot>(beamspotLabel_);
   primvertexToken_ = consumes<reco::VertexCollection>(primvertexLabel_);
 
  // Set histogram dimensions from config
 
   
   hDim.nBinP = pset.getUntrackedParameter<unsigned int>("nBinP");
   hDim.minP = pset.getUntrackedParameter<double>("minP");
   hDim.maxP = pset.getUntrackedParameter<double>("maxP");
 
   hDim.nBinPt = pset.getUntrackedParameter<unsigned int>("nBinPt");
   hDim.minPt = pset.getUntrackedParameter<double>("minPt");
   hDim.maxPt = pset.getUntrackedParameter<double>("maxPt");
 
   doAbsEta_ = pset.getUntrackedParameter<bool>("doAbsEta");
   hDim.doAbsEta = doAbsEta_;
   hDim.nBinEta  = pset.getUntrackedParameter<unsigned int>("nBinEta");
   hDim.minEta = pset.getUntrackedParameter<double>("minEta");
   hDim.maxEta = pset.getUntrackedParameter<double>("maxEta");
 
   hDim.nBinDxy  = pset.getUntrackedParameter<unsigned int>("nBinDxy");
   hDim.minDxy = pset.getUntrackedParameter<double>("minDxy");
   hDim.maxDxy = pset.getUntrackedParameter<double>("maxDxy");
 
   hDim.nBinDz  = pset.getUntrackedParameter<unsigned int>("nBinDz");
   hDim.minDz = pset.getUntrackedParameter<double>("minDz");
   hDim.maxDz = pset.getUntrackedParameter<double>("maxDz");
 
   hDim.nBinPhi  = pset.getUntrackedParameter<unsigned int>("nBinPhi");
   hDim.minPhi = pset.getUntrackedParameter<double>("minPhi", -TMath::Pi());
   hDim.maxPhi = pset.getUntrackedParameter<double>("maxPhi",  TMath::Pi());
 
   hDim.nBinErr  = pset.getUntrackedParameter<unsigned int>("nBinErr");
   hDim.nBinPull = pset.getUntrackedParameter<unsigned int>("nBinPull");
 
   hDim.wPull = pset.getUntrackedParameter<double>("wPull");
 
   hDim.minErrP = pset.getUntrackedParameter<double>("minErrP");
   hDim.maxErrP = pset.getUntrackedParameter<double>("maxErrP");
 
   hDim.minErrPt = pset.getUntrackedParameter<double>("minErrPt");
   hDim.maxErrPt = pset.getUntrackedParameter<double>("maxErrPt");
 
   hDim.minErrQPt = pset.getUntrackedParameter<double>("minErrQPt");
   hDim.maxErrQPt = pset.getUntrackedParameter<double>("maxErrQPt");
 
   hDim.minErrEta = pset.getUntrackedParameter<double>("minErrEta");
   hDim.maxErrEta = pset.getUntrackedParameter<double>("maxErrEta");
 
   hDim.minErrPhi = pset.getUntrackedParameter<double>("minErrPhi");
   hDim.maxErrPhi = pset.getUntrackedParameter<double>("maxErrPhi");
 
   hDim.minErrDxy = pset.getUntrackedParameter<double>("minErrDxy");
   hDim.maxErrDxy = pset.getUntrackedParameter<double>("maxErrDxy");
 
   hDim.minErrDz  = pset.getUntrackedParameter<double>("minErrDz" );
   hDim.maxErrDz  = pset.getUntrackedParameter<double>("maxErrDz" );
 
   hDim.nTrks = pset.getUntrackedParameter<unsigned int>("nTrks");
   hDim.nAssoc = pset.getUntrackedParameter<unsigned int>("nAssoc");
   hDim.nDof = pset.getUntrackedParameter<unsigned int>("nDof", 55);
 
  
   // Labels for simulation and reconstruction tracks
   simLabel_  = pset.getParameter<InputTag>("simLabel" );
   muonLabel_ = pset.getParameter<InputTag>("muonLabel");
   simToken_ = consumes<TrackingParticleCollection>(simLabel_);
   muonToken_ = consumes<edm::View<reco::Muon> >(muonLabel_);
 
   // Labels for sim-reco association
   doAssoc_ = pset.getUntrackedParameter<bool>("doAssoc", true);
   muAssocLabel_ = pset.getParameter<InputTag>("muAssocLabel");
   if(doAssoc_) {
     muAssocToken_ = consumes<reco::MuonToTrackingParticleAssociator>(muAssocLabel_);
   }
  
 // Different momentum assignment and additional histos in case of PF muons
   usePFMuon_ = pset.getUntrackedParameter<bool>("usePFMuon");
   hDim.usePFMuon = usePFMuon_;
 
  
 
   //type of track
   std::string trackType = pset.getParameter< std::string >("trackType");
   if (trackType == "inner") trackType_ = reco::InnerTk;
   else if (trackType == "outer") trackType_ = reco::OuterTk;
   else if (trackType == "global") trackType_ = reco::GlobalTk;
   else if (trackType == "segments") trackType_ = reco::Segments;
   else throw cms::Exception("Configuration") << "Track type '" << trackType << "' not supported.\n";
 
 //  seedPropagatorName_ = pset.getParameter<string>("SeedPropagator");
 
   ParameterSet tpset = pset.getParameter<ParameterSet>("tpSelector");
   tpSelector_ = TrackingParticleSelector(tpset.getParameter<double>("ptMin"),
                                          tpset.getParameter<double>("minRapidity"),
                                          tpset.getParameter<double>("maxRapidity"),
                                          tpset.getParameter<double>("tip"),
                                          tpset.getParameter<double>("lip"),
                                          tpset.getParameter<int>("minHit"),
                                          tpset.getParameter<bool>("signalOnly"),
                                          tpset.getParameter<bool>("chargedOnly"),
                                          tpset.getParameter<bool>("stableOnly"),
                                          tpset.getParameter<std::vector<int> >("pdgId"));
 
 
   // the service parameters
   ParameterSet serviceParameters 
     = pset.getParameter<ParameterSet>("ServiceParameters");
   theMuonService = new MuonServiceProxy(serviceParameters);
 
   // retrieve the instance of DQMService
   dbe_ = Service<DQMStore>().operator->();
   subsystemname_ = pset.getUntrackedParameter<std::string>("subSystemFolder", "YourSubsystem") ;
 
   subDir_ = pset.getUntrackedParameter<string>("subDir");
   if ( subDir_.empty() ) subDir_ = "RecoMuonV";
   if ( subDir_[subDir_.size()-1] == '/' ) subDir_.erase(subDir_.size()-1);
 
 
 }

RecoMuonValidator::~RecoMuonValidator ( )

Definition at line 605 of file RecoMuonValidator.cc.

References theMuonService.

 {
   if ( theMuonService ) delete theMuonService;
 }

Member Function Documentation

void RecoMuonValidator::analyze	(	const edm::Event &	event,
		const edm::EventSetup &	eventSetup
	)

virtual

Implements edm::stream::EDAnalyzerBase.

Definition at line 630 of file RecoMuonValidator.cc.

 {
   // Look for the Primary Vertex (and use the BeamSpot instead, if you can't find it):
   reco::Vertex::Point posVtx;
   reco::Vertex::Error errVtx;
   edm::Handle<reco::VertexCollection> recVtxs;
   event.getByToken(primvertexToken_,recVtxs);
   unsigned int theIndexOfThePrimaryVertex = 999.;
   for (unsigned int ind=0; ind<recVtxs->size(); ++ind) {
     if ( (*recVtxs)[ind].isValid() && !((*recVtxs)[ind].isFake()) ) {
       theIndexOfThePrimaryVertex = ind;
       break;
     }
   }
   if (theIndexOfThePrimaryVertex<100) {
     posVtx = ((*recVtxs)[theIndexOfThePrimaryVertex]).position();
     errVtx = ((*recVtxs)[theIndexOfThePrimaryVertex]).error();
   }
   else {
     LogInfo("RecoMuonValidator") << "reco::PrimaryVertex not found, use BeamSpot position instead\n";
     edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
     event.getByToken(beamspotToken_,recoBeamSpotHandle);
     reco::BeamSpot bs = *recoBeamSpotHandle;
     posVtx = bs.position();
     errVtx(0,0) = bs.BeamWidthX();
     errVtx(1,1) = bs.BeamWidthY();
     errVtx(2,2) = bs.sigmaZ();
   }
   const reco::Vertex thePrimaryVertex(posVtx,errVtx);
 
 
   // Get TrackingParticles
   Handle<TrackingParticleCollection> simHandle;
   event.getByToken(simToken_, simHandle);
   const TrackingParticleCollection simColl = *(simHandle.product());
 
   // Get Muons
   Handle<edm::View<Muon> > muonHandle;
   event.getByToken(muonToken_, muonHandle);
   View<Muon> muonColl = *(muonHandle.product());
 
   reco::MuonToTrackingParticleAssociator const* assoByHits = nullptr;
   if ( doAssoc_ ) {
     edm::Handle<reco::MuonToTrackingParticleAssociator> associatorBase;
     event.getByToken(muAssocToken_, associatorBase);
     assoByHits = associatorBase.product();
   }
 
   const TrackingParticleCollection::size_type nSim = simColl.size();
 
   edm::RefToBaseVector<reco::Muon> Muons;
   for (size_t i = 0; i < muonHandle->size(); ++i) {
       Muons.push_back(muonHandle->refAt(i));
   }
 
   edm::RefVector<TrackingParticleCollection> allTPs;
   for (size_t i = 0; i < nSim; ++i) {
       allTPs.push_back(TrackingParticleRef(simHandle,i));
   }
  
 
   muonME_->hNSim_->Fill(nSim);
   muonME_->hNMuon_->Fill(muonColl.size());
 
   reco::MuonToSimCollection muonToSimColl;
   reco::SimToMuonCollection simToMuonColl;
 
 
   if ( doAssoc_ ) {
   assoByHits->associateMuons(muonToSimColl, simToMuonColl, Muons, trackType_, allTPs);
   } else {
 
 /*
     // SimToMuon associations
     Handle<reco::RecoToSimCollection> simToTrkMuHandle;
     event.getByLabel(trkMuAssocLabel_, simToTrkMuHandle);
     trkSimRecColl = *(simToTrkMuHandle.product());
 
     Handle<reco::RecoToSimCollection> simToStaMuHandle;
     event.getByLabel(staMuAssocLabel_, simToStaMuHandle);
     staSimRecColl = *(simToStaMuHandle.product());
 
     Handle<reco::RecoToSimCollection> simToGlbMuHandle;
     event.getByLabel(glbMuAssocLabel_, simToGlbMuHandle);
     glbSimRecColl = *(simToGlbMuHandle.product());
 
     // MuonToSim associations
     Handle<reco::SimToRecoCollection> trkMuToSimHandle;
     event.getByLabel(trkMuAssocLabel_, trkMuToSimHandle);
     trkRecSimColl = *(trkMuToSimHandle.product());
 
     Handle<reco::SimToRecoCollection> staMuToSimHandle;
     event.getByLabel(staMuAssocLabel_, staMuToSimHandle);
     staRecSimColl = *(staMuToSimHandle.product());
 
     Handle<reco::SimToRecoCollection> glbMuToSimHandle;
     event.getByLabel(glbMuAssocLabel_, glbMuToSimHandle);
     glbRecSimColl = *(glbMuToSimHandle.product());
 */
   }
 
 
 
   int glbNTrackerHits = 0; int trkNTrackerHits = 0;
   int glbNMuonHits = 0; int staNMuonHits = 0;
   int NTrackerHits = 0; int NMuonHits = 0;
   
 
   // Analyzer reco::Muon  
   for(View<Muon>::const_iterator iMuon = muonColl.begin();
       iMuon != muonColl.end(); ++iMuon) {
       
     double muonP, muonPt, muonEta, muonPhi;
     if (usePFMuon_) {
       muonP   = iMuon->pfP4().P();
       muonPt  = iMuon->pfP4().Pt();
       muonEta = iMuon->pfP4().Eta(); 
       muonPhi = iMuon->pfP4().Phi();
     }
     else {
       muonP   = iMuon->p(); 
       muonPt  = iMuon->pt();
       muonEta = iMuon->eta();
       muonPhi = iMuon->phi();
     }
 
     //histograms for fractions
     commonME_->hMuonAllP_->Fill(muonP);
     commonME_->hMuonAllPt_->Fill(muonPt);
     commonME_->hMuonAllEta_->Fill(muonEta);
     commonME_->hMuonAllPhi_->Fill(muonPhi);
 
     if (!selector_(*iMuon)) continue;
     if (wantTightMuon_)
       {
     if (!muon::isTightMuon(*iMuon, thePrimaryVertex)) continue;
       }
 
     TrackRef Track = iMuon->track();
 
     if (Track.isNonnull()) {
       commonME_->hMuonTrackP_->Fill(Track->p());
       commonME_->hMuonTrackPt_->Fill(Track->pt());
       commonME_->hMuonTrackEta_->Fill(Track->eta());
       commonME_->hMuonTrackPhi_->Fill(Track->phi());
       
       //ip histograms
       commonME_->hMuonTrackDxy_->Fill(Track->dxy());
       commonME_->hMuonTrackDz_->Fill(Track->dz());
     }
     
     if (iMuon->isGlobalMuon()) {
       Track = iMuon->combinedMuon();
       glbNTrackerHits = countTrackerHits(*Track);
       glbNMuonHits = countMuonHits(*Track);
     } else if (iMuon->isTrackerMuon()) {
       Track = iMuon->track();
       trkNTrackerHits = countTrackerHits(*Track);
     } else {
       Track = iMuon->standAloneMuon();
     } 
 
     NTrackerHits = countTrackerHits(*Track);
     muonME_->hNTrackerHits_->Fill(NTrackerHits);
     muonME_->hNTrackerHits_vs_Pt_->Fill(Track->pt(), NTrackerHits);
     muonME_->hNTrackerHits_vs_Eta_->Fill(Track->eta(), NTrackerHits);
 
     NMuonHits = countMuonHits(*Track);
     muonME_->hNMuonHits_->Fill(NMuonHits);
     muonME_->hNMuonHits_vs_Pt_->Fill(Track->pt(), NMuonHits);
     muonME_->hNMuonHits_vs_Eta_->Fill(Track->eta(), NMuonHits);
 
 //list of histos for each type
 
 //      muonME_->hNTrks_->Fill();
     muonME_->hNTrksEta_->Fill(Track->eta());
     muonME_->hNTrksPt_->Fill(Track->pt());
 
     commonME_->hMuonP_->Fill(muonP);
     commonME_->hMuonPt_->Fill(muonPt);
     commonME_->hMuonEta_->Fill(muonEta);
     commonME_->hMuonPhi_->Fill(muonPhi);
 
     if (iMuon->isGlobalMuon()) {
       double gtHitPat = iMuon->globalTrack()->hitPattern().numberOfHits(HitPattern::TRACK_HITS)
         - iMuon->globalTrack()->hitPattern().numberOfValidHits();
 
       double itHitPat = iMuon->innerTrack()->hitPattern().numberOfHits(HitPattern::TRACK_HITS)
         - iMuon->innerTrack()->hitPattern().numberOfValidHits();
 
       double otHitPat = iMuon->outerTrack()->hitPattern().numberOfHits(HitPattern::TRACK_HITS)
         - iMuon->outerTrack()->hitPattern().numberOfValidHits();
       
       commonME_->hNInvalidHitsGTHitPattern_->Fill(gtHitPat);
       commonME_->hNInvalidHitsITHitPattern_->Fill(itHitPat);
       commonME_->hNInvalidHitsOTHitPattern_->Fill(otHitPat);
       commonME_->hNDeltaInvalidHitsHitPattern_->Fill(gtHitPat - itHitPat - otHitPat);
 
       //must be global and standalone
       if (iMuon->isStandAloneMuon()) { 
     commonME_->hStaToGlbDiffNMuonHitsEta_->Fill(Track->eta(),staNMuonHits-glbNMuonHits);
     commonME_->hStaToGlbDiffNMuonHitsPt_->Fill(Track->pt(),staNMuonHits-glbNMuonHits);
     commonME_->hStaToGlbDiffNMuonHits_->Fill(staNMuonHits-glbNMuonHits);
       }
       
       //must be global and tracker
       if (iMuon->isTrackerMuon()) {
     commonME_->hTrkToGlbDiffNTrackerHitsEta_->Fill(Track->eta(),trkNTrackerHits-glbNTrackerHits);
     commonME_->hTrkToGlbDiffNTrackerHitsPt_->Fill(Track->pt(),trkNTrackerHits-glbNTrackerHits);
     commonME_->hTrkToGlbDiffNTrackerHits_->Fill(trkNTrackerHits-glbNTrackerHits);
       }
     }
 
   }//end of reco muon loop
 
 
   // Associate by hits
   for(TrackingParticleCollection::size_type i=0; i<nSim; i++) {
     TrackingParticleRef simRef(simHandle, i);
     const TrackingParticle* simTP = simRef.get();
     if ( ! tpSelector_(*simTP) ) continue;
 
     //denominators for efficiency plots
     const double simP   = simRef->p();
     const double simPt  = simRef->pt();
     const double simEta = doAbsEta_ ? fabs(simRef->eta()) : simRef->eta();
     const double simPhi = simRef->phi();
     
     GlobalPoint  simVtx(simRef->vertex().x(), simRef->vertex().y(), simRef->vertex().z());
     GlobalVector simMom(simRef->momentum().x(), simRef->momentum().y(), simRef->momentum().z());
     const double simDxy = -simVtx.x()*sin(simPhi)+simVtx.y()*cos(simPhi);
     const double simDz  = simVtx.z() - (simVtx.x()*simMom.x()+simVtx.y()*simMom.y())*simMom.z()/simMom.perp2();
     
     const unsigned int nSimHits = simRef->numberOfHits();
 
     muonME_->hSimP_  ->Fill(simP  );
     muonME_->hSimPt_ ->Fill(simPt );
     muonME_->hSimEta_->Fill(simEta);
     muonME_->hSimPhi_->Fill(simPhi);
     muonME_->hSimDxy_->Fill(simDxy);
     muonME_->hSimDz_->Fill(simDz);
     muonME_->hNSimHits_->Fill(nSimHits);
 
     // Get sim-reco association for a simRef
     vector<pair<RefToBase<Muon>, double> > MuRefV;
     if ( simToMuonColl.find(simRef) != simToMuonColl.end() ) {
       MuRefV = simToMuonColl[simRef];
 
       if ( !MuRefV.empty()) {
         muonME_->hNSimToReco_->Fill(MuRefV.size());
         const Muon* Mu = MuRefV.begin()->first.get();
         if (!selector_(*Mu)) continue;
     if (wantTightMuon_)
       {
         if (!muon::isTightMuon(*Mu, thePrimaryVertex)) continue;
       }
 
         muonME_->fill(&*simTP, Mu); 
       }
     }
   }
 }

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

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 548 of file RecoMuonValidator.cc.

                                                           {
 
 
   // book histograms
   ibooker.cd();
 
   ibooker.setCurrentFolder(subDir_);
 
   commonME_ = new CommonME;
   muonME_  = new MuonME;
 
   //commonME
   const int nHits = 100;
 
   // - diffs
   commonME_->hTrkToGlbDiffNTrackerHits_ = ibooker.book1D("TrkGlbDiffNTrackerHits", "Difference of number of tracker hits (tkMuon - globalMuon)", 2*nHits+1, -nHits-0.5, nHits+0.5);
   commonME_->hStaToGlbDiffNMuonHits_ = ibooker.book1D("StaGlbDiffNMuonHits", "Difference of number of muon hits (staMuon - globalMuon)", 2*nHits+1, -nHits-0.5, nHits+0.5);
 
   commonME_->hTrkToGlbDiffNTrackerHitsEta_ = ibooker.book2D("TrkGlbDiffNTrackerHitsEta", "Difference of number of tracker hits (tkMuon - globalMuon)", hDim.nBinEta, hDim.minEta, hDim.maxEta,2*nHits+1, -nHits-0.5, nHits+0.5);
   commonME_->hStaToGlbDiffNMuonHitsEta_ = ibooker.book2D("StaGlbDiffNMuonHitsEta", "Difference of number of muon hits (staMuon - globalMuon)", hDim.nBinEta, hDim.minEta, hDim.maxEta,2*nHits+1, -nHits-0.5, nHits+0.5);
 
   commonME_->hTrkToGlbDiffNTrackerHitsPt_ = ibooker.book2D("TrkGlbDiffNTrackerHitsPt", "Difference of number of tracker hits (tkMuon - globalMuon)", hDim.nBinPt, hDim.minPt, hDim.maxPt,2*nHits+1, -nHits-0.5, nHits+0.5);
   commonME_->hStaToGlbDiffNMuonHitsPt_ = ibooker.book2D("StaGlbDiffNMuonHitsPt", "Difference of number of muon hits (staMuon - globalMuon)", hDim.nBinPt, hDim.minPt, hDim.maxPt,2*nHits+1, -nHits-0.5, nHits+0.5);
 
   // -global muon hit pattern
   commonME_->hNInvalidHitsGTHitPattern_ = ibooker.book1D("NInvalidHitsGTHitPattern", "Number of invalid hits on a global track", nHits+1, -0.5, nHits+0.5);
   commonME_->hNInvalidHitsITHitPattern_ = ibooker.book1D("NInvalidHitsITHitPattern", "Number of invalid hits on an inner track", nHits+1, -0.5, nHits+0.5);
   commonME_->hNInvalidHitsOTHitPattern_ = ibooker.book1D("NInvalidHitsOTHitPattern", "Number of invalid hits on an outer track", nHits+1, -0.5, nHits+0.5);
   commonME_->hNDeltaInvalidHitsHitPattern_ = ibooker.book1D("hNDeltaInvalidHitsHitPattern", "The discrepancy for Number of invalid hits on an global track and inner and outer tracks", 2*nHits+1, -nHits-0.5, nHits+0.5);
 
   //muon based kinematics
   commonME_->hMuonP_   = ibooker.book1D("PMuon"  , "p of muon"    , hDim.nBinP  , hDim.minP  , hDim.maxP  );
   commonME_->hMuonPt_  = ibooker.book1D("PtMuon" , "p_{T} of muon", hDim.nBinPt , hDim.minPt , hDim.maxPt );
   commonME_->hMuonEta_ = ibooker.book1D("EtaMuon", "#eta of muon" , hDim.nBinEta, hDim.minEta, hDim.maxEta);
   commonME_->hMuonPhi_ = ibooker.book1D("PhiMuon", "#phi of muon" , hDim.nBinPhi, hDim.minPhi, hDim.maxPhi);
   //track based kinematics
   commonME_->hMuonTrackP_   = ibooker.book1D("PMuonTrack"  , "p of reco muon track"    , hDim.nBinP  , hDim.minP  , hDim.maxP  );
   commonME_->hMuonTrackPt_  = ibooker.book1D("PtMuonTrack" , "p_{T} of reco muon track", hDim.nBinPt , hDim.minPt , hDim.maxPt );
   commonME_->hMuonTrackEta_ = ibooker.book1D("EtaMuonTrack", "#eta of reco muon track" , hDim.nBinEta, hDim.minEta, hDim.maxEta);
   commonME_->hMuonTrackPhi_ = ibooker.book1D("PhiMuonTrack", "#phi of reco muon track" , hDim.nBinPhi, hDim.minPhi, hDim.maxPhi);
   commonME_->hMuonTrackDxy_ = ibooker.book1D("DxyMuonTrack", "Dxy of reco muon track" , hDim.nBinDxy, hDim.minDxy, hDim.maxDxy);
   commonME_->hMuonTrackDz_ = ibooker.book1D("DzMuonTrack", "Dz of reco muon track" , hDim.nBinDz, hDim.minDz, hDim.maxDz);
 
   //histograms for fractions
   commonME_->hMuonAllP_   = ibooker.book1D("PMuonAll"  , "p of muons of all types"    , hDim.nBinP  , hDim.minP  , hDim.maxP  );
   commonME_->hMuonAllPt_  = ibooker.book1D("PtMuonAll" , "p_{T} of muon of all types", hDim.nBinPt , hDim.minPt , hDim.maxPt );
   commonME_->hMuonAllEta_ = ibooker.book1D("EtaMuonAll", "#eta of muon of all types" , hDim.nBinEta, hDim.minEta, hDim.maxEta);
   commonME_->hMuonAllPhi_ = ibooker.book1D("PhiMuonAll", "#phi of muon of all types" , hDim.nBinPhi, hDim.minPhi, hDim.maxPhi);
 
   muonME_->bookHistos(ibooker, subDir_, hDim);
 }

int RecoMuonValidator::countMuonHits ( const reco::Track & track ) const

virtual

Definition at line 894 of file RecoMuonValidator.cc.

References prof2calltree::count, DetId::det(), DetId::Muon, reco::Track::recHitsBegin(), reco::Track::recHitsEnd(), and query::result.

Referenced by analyze().

                                                              {
   TransientTrackingRecHit::ConstRecHitContainer result;
   
   int count = 0;
 
   for (trackingRecHit_iterator hit = track.recHitsBegin(); hit != track.recHitsEnd(); ++hit) {
     if((*hit)->isValid()) {
       DetId recoid = (*hit)->geographicalId();
       if ( recoid.det() == DetId::Muon ) count++;
     }
   }
   return count;
 }

int RecoMuonValidator::countTrackerHits ( const reco::Track & track ) const

virtual

Definition at line 909 of file RecoMuonValidator.cc.

References prof2calltree::count, DetId::det(), reco::Track::recHitsBegin(), reco::Track::recHitsEnd(), query::result, and DetId::Tracker.

Referenced by analyze().

                                                                 {
   TransientTrackingRecHit::ConstRecHitContainer result;
   
   int count = 0;
 
   for (trackingRecHit_iterator hit = track.recHitsBegin(); hit != track.recHitsEnd(); ++hit) {
     if((*hit)->isValid()) {
       DetId recoid = (*hit)->geographicalId();
       if ( recoid.det() == DetId::Tracker ) count++;
     }
   }
   return count;
 }

void RecoMuonValidator::dqmBeginRun	(	const edm::Run &	,
		const edm::EventSetup &	eventSetup
	)

virtual

Reimplemented from DQMEDAnalyzer.

Definition at line 614 of file RecoMuonValidator.cc.

References theMuonService.

 {
   if ( theMuonService ) theMuonService->update(eventSetup);
 }

void RecoMuonValidator::endRun ( void )

virtual

Definition at line 622 of file RecoMuonValidator.cc.

References dbe_, and outputFileName_.

 {
   if ( dbe_ && ! outputFileName_.empty() ) dbe_->save(outputFileName_);
 }

Member Data Documentation

edm::InputTag RecoMuonValidator::beamspotLabel_

protected

Definition at line 58 of file RecoMuonValidator.h.

Referenced by RecoMuonValidator().

edm::EDGetTokenT<reco::BeamSpot> RecoMuonValidator::beamspotToken_

protected

Definition at line 60 of file RecoMuonValidator.h.

Referenced by analyze(), and RecoMuonValidator().

CommonME* RecoMuonValidator::commonME_

protected

Definition at line 84 of file RecoMuonValidator.h.

Referenced by analyze(), and bookHistograms().

DQMStore* RecoMuonValidator::dbe_

protected

Definition at line 69 of file RecoMuonValidator.h.

Referenced by endRun(), and RecoMuonValidator().

bool RecoMuonValidator::doAbsEta_

protected

Definition at line 71 of file RecoMuonValidator.h.

Referenced by analyze(), and RecoMuonValidator().

bool RecoMuonValidator::doAssoc_

protected

Definition at line 72 of file RecoMuonValidator.h.

Referenced by analyze(), and RecoMuonValidator().

HistoDimensions RecoMuonValidator::hDim

protected

Definition at line 130 of file RecoMuonValidator.h.

Referenced by bookHistograms(), and RecoMuonValidator().

edm::InputTag RecoMuonValidator::muAssocLabel_

protected

Definition at line 55 of file RecoMuonValidator.h.

Referenced by RecoMuonValidator().

edm::EDGetTokenT<reco::MuonToTrackingParticleAssociator> RecoMuonValidator::muAssocToken_

protected

Definition at line 56 of file RecoMuonValidator.h.

Referenced by analyze(), and RecoMuonValidator().

edm::InputTag RecoMuonValidator::muonLabel_

protected

Definition at line 50 of file RecoMuonValidator.h.

Referenced by RecoMuonValidator().

MuonME* RecoMuonValidator::muonME_

protected

Definition at line 81 of file RecoMuonValidator.h.

Referenced by analyze(), and bookHistograms().

std::string RecoMuonValidator::muonSelection_

protected

Definition at line 51 of file RecoMuonValidator.h.

edm::EDGetTokenT<edm::View<reco::Muon> > RecoMuonValidator::muonToken_

protected

Definition at line 53 of file RecoMuonValidator.h.

Referenced by analyze(), and RecoMuonValidator().

std::string RecoMuonValidator::outputFileName_

protected

Definition at line 63 of file RecoMuonValidator.h.

Referenced by endRun(), and RecoMuonValidator().

edm::InputTag RecoMuonValidator::primvertexLabel_

protected

Definition at line 59 of file RecoMuonValidator.h.

Referenced by RecoMuonValidator().

edm::EDGetTokenT<reco::VertexCollection> RecoMuonValidator::primvertexToken_

protected

Definition at line 61 of file RecoMuonValidator.h.

Referenced by analyze(), and RecoMuonValidator().

edm::ParameterSet RecoMuonValidator::pset

protected

Definition at line 66 of file RecoMuonValidator.h.

StringCutObjectSelector<reco::Muon> RecoMuonValidator::selector_

private

Definition at line 132 of file RecoMuonValidator.h.

Referenced by analyze().

edm::InputTag RecoMuonValidator::simLabel_

protected

Definition at line 49 of file RecoMuonValidator.h.

Referenced by RecoMuonValidator().

edm::EDGetTokenT<TrackingParticleCollection> RecoMuonValidator::simToken_

protected

Definition at line 52 of file RecoMuonValidator.h.

Referenced by analyze(), and RecoMuonValidator().

std::string RecoMuonValidator::subDir_

protected

Definition at line 64 of file RecoMuonValidator.h.

Referenced by bookHistograms(), and RecoMuonValidator().

std::string RecoMuonValidator::subsystemname_

protected

Definition at line 65 of file RecoMuonValidator.h.

Referenced by RecoMuonValidator().

MuonServiceProxy* RecoMuonValidator::theMuonService

protected

Definition at line 68 of file RecoMuonValidator.h.

Referenced by dqmBeginRun(), RecoMuonValidator(), and ~RecoMuonValidator().

TrackingParticleSelector RecoMuonValidator::tpSelector_

protected

Definition at line 76 of file RecoMuonValidator.h.

Referenced by analyze(), and RecoMuonValidator().

reco::MuonTrackType RecoMuonValidator::trackType_

protected

Definition at line 79 of file RecoMuonValidator.h.

Referenced by analyze(), and RecoMuonValidator().

bool RecoMuonValidator::usePFMuon_

protected

Definition at line 73 of file RecoMuonValidator.h.

Referenced by analyze(), and RecoMuonValidator().

unsigned int RecoMuonValidator::verbose_

protected

Definition at line 47 of file RecoMuonValidator.h.

Referenced by RecoMuonValidator().

bool RecoMuonValidator::wantTightMuon_

private

Definition at line 133 of file RecoMuonValidator.h.

Referenced by analyze(), and RecoMuonValidator().

Classes

Public Member Functions

Protected Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation