#include <MuonAnalysis/MomentumScaleCalibration/plugins/TestCorrection.cc>

Inheritance diagram for TestCorrection:

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

	TestCorrection (const edm::ParameterSet &)

	~TestCorrection ()

	~TestCorrection ()

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
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 (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &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 ()

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

virtual void	analyze (const edm::Event &, const edm::EventSetup &) override

lorentzVector	correctMuon (const lorentzVector &muon)

lorentzVector	correctMuon (const lorentzVector &muon)

virtual void	endJob ()

virtual void	endJob () override

template<typename T >
std::vector< MuScleFitMuon >	fillMuonCollection (const std::vector< T > &tracks)

template<typename T >
std::vector< MuScleFitMuon >	fillMuonCollection (const std::vector< T > &tracks)

virtual void	initialize (const edm::EventSetup &)

virtual void	initialize (const edm::EventSetup &)

Private Member Functions inherited from MuScleFitBase
	MuScleFitBase (const edm::ParameterSet &iConfig)

virtual	~MuScleFitBase ()

void	clearHistoMap ()
	Clean the histograms map. More...

void	fillHistoMap (TFile *outputFile, unsigned int iLoop)
	Create the histograms map. More...

void	readProbabilityDistributionsFromFile ()
	Read probability distributions from a local root file. More...

void	writeHistoMap (const unsigned int iLoop)
	Save the histograms map to file. More...

Private Attributes
std::auto_ptr< BackgroundFunction >	background_

TH1F *	correctedPt_

TProfile *	correctedPtVsEta_

std::auto_ptr < MomentumScaleCorrector >	corrector_

int	eventCounter_

edm::EDGetTokenT < reco::MuonCollection >	glbMuonsToken_

std::auto_ptr< ResolutionFunction >	resolution_

edm::EDGetTokenT < reco::TrackCollection >	saMuonsToken_

edm::EDGetTokenT < reco::TrackCollection >	tracksToken_

TH1F *	uncorrectedPt_

TProfile *	uncorrectedPtVsEta_

Private Attributes inherited from MuScleFitBase
int	debug_

std::vector< GenMuonPair >	genMuonPairs_
	Stores the genMuon pairs and the motherId prior to the creation of the internal tree. More...

std::map< std::string, Histograms * >	mapHisto_
	The map of histograms. More...

std::vector< MuonPair >	muonPairs_
	Used to store the muon pairs plus run and event number prior to the creation of the internal tree. More...

std::string	probabilitiesFile_

std::string	probabilitiesFileInPath_

std::vector< TFile * >	theFiles_
	The files were the histograms are saved. More...

std::string	theGenInfoRootFileName_

edm::InputTag	theMuonLabel_

int	theMuonType_

std::string	theRootFileName_

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

Description: <one line="" class="" summary>="">

Implementation: <Notes on="" implementation>="">

Definition at line 63 of file TestCorrection.cc.

Constructor & Destructor Documentation

TestCorrection::TestCorrection ( const edm::ParameterSet & iConfig )

explicit

Definition at line 148 of file TestCorrection.cc.

References background_, correctedPt_, correctedPtVsEta_, corrector_, gather_cfg::cout, eventCounter_, MuScleFitBase::fillHistoMap(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), download_sqlite_cfg::outputFile, MuScleFitUtils::parResol, MuScleFitUtils::resfind, resolution_, MuScleFitUtils::resolutionFunction, MuScleFitUtils::resolutionFunctionForVec, resolutionFunctionVecService(), AlCaHLTBitMon_QueryRunRegistry::string, MuScleFitBase::theFiles_, MuScleFitBase::theRootFileName_, uncorrectedPt_, and uncorrectedPtVsEta_.

                                                              :
   MuScleFitBase( iConfig ),
   glbMuonsToken_(mayConsume<reco::MuonCollection>(theMuonLabel_)),
   saMuonsToken_(mayConsume<reco::TrackCollection>(theMuonLabel_)),
   tracksToken_(mayConsume<reco::TrackCollection>(theMuonLabel_))
 {
   //now do what ever initialization is needed
   TFile * outputFile = new TFile(theRootFileName_.c_str(), "RECREATE");
   theFiles_.push_back(outputFile);
   // outputFile_ = new TFile(theRootFileName_.c_str(), "RECREATE");
   // outputFile_->cd();
   outputFile->cd();
   MuScleFitUtils::resfind = iConfig.getParameter<std::vector<int> >("resfind");
   fillHistoMap(outputFile, 0);
   uncorrectedPt_ = new TH1F("uncorrectedPt", "uncorrected pt", 1000, 0, 100);
   uncorrectedPtVsEta_ = new TProfile("uncorrectedPtVsEta", "uncorrected pt vs eta", 1000, 0, 100, -3., 3.);
   correctedPt_ = new TH1F("correctedPt", "corrected pt", 1000, 0, 100);
   correctedPtVsEta_ = new TProfile("correctedPtVsEta", "corrected pt vs eta", 1000, 0, 100, -3., 3.);
   eventCounter_ = 0;
   // Create the corrector and set the parameters
   corrector_.reset(new MomentumScaleCorrector( iConfig.getUntrackedParameter<std::string>("CorrectionsIdentifier") ) );
   std::cout << "corrector_ = " << &*corrector_ << std::endl;
   resolution_.reset(new ResolutionFunction(iConfig.getUntrackedParameter<std::string>("ResolutionsIdentifier") ) );
   std::cout << "resolution_ = " << &*resolution_ << std::endl;
   background_.reset(new BackgroundFunction(iConfig.getUntrackedParameter<std::string>("BackgroundIdentifier") ) );
 
   // Initialize the parameters of MuScleFitUtils from those saved in the functions.
   // MuScleFitUtils::parScale = corrector_.getFunction(0)->parameters();
   MuScleFitUtils::resolutionFunction = resolution_->function(0);
   MuScleFitUtils::resolutionFunctionForVec = resolutionFunctionVecService( resolution_->identifiers()[0] );
 
   MuScleFitUtils::parResol = resolution_->parameters();
 }

TestCorrection::~TestCorrection ( )

Definition at line 182 of file TestCorrection.cc.

References svgfig::canvas(), correctedPt_, correctedPtVsEta_, gather_cfg::cout, eventCounter_, MuScleFitBase::theFiles_, uncorrectedPt_, uncorrectedPtVsEta_, and MuScleFitBase::writeHistoMap().

 {
   theFiles_[0]->cd();
   TCanvas canvas("ptComparison","pt comparison", 1000, 800);
   canvas.cd();
   uncorrectedPt_->GetXaxis()->SetTitle("Pt(GeV)");
   correctedPt_->SetLineColor(kRed);
   TLegend * legend = new TLegend(0.7,0.71,0.98,1.);
   legend->SetTextSize(0.02);
   legend->SetFillColor(0); // Have a white background
   legend->AddEntry(uncorrectedPt_, "original pt");
   legend->AddEntry(correctedPt_, "corrected pt");
   uncorrectedPt_->Draw();
   correctedPt_->Draw("same");
   legend->Draw("same");
 
   canvas.Write();
   uncorrectedPt_->Write();
   uncorrectedPtVsEta_->Write();
   correctedPt_->Write();
   correctedPtVsEta_->Write();
 
   writeHistoMap(0);
   theFiles_[0]->Close();
 
   std::cout << "Total analyzed events = " << eventCounter_ << std::endl;
 }

TestCorrection::TestCorrection ( const edm::ParameterSet & )

explicit

TestCorrection::~TestCorrection ( )

Member Function Documentation

virtual void TestCorrection::analyze	(	const edm::Event &	,
		const edm::EventSetup &
	)

privatevirtual

Implements edm::EDAnalyzer.

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

overrideprivatevirtual

Implements edm::EDAnalyzer.

Definition at line 215 of file TestCorrection.cc.

References funct::abs(), correctedPt_, correctedPtVsEta_, correctMuon(), gather_cfg::cout, eventCounter_, fillMuonCollection(), MuScleFitUtils::findBestRecoRes(), edm::Event::getByToken(), glbMuonsToken_, initialize(), MuScleFitBase::mapHisto_, patZpeak::muons, MuScleFitUtils::ResFound, saMuonsToken_, MuScleFitUtils::SavedPair, MuScleFitBase::theMuonType_, testEve_cfg::tracks, tracksToken_, uncorrectedPt_, and uncorrectedPtVsEta_.

                                                                                 {
   using namespace edm;
 
   initialize(iSetup);
 
   ++eventCounter_;
   if ( eventCounter_%100 == 0 ) {
     std::cout << "Event number " << eventCounter_ << std::endl;
   }
 
   // Take the reco-muons, depending on the type selected in the cfg
   // --------------------------------------------------------------
 
   std::vector<MuScleFitMuon> muons;
 
   if (theMuonType_==1) { // GlobalMuons
     Handle<reco::MuonCollection> glbMuons;
     iEvent.getByToken (glbMuonsToken_, glbMuons);
     muons = fillMuonCollection(*glbMuons);
   }
   else if (theMuonType_==2) { // StandaloneMuons
     Handle<reco::TrackCollection> saMuons;
     iEvent.getByToken (saMuonsToken_, saMuons);
     muons = fillMuonCollection(*saMuons);
   }
   else if (theMuonType_==3) { // Tracker tracks
     Handle<reco::TrackCollection> tracks;
     iEvent.getByToken (tracksToken_, tracks);
     muons = fillMuonCollection(*tracks);
   }
 
   // Find the two muons from the resonance, and set ResFound bool
   // ------------------------------------------------------------
   std::pair <MuScleFitMuon, MuScleFitMuon> recMuFromBestRes =
     MuScleFitUtils::findBestRecoRes (muons);
   if (MuScleFitUtils::ResFound) {
     MuScleFitUtils::SavedPair.push_back( std::make_pair (recMuFromBestRes.first.p4(), recMuFromBestRes.second.p4()) );
   } else {
     MuScleFitUtils::SavedPair.push_back( std::make_pair (lorentzVector(0.,0.,0.,0.), lorentzVector(0.,0.,0.,0.)) );
   }
 
   // If resonance found, do the hard work
   // ------------------------------------
   if (MuScleFitUtils::ResFound) {
 
     // Find weight and reference mass for this muon pair
     // -------------------------------------------------
     // double weight = MuScleFitUtils::computeWeight ((recMu1+recMu2).mass());
 
     // Use the correction function to correct the pt scale of the muons. Note that this takes into
     // account the corrections from all iterations.
     lorentzVector recMu1;
     recMu1 = correctMuon(recMu1);
     lorentzVector recMu2;
     recMu2 = correctMuon(recMu2);
 
     reco::Particle::LorentzVector bestRecRes (recMu1+recMu2);
 
     //Fill histograms
     //------------------
     mapHisto_["hRecBestMu"]->Fill(recMu1);
     if ((std::abs(recMu1.eta())<2.5) && (recMu1.pt()>2.5)) {
       mapHisto_["hRecBestMu_Acc"]->Fill(recMu1);
     }
     mapHisto_["hRecBestMu"]->Fill(recMu2);
     if ((std::abs(recMu2.eta())<2.5) && (recMu2.pt()>2.5)) {
       mapHisto_["hRecBestMu_Acc"]->Fill(recMu2);
     }
     mapHisto_["hDeltaRecBestMu"]->Fill(recMu1, recMu2);
 
     mapHisto_["hRecBestRes"]->Fill(bestRecRes);
     if ((std::abs(recMu1.eta())<2.5) && (recMu1.pt()>2.5) && (std::abs(recMu2.eta())<2.5) &&  (recMu2.pt()>2.5)){
       mapHisto_["hRecBestRes_Acc"]->Fill(bestRecRes);
       // Fill histogram of Res mass vs muon variable
       mapHisto_["hRecBestResVSMu"]->Fill (recMu1, bestRecRes, -1);
       mapHisto_["hRecBestResVSMu"]->Fill (recMu2, bestRecRes, +1);
     }
   }
 
   // Loop on the recMuons
   std::vector<MuScleFitMuon>::const_iterator recMuon = muons.begin();
   int muonCount = 0;
   for ( ; recMuon!=muons.end(); ++recMuon, ++muonCount ) {
 
     // Fill the histogram with uncorrected pt values
     uncorrectedPt_->Fill(recMuon->pt());
     uncorrectedPtVsEta_->Fill(recMuon->pt(), recMuon->eta());
 
     // Fill the histogram with corrected pt values
     std::cout << "correcting muon["<<muonCount<<"] with pt = " << recMuon->pt() << std::endl;
     double corrPt = (*corrector_)(*recMuon);
     std::cout << "to pt = " << corrPt << std::endl;
     correctedPt_->Fill(corrPt);
     correctedPtVsEta_->Fill(corrPt, recMuon->eta());
     // correctedPt_->Fill(recMuon->pt());
   }
 }

lorentzVector TestCorrection::correctMuon ( const lorentzVector & muon )

private

lorentzVector TestCorrection::correctMuon ( const lorentzVector & muon )

private

Definition at line 313 of file TestCorrection.cc.

References corrector_, and MuScleFitUtils::fromPtEtaPhiToPxPyPz().

Referenced by analyze().

                                                                       {
   double corrPt = corrector_->correct(muon);
   double ptEtaPhiE[4] = {corrPt, muon.Eta(), muon.Phi(), muon.E()};
   return MuScleFitUtils::fromPtEtaPhiToPxPyPz(ptEtaPhiE);
 }

virtual void TestCorrection::endJob ( void )

inlineprivatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 69 of file TestCorrection.h.

69 {};

virtual void TestCorrection::endJob ( void )

inlineoverrideprivatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 71 of file TestCorrection.cc.

71 {};

template<typename T >

std::vector<MuScleFitMuon> TestCorrection::fillMuonCollection ( const std::vector< T > & tracks )

inlineprivate

Definition at line 71 of file TestCorrection.h.

References gather_cfg::cout, MuScleFitBase::debug_, RPCpg::mu, metsig::muon, patZpeak::muons, and mathSSE::sqrt().

   {
     std::vector<MuScleFitMuon> muons;
     typename std::vector<T>::const_iterator track;
     for( track = tracks.begin(); track != tracks.end(); ++track ) {
       reco::Particle::LorentzVector mu;
       mu = reco::Particle::LorentzVector(track->px(),track->py(),track->pz(),
                      sqrt(track->p()*track->p() + + 0.011163612));
       
       Double_t hitsTk(0), hitsMuon(0), ptError(0);
       if ( const reco::Muon* myMu = dynamic_cast<const reco::Muon*>(&(*track))  ){
     hitsTk =   myMu->innerTrack()->hitPattern().numberOfValidTrackerHits();
     hitsMuon = myMu->innerTrack()->hitPattern().numberOfValidMuonHits();
     ptError =  myMu->innerTrack()->ptError();
       }
       else if ( const pat::Muon* myMu = dynamic_cast<const pat::Muon*>(&(*track)) ) {
     hitsTk =   myMu->innerTrack()->hitPattern().numberOfValidTrackerHits();
     hitsMuon = myMu->innerTrack()->hitPattern().numberOfValidMuonHits();
     ptError =  myMu->innerTrack()->ptError();
       }
       else if (const reco::Track* myMu = dynamic_cast<const reco::Track*>(&(*track))){
     hitsTk =   myMu->hitPattern().numberOfValidTrackerHits();
     hitsMuon = myMu->hitPattern().numberOfValidMuonHits();
     ptError =  myMu->ptError();
       }
       
       MuScleFitMuon muon(mu,track->charge(),ptError,hitsTk,hitsMuon,false);
 
     if (debug_>0) {
       std::cout<<"[TestCorrection::fillMuonCollection] after MuScleFitMuon initialization"<<std::endl;
       std::cout<<"  muon = "<<muon<<std::endl;
     }
 
     muons.push_back(muon);
     }
     return muons;
   }

template<typename T >

std::vector<MuScleFitMuon> TestCorrection::fillMuonCollection ( const std::vector< T > & tracks )

inlineprivate

Definition at line 73 of file TestCorrection.cc.

References gather_cfg::cout, MuScleFitBase::debug_, RPCpg::mu, metsig::muon, patZpeak::muons, and mathSSE::sqrt().

Referenced by analyze().

   {
     std::vector<MuScleFitMuon> muons;
     typename std::vector<T>::const_iterator track;
     for( track = tracks.begin(); track != tracks.end(); ++track ) {
       reco::Particle::LorentzVector mu;
       mu = reco::Particle::LorentzVector(track->px(),track->py(),track->pz(),
                      sqrt(track->p()*track->p() + + 0.011163612));
 
       Double_t hitsTk(0), hitsMuon(0), ptError(0);
       if ( const reco::Muon* myMu = dynamic_cast<const reco::Muon*>(&(*track))  ){
     hitsTk =   myMu->innerTrack()->hitPattern().numberOfValidTrackerHits();
     hitsMuon = myMu->innerTrack()->hitPattern().numberOfValidMuonHits();
     ptError =  myMu->innerTrack()->ptError();
       }
       else if ( const pat::Muon* myMu = dynamic_cast<const pat::Muon*>(&(*track)) ) {
     hitsTk =   myMu->innerTrack()->hitPattern().numberOfValidTrackerHits();
     hitsMuon = myMu->innerTrack()->hitPattern().numberOfValidMuonHits();
     ptError =  myMu->innerTrack()->ptError();
       }
       else if (const reco::Track* myMu = dynamic_cast<const reco::Track*>(&(*track))){
     hitsTk =   myMu->hitPattern().numberOfValidTrackerHits();
     hitsMuon = myMu->hitPattern().numberOfValidMuonHits();
     ptError =  myMu->ptError();
       }
 
       MuScleFitMuon muon(mu,track->charge(),ptError,hitsTk,hitsMuon);
 
     if (debug_>0) {
       std::cout<<"[TestCorrection::fillMuonCollection] after MuScleFitMuon initialization"<<std::endl;
       std::cout<<"  muon = "<<muon<<std::endl;
     }
 
     muons.push_back(muon);
     }
     return muons;
   }

virtual void TestCorrection::initialize ( const edm::EventSetup & )

privatevirtual

void TestCorrection::initialize ( const edm::EventSetup & )

privatevirtual

Definition at line 320 of file TestCorrection.cc.

References MuScleFitBase::readProbabilityDistributionsFromFile().

Referenced by analyze().

 {
   // Read the pdf from root file. They are used by massProb when finding the muon pair, needed
   // for the mass histograms.
   readProbabilityDistributionsFromFile();
 }