TestCorrection Class Reference

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

Inheritance diagram for TestCorrection:

Public Member Functions
	TestCorrection (const edm::ParameterSet &)
	TestCorrection (const edm::ParameterSet &)
	~TestCorrection ()
	~TestCorrection () override
Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzer ()
SerialTaskQueue *	globalLuminosityBlocksQueue ()
SerialTaskQueue *	globalRunsQueue ()
ModuleDescription const &	moduleDescription () const
std::string	workerType () const
	~EDAnalyzer () override
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...
	EDConsumerBase ()
	EDConsumerBase (EDConsumerBase &&)=default
	EDConsumerBase (EDConsumerBase const &)=delete
ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const
std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const
std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const * > *, NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
EDConsumerBase &	operator= (EDConsumerBase &&)=default
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)
virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &)
void	analyze (const edm::Event &, const edm::EventSetup &) override
lorentzVector	correctMuon (const lorentzVector &muon)
lorentzVector	correctMuon (const lorentzVector &muon)
virtual void	endJob ()
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 () noexcept(false)
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::unique_ptr< BackgroundFunction >	background_
TH1F *	correctedPt_
TProfile *	correctedPtVsEta_
std::unique_ptr< MomentumScaleCorrector >	corrector_
int	eventCounter_
edm::EDGetTokenT< reco::MuonCollection >	glbMuonsToken_
std::unique_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_
int	theCompressionSettings_
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 &)
static bool	wantsGlobalLuminosityBlocks ()
static bool	wantsGlobalRuns ()
static bool	wantsInputProcessBlocks ()
static bool	wantsProcessBlocks ()
static bool	wantsStreamLuminosityBlocks ()
static bool	wantsStreamRuns ()
Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept
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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()
template<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept
template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

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

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

Definition at line 60 of file TestCorrection.cc.

Constructor & Destructor Documentation

TestCorrection() [1/2]

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

explicit

Definition at line 139 of file TestCorrection.cc.

    : 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_ =
      std::make_unique<MomentumScaleCorrector>(iConfig.getUntrackedParameter<std::string>("CorrectionsIdentifier"));
  std::cout << "corrector_ = " << &*corrector_ << std::endl;
  resolution_ =
      std::make_unique<ResolutionFunction>(iConfig.getUntrackedParameter<std::string>("ResolutionsIdentifier"));
  std::cout << "resolution_ = " << &*resolution_ << std::endl;
  background_ =
      std::make_unique<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();
}

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_.

~TestCorrection() [1/2]

TestCorrection::~TestCorrection ( )

override

Definition at line 175 of file TestCorrection.cc.

                                {
  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;
}

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

TestCorrection() [2/2]

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

explicit

~TestCorrection() [2/2]

TestCorrection::~TestCorrection

(

)

Member Function Documentation

analyze() [1/2]

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

privatevirtual

Implements edm::EDAnalyzer.

analyze() [2/2]

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

overrideprivatevirtual

Implements edm::EDAnalyzer.

Definition at line 207 of file TestCorrection.cc.

                                                                                {
  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());
  }
}

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

correctMuon() [1/2]

lorentzVector TestCorrection::correctMuon ( const lorentzVector &  muon )

private

Definition at line 301 of file TestCorrection.cc.

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

References corrector_, and MuScleFitUtils::fromPtEtaPhiToPxPyPz().

Referenced by analyze().

correctMuon() [2/2]

lorentzVector TestCorrection::correctMuon ( const lorentzVector &  muon )

private

endJob() [1/2]

virtual void TestCorrection::endJob ( void  )

inlineprivatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 69 of file TestCorrection.h.

{};

endJob() [2/2]

void TestCorrection::endJob ( void  )

inlineoverrideprivatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 68 of file TestCorrection.cc.

{};

fillMuonCollection() [1/2]

template<typename T >

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

inlineprivate

Definition at line 70 of file TestCorrection.cc.

                                                                          {
    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;
  }

References gather_cfg::cout, MuScleFitBase::debug_, amptDefaultParameters_cff::mu, HLT_FULL_cff::muon, PDWG_BPHSkim_cff::muons, mathSSE::sqrt(), HLT_FULL_cff::track, and tracks.

Referenced by analyze().

fillMuonCollection() [2/2]

template<typename T >

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

inlineprivate

Definition at line 71 of file TestCorrection.h.

  {
    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;
  }

References gather_cfg::cout, MuScleFitBase::debug_, amptDefaultParameters_cff::mu, HLT_FULL_cff::muon, PDWG_BPHSkim_cff::muons, mathSSE::sqrt(), HLT_FULL_cff::track, and tracks.

initialize() [1/2]

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

privatevirtual

Definition at line 308 of file TestCorrection.cc.

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

References MuScleFitBase::readProbabilityDistributionsFromFile().

Referenced by analyze().

initialize() [2/2]

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

privatevirtual

Member Data Documentation

background_

std::unique_ptr< BackgroundFunction > TestCorrection::background_

private

Definition at line 120 of file TestCorrection.cc.

Referenced by TestCorrection().

correctedPt_

TH1F * TestCorrection::correctedPt_

private

Definition at line 113 of file TestCorrection.cc.

Referenced by analyze(), TestCorrection(), and ~TestCorrection().

correctedPtVsEta_

TProfile * TestCorrection::correctedPtVsEta_

private

Definition at line 114 of file TestCorrection.cc.

Referenced by analyze(), TestCorrection(), and ~TestCorrection().

corrector_

std::unique_ptr< MomentumScaleCorrector > TestCorrection::corrector_

private

Definition at line 118 of file TestCorrection.cc.

Referenced by correctMuon(), and TestCorrection().

eventCounter_

int TestCorrection::eventCounter_

private

Definition at line 116 of file TestCorrection.cc.

Referenced by analyze(), TestCorrection(), and ~TestCorrection().

glbMuonsToken_

edm::EDGetTokenT<reco::MuonCollection> TestCorrection::glbMuonsToken_

private

Definition at line 122 of file TestCorrection.cc.

Referenced by analyze().

resolution_

std::unique_ptr< ResolutionFunction > TestCorrection::resolution_

private

Definition at line 119 of file TestCorrection.cc.

Referenced by TestCorrection().

saMuonsToken_

edm::EDGetTokenT<reco::TrackCollection> TestCorrection::saMuonsToken_

private

Definition at line 123 of file TestCorrection.cc.

Referenced by analyze().

tracksToken_

edm::EDGetTokenT<reco::TrackCollection> TestCorrection::tracksToken_

private

Definition at line 124 of file TestCorrection.cc.

Referenced by analyze().

uncorrectedPt_

TH1F * TestCorrection::uncorrectedPt_

private

Definition at line 111 of file TestCorrection.cc.

Referenced by analyze(), TestCorrection(), and ~TestCorrection().

uncorrectedPtVsEta_

TProfile * TestCorrection::uncorrectedPtVsEta_

private

Definition at line 112 of file TestCorrection.cc.

Referenced by analyze(), TestCorrection(), and ~TestCorrection().