CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
List of all members | Public Member Functions | Private Member Functions | Private Attributes
TestCorrection Class Reference

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

Inheritance diagram for TestCorrection:
edm::one::EDAnalyzer<> MuScleFitBase edm::one::EDAnalyzerBase edm::EDConsumerBase

Public Member Functions

 TestCorrection (const edm::ParameterSet &)
 
 ~TestCorrection () override
 
- Public Member Functions inherited from edm::one::EDAnalyzer<>
 EDAnalyzer ()=default
 
 EDAnalyzer (const EDAnalyzer &)=delete
 
SerialTaskQueueglobalLuminosityBlocksQueue () final
 
SerialTaskQueueglobalRunsQueue () final
 
const EDAnalyzeroperator= (const EDAnalyzer &)=delete
 
bool wantsGlobalLuminosityBlocks () const final
 
bool wantsGlobalRuns () const final
 
bool wantsInputProcessBlocks () const final
 
bool wantsProcessBlocks () const final
 
- Public Member Functions inherited from edm::one::EDAnalyzerBase
void callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
 
 EDAnalyzerBase ()
 
ModuleDescription const & moduleDescription () const
 
bool wantsStreamLuminosityBlocks () const
 
bool wantsStreamRuns () const
 
 ~EDAnalyzerBase () override
 
- Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfoconsumesInfo () const
 
void convertCurrentProcessAlias (std::string const &processName)
 Convert "@currentProcess" in InputTag process names to the actual current process name. More...
 
 EDConsumerBase ()
 
 EDConsumerBase (EDConsumerBase const &)=delete
 
 EDConsumerBase (EDConsumerBase &&)=default
 
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 const & operator= (EDConsumerBase const &)=delete
 
EDConsumerBaseoperator= (EDConsumerBase &&)=default
 
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

void analyze (const edm::Event &, const edm::EventSetup &) override
 
lorentzVector correctMuon (const lorentzVector &muon)
 
void endJob () override
 
template<typename T >
std::vector< MuScleFitMuonfillMuonCollection (const std::vector< T > &tracks)
 
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< BackgroundFunctionbackground_
 
TH1F * correctedPt_
 
TProfile * correctedPtVsEta_
 
std::unique_ptr< MomentumScaleCorrectorcorrector_
 
int eventCounter_
 
edm::EDGetTokenT< reco::MuonCollectionglbMuonsToken_
 
std::unique_ptr< ResolutionFunctionresolution_
 
edm::EDGetTokenT< reco::TrackCollectionsaMuonsToken_
 
edm::EDGetTokenT< reco::TrackCollectiontracksToken_
 
TH1F * uncorrectedPt_
 
TProfile * uncorrectedPtVsEta_
 
- Private Attributes inherited from MuScleFitBase
int debug_
 
std::vector< GenMuonPairgenMuonPairs_
 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< MuonPairmuonPairs_
 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::one::EDAnalyzerBase
typedef EDAnalyzerBase ModuleType
 
- Public Types inherited from edm::EDConsumerBase
typedef ProductLabels Labels
 
- Static Public Member Functions inherited from edm::one::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)
 
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< Bconsumes (edm::InputTag tag) noexcept
 
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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes ()
 
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes (ESInputTag const &tag)
 
template<Transition Tr = Transition::Event>
constexpr auto esConsumes ()
 
template<Transition Tr = Transition::Event>
auto esConsumes (ESInputTag tag)
 
template<Transition Tr = Transition::Event>
ESGetTokenGeneric esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
 Used with EventSetupRecord::doGet. More...
 
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)
 
void resetItemsToGetFrom (BranchType iType)
 

Detailed Description

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

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

Definition at line 60 of file TestCorrection.cc.

Constructor & Destructor Documentation

◆ TestCorrection()

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

Definition at line 133 of file TestCorrection.cc.

References background_, correctedPt_, correctedPtVsEta_, corrector_, 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_.

134  : MuScleFitBase(iConfig),
135  glbMuonsToken_(mayConsume<reco::MuonCollection>(theMuonLabel_)),
136  saMuonsToken_(mayConsume<reco::TrackCollection>(theMuonLabel_)),
137  tracksToken_(mayConsume<reco::TrackCollection>(theMuonLabel_)) {
138  //now do what ever initialization is needed
139  TFile* outputFile = new TFile(theRootFileName_.c_str(), "RECREATE");
140  theFiles_.push_back(outputFile);
141  // outputFile_ = new TFile(theRootFileName_.c_str(), "RECREATE");
142  // outputFile_->cd();
143  outputFile->cd();
144  MuScleFitUtils::resfind = iConfig.getParameter<std::vector<int> >("resfind");
146  uncorrectedPt_ = new TH1F("uncorrectedPt", "uncorrected pt", 1000, 0, 100);
147  uncorrectedPtVsEta_ = new TProfile("uncorrectedPtVsEta", "uncorrected pt vs eta", 1000, 0, 100, -3., 3.);
148  correctedPt_ = new TH1F("correctedPt", "corrected pt", 1000, 0, 100);
149  correctedPtVsEta_ = new TProfile("correctedPtVsEta", "corrected pt vs eta", 1000, 0, 100, -3., 3.);
150  eventCounter_ = 0;
151  // Create the corrector and set the parameters
152  corrector_ =
153  std::make_unique<MomentumScaleCorrector>(iConfig.getUntrackedParameter<std::string>("CorrectionsIdentifier"));
154  edm::LogPrint("TestCorrection") << "corrector_ = " << &*corrector_ << std::endl;
155  resolution_ =
156  std::make_unique<ResolutionFunction>(iConfig.getUntrackedParameter<std::string>("ResolutionsIdentifier"));
157  edm::LogPrint("TestCorrection") << "resolution_ = " << &*resolution_ << std::endl;
158  background_ =
159  std::make_unique<BackgroundFunction>(iConfig.getUntrackedParameter<std::string>("BackgroundIdentifier"));
160 
161  // Initialize the parameters of MuScleFitUtils from those saved in the functions.
162  // MuScleFitUtils::parScale = corrector_.getFunction(0)->parameters();
165 
166  MuScleFitUtils::parResol = resolution_->parameters();
167 }
MuScleFitBase(const edm::ParameterSet &iConfig)
Definition: MuScleFitBase.h:20
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
edm::InputTag theMuonLabel_
Definition: MuScleFitBase.h:48
static std::vector< double > parResol
edm::EDGetTokenT< reco::TrackCollection > saMuonsToken_
std::unique_ptr< BackgroundFunction > background_
T getUntrackedParameter(std::string const &, T const &) const
resolutionFunctionBase< std::vector< double > > * resolutionFunctionVecService(const int identifier)
Service to build the resolution functor corresponding to the passed identifier when receiving a std::...
Definition: Functions.cc:92
std::unique_ptr< MomentumScaleCorrector > corrector_
Log< level::Warning, true > LogPrint
std::string theRootFileName_
Definition: MuScleFitBase.h:50
void fillHistoMap(TFile *outputFile, unsigned int iLoop)
Create the histograms map.
Definition: MuScleFitBase.cc:9
std::vector< TFile * > theFiles_
The files were the histograms are saved.
Definition: MuScleFitBase.h:76
edm::EDGetTokenT< reco::MuonCollection > glbMuonsToken_
edm::EDGetTokenT< reco::TrackCollection > tracksToken_
TProfile * uncorrectedPtVsEta_
TProfile * correctedPtVsEta_
static std::vector< int > resfind
static resolutionFunctionBase< std::vector< double > > * resolutionFunctionForVec
static resolutionFunctionBase< double * > * resolutionFunction
std::unique_ptr< ResolutionFunction > resolution_

◆ ~TestCorrection()

TestCorrection::~TestCorrection ( )
override

Definition at line 169 of file TestCorrection.cc.

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

169  {
170  theFiles_[0]->cd();
171  TCanvas canvas("ptComparison", "pt comparison", 1000, 800);
172  canvas.cd();
173  uncorrectedPt_->GetXaxis()->SetTitle("Pt(GeV)");
174  correctedPt_->SetLineColor(kRed);
175  TLegend* legend = new TLegend(0.7, 0.71, 0.98, 1.);
176  legend->SetTextSize(0.02);
177  legend->SetFillColor(0); // Have a white background
178  legend->AddEntry(uncorrectedPt_, "original pt");
179  legend->AddEntry(correctedPt_, "corrected pt");
180  uncorrectedPt_->Draw();
181  correctedPt_->Draw("same");
182  legend->Draw("same");
183 
184  canvas.Write();
185  uncorrectedPt_->Write();
186  uncorrectedPtVsEta_->Write();
187  correctedPt_->Write();
188  correctedPtVsEta_->Write();
189 
190  writeHistoMap(0);
191  theFiles_[0]->Close();
192 
193  edm::LogPrint("TestCorrection") << "Total analyzed events = " << eventCounter_ << std::endl;
194 }
Log< level::Warning, true > LogPrint
void writeHistoMap(const unsigned int iLoop)
Save the histograms map to file.
std::vector< TFile * > theFiles_
The files were the histograms are saved.
Definition: MuScleFitBase.h:76
def canvas(sub, attr)
Definition: svgfig.py:482
TProfile * uncorrectedPtVsEta_
TProfile * correctedPtVsEta_

Member Function Documentation

◆ analyze()

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

Implements edm::one::EDAnalyzerBase.

Definition at line 201 of file TestCorrection.cc.

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

201  {
202  using namespace edm;
203 
204  initialize(iSetup);
205 
206  ++eventCounter_;
207  if (eventCounter_ % 100 == 0) {
208  edm::LogPrint("TestCorrection") << "Event number " << eventCounter_ << std::endl;
209  }
210 
211  // Take the reco-muons, depending on the type selected in the cfg
212  // --------------------------------------------------------------
213 
214  std::vector<MuScleFitMuon> muons;
215 
216  if (theMuonType_ == 1) { // GlobalMuons
218  iEvent.getByToken(glbMuonsToken_, glbMuons);
219  muons = fillMuonCollection(*glbMuons);
220  } else if (theMuonType_ == 2) { // StandaloneMuons
222  iEvent.getByToken(saMuonsToken_, saMuons);
223  muons = fillMuonCollection(*saMuons);
224  } else if (theMuonType_ == 3) { // Tracker tracks
226  iEvent.getByToken(tracksToken_, tracks);
228  }
229 
230  // Find the two muons from the resonance, and set ResFound bool
231  // ------------------------------------------------------------
232  std::pair<MuScleFitMuon, MuScleFitMuon> recMuFromBestRes = MuScleFitUtils::findBestRecoRes(muons);
234  MuScleFitUtils::SavedPair.push_back(std::make_pair(recMuFromBestRes.first.p4(), recMuFromBestRes.second.p4()));
235  } else {
236  MuScleFitUtils::SavedPair.push_back(std::make_pair(lorentzVector(0., 0., 0., 0.), lorentzVector(0., 0., 0., 0.)));
237  }
238 
239  // If resonance found, do the hard work
240  // ------------------------------------
242  // Find weight and reference mass for this muon pair
243  // -------------------------------------------------
244  // double weight = MuScleFitUtils::computeWeight ((recMu1+recMu2).mass());
245 
246  // Use the correction function to correct the pt scale of the muons. Note that this takes into
247  // account the corrections from all iterations.
248  lorentzVector recMu1;
249  recMu1 = correctMuon(recMu1);
250  lorentzVector recMu2;
251  recMu2 = correctMuon(recMu2);
252 
253  reco::Particle::LorentzVector bestRecRes(recMu1 + recMu2);
254 
255  //Fill histograms
256  //------------------
257  mapHisto_["hRecBestMu"]->Fill(recMu1);
258  if ((std::abs(recMu1.eta()) < 2.5) && (recMu1.pt() > 2.5)) {
259  mapHisto_["hRecBestMu_Acc"]->Fill(recMu1);
260  }
261  mapHisto_["hRecBestMu"]->Fill(recMu2);
262  if ((std::abs(recMu2.eta()) < 2.5) && (recMu2.pt() > 2.5)) {
263  mapHisto_["hRecBestMu_Acc"]->Fill(recMu2);
264  }
265  mapHisto_["hDeltaRecBestMu"]->Fill(recMu1, recMu2);
266 
267  mapHisto_["hRecBestRes"]->Fill(bestRecRes);
268  if ((std::abs(recMu1.eta()) < 2.5) && (recMu1.pt() > 2.5) && (std::abs(recMu2.eta()) < 2.5) &&
269  (recMu2.pt() > 2.5)) {
270  mapHisto_["hRecBestRes_Acc"]->Fill(bestRecRes);
271  // Fill histogram of Res mass vs muon variable
272  mapHisto_["hRecBestResVSMu"]->Fill(recMu1, bestRecRes, -1);
273  mapHisto_["hRecBestResVSMu"]->Fill(recMu2, bestRecRes, +1);
274  }
275  }
276 
277  // Loop on the recMuons
278  std::vector<MuScleFitMuon>::const_iterator recMuon = muons.begin();
279  int muonCount = 0;
280  for (; recMuon != muons.end(); ++recMuon, ++muonCount) {
281  // Fill the histogram with uncorrected pt values
282  uncorrectedPt_->Fill(recMuon->pt());
283  uncorrectedPtVsEta_->Fill(recMuon->pt(), recMuon->eta());
284 
285  // Fill the histogram with corrected pt values
286  edm::LogPrint("TestCorrection") << "correcting muon[" << muonCount << "] with pt = " << recMuon->pt() << std::endl;
287  double corrPt = (*corrector_)(*recMuon);
288  edm::LogPrint("TestCorrection") << "to pt = " << corrPt << std::endl;
289  correctedPt_->Fill(corrPt);
290  correctedPtVsEta_->Fill(corrPt, recMuon->eta());
291  // correctedPt_->Fill(recMuon->pt());
292  }
293 }
lorentzVector correctMuon(const lorentzVector &muon)
virtual void initialize(const edm::EventSetup &)
edm::EDGetTokenT< reco::TrackCollection > saMuonsToken_
std::map< std::string, Histograms * > mapHisto_
The map of histograms.
Definition: MuScleFitBase.h:79
static bool ResFound
reco::Particle::LorentzVector lorentzVector
Definition: GenMuonPair.h:9
static std::pair< MuScleFitMuon, MuScleFitMuon > findBestRecoRes(const std::vector< MuScleFitMuon > &muons)
int iEvent
Definition: GenABIO.cc:224
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
static std::vector< std::pair< lorentzVector, lorentzVector > > SavedPair
Log< level::Warning, true > LogPrint
std::vector< MuScleFitMuon > fillMuonCollection(const std::vector< T > &tracks)
edm::EDGetTokenT< reco::MuonCollection > glbMuonsToken_
HLT enums.
edm::EDGetTokenT< reco::TrackCollection > tracksToken_
TProfile * uncorrectedPtVsEta_
TProfile * correctedPtVsEta_
math::XYZTLorentzVector LorentzVector
Lorentz vector.
Definition: Particle.h:21

◆ correctMuon()

lorentzVector TestCorrection::correctMuon ( const lorentzVector muon)
private

Definition at line 295 of file TestCorrection.cc.

References corrector_, and MuScleFitUtils::fromPtEtaPhiToPxPyPz().

Referenced by analyze().

295  {
296  double corrPt = corrector_->correct(muon);
297  double ptEtaPhiE[4] = {corrPt, muon.Eta(), muon.Phi(), muon.E()};
298  return MuScleFitUtils::fromPtEtaPhiToPxPyPz(ptEtaPhiE);
299 }
static lorentzVector fromPtEtaPhiToPxPyPz(const double *ptEtaPhiE)
std::unique_ptr< MomentumScaleCorrector > corrector_

◆ endJob()

void TestCorrection::endJob ( void  )
inlineoverrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 68 of file TestCorrection.cc.

68 {};

◆ fillMuonCollection()

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

Definition at line 70 of file TestCorrection.cc.

References MuScleFitBase::debug_, amptDefaultParameters_cff::mu, HLT_2022v15_cff::muon, PDWG_BPHSkim_cff::muons, mathSSE::sqrt(), HLT_2022v15_cff::track, and pwdgSkimBPark_cfi::tracks.

Referenced by analyze().

70  {
71  std::vector<MuScleFitMuon> muons;
72  typename std::vector<T>::const_iterator track;
73  for (track = tracks.begin(); track != tracks.end(); ++track) {
76  track->px(), track->py(), track->pz(), sqrt(track->p() * track->p() + +0.011163612));
77 
78  Double_t hitsTk(0), hitsMuon(0), ptError(0);
79  if (const reco::Muon* myMu = dynamic_cast<const reco::Muon*>(&(*track))) {
80  hitsTk = myMu->innerTrack()->hitPattern().numberOfValidTrackerHits();
81  hitsMuon = myMu->innerTrack()->hitPattern().numberOfValidMuonHits();
82  ptError = myMu->innerTrack()->ptError();
83  } else if (const pat::Muon* myMu = dynamic_cast<const pat::Muon*>(&(*track))) {
84  hitsTk = myMu->innerTrack()->hitPattern().numberOfValidTrackerHits();
85  hitsMuon = myMu->innerTrack()->hitPattern().numberOfValidMuonHits();
86  ptError = myMu->innerTrack()->ptError();
87  } else if (const reco::Track* myMu = dynamic_cast<const reco::Track*>(&(*track))) {
88  hitsTk = myMu->hitPattern().numberOfValidTrackerHits();
89  hitsMuon = myMu->hitPattern().numberOfValidMuonHits();
90  ptError = myMu->ptError();
91  }
92 
93  MuScleFitMuon muon(mu, track->charge(), ptError, hitsTk, hitsMuon);
94 
95  if (debug_ > 0) {
96  edm::LogPrint("TestCorrection") << "[TestCorrection::fillMuonCollection] after MuScleFitMuon initialization"
97  << std::endl;
98  edm::LogPrint("TestCorrection") << " muon = " << muon << std::endl;
99  }
100 
101  muons.push_back(muon);
102  }
103  return muons;
104  }
T sqrt(T t)
Definition: SSEVec.h:19
Log< level::Warning, true > LogPrint
math::XYZTLorentzVector LorentzVector
Lorentz vector.
Definition: Particle.h:21
Analysis-level muon class.
Definition: Muon.h:51

◆ initialize()

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

Definition at line 302 of file TestCorrection.cc.

References MuScleFitBase::readProbabilityDistributionsFromFile().

Referenced by analyze().

302  {
303  // Read the pdf from root file. They are used by massProb when finding the muon pair, needed
304  // for the mass histograms.
306 }
void readProbabilityDistributionsFromFile()
Read probability distributions from a local root file.

Member Data Documentation

◆ background_

std::unique_ptr<BackgroundFunction> TestCorrection::background_
private

Definition at line 121 of file TestCorrection.cc.

Referenced by TestCorrection().

◆ correctedPt_

TH1F* TestCorrection::correctedPt_
private

Definition at line 114 of file TestCorrection.cc.

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

◆ correctedPtVsEta_

TProfile* TestCorrection::correctedPtVsEta_
private

Definition at line 115 of file TestCorrection.cc.

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

◆ corrector_

std::unique_ptr<MomentumScaleCorrector> TestCorrection::corrector_
private

Definition at line 119 of file TestCorrection.cc.

Referenced by correctMuon(), and TestCorrection().

◆ eventCounter_

int TestCorrection::eventCounter_
private

Definition at line 117 of file TestCorrection.cc.

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

◆ glbMuonsToken_

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

Definition at line 123 of file TestCorrection.cc.

Referenced by analyze().

◆ resolution_

std::unique_ptr<ResolutionFunction> TestCorrection::resolution_
private

Definition at line 120 of file TestCorrection.cc.

Referenced by TestCorrection().

◆ saMuonsToken_

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

Definition at line 124 of file TestCorrection.cc.

Referenced by analyze().

◆ tracksToken_

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

Definition at line 125 of file TestCorrection.cc.

Referenced by analyze().

◆ uncorrectedPt_

TH1F* TestCorrection::uncorrectedPt_
private

Definition at line 112 of file TestCorrection.cc.

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

◆ uncorrectedPtVsEta_

TProfile* TestCorrection::uncorrectedPtVsEta_
private

Definition at line 113 of file TestCorrection.cc.

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