File indexing completed on 2024-04-06 12:22:41
0001 #ifndef TESTCORRECTION_HH
0002 #define TESTCORRECTION_HH
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022
0023 #include <memory>
0024 #include <string>
0025 #include <vector>
0026
0027
0028 #include "FWCore/Framework/interface/Frameworkfwd.h"
0029 #include "FWCore/Framework/interface/one/EDAnalyzer.h"
0030 #include "FWCore/Framework/interface/Event.h"
0031 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0032
0033 #include "DataFormats/TrackReco/interface/Track.h"
0034 #include "DataFormats/MuonReco/interface/Muon.h"
0035 #include "DataFormats/MuonReco/interface/MuonFwd.h"
0036 #include "DataFormats/Candidate/interface/Candidate.h"
0037 #include "DataFormats/PatCandidates/interface/CompositeCandidate.h"
0038 #include "DataFormats/PatCandidates/interface/Muon.h"
0039 #include "RecoMuon/TrackingTools/interface/MuonPatternRecoDumper.h"
0040 #include "RecoMuon/TrackingTools/interface/MuonServiceProxy.h"
0041
0042 #include "DataFormats/Candidate/interface/LeafCandidate.h"
0043
0044
0045 #include "MuScleFitBase.h"
0046 #include "MuonAnalysis/MomentumScaleCalibration/interface/MomentumScaleCorrector.h"
0047 #include "MuonAnalysis/MomentumScaleCalibration/interface/ResolutionFunction.h"
0048 #include "MuonAnalysis/MomentumScaleCalibration/interface/BackgroundFunction.h"
0049
0050 #include "TFile.h"
0051 #include "TProfile.h"
0052 #include "TH1F.h"
0053 #include "TCanvas.h"
0054 #include "TLegend.h"
0055
0056
0057
0058
0059
0060 class TestCorrection : public edm::one::EDAnalyzer<>, MuScleFitBase {
0061 public:
0062 explicit TestCorrection(const edm::ParameterSet&);
0063 ~TestCorrection() override;
0064
0065 private:
0066 virtual void initialize(const edm::EventSetup&);
0067 void analyze(const edm::Event&, const edm::EventSetup&) override;
0068 void endJob() override{};
0069 template <typename T>
0070 std::vector<MuScleFitMuon> fillMuonCollection(const std::vector<T>& tracks) {
0071 std::vector<MuScleFitMuon> muons;
0072 typename std::vector<T>::const_iterator track;
0073 for (track = tracks.begin(); track != tracks.end(); ++track) {
0074 reco::Particle::LorentzVector mu;
0075 mu = reco::Particle::LorentzVector(
0076 track->px(), track->py(), track->pz(), sqrt(track->p() * track->p() + +0.011163612));
0077
0078 Double_t hitsTk(0), hitsMuon(0), ptError(0);
0079 if (const reco::Muon* myMu = dynamic_cast<const reco::Muon*>(&(*track))) {
0080 hitsTk = myMu->innerTrack()->hitPattern().numberOfValidTrackerHits();
0081 hitsMuon = myMu->innerTrack()->hitPattern().numberOfValidMuonHits();
0082 ptError = myMu->innerTrack()->ptError();
0083 } else if (const pat::Muon* myMu = dynamic_cast<const pat::Muon*>(&(*track))) {
0084 hitsTk = myMu->innerTrack()->hitPattern().numberOfValidTrackerHits();
0085 hitsMuon = myMu->innerTrack()->hitPattern().numberOfValidMuonHits();
0086 ptError = myMu->innerTrack()->ptError();
0087 } else if (const reco::Track* myMu = dynamic_cast<const reco::Track*>(&(*track))) {
0088 hitsTk = myMu->hitPattern().numberOfValidTrackerHits();
0089 hitsMuon = myMu->hitPattern().numberOfValidMuonHits();
0090 ptError = myMu->ptError();
0091 }
0092
0093 MuScleFitMuon muon(mu, track->charge(), ptError, hitsTk, hitsMuon);
0094
0095 if (debug_ > 0) {
0096 edm::LogPrint("TestCorrection") << "[TestCorrection::fillMuonCollection] after MuScleFitMuon initialization"
0097 << std::endl;
0098 edm::LogPrint("TestCorrection") << " muon = " << muon << std::endl;
0099 }
0100
0101 muons.push_back(muon);
0102 }
0103 return muons;
0104 }
0105
0106 lorentzVector correctMuon(const lorentzVector& muon);
0107
0108
0109
0110
0111
0112 TH1F* uncorrectedPt_;
0113 TProfile* uncorrectedPtVsEta_;
0114 TH1F* correctedPt_;
0115 TProfile* correctedPtVsEta_;
0116
0117 int eventCounter_;
0118
0119 std::unique_ptr<MomentumScaleCorrector> corrector_;
0120 std::unique_ptr<ResolutionFunction> resolution_;
0121 std::unique_ptr<BackgroundFunction> background_;
0122
0123 edm::EDGetTokenT<reco::MuonCollection> glbMuonsToken_;
0124 edm::EDGetTokenT<reco::TrackCollection> saMuonsToken_;
0125 edm::EDGetTokenT<reco::TrackCollection> tracksToken_;
0126 };
0127
0128 #endif
0129
0130
0131
0132
0133 TestCorrection::TestCorrection(const edm::ParameterSet& iConfig)
0134 : MuScleFitBase(iConfig),
0135 glbMuonsToken_(mayConsume<reco::MuonCollection>(theMuonLabel_)),
0136 saMuonsToken_(mayConsume<reco::TrackCollection>(theMuonLabel_)),
0137 tracksToken_(mayConsume<reco::TrackCollection>(theMuonLabel_)) {
0138
0139 TFile* outputFile = new TFile(theRootFileName_.c_str(), "RECREATE");
0140 theFiles_.push_back(outputFile);
0141
0142
0143 outputFile->cd();
0144 MuScleFitUtils::resfind = iConfig.getParameter<std::vector<int> >("resfind");
0145 fillHistoMap(outputFile, 0);
0146 uncorrectedPt_ = new TH1F("uncorrectedPt", "uncorrected pt", 1000, 0, 100);
0147 uncorrectedPtVsEta_ = new TProfile("uncorrectedPtVsEta", "uncorrected pt vs eta", 1000, 0, 100, -3., 3.);
0148 correctedPt_ = new TH1F("correctedPt", "corrected pt", 1000, 0, 100);
0149 correctedPtVsEta_ = new TProfile("correctedPtVsEta", "corrected pt vs eta", 1000, 0, 100, -3., 3.);
0150 eventCounter_ = 0;
0151
0152 corrector_ =
0153 std::make_unique<MomentumScaleCorrector>(iConfig.getUntrackedParameter<std::string>("CorrectionsIdentifier"));
0154 edm::LogPrint("TestCorrection") << "corrector_ = " << &*corrector_ << std::endl;
0155 resolution_ =
0156 std::make_unique<ResolutionFunction>(iConfig.getUntrackedParameter<std::string>("ResolutionsIdentifier"));
0157 edm::LogPrint("TestCorrection") << "resolution_ = " << &*resolution_ << std::endl;
0158 background_ =
0159 std::make_unique<BackgroundFunction>(iConfig.getUntrackedParameter<std::string>("BackgroundIdentifier"));
0160
0161
0162
0163 MuScleFitUtils::resolutionFunction = resolution_->function(0);
0164 MuScleFitUtils::resolutionFunctionForVec = resolutionFunctionVecService(resolution_->identifiers()[0]);
0165
0166 MuScleFitUtils::parResol = resolution_->parameters();
0167 }
0168
0169 TestCorrection::~TestCorrection() {
0170 theFiles_[0]->cd();
0171 TCanvas canvas("ptComparison", "pt comparison", 1000, 800);
0172 canvas.cd();
0173 uncorrectedPt_->GetXaxis()->SetTitle("Pt(GeV)");
0174 correctedPt_->SetLineColor(kRed);
0175 TLegend* legend = new TLegend(0.7, 0.71, 0.98, 1.);
0176 legend->SetTextSize(0.02);
0177 legend->SetFillColor(0);
0178 legend->AddEntry(uncorrectedPt_, "original pt");
0179 legend->AddEntry(correctedPt_, "corrected pt");
0180 uncorrectedPt_->Draw();
0181 correctedPt_->Draw("same");
0182 legend->Draw("same");
0183
0184 canvas.Write();
0185 uncorrectedPt_->Write();
0186 uncorrectedPtVsEta_->Write();
0187 correctedPt_->Write();
0188 correctedPtVsEta_->Write();
0189
0190 writeHistoMap(0);
0191 theFiles_[0]->Close();
0192
0193 edm::LogPrint("TestCorrection") << "Total analyzed events = " << eventCounter_ << std::endl;
0194 }
0195
0196
0197
0198
0199
0200
0201 void TestCorrection::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
0202 using namespace edm;
0203
0204 initialize(iSetup);
0205
0206 ++eventCounter_;
0207 if (eventCounter_ % 100 == 0) {
0208 edm::LogPrint("TestCorrection") << "Event number " << eventCounter_ << std::endl;
0209 }
0210
0211
0212
0213
0214 std::vector<MuScleFitMuon> muons;
0215
0216 if (theMuonType_ == 1) {
0217 Handle<reco::MuonCollection> glbMuons;
0218 iEvent.getByToken(glbMuonsToken_, glbMuons);
0219 muons = fillMuonCollection(*glbMuons);
0220 } else if (theMuonType_ == 2) {
0221 Handle<reco::TrackCollection> saMuons;
0222 iEvent.getByToken(saMuonsToken_, saMuons);
0223 muons = fillMuonCollection(*saMuons);
0224 } else if (theMuonType_ == 3) {
0225 Handle<reco::TrackCollection> tracks;
0226 iEvent.getByToken(tracksToken_, tracks);
0227 muons = fillMuonCollection(*tracks);
0228 }
0229
0230
0231
0232 std::pair<MuScleFitMuon, MuScleFitMuon> recMuFromBestRes = MuScleFitUtils::findBestRecoRes(muons);
0233 if (MuScleFitUtils::ResFound) {
0234 MuScleFitUtils::SavedPair.push_back(std::make_pair(recMuFromBestRes.first.p4(), recMuFromBestRes.second.p4()));
0235 } else {
0236 MuScleFitUtils::SavedPair.push_back(std::make_pair(lorentzVector(0., 0., 0., 0.), lorentzVector(0., 0., 0., 0.)));
0237 }
0238
0239
0240
0241 if (MuScleFitUtils::ResFound) {
0242
0243
0244
0245
0246
0247
0248 lorentzVector recMu1;
0249 recMu1 = correctMuon(recMu1);
0250 lorentzVector recMu2;
0251 recMu2 = correctMuon(recMu2);
0252
0253 reco::Particle::LorentzVector bestRecRes(recMu1 + recMu2);
0254
0255
0256
0257 mapHisto_["hRecBestMu"]->Fill(recMu1);
0258 if ((std::abs(recMu1.eta()) < 2.5) && (recMu1.pt() > 2.5)) {
0259 mapHisto_["hRecBestMu_Acc"]->Fill(recMu1);
0260 }
0261 mapHisto_["hRecBestMu"]->Fill(recMu2);
0262 if ((std::abs(recMu2.eta()) < 2.5) && (recMu2.pt() > 2.5)) {
0263 mapHisto_["hRecBestMu_Acc"]->Fill(recMu2);
0264 }
0265 mapHisto_["hDeltaRecBestMu"]->Fill(recMu1, recMu2);
0266
0267 mapHisto_["hRecBestRes"]->Fill(bestRecRes);
0268 if ((std::abs(recMu1.eta()) < 2.5) && (recMu1.pt() > 2.5) && (std::abs(recMu2.eta()) < 2.5) &&
0269 (recMu2.pt() > 2.5)) {
0270 mapHisto_["hRecBestRes_Acc"]->Fill(bestRecRes);
0271
0272 mapHisto_["hRecBestResVSMu"]->Fill(recMu1, bestRecRes, -1);
0273 mapHisto_["hRecBestResVSMu"]->Fill(recMu2, bestRecRes, +1);
0274 }
0275 }
0276
0277
0278 std::vector<MuScleFitMuon>::const_iterator recMuon = muons.begin();
0279 int muonCount = 0;
0280 for (; recMuon != muons.end(); ++recMuon, ++muonCount) {
0281
0282 uncorrectedPt_->Fill(recMuon->pt());
0283 uncorrectedPtVsEta_->Fill(recMuon->pt(), recMuon->eta());
0284
0285
0286 edm::LogPrint("TestCorrection") << "correcting muon[" << muonCount << "] with pt = " << recMuon->pt() << std::endl;
0287 double corrPt = (*corrector_)(*recMuon);
0288 edm::LogPrint("TestCorrection") << "to pt = " << corrPt << std::endl;
0289 correctedPt_->Fill(corrPt);
0290 correctedPtVsEta_->Fill(corrPt, recMuon->eta());
0291
0292 }
0293 }
0294
0295 lorentzVector TestCorrection::correctMuon(const lorentzVector& muon) {
0296 double corrPt = corrector_->correct(muon);
0297 double ptEtaPhiE[4] = {corrPt, muon.Eta(), muon.Phi(), muon.E()};
0298 return MuScleFitUtils::fromPtEtaPhiToPxPyPz(ptEtaPhiE);
0299 }
0300
0301
0302 void TestCorrection::initialize(const edm::EventSetup&) {
0303
0304
0305 readProbabilityDistributionsFromFile();
0306 }
0307
0308 #include "FWCore/Framework/interface/MakerMacros.h"
0309 DEFINE_FWK_MODULE(TestCorrection);