#include <GlobalMuonMatchAnalyzer.h>

Inheritance diagram for GlobalMuonMatchAnalyzer:

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

	~GlobalMuonMatchAnalyzer ()

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

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

	DQMEDAnalyzer (void)

Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzer ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

virtual	~EDAnalyzer ()

Public Member Functions inherited from edm::EDConsumerBase
	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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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

virtual void	beginJob ()

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)

virtual void	endJob ()

virtual void	endRun ()

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_

std::string	muAssociatorName_

std::string	out

edm::InputTag	staName_

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

std::string	subsystemname_

const TrackAssociatorBase *	tkAssociator_

std::string	tkAssociatorName_

edm::InputTag	tkName_

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

edm::InputTag	tpName_

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

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

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

Author: Adam Everett Purdue University

Definition at line 45 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 39 of file GlobalMuonMatchAnalyzer.cc.

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

 {
   iConfig = ps;
   //now do what ever initialization is needed
   tkAssociatorName_ = iConfig.getUntrackedParameter<std::string>("tkAssociator");
   muAssociatorName_ = iConfig.getUntrackedParameter<std::string>("muAssociator");
 
 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 ( )

Definition at line 63 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
	)

privatevirtual

Implements edm::EDAnalyzer.

Definition at line 78 of file GlobalMuonMatchAnalyzer.cc.

References TrackAssociatorBase::associateRecoToSim(), TrackAssociatorBase::associateSimToReco(), reco::TrackBase::eta(), MonitorElement::Fill(), edm::Event::getByToken(), glbToken_, h_fakeMatch, h_goodMatch, h_goodMatchSim, h_shouldMatch, h_staOnlySim, h_tkOnlySim, h_totReco, i, electronStore::links, muAssociator_, reco::TrackBase::pt(), dt_dqm_sourceclient_common_cff::reco, staToken_, tkAssociator_, 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);
 
    reco::RecoToSimCollection tkrecoToSimCollection;
    reco::SimToRecoCollection tksimToRecoCollection;
    tkrecoToSimCollection = tkAssociator_->associateRecoToSim(tkHandle,tpHandle,&iEvent,&iSetup);
    tksimToRecoCollection = tkAssociator_->associateSimToReco(tkHandle,tpHandle,&iEvent,&iSetup);
 
    reco::RecoToSimCollection starecoToSimCollection;
    reco::SimToRecoCollection stasimToRecoCollection;
    starecoToSimCollection = muAssociator_->associateRecoToSim(staHandle,tpHandle,&iEvent,&iSetup);
    stasimToRecoCollection = muAssociator_->associateSimToReco(staHandle,tpHandle,&iEvent,&iSetup);
 
    reco::RecoToSimCollection glbrecoToSimCollection;
    reco::SimToRecoCollection glbsimToRecoCollection;
    glbrecoToSimCollection = muAssociator_->associateRecoToSim(glbHandle,tpHandle,&iEvent,&iSetup);
    glbsimToRecoCollection = muAssociator_->associateSimToReco(glbHandle,tpHandle,&iEvent,&iSetup);
 
 
    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.size() != 0) {
      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.size() != 0) {
      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.size() != 0) {
      rTk = rvTk.begin()->first;
        }
      }
      
      if( rvSta.size() != 0 && rvTk.size() != 0 ){
        //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.size() != 0) {
      tp1r = tp1.begin()->first;
        }
      }
      
      std::vector<std::pair<TrackingParticleRef, double> > tp2;
      TrackingParticleRef tp2r;
      if(starecoToSimCollection.find(staRef) != starecoToSimCollection.end()){
        tp2 = starecoToSimCollection[staRef];
        if(tp2.size() != 0) {
      tp2r = tp2.begin()->first;
        }
      }
      
      std::vector<std::pair<TrackingParticleRef, double> > tp3;
      TrackingParticleRef tp3r;
      if(tkrecoToSimCollection.find(tkRef) != tkrecoToSimCollection.end()){
        tp3 = tkrecoToSimCollection[tkRef];
        if(tp3.size() != 0) {
      tp3r = tp3.begin()->first;
        }
      }
      
      
      if(tp1.size() != 0) {
        //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::beginJob ( void )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 228 of file GlobalMuonMatchAnalyzer.cc.

229 {

230 }

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

overrideprivatevirtual

Implements thread_unsafe::DQMEDAnalyzer.

Definition at line 245 of file GlobalMuonMatchAnalyzer.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), DQMStore::IBooker::cd(), TrackerOfflineValidation_Dqm_cff::dirName, edm::EventSetup::get(), h_effic, h_efficPt, h_fake, h_fakeMatch, h_fakePt, h_goodMatch, h_goodMatchSim, h_shouldMatch, h_staOnlySim, h_tkOnlySim, h_totReco, muAssociator_, muAssociatorName_, edm::ESHandle< class >::product(), DQMStore::IBooker::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, tkAssociator_, and tkAssociatorName_.

 {
   // Tk Associator
 
   edm::ESHandle<TrackAssociatorBase> tkassociatorHandle;
   iSetup.get<TrackAssociatorRecord>().get(tkAssociatorName_,tkassociatorHandle);
   tkAssociator_ = tkassociatorHandle.product();
 
   // Mu Associator
   edm::ESHandle<TrackAssociatorBase> muassociatorHandle;
   iSetup.get<TrackAssociatorRecord>().get(muAssociatorName_,muassociatorHandle);
   muAssociator_ = muassociatorHandle.product();
   ibooker.cd();
   std::string dirName="Matcher/";
   //  ibooker.setCurrentFolder("RecoMuonV/Matcher");
   ibooker.setCurrentFolder(dirName.c_str()) ;
 
   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 283 of file GlobalMuonMatchAnalyzer.cc.

References newFWLiteAna::bin, relativeConstraints::error, MonitorElement::getTH2F(), dt_dqm_sourceclient_common_cff::reco, 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 313 of file GlobalMuonMatchAnalyzer.cc.

References newFWLiteAna::bin, relativeConstraints::error, MonitorElement::getTH2F(), dt_dqm_sourceclient_common_cff::reco, 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::endJob ( void )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 231 of file GlobalMuonMatchAnalyzer.cc.

231 {}

void GlobalMuonMatchAnalyzer::endRun ( void )

privatevirtual

Definition at line 233 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.size() != 0 && dbe_ ) dbe_->save(out);
 }