Physics/src/TopDiLeptonDQM.cc

0001 /*

0002  *  $Date: 2012/01/11 13:53:29 $

0003  *  $Revision: 1.14 $

0004  *  \author M. Marienfeld - DESY Hamburg

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.;  // 10^(3.)=1000

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   //  Global Event Variables

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   //  Analyze Primary Vertex

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     //    double ndof      = primaryVertex.ndof();

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   //  Analyze Trigger Results

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         // Check for all trigger paths

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         // Check for signal & control trigger paths

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   //  Analyze Muon Isolation

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       // Vertex and kinematic cuts

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   //  Analyze Electron Isolation

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       // Vertex and kinematic cuts

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   //  TWO Isolated MUONS

0386   // --------------------

0387
0388   if (N_iso_mu > 1) {
0389     // Vertex cut

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       // Opposite muon charges -> Right Charge (RC)

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           // Determinating trigger efficiencies

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       // Same muon charges -> Wrong Charge (WC)

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   //  TWO Isolated LEPTONS (mu/e)

0450   // -----------------------------

0451
0452   if (N_iso_el > 0 && N_iso_mu > 0) {
0453     // Vertex cut

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       // Opposite lepton charges -> Right Charge (RC)

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           // Determinating trigger efficiencies

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       // Same muon charges -> Wrong Charge (WC)

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   //  TWO Isolated ELECTRONS

0520   // ------------------------

0521
0522   if (N_iso_el > 1) {
0523     // Vertex cut

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       // Opposite lepton charges -> Right Charge (RC)

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           // Determinating trigger efficiencies

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       // Same muon charges -> Wrong Charge (WC)

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 }