#include <GlobalMuonMatchAnalyzer.h>

Inheritance diagram for GlobalMuonMatchAnalyzer:

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

	~GlobalMuonMatchAnalyzer () override

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	analyze (const edm::Event &, const edm::EventSetup &) override

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

void	computeEfficiencyEta (MonitorElement , MonitorElement recoTH2, MonitorElement *simTH2)

void	computeEfficiencyPt (MonitorElement , MonitorElement recoTH2, MonitorElement *simTH2)

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

Private Attributes
DQMStore *	dbe_

edm::InputTag	glbName_

edm::EDGetTokenT< edm::View< reco::Track > >	glbToken_

MonitorElement *	h_effic

MonitorElement *	h_efficPt

MonitorElement *	h_fake

MonitorElement *	h_fakeMatch

MonitorElement *	h_fakePt

MonitorElement *	h_goodMatch

MonitorElement *	h_goodMatchSim

MonitorElement *	h_shouldMatch

MonitorElement *	h_staOnlySim

MonitorElement *	h_tkOnlySim

MonitorElement *	h_totReco

edm::ParameterSet	iConfig

const TrackAssociatorBase *	muAssociator_

edm::InputTag	muAssociatorName_

edm::EDGetTokenT< reco::TrackToTrackingParticleAssociator >	muAssociatorToken_

std::string	out

edm::InputTag	staName_

edm::EDGetTokenT< edm::View< reco::Track > >	staToken_

std::string	subsystemname_

const TrackAssociatorBase *	tkAssociator_

edm::InputTag	tkAssociatorName_

edm::EDGetTokenT< reco::TrackToTrackingParticleAssociator >	tkAssociatorToken_

edm::InputTag	tkName_

edm::EDGetTokenT< edm::View< reco::Track > >	tkToken_

edm::InputTag	tpName_

edm::EDGetTokenT< edm::View< reco::Track > >	tpToken_

Detailed Description

Author: Adam Everett Purdue University

Definition at line 46 of file GlobalMuonMatchAnalyzer.h.

Constructor & Destructor Documentation

GlobalMuonMatchAnalyzer::GlobalMuonMatchAnalyzer ( const edm::ParameterSet & ps )

explicit

Class: GlobalMuonMatchAnalyzer

Authors :

Author: Adam Everett - Purdue University

Definition at line 37 of file GlobalMuonMatchAnalyzer.cc.

References dbe_, edm::ParameterSet::getUntrackedParameter(), glbName_, glbToken_, iConfig, muAssociatorName_, muAssociatorToken_, Utilities::operator, out, staName_, staToken_, AlCaHLTBitMon_QueryRunRegistry::string, subsystemname_, tkAssociatorName_, tkAssociatorToken_, tkName_, tkToken_, tpName_, and tpToken_.

 {
   iConfig = ps;
   //now do what ever initialization is needed
   tkAssociatorName_ = iConfig.getUntrackedParameter<edm::InputTag>("tkAssociator");
   muAssociatorName_ = iConfig.getUntrackedParameter<edm::InputTag>("muAssociator");
 
   tkAssociatorToken_ = consumes<reco::TrackToTrackingParticleAssociator>(tkAssociatorName_);
   muAssociatorToken_ = consumes<reco::TrackToTrackingParticleAssociator>(muAssociatorName_);
 
 subsystemname_ = iConfig.getUntrackedParameter<std::string>("subSystemFolder", "YourSubsystem") ;
   tpName_ = iConfig.getUntrackedParameter<edm::InputTag>("tpLabel");
   tkName_ = iConfig.getUntrackedParameter<edm::InputTag>("tkLabel");
   staName_ = iConfig.getUntrackedParameter<edm::InputTag>("muLabel");
   glbName_ = iConfig.getUntrackedParameter<edm::InputTag>("glbLabel");
 
   out = iConfig.getUntrackedParameter<std::string>("out");
   dbe_ = edm::Service<DQMStore>().operator->();
 
   tpToken_ = consumes<edm::View<reco::Track> >(tpName_);
   tkToken_ = consumes<edm::View<reco::Track> >(tkName_);
   staToken_ = consumes<edm::View<reco::Track> >(staName_);
   glbToken_ = consumes<edm::View<reco::Track> >(glbName_);
 }

GlobalMuonMatchAnalyzer::~GlobalMuonMatchAnalyzer ( )

override

Definition at line 64 of file GlobalMuonMatchAnalyzer.cc.

 {
  
    // do anything here that needs to be done at desctruction time
    // (e.g. close files, deallocate resources etc.)
 
 }

Member Function Documentation

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

overrideprivate

Definition at line 79 of file GlobalMuonMatchAnalyzer.cc.

References reco::TrackToTrackingParticleAssociator::associateRecoToSim(), reco::TrackToTrackingParticleAssociator::associateSimToReco(), edm::AssociationMap< Tag >::end(), reco::TrackBase::eta(), MonitorElement::Fill(), edm::AssociationMap< Tag >::find(), edm::Event::getByToken(), glbToken_, h_fakeMatch, h_goodMatch, h_goodMatchSim, h_shouldMatch, h_staOnlySim, h_tkOnlySim, h_totReco, mps_fire::i, muAssociatorToken_, edm::Handle< T >::product(), reco::TrackBase::pt(), staToken_, tkAssociatorToken_, tkToken_, and tpToken_.

 {
    using namespace edm;
    using namespace reco;
 
    Handle<TrackingParticleCollection> tpHandle;
    iEvent.getByToken(tpToken_,tpHandle);
    const TrackingParticleCollection tpColl = *(tpHandle.product());
 
    Handle<reco::MuonTrackLinksCollection> muHandle;
    iEvent.getByToken(glbToken_,muHandle);
    const reco::MuonTrackLinksCollection muColl = *(muHandle.product());
 
    Handle<View<Track> > staHandle;
    iEvent.getByToken(staToken_,staHandle);
 
    Handle<View<Track> > glbHandle;
    iEvent.getByToken(glbToken_,glbHandle);
 
    Handle<View<Track> > tkHandle;
    iEvent.getByToken(tkToken_,tkHandle);
 
    edm::Handle<reco::TrackToTrackingParticleAssociator> tkAssociator;
    iEvent.getByToken(tkAssociatorToken_,tkAssociator);
 
    // Mu Associator
    edm::Handle<reco::TrackToTrackingParticleAssociator> muAssociator;
   iEvent.getByToken(muAssociatorToken_,muAssociator);
 
    
    reco::RecoToSimCollection tkrecoToSimCollection = tkAssociator->associateRecoToSim(tkHandle,tpHandle);
    reco::SimToRecoCollection tksimToRecoCollection = tkAssociator->associateSimToReco(tkHandle,tpHandle);
 
    reco::RecoToSimCollection starecoToSimCollection = muAssociator->associateRecoToSim(staHandle,tpHandle);
    reco::SimToRecoCollection stasimToRecoCollection = muAssociator->associateSimToReco(staHandle,tpHandle);
 
    reco::RecoToSimCollection glbrecoToSimCollection = muAssociator->associateRecoToSim(glbHandle,tpHandle);
    reco::SimToRecoCollection glbsimToRecoCollection = muAssociator->associateSimToReco(glbHandle,tpHandle);
 
 
    for (TrackingParticleCollection::size_type i=0; i<tpColl.size(); ++i){
      TrackingParticleRef tp(tpHandle,i);
 
      std::vector<std::pair<RefToBase<Track>, double> > rvGlb;
      RefToBase<Track> rGlb;
      if(glbsimToRecoCollection.find(tp) != glbsimToRecoCollection.end()){
        rvGlb = glbsimToRecoCollection[tp];
        if(!rvGlb.empty()) {
      rGlb = rvGlb.begin()->first;
        }
      }
 
      std::vector<std::pair<RefToBase<Track>, double> > rvSta;
      RefToBase<Track> rSta;
      if(stasimToRecoCollection.find(tp) != stasimToRecoCollection.end()){
        rvSta = stasimToRecoCollection[tp];
        if(!rvSta.empty()) {
      rSta = rvSta.begin()->first;
        }
      }
 
      std::vector<std::pair<RefToBase<Track>, double> > rvTk;
      RefToBase<Track> rTk;
      if(tksimToRecoCollection.find(tp) != tksimToRecoCollection.end()){
        rvTk = tksimToRecoCollection[tp];
        if(!rvTk.empty()) {
      rTk = rvTk.begin()->first;
        }
      }
      
      if( !rvSta.empty() && !rvTk.empty() ){
        //should have matched
        h_shouldMatch->Fill(rTk->eta(),rTk->pt());
      }
 
      for ( reco::MuonTrackLinksCollection::const_iterator links = muHandle->begin(); links != muHandle->end(); ++links ) {
        if( rGlb == RefToBase<Track>(links->globalTrack() ) ) {
      if( RefToBase<Track>(links->trackerTrack() ) == rTk && 
          RefToBase<Track>(links->standAloneTrack() ) == rSta ) {
        //goodMatch
        h_goodMatchSim->Fill(rGlb->eta(),rGlb->pt());
      } 
      if ( RefToBase<Track>(links->trackerTrack() ) == rTk &&
           RefToBase<Track>(links->standAloneTrack() ) != rSta ) {
        //tkOnlyMatch
        h_tkOnlySim->Fill(rGlb->eta(),rGlb->pt());
      } 
      if ( RefToBase<Track>(links->standAloneTrack() ) == rSta &&
           RefToBase<Track>(links->trackerTrack() ) != rTk ) {
        //staOnlyMatch
        h_staOnlySim->Fill(rGlb->eta(),rGlb->pt());
      }
        }
      }
 
    }
    
    
    for ( reco::MuonTrackLinksCollection::const_iterator links = muHandle->begin(); links != muHandle->end(); ++links ) {
      RefToBase<Track> glbRef = RefToBase<Track>(links->globalTrack() );
      RefToBase<Track> staRef = RefToBase<Track>(links->standAloneTrack() );
      RefToBase<Track> tkRef  = RefToBase<Track>(links->trackerTrack() );
      
      std::vector<std::pair<TrackingParticleRef, double> > tp1;
      TrackingParticleRef tp1r;
      if(glbrecoToSimCollection.find(glbRef) != glbrecoToSimCollection.end()){
        tp1 = glbrecoToSimCollection[glbRef];
        if(!tp1.empty()) {
      tp1r = tp1.begin()->first;
        }
      }
      
      std::vector<std::pair<TrackingParticleRef, double> > tp2;
      TrackingParticleRef tp2r;
      if(starecoToSimCollection.find(staRef) != starecoToSimCollection.end()){
        tp2 = starecoToSimCollection[staRef];
        if(!tp2.empty()) {
      tp2r = tp2.begin()->first;
        }
      }
      
      std::vector<std::pair<TrackingParticleRef, double> > tp3;
      TrackingParticleRef tp3r;
      if(tkrecoToSimCollection.find(tkRef) != tkrecoToSimCollection.end()){
        tp3 = tkrecoToSimCollection[tkRef];
        if(!tp3.empty()) {
      tp3r = tp3.begin()->first;
        }
      }
      
      
      if(!tp1.empty()) {
        //was reconstructed
        h_totReco->Fill(glbRef->eta(),glbRef->pt());
        if(tp2r == tp3r) { // && tp1r == tp3r) {
      //came from same TP
      h_goodMatch->Fill(glbRef->eta(),glbRef->pt());
        } else {
      //mis-match
      h_fakeMatch->Fill(glbRef->eta(),glbRef->pt());
        }
      }
      
    }   
 
    
 }

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

overrideprivate

Definition at line 242 of file GlobalMuonMatchAnalyzer.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), DQMStore::IBooker::cd(), TrackerOfflineValidation_Dqm_cff::dirName, h_effic, h_efficPt, h_fake, h_fakeMatch, h_fakePt, h_goodMatch, h_goodMatchSim, h_shouldMatch, h_staOnlySim, h_tkOnlySim, h_totReco, DQMStore::IBooker::setCurrentFolder(), and AlCaHLTBitMon_QueryRunRegistry::string.

 {
   // Tk Associator
 
   ibooker.cd();
   std::string dirName="Matcher/";
   //  ibooker.setCurrentFolder("RecoMuonV/Matcher");
   ibooker.setCurrentFolder(dirName) ;
 
   h_shouldMatch = ibooker.book2D("h_shouldMatch","SIM associated to Tk and Sta",50,-2.5,2.5,100,0.,500.);
   h_goodMatchSim = ibooker.book2D("h_goodMatchSim","SIM associated to Glb Sta Tk",50,-2.5,2.5,100,0.,500.);
   h_tkOnlySim = ibooker.book2D("h_tkOnlySim","SIM associated to Glb Tk",50,-2.5,2.5,100,0.,500.);
   h_staOnlySim = ibooker.book2D("h_staOnlySim","SIM associated to Glb Sta",50,-2.5,2.5,100,0.,500.);
 
   h_totReco = ibooker.book2D("h_totReco","Total Glb Reconstructed",50,-2.5,2.5,100,0.,500.);
   h_goodMatch = ibooker.book2D("h_goodMatch","Sta and Tk from same SIM",50,-2.5,2.5,100, 0., 500.);
   h_fakeMatch = ibooker.book2D("h_fakeMatch","Sta and Tk not from same SIM",50,-2.5,2.5,100,0.,500.);
 
   h_effic = ibooker.book1D("h_effic","Efficiency vs #eta",50,-2.5,2.5);
   h_efficPt = ibooker.book1D("h_efficPt","Efficiency vs p_{T}",100,0.,100.);
 
   h_fake = ibooker.book1D("h_fake","Fake fraction vs #eta",50,-2.5,2.5);
   h_fakePt = ibooker.book1D("h_fakePt","Fake fraction vs p_{T}",100,0.,100.);
 
 }

void GlobalMuonMatchAnalyzer::computeEfficiencyEta	(	MonitorElement *	effHist,
		MonitorElement *	recoTH2,
		MonitorElement *	simTH2
	)

private

Definition at line 272 of file GlobalMuonMatchAnalyzer.cc.

References stringResolutionProvider_cfi::bin, relativeConstraints::error, MonitorElement::getTH2F(), MonitorElement::setBinContent(), MonitorElement::setBinError(), and mathSSE::sqrt().

Referenced by endRun().

                                                                                                                           {
   TH2F * h1 = recoTH2->getTH2F();
   TH1D* reco = h1->ProjectionX();
 
   TH2F * h2 =simTH2->getTH2F();
   TH1D* sim  = h2 ->ProjectionX();
 
     
   TH1F *hEff = (TH1F*) reco->Clone();  
   
   hEff->Divide(sim);
   
   hEff->SetName("tmp_"+TString(reco->GetName()));
   
   // Set the error accordingly to binomial statistics
   int nBinsEta = hEff->GetNbinsX();
   for(int bin = 1; bin <=  nBinsEta; bin++) {
     float nSimHit = sim->GetBinContent(bin);
     float eff = hEff->GetBinContent(bin);
     float error = 0;
     if(nSimHit != 0 && eff <= 1) {
       error = sqrt(eff*(1-eff)/nSimHit);
     }
     hEff->SetBinError(bin, error);
     effHist->setBinContent(bin,eff);
     effHist->setBinError(bin,error);
   }
   
 }

void GlobalMuonMatchAnalyzer::computeEfficiencyPt	(	MonitorElement *	effHist,
		MonitorElement *	recoTH2,
		MonitorElement *	simTH2
	)

private

Definition at line 302 of file GlobalMuonMatchAnalyzer.cc.

References stringResolutionProvider_cfi::bin, relativeConstraints::error, MonitorElement::getTH2F(), MonitorElement::setBinContent(), MonitorElement::setBinError(), and mathSSE::sqrt().

Referenced by endRun().

                                                                                                                          {
   TH2F * h1 = recoTH2->getTH2F();
   TH1D* reco = h1->ProjectionY();
 
   TH2F * h2 = simTH2->getTH2F();
   TH1D* sim  = h2 ->ProjectionY();
 
     
   TH1F *hEff = (TH1F*) reco->Clone();  
   
   hEff->Divide(sim);
   
   hEff->SetName("tmp_"+TString(reco->GetName()));
   
   // Set the error accordingly to binomial statistics
   int nBinsPt = hEff->GetNbinsX();
   for(int bin = 1; bin <=  nBinsPt; bin++) {
     float nSimHit = sim->GetBinContent(bin);
     float eff = hEff->GetBinContent(bin);
     float error = 0;
     if(nSimHit != 0 && eff <= 1) {
       error = sqrt(eff*(1-eff)/nSimHit);
     }
     hEff->SetBinError(bin, error);
     effHist->setBinContent(bin,eff);
     effHist->setBinError(bin,error);
   }
   
 }

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

overrideprivate

Definition at line 230 of file GlobalMuonMatchAnalyzer.cc.

References computeEfficiencyEta(), computeEfficiencyPt(), dbe_, h_effic, h_efficPt, h_fake, h_fakeMatch, h_fakePt, h_goodMatchSim, h_shouldMatch, h_totReco, and out.

                                                                         {
   computeEfficiencyEta(h_effic,h_goodMatchSim,h_shouldMatch);
   computeEfficiencyPt(h_efficPt,h_goodMatchSim,h_shouldMatch);
 
   computeEfficiencyEta(h_fake,h_fakeMatch,h_totReco);
   computeEfficiencyPt(h_fakePt,h_fakeMatch,h_totReco);
 
   if( !out.empty() && dbe_ ) dbe_->save(out);
 }