rivet is hosted by Hepforge, IPPP Durham
ATLAS_2013_I1190187.cc
Go to the documentation of this file.
00001 // -*- C++ -*-
00002 #include "Rivet/Analysis.hh"
00003 #include "Rivet/Projections/FinalState.hh"
00004 #include "Rivet/Projections/IdentifiedFinalState.hh"
00005 #include "Rivet/Projections/VetoedFinalState.hh"
00006 #include "Rivet/Projections/FastJets.hh"
00007 #include "Rivet/Projections/DressedLeptons.hh"
00008 #include "Rivet/Projections/MissingMomentum.hh"
00009 
00010 namespace Rivet {
00011 
00012 
00013   /// ATLAS Wee Wemu Wmumu analysis at Z TeV
00014   class ATLAS_2013_I1190187 : public Analysis {
00015   public:
00016 
00017     /// Default constructor
00018     ATLAS_2013_I1190187()
00019       : Analysis("ATLAS_2013_I1190187")
00020     {    }
00021 
00022 
00023     void init() {
00024       FinalState fs;
00025 
00026       Cut etaRanges_EL = (Cuts::abseta < 1.37 || Cuts::absetaIn(1.52, 2.47)) && Cuts::pT > 20*GeV;
00027       Cut etaRanges_MU = Cuts::abseta < 2.4 && Cuts::pT > 20*GeV;
00028 
00029       MissingMomentum met(fs);
00030       addProjection(met, "MET");
00031 
00032       IdentifiedFinalState Photon(fs);
00033       Photon.acceptIdPair(PID::PHOTON);
00034 
00035       IdentifiedFinalState bare_EL(fs);
00036       bare_EL.acceptIdPair(PID::ELECTRON);
00037 
00038       IdentifiedFinalState bare_MU(fs);
00039       bare_MU.acceptIdPair(PID::MUON);
00040 
00041       IdentifiedFinalState neutrinoFS(fs);
00042       neutrinoFS.acceptNeutrinos();
00043       addProjection(neutrinoFS, "Neutrinos");
00044 
00045       ////////////////////////////////////////////////////////
00046       // DRESSED LEPTONS
00047       //    3.arg: 0.1      = dR(lep,phot)
00048       //    4.arg: true     = do clustering
00049       //    7.arg: false    = ignore photons from hadron or tau
00050       //
00051       //////////////////////////////////////////////////////////
00052       DressedLeptons electronFS(Photon, bare_EL, 0.1, etaRanges_EL);
00053       addProjection(electronFS, "ELECTRON_FS");
00054 
00055       DressedLeptons muonFS(Photon, bare_MU, 0.1, etaRanges_MU);
00056       addProjection(muonFS, "MUON_FS");
00057 
00058       VetoedFinalState jetinput;
00059       jetinput.addVetoOnThisFinalState(bare_MU);
00060       jetinput.addVetoOnThisFinalState(neutrinoFS);
00061 
00062       FastJets jetpro(jetinput, FastJets::ANTIKT, 0.4);
00063       addProjection(jetpro, "jet");
00064 
00065       // Book histograms
00066       _h_Wl1_pT_mumu = bookHisto1D(1, 1, 2);
00067       _h_Wl1_pT_ee = bookHisto1D(1, 1, 1);
00068       _h_Wl1_pT_emu = bookHisto1D(1, 1, 3);
00069       _h_Wl1_pT_inclusive = bookHisto1D(4, 1, 1);
00070     }
00071 
00072 
00073     /// Do the analysis
00074     void analyze(const Event& e) {
00075 
00076       const  vector<DressedLepton>& muonFS = applyProjection<DressedLeptons>(e, "MUON_FS").dressedLeptons();
00077       const  vector<DressedLepton>& electronFS = applyProjection<DressedLeptons>(e, "ELECTRON_FS").dressedLeptons();
00078       const MissingMomentum& met = applyProjection<MissingMomentum>(e, "MET");
00079 
00080       vector<DressedLepton> dressed_lepton, isolated_lepton, fiducial_lepton;
00081       dressed_lepton.insert(dressed_lepton.end(), muonFS.begin(), muonFS.end());
00082       dressed_lepton.insert(dressed_lepton.end(), electronFS.begin(), electronFS.end());
00083 
00084       ////////////////////////////////////////////////////////////////////////////
00085       // OVERLAP REMOVAL
00086       //    -electrons with dR(e,mu)<0.1 are removed
00087       //    -lower pT electrons with dR(e,e)<0.1 are removed
00088       //
00089       ////////////////////////////////////////////////////////////////////////////
00090       foreach (DressedLepton& l1, dressed_lepton) {
00091         bool l_isolated = true;
00092         foreach (DressedLepton& l2, dressed_lepton) {
00093           if (l1 != l2 && l2.constituentLepton().abspid() == PID::ELECTRON) {
00094             double overlapControl_ll= deltaR(l1.constituentLepton(),l2.constituentLepton());
00095             if (overlapControl_ll < 0.1) {
00096               l_isolated = false;
00097               // e/e overlap removal
00098               if (l1.constituentLepton().abspid() == PID::ELECTRON) {
00099                 if (l1.constituentLepton().pT()>l2.constituentLepton().pT()) {
00100                   isolated_lepton.push_back(l1);//keep e with highest pT
00101                 } else {
00102                   isolated_lepton.push_back(l2);//keep e with highest pT
00103                 }
00104               }
00105               // e/mu overlap removal
00106               if (l1.constituentLepton().abspid() == PID::MUON) isolated_lepton.push_back(l1); //keep mu
00107             }
00108           }
00109         }
00110         if (l_isolated) isolated_lepton.push_back(l1);
00111       }
00112 
00113 
00114       ///////////////////////////////////////////////////////////////////////////////////////////////////////////
00115       // PRESELECTION:
00116       // "isolated_lepton:"
00117       //    * electron: pt>20 GeV, |eta|<1.37, 1.52<|eta|<2.47, dR(electron,muon)>0.1
00118       //    * muon:     pt>20 GeV, |eta|<2.4
00119       //        *   dR(l,l)>0.1
00120       //
00121       // "fiducial_lepton"= isolated_lepton with
00122       //                * 2 leptons (e or mu)
00123       //              * leading lepton pt (pT_l1) >25 GeV
00124       //            * opposite charged leptons
00125       //
00126       ///////////////////////////////////////////////////////////////////////////////////////////////////////////
00127       if (isolated_lepton.size() != 2) vetoEvent;
00128       sort(isolated_lepton.begin(), isolated_lepton.end(), cmpMomByPt);
00129       if (isolated_lepton[0].pT() > 25*GeV && threeCharge(isolated_lepton[0]) != threeCharge(isolated_lepton[1])) {
00130         fiducial_lepton.insert(fiducial_lepton.end(), isolated_lepton.begin(), isolated_lepton.end());
00131       }
00132       if (fiducial_lepton.size() == 0) vetoEvent;
00133       double pT_l1 = fiducial_lepton[0].pT();
00134       double M_l1l2 = (fiducial_lepton[0].momentum() + fiducial_lepton[1].momentum()).mass();
00135       double pT_l1l2 = (fiducial_lepton[0].momentum() + fiducial_lepton[1].momentum()).pT();
00136 
00137 
00138       /////////////////////////////////////////////////////////////////////////
00139       // JETS
00140       //    -"alljets": found by "jetpro" projection && pT()>25 GeV && |y|<4.5
00141       //    -"vetojets": "alljets"  && dR(electron,jet)>0.3
00142       //
00143       /////////////////////////////////////////////////////////////////////////
00144       Jets alljets, vetojets;
00145       foreach (const Jet& j, applyProjection<FastJets>(e, "jet").jetsByPt(25)) {
00146         if (j.absrap() > 4.5 ) continue;
00147         alljets.push_back(j);
00148         bool deltaRcontrol = true;
00149         foreach (DressedLepton& fl,fiducial_lepton) {
00150           if (fl.constituentLepton().abspid() == PID::ELECTRON) { //electrons
00151             double deltaRjets = deltaR(fl.constituentLepton().momentum(), j.momentum(), RAPIDITY);
00152             if (deltaRjets <= 0.3) deltaRcontrol = false; //false if at least one electron is in the overlap region
00153           }
00154         }
00155         if (deltaRcontrol) vetojets.push_back(j);
00156       }
00157 
00158 
00159       /////////////////////////////////////////////////////////////////////////////////////////////////
00160       // MISSING ETrel
00161       //    -"mismom": fourvector of invisible momentum found by "met" projection
00162       //    -"delta_phi": delta phi between mismom and the nearest "fiducial_lepton" or "vetojet"
00163       //    -"MET_rel": missing transverse energy defined as:
00164       //            *"mismom"   for "delta_phi" >= (0.5*pi)
00165       //            *"mismom.pT()*sin(delta_phi)"   for "delta_phi" < (0.5*pi)
00166       //
00167       /////////////////////////////////////////////////////////////////////////////////////////////////
00168       FourMomentum mismom;
00169       double MET_rel = 0, delta_phi = 0;
00170       mismom = -met.visibleMomentum();
00171       vector<double> vL_MET_angle, vJet_MET_angle;
00172       vL_MET_angle.push_back(fabs(deltaPhi(fiducial_lepton[0].momentum(), mismom)));
00173       vL_MET_angle.push_back(fabs(deltaPhi(fiducial_lepton[1].momentum(), mismom)));
00174       foreach (double& lM, vL_MET_angle) if (lM > M_PI) lM = 2*M_PI - lM;
00175 
00176       std::sort(vL_MET_angle.begin(), vL_MET_angle.end());
00177       if (vetojets.size() == 0) delta_phi = vL_MET_angle[0];
00178       if (vetojets.size() > 0) {
00179         foreach (Jet& vj, vetojets) {
00180           double jet_MET_angle = fabs(deltaPhi(vj.momentum(), mismom));
00181           if (jet_MET_angle > M_PI) jet_MET_angle = 2*M_PI - jet_MET_angle;
00182           vJet_MET_angle.push_back(jet_MET_angle);
00183         }
00184         std::sort(vJet_MET_angle.begin(), vJet_MET_angle.end());
00185         if (vL_MET_angle[0] <= vJet_MET_angle[0]) delta_phi = vL_MET_angle[0];
00186         if (vL_MET_angle[0] > vJet_MET_angle[0]) delta_phi = vJet_MET_angle[0];
00187       }
00188 
00189       if (delta_phi >= (0.5*M_PI)) delta_phi = 0.5*M_PI;
00190       MET_rel = mismom.pT()*sin(delta_phi);
00191 
00192 
00193       ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
00194       // CUTS
00195       //        -jetveto: event with at least one vetojet is vetoed
00196       //        -M_Z: Z mass M_Z=91.1876*GeV
00197       //
00198       //    * ee   channel: MET_rel > 45 GeV, M_l1l2 > 15 GeV, |M_l1l2-M_Z| > 15 GeV, jetveto, pT_l1l2 > 30 GeV
00199       //    * mumu channel: MET_rel > 45 GeV, M_l1l2 > 15 GeV, |M_l1l2-M_Z| > 15 GeV, jetveto, pT_l1l2 > 30 GeV
00200       //        * emu  channel: MET_rel > 25 GeV, M_l1l2 > 10 GeV, |M_l1l2-M_Z| > 0  GeV, jetveto, pT_l1l2 > 30 GeV
00201       //
00202       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
00203 
00204       // Get event weight for histo filling
00205       const double weight = e.weight();
00206 
00207       // ee channel
00208       if (fiducial_lepton[0].abspid() == PID::ELECTRON && fiducial_lepton[1].abspid() == PID::ELECTRON) {
00209         if (MET_rel <= 45*GeV) vetoEvent;
00210         if (M_l1l2 <= 15*GeV) vetoEvent;
00211         if (fabs(M_l1l2 - 91.1876*GeV) <= 15*GeV) vetoEvent;
00212         if (vetojets.size() != 0) vetoEvent;
00213         if (pT_l1l2 <= 30*GeV) vetoEvent;
00214         _h_Wl1_pT_ee->fill(sqrtS()*GeV, weight);
00215         _h_Wl1_pT_inclusive->fill(pT_l1, weight);
00216       }
00217 
00218       // mumu channel
00219       else if (fiducial_lepton[0].abspid() == PID::MUON && fiducial_lepton[1].abspid() == PID::MUON) {
00220         if (MET_rel <= 45*GeV) vetoEvent;
00221         if (M_l1l2 <= 15*GeV) vetoEvent;
00222         if (fabs(M_l1l2-91.1876*GeV) <= 15*GeV) vetoEvent;
00223         if (vetojets.size() != 0) vetoEvent;
00224         if (pT_l1l2 <= 30*GeV) vetoEvent;
00225         _h_Wl1_pT_mumu->fill(sqrtS()*GeV, weight);
00226         _h_Wl1_pT_inclusive->fill(pT_l1, weight);
00227       }
00228 
00229       // emu channel
00230       else if (fiducial_lepton[0].abspid() != fiducial_lepton[1].abspid()) {
00231         if (MET_rel <= 25*GeV) vetoEvent;
00232         if (M_l1l2 <= 10*GeV) vetoEvent;
00233         if (vetojets.size() != 0) vetoEvent;
00234         if (pT_l1l2 <= 30*GeV) vetoEvent;
00235         _h_Wl1_pT_emu->fill(sqrtS()*GeV, weight);
00236         _h_Wl1_pT_inclusive->fill(pT_l1, weight);
00237       }
00238     }
00239 
00240 
00241     /// Finalize
00242     void finalize() {
00243       const double norm = crossSection()/sumOfWeights()/femtobarn;
00244       scale(_h_Wl1_pT_ee, norm);
00245       scale(_h_Wl1_pT_mumu, norm);
00246       scale(_h_Wl1_pT_emu, norm);
00247       normalize(_h_Wl1_pT_inclusive, 1);
00248     }
00249 
00250 
00251   private:
00252 
00253     Histo1DPtr _h_Wl1_pT_ee, _h_Wl1_pT_mumu, _h_Wl1_pT_emu, _h_Wl1_pT_inclusive;
00254 
00255   };
00256 
00257 
00258   // The hook for the plugin system
00259   DECLARE_RIVET_PLUGIN(ATLAS_2013_I1190187);
00260 
00261 }