File indexing completed on 2025-03-13 02:31:36
0001
0002
0003
0004
0005
0006
0007 #include "TLorentzVector.h"
0008 #include "DataFormats/Math/interface/deltaR.h"
0009 #include "DataFormats/Provenance/interface/RunLumiEventNumber.h"
0010 #include "DQM/Physics/src/TopDiLeptonDQM.h"
0011 #include "FWCore/Common/interface/TriggerNames.h"
0012
0013 using namespace std;
0014 using namespace edm;
0015
0016 TopDiLeptonDQM::TopDiLeptonDQM(const edm::ParameterSet& ps) {
0017 moduleName_ = ps.getUntrackedParameter<string>("moduleName");
0018 outputFile_ = ps.getUntrackedParameter<string>("outputFile");
0019 triggerResults_ = consumes<TriggerResults>(ps.getParameter<edm::InputTag>("TriggerResults"));
0020 hltPaths_ = ps.getParameter<vector<string> >("hltPaths");
0021 hltPaths_sig_ = ps.getParameter<vector<string> >("hltPaths_sig");
0022 hltPaths_trig_ = ps.getParameter<vector<string> >("hltPaths_trig");
0023
0024 vertex_ = consumes<reco::VertexCollection>(ps.getParameter<edm::InputTag>("vertexCollection"));
0025 vertex_X_cut_ = ps.getParameter<double>("vertex_X_cut");
0026 vertex_Y_cut_ = ps.getParameter<double>("vertex_Y_cut");
0027 vertex_Z_cut_ = ps.getParameter<double>("vertex_Z_cut");
0028
0029 muons_ = consumes<reco::MuonCollection>(ps.getParameter<edm::InputTag>("muonCollection"));
0030 muon_pT_cut_ = ps.getParameter<double>("muon_pT_cut");
0031 muon_eta_cut_ = ps.getParameter<double>("muon_eta_cut");
0032 muon_iso_cut_ = ps.getParameter<double>("muon_iso_cut");
0033
0034 elecs_ = consumes<reco::GsfElectronCollection>(ps.getParameter<edm::InputTag>("elecCollection"));
0035 elec_pT_cut_ = ps.getParameter<double>("elec_pT_cut");
0036 elec_eta_cut_ = ps.getParameter<double>("elec_eta_cut");
0037 elec_iso_cut_ = ps.getParameter<double>("elec_iso_cut");
0038 elec_emf_cut_ = ps.getParameter<double>("elec_emf_cut");
0039
0040 MassWindow_up_ = ps.getParameter<double>("MassWindow_up");
0041 MassWindow_down_ = ps.getParameter<double>("MassWindow_down");
0042
0043 for (int i = 0; i < 100; ++i) {
0044 N_sig[i] = 0;
0045 N_trig[i] = 0;
0046 Eff[i] = 0.;
0047 }
0048
0049 N_mumu = 0;
0050 N_muel = 0;
0051 N_elel = 0;
0052 Events_ = nullptr;
0053 Trigs_ = nullptr;
0054 TriggerEff_ = nullptr;
0055 Ntracks_ = nullptr;
0056 Nmuons_ = nullptr;
0057 Nmuons_iso_ = nullptr;
0058 Nmuons_charge_ = nullptr;
0059 VxVy_muons_ = nullptr;
0060 Vz_muons_ = nullptr;
0061 pT_muons_ = nullptr;
0062 eta_muons_ = nullptr;
0063 phi_muons_ = nullptr;
0064 Nelecs_ = nullptr;
0065 Nelecs_iso_ = nullptr;
0066 Nelecs_charge_ = nullptr;
0067 HoverE_elecs_ = nullptr;
0068 pT_elecs_ = nullptr;
0069 eta_elecs_ = nullptr;
0070 phi_elecs_ = nullptr;
0071 MuIso_emEt03_ = nullptr;
0072 MuIso_hadEt03_ = nullptr;
0073 MuIso_hoEt03_ = nullptr;
0074 MuIso_nJets03_ = nullptr;
0075 MuIso_nTracks03_ = nullptr;
0076 MuIso_sumPt03_ = nullptr;
0077 MuIso_CombRelIso03_ = nullptr;
0078 ElecIso_cal_ = nullptr;
0079 ElecIso_trk_ = nullptr;
0080 ElecIso_CombRelIso_ = nullptr;
0081 dimassRC_ = nullptr;
0082 dimassWC_ = nullptr;
0083 dimassRC_LOGX_ = nullptr;
0084 dimassWC_LOGX_ = nullptr;
0085 dimassRC_LOG10_ = nullptr;
0086 dimassWC_LOG10_ = nullptr;
0087 D_eta_muons_ = nullptr;
0088 D_phi_muons_ = nullptr;
0089 D_eta_elecs_ = nullptr;
0090 D_phi_elecs_ = nullptr;
0091 D_eta_lepts_ = nullptr;
0092 D_phi_lepts_ = nullptr;
0093 }
0094
0095 TopDiLeptonDQM::~TopDiLeptonDQM() {}
0096
0097 void TopDiLeptonDQM::bookHistograms(DQMStore::IBooker& iBooker, edm::Run const&, edm::EventSetup const&) {
0098 iBooker.setCurrentFolder(moduleName_);
0099
0100 Events_ = iBooker.book1D("00_Events", "Isolated dilepton events", 5, 0., 5.);
0101 Events_->setBinLabel(2, "#mu #mu", 1);
0102 Events_->setBinLabel(3, "#mu e", 1);
0103 Events_->setBinLabel(4, "e e", 1);
0104
0105 Trigs_ = iBooker.book1D("01_Trigs", "Fired muon/electron triggers", 15, 0., 15.);
0106 TriggerEff_ = iBooker.book1D("02_TriggerEff", "HL Trigger Efficiencies", 10, 0., 10.);
0107 TriggerEff_->setTitle(
0108 "HL Trigger Efficiencies #epsilon_{signal} = #frac{[signal] && "
0109 "[control]}{[control]}");
0110 Ntracks_ = iBooker.book1D("Ntracks", "Number of tracks", 50, 0., 50.);
0111
0112 Nmuons_ = iBooker.book1D("03_Nmuons", "Number of muons", 20, 0., 10.);
0113 Nmuons_iso_ = iBooker.book1D("04_Nmuons_iso", "Number of isolated muons", 20, 0., 10.);
0114 Nmuons_charge_ = iBooker.book1D("Nmuons_charge", "Number of muons * moun charge", 19, -10., 10.);
0115 VxVy_muons_ = iBooker.book2D("VxVy_muons", "Vertex x-y-positon (global)", 40, -1., 1., 40, -1., 1.);
0116 Vz_muons_ = iBooker.book1D("Vz_muons", "Vertex z-positon (global)", 40, -20., 20.);
0117 pT_muons_ = iBooker.book1D("pT_muons", "P_T of muons", 40, 0., 200.);
0118 eta_muons_ = iBooker.book1D("eta_muons", "Eta of muons", 50, -5., 5.);
0119 phi_muons_ = iBooker.book1D("phi_muons", "Phi of muons", 40, -4., 4.);
0120
0121 Nelecs_ = iBooker.book1D("05_Nelecs", "Number of electrons", 20, 0., 10.);
0122 Nelecs_iso_ = iBooker.book1D("06_Nelecs_iso", "Number of isolated electrons", 20, 0., 10.);
0123 Nelecs_charge_ = iBooker.book1D("Nelecs_charge", "Number of elecs * elec charge", 19, -10., 10.);
0124 HoverE_elecs_ = iBooker.book1D("HoverE_elecs", "Hadronic over Ecal energy", 50, 0., 1.);
0125 pT_elecs_ = iBooker.book1D("pT_elecs", "P_T of electrons", 40, 0., 200.);
0126 eta_elecs_ = iBooker.book1D("eta_elecs", "Eta of electrons", 50, -5., 5.);
0127 phi_elecs_ = iBooker.book1D("phi_elecs", "Phi of electrons", 40, -4., 4.);
0128
0129 MuIso_emEt03_ = iBooker.book1D("MuIso_emEt03", "Muon emEt03", 20, 0., 20.);
0130 MuIso_hadEt03_ = iBooker.book1D("MuIso_hadEt03", "Muon hadEt03", 20, 0., 20.);
0131 MuIso_hoEt03_ = iBooker.book1D("MuIso_hoEt03", "Muon hoEt03", 20, 0., 20.);
0132 MuIso_nJets03_ = iBooker.book1D("MuIso_nJets03", "Muon nJets03", 10, 0., 10.);
0133 MuIso_nTracks03_ = iBooker.book1D("MuIso_nTracks03", "Muon nTracks03", 20, 0., 20.);
0134 MuIso_sumPt03_ = iBooker.book1D("MuIso_sumPt03", "Muon sumPt03", 20, 0., 40.);
0135 MuIso_CombRelIso03_ = iBooker.book1D("07_MuIso_CombRelIso03", "Muon CombRelIso03", 20, 0., 1.);
0136
0137 ElecIso_cal_ = iBooker.book1D("ElecIso_cal", "Electron Iso_cal", 21, -1., 20.);
0138 ElecIso_trk_ = iBooker.book1D("ElecIso_trk", "Electron Iso_trk", 21, -2., 40.);
0139 ElecIso_CombRelIso_ = iBooker.book1D("08_ElecIso_CombRelIso", "Electron CombRelIso", 20, 0., 1.);
0140
0141 const int nbins = 200;
0142
0143 double logmin = 0.;
0144 double logmax = 3.;
0145
0146 float bins[nbins + 1];
0147
0148 for (int i = 0; i <= nbins; i++) {
0149 double log = logmin + (logmax - logmin) * i / nbins;
0150 bins[i] = std::pow(10.0, log);
0151 }
0152
0153 dimassRC_ = iBooker.book1D("09_dimassRC", "Dilepton mass RC", 50, 0., 200.);
0154 dimassWC_ = iBooker.book1D("11_dimassWC", "Dilepton mass WC", 50, 0., 200.);
0155 dimassRC_LOGX_ = iBooker.book1D("10_dimassRC_LOGX", "Dilepton mass RC LOG", nbins, &bins[0]);
0156 dimassWC_LOGX_ = iBooker.book1D("12_dimassWC_LOGX", "Dilepton mass WC LOG", nbins, &bins[0]);
0157 dimassRC_LOG10_ = iBooker.book1D("dimassRC_LOG10", "Dilepton mass RC LOG", 50, 0., 2.5);
0158 dimassWC_LOG10_ = iBooker.book1D("dimassWC_LOG10", "Dilepton mass WC LOG", 50, 0., 2.5);
0159
0160 D_eta_muons_ = iBooker.book1D("13_D_eta_muons", "#Delta eta_muons", 20, -5., 5.);
0161 D_phi_muons_ = iBooker.book1D("14_D_phi_muons", "#Delta phi_muons", 20, -5., 5.);
0162 D_eta_elecs_ = iBooker.book1D("D_eta_elecs", "#Delta eta_elecs", 20, -5., 5.);
0163 D_phi_elecs_ = iBooker.book1D("D_phi_elecs", "#Delta phi_elecs", 20, -5., 5.);
0164 D_eta_lepts_ = iBooker.book1D("D_eta_lepts", "#Delta eta_lepts", 20, -5., 5.);
0165 D_phi_lepts_ = iBooker.book1D("D_phi_lepts", "#Delta phi_lepts", 20, -5., 5.);
0166 }
0167
0168 void TopDiLeptonDQM::analyze(const edm::Event& evt, const edm::EventSetup& context) {
0169
0170
0171
0172
0173 const int N_TriggerPaths = hltPaths_.size();
0174 const int N_SignalPaths = hltPaths_sig_.size();
0175 const int N_ControlPaths = hltPaths_trig_.size();
0176
0177 bool Fired_Signal_Trigger[100] = {false};
0178 bool Fired_Control_Trigger[100] = {false};
0179
0180 int N_iso_mu = 0;
0181 int N_iso_el = 0;
0182
0183 double DilepMass = 0.;
0184
0185 double vertex_X = 100.;
0186 double vertex_Y = 100.;
0187 double vertex_Z = 100.;
0188
0189
0190
0191
0192
0193 edm::Handle<reco::VertexCollection> vertexs;
0194 evt.getByToken(vertex_, vertexs);
0195
0196 if (!vertexs.failedToGet()) {
0197 reco::Vertex primaryVertex = vertexs->front();
0198
0199 int numberTracks = primaryVertex.tracksSize();
0200
0201 bool fake = primaryVertex.isFake();
0202
0203 Ntracks_->Fill(numberTracks);
0204
0205 if (!fake && numberTracks > 3) {
0206 vertex_X = primaryVertex.x();
0207 vertex_Y = primaryVertex.y();
0208 vertex_Z = primaryVertex.z();
0209 }
0210 }
0211
0212
0213
0214
0215
0216 edm::Handle<TriggerResults> trigResults;
0217 evt.getByToken(triggerResults_, trigResults);
0218
0219 if (!trigResults.failedToGet()) {
0220 int N_Triggers = trigResults->size();
0221
0222 const edm::TriggerNames& trigName = evt.triggerNames(*trigResults);
0223
0224 for (int i_Trig = 0; i_Trig < N_Triggers; ++i_Trig) {
0225 if (trigResults.product()->accept(i_Trig)) {
0226
0227
0228 for (int i = 0; i < N_TriggerPaths; i++) {
0229 if (trigName.triggerName(i_Trig) == hltPaths_[i]) {
0230 Trigs_->Fill(i);
0231 Trigs_->setBinLabel(i + 1, hltPaths_[i], 1);
0232 }
0233 }
0234
0235
0236
0237 for (int j = 0; j < N_SignalPaths; ++j) {
0238 if (trigName.triggerName(i_Trig) == hltPaths_sig_[j])
0239 Fired_Signal_Trigger[j] = true;
0240 }
0241
0242 for (int k = 0; k < N_ControlPaths; ++k) {
0243 if (trigName.triggerName(i_Trig) == hltPaths_trig_[k])
0244 Fired_Control_Trigger[k] = true;
0245 }
0246 }
0247 }
0248 }
0249
0250
0251
0252
0253
0254 edm::Handle<reco::MuonCollection> muons;
0255 evt.getByToken(muons_, muons);
0256
0257 reco::MuonCollection::const_iterator muon;
0258
0259 if (!muons.failedToGet()) {
0260 Nmuons_->Fill(muons->size());
0261
0262 for (muon = muons->begin(); muon != muons->end(); ++muon) {
0263 float N_muons = muons->size();
0264 float Q_muon = muon->charge();
0265
0266 Nmuons_charge_->Fill(N_muons * Q_muon);
0267
0268 double track_X = 100.;
0269 double track_Y = 100.;
0270 double track_Z = 100.;
0271
0272 if (muon->isGlobalMuon()) {
0273 reco::TrackRef track = muon->globalTrack();
0274
0275 track_X = track->vx();
0276 track_Y = track->vy();
0277 track_Z = track->vz();
0278
0279 VxVy_muons_->Fill(track_X, track_Y);
0280 Vz_muons_->Fill(track_Z);
0281 }
0282
0283
0284
0285 if (track_X > vertex_X_cut_)
0286 continue;
0287 if (track_Y > vertex_Y_cut_)
0288 continue;
0289 if (track_Z > vertex_Z_cut_)
0290 continue;
0291 if (muon->pt() < muon_pT_cut_)
0292 continue;
0293 if (abs(muon->eta()) > muon_eta_cut_)
0294 continue;
0295
0296 reco::MuonIsolation muIso03 = muon->isolationR03();
0297
0298 double muonCombRelIso = 1.;
0299
0300 if (muon->pt() != 0.)
0301 muonCombRelIso = (muIso03.emEt + muIso03.hadEt + muIso03.hoEt + muIso03.sumPt) / muon->pt();
0302
0303 MuIso_CombRelIso03_->Fill(muonCombRelIso);
0304
0305 MuIso_emEt03_->Fill(muIso03.emEt);
0306 MuIso_hadEt03_->Fill(muIso03.hadEt);
0307 MuIso_hoEt03_->Fill(muIso03.hoEt);
0308 MuIso_nJets03_->Fill(muIso03.nJets);
0309 MuIso_nTracks03_->Fill(muIso03.nTracks);
0310 MuIso_sumPt03_->Fill(muIso03.sumPt);
0311
0312 if (muonCombRelIso < muon_iso_cut_)
0313 ++N_iso_mu;
0314 }
0315
0316 Nmuons_iso_->Fill(N_iso_mu);
0317 }
0318
0319
0320
0321
0322
0323 edm::Handle<reco::GsfElectronCollection> elecs;
0324 evt.getByToken(elecs_, elecs);
0325
0326 reco::GsfElectronCollection::const_iterator elec;
0327
0328 if (!elecs.failedToGet()) {
0329 Nelecs_->Fill(elecs->size());
0330
0331 for (elec = elecs->begin(); elec != elecs->end(); ++elec) {
0332 float N_elecs = elecs->size();
0333 float Q_elec = elec->charge();
0334 float HoverE = elec->hcalOverEcal();
0335
0336 HoverE_elecs_->Fill(HoverE);
0337
0338 Nelecs_charge_->Fill(N_elecs * Q_elec);
0339
0340 double track_X = 100.;
0341 double track_Y = 100.;
0342 double track_Z = 100.;
0343
0344 reco::GsfTrackRef track = elec->gsfTrack();
0345
0346 track_X = track->vx();
0347 track_Y = track->vy();
0348 track_Z = track->vz();
0349
0350
0351
0352 if (track_X > vertex_X_cut_)
0353 continue;
0354 if (track_Y > vertex_Y_cut_)
0355 continue;
0356 if (track_Z > vertex_Z_cut_)
0357 continue;
0358 if (elec->pt() < elec_pT_cut_)
0359 continue;
0360 if (abs(elec->eta()) > elec_eta_cut_)
0361 continue;
0362 if (HoverE > elec_emf_cut_)
0363 continue;
0364
0365 reco::GsfElectron::IsolationVariables elecIso = elec->dr03IsolationVariables();
0366
0367 double elecCombRelIso = 1.;
0368
0369 if (elec->et() != 0.)
0370 elecCombRelIso = (elecIso.ecalRecHitSumEt + elecIso.hcalRecHitSumEt[0] + elecIso.tkSumPt) / elec->et();
0371
0372 ElecIso_CombRelIso_->Fill(elecCombRelIso);
0373
0374 ElecIso_cal_->Fill(elecIso.ecalRecHitSumEt);
0375 ElecIso_trk_->Fill(elecIso.tkSumPt);
0376
0377 if (elecCombRelIso < elec_iso_cut_)
0378 ++N_iso_el;
0379 }
0380
0381 Nelecs_iso_->Fill(N_iso_el);
0382 }
0383
0384
0385
0386
0387
0388 if (N_iso_mu > 1) {
0389
0390
0391 if (vertex_X < vertex_X_cut_ && vertex_Y < vertex_Y_cut_ && vertex_Z < vertex_Z_cut_) {
0392 ++N_mumu;
0393
0394 Events_->Fill(1.);
0395
0396 reco::MuonCollection::const_reference mu1 = muons->at(0);
0397 reco::MuonCollection::const_reference mu2 = muons->at(1);
0398
0399 DilepMass = sqrt((mu1.energy() + mu2.energy()) * (mu1.energy() + mu2.energy()) -
0400 (mu1.px() + mu2.px()) * (mu1.px() + mu2.px()) - (mu1.py() + mu2.py()) * (mu1.py() + mu2.py()) -
0401 (mu1.pz() + mu2.pz()) * (mu1.pz() + mu2.pz()));
0402
0403
0404
0405 if (mu1.charge() * mu2.charge() < 0.) {
0406 dimassRC_LOG10_->Fill(log10(DilepMass));
0407 dimassRC_->Fill(DilepMass);
0408 dimassRC_LOGX_->Fill(DilepMass);
0409
0410 if (DilepMass > MassWindow_down_ && DilepMass < MassWindow_up_) {
0411 for (muon = muons->begin(); muon != muons->end(); ++muon) {
0412 pT_muons_->Fill(muon->pt());
0413 eta_muons_->Fill(muon->eta());
0414 phi_muons_->Fill(muon->phi());
0415 }
0416
0417 D_eta_muons_->Fill(mu1.eta() - mu2.eta());
0418 D_phi_muons_->Fill(mu1.phi() - mu2.phi());
0419
0420
0421
0422 for (int k = 0; k < N_SignalPaths; ++k) {
0423 if (Fired_Signal_Trigger[k] && Fired_Control_Trigger[k])
0424 ++N_sig[k];
0425
0426 if (Fired_Control_Trigger[k])
0427 ++N_trig[k];
0428
0429 if (N_trig[k] != 0)
0430 Eff[k] = N_sig[k] / static_cast<float>(N_trig[k]);
0431
0432 TriggerEff_->setBinContent(k + 1, Eff[k]);
0433 TriggerEff_->setBinLabel(k + 1, "#frac{[" + hltPaths_sig_[k] + "]}{vs. [" + hltPaths_trig_[k] + "]}", 1);
0434 }
0435 }
0436 }
0437
0438
0439
0440 if (mu1.charge() * mu2.charge() > 0.) {
0441 dimassWC_LOG10_->Fill(log10(DilepMass));
0442 dimassWC_->Fill(DilepMass);
0443 dimassWC_LOGX_->Fill(DilepMass);
0444 }
0445 }
0446 }
0447
0448
0449
0450
0451
0452 if (N_iso_el > 0 && N_iso_mu > 0) {
0453
0454
0455 if (vertex_X < vertex_X_cut_ && vertex_Y < vertex_Y_cut_ && vertex_Z < vertex_Z_cut_) {
0456 ++N_muel;
0457
0458 Events_->Fill(2.);
0459
0460 reco::MuonCollection::const_reference mu1 = muons->at(0);
0461 reco::GsfElectronCollection::const_reference el1 = elecs->at(0);
0462
0463 DilepMass = sqrt((mu1.energy() + el1.energy()) * (mu1.energy() + el1.energy()) -
0464 (mu1.px() + el1.px()) * (mu1.px() + el1.px()) - (mu1.py() + el1.py()) * (mu1.py() + el1.py()) -
0465 (mu1.pz() + el1.pz()) * (mu1.pz() + el1.pz()));
0466
0467
0468
0469 if (mu1.charge() * el1.charge() < 0.) {
0470 dimassRC_LOG10_->Fill(log10(DilepMass));
0471 dimassRC_->Fill(DilepMass);
0472 dimassRC_LOGX_->Fill(DilepMass);
0473
0474 if (DilepMass > MassWindow_down_ && DilepMass < MassWindow_up_) {
0475 for (muon = muons->begin(); muon != muons->end(); ++muon) {
0476 pT_muons_->Fill(muon->pt());
0477 eta_muons_->Fill(muon->eta());
0478 phi_muons_->Fill(muon->phi());
0479 }
0480
0481 for (elec = elecs->begin(); elec != elecs->end(); ++elec) {
0482 pT_elecs_->Fill(elec->pt());
0483 eta_elecs_->Fill(elec->eta());
0484 phi_elecs_->Fill(elec->phi());
0485 }
0486
0487 D_eta_lepts_->Fill(mu1.eta() - el1.eta());
0488 D_phi_lepts_->Fill(mu1.phi() - el1.phi());
0489
0490
0491
0492 for (int k = 0; k < N_SignalPaths; ++k) {
0493 if (Fired_Signal_Trigger[k] && Fired_Control_Trigger[k])
0494 ++N_sig[k];
0495
0496 if (Fired_Control_Trigger[k])
0497 ++N_trig[k];
0498
0499 if (N_trig[k] != 0)
0500 Eff[k] = N_sig[k] / static_cast<float>(N_trig[k]);
0501
0502 TriggerEff_->setBinContent(k + 1, Eff[k]);
0503 TriggerEff_->setBinLabel(k + 1, "#frac{[" + hltPaths_sig_[k] + "]}{vs. [" + hltPaths_trig_[k] + "]}", 1);
0504 }
0505 }
0506 }
0507
0508
0509
0510 if (mu1.charge() * el1.charge() > 0.) {
0511 dimassWC_LOG10_->Fill(log10(DilepMass));
0512 dimassWC_->Fill(DilepMass);
0513 dimassWC_LOGX_->Fill(DilepMass);
0514 }
0515 }
0516 }
0517
0518
0519
0520
0521
0522 if (N_iso_el > 1) {
0523
0524
0525 if (vertex_X < vertex_X_cut_ && vertex_Y < vertex_Y_cut_ && vertex_Z < vertex_Z_cut_) {
0526 ++N_elel;
0527
0528 Events_->Fill(3.);
0529
0530 reco::GsfElectronCollection::const_reference el1 = elecs->at(0);
0531 reco::GsfElectronCollection::const_reference el2 = elecs->at(1);
0532
0533 DilepMass = sqrt((el1.energy() + el2.energy()) * (el1.energy() + el2.energy()) -
0534 (el1.px() + el2.px()) * (el1.px() + el2.px()) - (el1.py() + el2.py()) * (el1.py() + el2.py()) -
0535 (el1.pz() + el2.pz()) * (el1.pz() + el2.pz()));
0536
0537
0538
0539 if (el1.charge() * el2.charge() < 0.) {
0540 dimassRC_LOG10_->Fill(log10(DilepMass));
0541 dimassRC_->Fill(DilepMass);
0542 dimassRC_LOGX_->Fill(DilepMass);
0543
0544 if (DilepMass > MassWindow_down_ && DilepMass < MassWindow_up_) {
0545 for (elec = elecs->begin(); elec != elecs->end(); ++elec) {
0546 pT_elecs_->Fill(elec->pt());
0547 eta_elecs_->Fill(elec->eta());
0548 phi_elecs_->Fill(elec->phi());
0549 }
0550
0551 D_eta_elecs_->Fill(el1.eta() - el2.eta());
0552 D_phi_elecs_->Fill(el1.phi() - el2.phi());
0553
0554
0555
0556 for (int k = 0; k < N_SignalPaths; ++k) {
0557 if (Fired_Signal_Trigger[k] && Fired_Control_Trigger[k])
0558 ++N_sig[k];
0559
0560 if (Fired_Control_Trigger[k])
0561 ++N_trig[k];
0562
0563 if (N_trig[k] != 0)
0564 Eff[k] = N_sig[k] / static_cast<float>(N_trig[k]);
0565
0566 TriggerEff_->setBinContent(k + 1, Eff[k]);
0567 TriggerEff_->setBinLabel(k + 1, "#frac{[" + hltPaths_sig_[k] + "]}{vs. [" + hltPaths_trig_[k] + "]}", 1);
0568 }
0569 }
0570 }
0571
0572
0573
0574 if (el1.charge() * el2.charge() > 0.) {
0575 dimassWC_LOG10_->Fill(log10(DilepMass));
0576 dimassWC_->Fill(DilepMass);
0577 dimassWC_LOGX_->Fill(DilepMass);
0578 }
0579 }
0580 }
0581 }