rivet is hosted by Hepforge, IPPP Durham
ATLAS_2012_I943401.cc
Go to the documentation of this file.
00001 // -*- C++ -*-
00002 #include "Rivet/Analysis.hh"
00003 #include "Rivet/Tools/BinnedHistogram.hh"
00004 #include "Rivet/Projections/FinalState.hh"
00005 #include "Rivet/Projections/ChargedFinalState.hh"
00006 #include "Rivet/Projections/VisibleFinalState.hh"
00007 #include "Rivet/Projections/IdentifiedFinalState.hh"
00008 #include "Rivet/Projections/FastJets.hh"
00009 #include "Rivet/Projections/VetoedFinalState.hh"
00010 
00011 namespace Rivet {
00012 
00013 
00014   class ATLAS_2012_I943401 : public Analysis {
00015   public:
00016 
00017     /// @name Constructors etc.
00018     //@{
00019 
00020     /// Constructor
00021 
00022     ATLAS_2012_I943401()
00023       : Analysis("ATLAS_2012_I943401")
00024     {    }
00025 
00026     //@}
00027 
00028 
00029   public:
00030 
00031     /// @name Analysis methods
00032     //@{
00033 
00034     /// Book histograms and initialise projections before the run
00035     void init() {
00036 
00037       // projection to find the electrons
00038       IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 20*GeV);
00039       elecs.acceptIdPair(PID::ELECTRON);
00040       addProjection(elecs, "elecs");
00041 
00042       // projection to find the muons
00043       IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
00044       muons.acceptIdPair(PID::MUON);
00045       addProjection(muons, "muons");
00046 
00047       // jet finder
00048       VetoedFinalState vfs;
00049       vfs.addVetoPairId(PID::MUON);
00050       addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
00051 
00052       // all tracks (to do deltaR with leptons)
00053       addProjection(ChargedFinalState(Cuts::abseta < 3 && Cuts::pT > 0.5*GeV), "cfs");
00054 
00055       // for pTmiss
00056       addProjection(VisibleFinalState(Cuts::abseta < 4.5), "vfs");
00057 
00058       // book histograms
00059 
00060       // counts in signal regions
00061       _count_OS_SR1 = bookHisto1D("count_OS_SR1", 1, 0., 1.);
00062       _count_OS_SR2 = bookHisto1D("count_OS_SR2", 1, 0., 1.);
00063       _count_OS_SR3 = bookHisto1D("count_OS_SR3", 1, 0., 1.);
00064       _count_SS_SR1 = bookHisto1D("count_SS_SR1", 1, 0., 1.);
00065       _count_SS_SR2 = bookHisto1D("count_SS_SR2", 1, 0., 1.);
00066       _count_FS_SR1 = bookHisto1D("count_FS_SR1", 1, 0., 1.);
00067       _count_FS_SR2 = bookHisto1D("count_FS_SR2", 1, 0., 1.);
00068       _count_FS_SR3 = bookHisto1D("count_FS_SR3", 1, 0., 1.);
00069 
00070       // histograms from paper
00071 
00072       _hist_mll_SS_D         = bookHisto1D( 1,1,1);
00073       _hist_mll_SS_B         = bookHisto1D( 1,1,2);
00074       _hist_eTmiss_SS_D      = bookHisto1D( 2,1,1);
00075       _hist_eTmiss_SS_B      = bookHisto1D( 2,1,2);
00076       _hist_mll_SS_2Jet_D    = bookHisto1D( 3,1,1);
00077       _hist_mll_SS_2Jet_B    = bookHisto1D( 3,1,2);
00078       _hist_njet_SS_D        = bookHisto1D( 5,1,1);
00079       _hist_njet_SS_B        = bookHisto1D( 5,1,2);
00080       _hist_pT_j1_SS_D       = bookHisto1D( 6,1,1);
00081       _hist_pT_j1_SS_B       = bookHisto1D( 6,1,2);
00082       _hist_pT_j2_SS_D       = bookHisto1D( 7,1,1);
00083       _hist_pT_j2_SS_B       = bookHisto1D( 7,1,2);
00084       _hist_pT_l1_SS_D       = bookHisto1D( 8,1,1);
00085       _hist_pT_l1_SS_B       = bookHisto1D( 8,1,2);
00086       _hist_pT_l2_SS_D       = bookHisto1D( 9,1,1);
00087       _hist_pT_l2_SS_B       = bookHisto1D( 9,1,2);
00088       _hist_mll_OS_D         = bookHisto1D(10,1,1);
00089       _hist_mll_OS_B         = bookHisto1D(10,1,2);
00090       _hist_eTmiss_OS_D      = bookHisto1D(11,1,1);
00091       _hist_eTmiss_OS_B      = bookHisto1D(11,1,2);
00092       _hist_eTmiss_3Jet_OS_D = bookHisto1D(12,1,1);
00093       _hist_eTmiss_3Jet_OS_B = bookHisto1D(12,1,2);
00094       _hist_eTmiss_4Jet_OS_D = bookHisto1D(13,1,1);
00095       _hist_eTmiss_4Jet_OS_B = bookHisto1D(13,1,2);
00096       _hist_njet_OS_D        = bookHisto1D(14,1,1);
00097       _hist_njet_OS_B        = bookHisto1D(14,1,2);
00098       _hist_pT_j1_OS_D       = bookHisto1D(15,1,1);
00099       _hist_pT_j1_OS_B       = bookHisto1D(15,1,2);
00100       _hist_pT_j2_OS_D       = bookHisto1D(16,1,1);
00101       _hist_pT_j2_OS_B       = bookHisto1D(16,1,2);
00102       _hist_pT_l1_OS_D       = bookHisto1D(17,1,1);
00103       _hist_pT_l1_OS_B       = bookHisto1D(17,1,2);
00104       _hist_pT_l2_OS_D       = bookHisto1D(18,1,1);
00105       _hist_pT_l2_OS_B       = bookHisto1D(18,1,2);
00106       //????
00107       //   <dataPointSet name="d04-x01-y01" dimension="2" path="/REF/ATLAS_2011_I943401" title="EVENTS/10 GEV" >
00108       //   <dataPointSet name="d04-x01-y02" dimension="2" path="/REF/ATLAS_2011_I943401" title="EVENTS/10 GEV" >
00109     }
00110 
00111     /// Perform the event analysis
00112     void analyze(const Event& event) {
00113       // event weight
00114       const double weight = event.weight();
00115 
00116       // get the jet candidates
00117       Jets cand_jets;
00118       foreach (const Jet& jet,
00119         applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
00120         if ( fabs( jet.eta() ) < 2.8 ) {
00121           cand_jets.push_back(jet);
00122         }
00123       }
00124 
00125       // electron candidates
00126       Particles cand_e =
00127         applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt();
00128 
00129       // Discard jets that overlap with electrons
00130       Jets recon_jets;
00131       foreach ( const Jet& jet, cand_jets ) {
00132         bool away_from_e = true;
00133           foreach ( const Particle& e, cand_e ) {
00134             if ( deltaR(e.momentum(),jet.momentum()) <= 0.2 ) {
00135               away_from_e = false;
00136               break;
00137             }
00138           }
00139           if ( away_from_e ) recon_jets.push_back( jet );
00140       }
00141       // get the charged tracks for isolation
00142       Particles chg_tracks =
00143         applyProjection<ChargedFinalState>(event, "cfs").particles();
00144 
00145       // Reconstructed electrons
00146       Particles recon_e;
00147       foreach ( const Particle& e, cand_e ) {
00148         // check not near a jet
00149         bool e_near_jet = false;
00150         foreach ( const Jet& jet, recon_jets ) {
00151           if ( deltaR(e.momentum(),jet.momentum()) < 0.4 ) {
00152             e_near_jet = true;
00153             break;
00154           }
00155         }
00156         if ( e_near_jet ) continue;
00157         // check the isolation
00158         double pTinCone = -e.pT();
00159         foreach ( const Particle& track, chg_tracks ) {
00160           if ( deltaR(e.momentum(),track.momentum()) < 0.2 )
00161             pTinCone += track.pT();
00162         }
00163         if ( pTinCone < 0.1*e.perp() )
00164           recon_e.push_back(e);
00165       }
00166 
00167       // Reconstructed Muons
00168       Particles recon_mu;
00169       Particles cand_mu =
00170         applyProjection<IdentifiedFinalState>(event,"muons").particlesByPt();
00171       foreach ( const Particle& mu, cand_mu ) {
00172         // check not near a jet
00173         bool mu_near_jet = false;
00174         foreach ( const Jet& jet, recon_jets ) {
00175           if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
00176             mu_near_jet = true;
00177             break;
00178           }
00179         }
00180         if ( mu_near_jet ) continue;
00181         // isolation
00182         double pTinCone = -mu.pT();
00183         foreach ( const Particle& track, chg_tracks ) {
00184           if ( deltaR(mu.momentum(),track.momentum()) < 0.2 )
00185             pTinCone += track.pT();
00186         }
00187         if ( pTinCone < 1.8*GeV )
00188           recon_mu.push_back(mu);
00189       }
00190 
00191       // pTmiss
00192       Particles vfs_particles
00193         = applyProjection<VisibleFinalState>(event, "vfs").particles();
00194       FourMomentum pTmiss;
00195       foreach ( const Particle& p, vfs_particles ) {
00196         pTmiss -= p.momentum();
00197       }
00198       double eTmiss = pTmiss.pT();
00199 
00200       // ATLAS calo problem
00201       if(rand()/static_cast<double>(RAND_MAX)<=0.42) {
00202         foreach ( const Particle& e, recon_e ) {
00203           double eta = e.eta();
00204           double phi = e.azimuthalAngle(MINUSPI_PLUSPI);
00205           if (inRange(eta, -0.1, 1.5) && inRange(phi, -0.9, -0.5)) vetoEvent;
00206         }
00207         foreach ( const Jet& jet, recon_jets ) {
00208           double eta = jet.rapidity();
00209           double phi = jet.azimuthalAngle(MINUSPI_PLUSPI);
00210           if (jet.pT() > 40*GeV && inRange(eta, -0.1, 1.5) && inRange(phi, -0.9, -0.5)) vetoEvent;
00211         }
00212       }
00213 
00214       // Exactly two leptons for each event
00215       if ( recon_mu.size() + recon_e.size() != 2) vetoEvent;
00216       // two electrons highest pT > 25
00217       Particles recon_leptons;
00218       if (recon_e.size()==2 && recon_e[0].pT()>25*GeV) {
00219         recon_leptons = recon_e;
00220       }
00221       // two muons highest pT > 20
00222       else if (recon_mu.size()==2 && recon_mu[0].pT() > 20*GeV) {
00223         recon_leptons = recon_mu;
00224       } else if (recon_e.size()==1 && recon_mu.size()==1 &&
00225                  (recon_e[0].pT() > 25*GeV || recon_mu[0].pT() > 20*GeV )) {
00226         if (recon_mu[0].pT() < recon_e[0].pT()) {
00227           recon_leptons.push_back(recon_e [0]);
00228           recon_leptons.push_back(recon_mu[0]);
00229         } else {
00230           recon_leptons.push_back(recon_mu[0]);
00231           recon_leptons.push_back(recon_e [0]);
00232         }
00233       }
00234       // fails trigger
00235       else vetoEvent;
00236 
00237       double mll = (recon_leptons[0].momentum()+recon_leptons[1].momentum()).mass();
00238       // lepton pair mass > 12.
00239       if (mll < 12*GeV) vetoEvent;
00240 
00241       // same sign or opposite sign event
00242       int sign = recon_leptons[0].pid()*recon_leptons[1].pid();
00243 
00244       // same sign leptons
00245       if(sign>0) {
00246         _hist_mll_SS_D   ->fill(mll   ,weight);
00247         _hist_mll_SS_B   ->fill(mll   ,weight);
00248         _hist_eTmiss_SS_D->fill(eTmiss,weight);
00249         _hist_eTmiss_SS_B->fill(eTmiss,weight);
00250         if(recon_jets.size()>=2) {
00251           _hist_mll_SS_2Jet_D   ->fill(mll   ,weight);
00252           _hist_mll_SS_2Jet_B   ->fill(mll   ,weight);
00253         }
00254         _hist_njet_SS_D ->fill(recon_jets.size(),weight);
00255         _hist_njet_SS_B ->fill(recon_jets.size(),weight);
00256         if(!recon_jets.empty()) {
00257           _hist_pT_j1_SS_D->fill(recon_jets[0].perp(),weight);
00258           _hist_pT_j1_SS_B->fill(recon_jets[0].perp(),weight);
00259         }
00260         if(recon_jets.size()>2) {
00261           _hist_pT_j2_SS_D->fill(recon_jets[1].perp(),weight);
00262           _hist_pT_j2_SS_B->fill(recon_jets[1].perp(),weight);
00263         }
00264         _hist_pT_l1_SS_D->fill(recon_leptons[0].perp(),weight);
00265         _hist_pT_l1_SS_B->fill(recon_leptons[0].perp(),weight);
00266         _hist_pT_l2_SS_D->fill(recon_leptons[1].perp(),weight);
00267         _hist_pT_l2_SS_B->fill(recon_leptons[1].perp(),weight);
00268         // SS-SR1
00269         if(eTmiss>100.) {
00270           _count_SS_SR1->fill(0.5,weight);
00271         }
00272         // SS-SR2
00273         if(eTmiss>80. && recon_jets.size()>=2 &&
00274            recon_jets[1].perp()>50.) {
00275           _count_SS_SR2->fill(0.5,weight);
00276         }
00277       }
00278       // opposite sign
00279       else {
00280         _hist_mll_OS_D->fill(mll   ,weight);
00281         _hist_mll_OS_B->fill(mll   ,weight);
00282         _hist_eTmiss_OS_D->fill(eTmiss,weight);
00283         _hist_eTmiss_OS_B->fill(eTmiss,weight);
00284         if(recon_jets.size()>=3){
00285           _hist_eTmiss_3Jet_OS_D->fill(eTmiss,weight);
00286           _hist_eTmiss_3Jet_OS_B->fill(eTmiss,weight);
00287         }
00288         if(recon_jets.size()>=4){
00289           _hist_eTmiss_4Jet_OS_D->fill(eTmiss,weight);
00290           _hist_eTmiss_4Jet_OS_B->fill(eTmiss,weight);
00291         }
00292         _hist_njet_OS_D->fill(recon_jets.size(),weight);
00293         _hist_njet_OS_B->fill(recon_jets.size(),weight);
00294         if(!recon_jets.empty()) {
00295           _hist_pT_j1_OS_D->fill(recon_jets[0].perp(),weight);
00296           _hist_pT_j1_OS_B->fill(recon_jets[0].perp(),weight);
00297         }
00298         if(recon_jets.size()>2) {
00299           _hist_pT_j2_OS_D->fill(recon_jets[1].perp(),weight);
00300           _hist_pT_j2_OS_B->fill(recon_jets[1].perp(),weight);
00301         }
00302         _hist_pT_l1_OS_D->fill(recon_leptons[0].perp(),weight);
00303         _hist_pT_l1_OS_B->fill(recon_leptons[0].perp(),weight);
00304         _hist_pT_l2_OS_D->fill(recon_leptons[1].perp(),weight);
00305         _hist_pT_l2_OS_B->fill(recon_leptons[1].perp(),weight);
00306         // different signal regions
00307         // OS-SR1
00308         if(eTmiss>250.) {
00309           _count_OS_SR1->fill(0.5,weight);
00310         }
00311         // OS-SR2
00312         if(eTmiss>220. && recon_jets.size()>=3 &&
00313            recon_jets[0].perp()>80. &&
00314            recon_jets[2].perp()>40.) {
00315           _count_OS_SR2->fill(0.5,weight);
00316         }
00317         // OS-SR3
00318         if(eTmiss>100. && recon_jets.size()>=4 &&
00319            recon_jets[0].perp()>100. &&
00320            recon_jets[3].perp()>70.) {
00321           _count_OS_SR3->fill(0.5,weight);
00322         }
00323         // same flavour analysis
00324         static const double beta   = 0.75;
00325         static const double tau_e  = 0.96;
00326         static const double tau_mu = 0.816;
00327         double fs_weight = weight;
00328         if (recon_leptons[0].abspid() == PID::ELECTRON && recon_leptons[1].abspid() == PID::ELECTRON) {
00329           fs_weight /= beta*(1.-sqr(1.-tau_e));
00330         } else if (recon_leptons[0].abspid() == PID::MUON && recon_leptons[1].abspid()==PID::MUON) {
00331           fs_weight *= beta/(1.-sqr(1.-tau_mu));
00332         } else {
00333           fs_weight /= -(1.-(1.-tau_e)*(1.-tau_mu));
00334         }
00335         // FS-SR1
00336         if(eTmiss>80.&& (mll<80.||mll>100.)) {
00337           _count_FS_SR1->fill(0.5,fs_weight);
00338         }
00339         // FS-SR2
00340         if(eTmiss>80.&&recon_jets.size()>=2) {
00341           _count_FS_SR2->fill(0.5,fs_weight);
00342         }
00343         // FS-SR3
00344         if(eTmiss>250.) {
00345           _count_FS_SR3->fill(0.5,fs_weight);
00346         }
00347       }
00348     }
00349 
00350     //@}
00351 
00352 
00353     void finalize() {
00354 
00355       double norm = crossSection()/femtobarn*1.04/sumOfWeights();
00356       // event counts
00357       scale(_count_OS_SR1,norm);
00358       scale(_count_OS_SR2,norm);
00359       scale(_count_OS_SR3,norm);
00360       scale(_count_SS_SR1,norm);
00361       scale(_count_SS_SR2,norm);
00362       scale(_count_FS_SR1,norm);
00363       scale(_count_FS_SR2,norm);
00364       scale(_count_FS_SR3,norm);
00365       // histograms
00366       scale(_hist_mll_SS_D     ,norm*20.);
00367       scale(_hist_mll_SS_B     ,norm*20.);
00368       scale(_hist_eTmiss_SS_D  ,norm*20.);
00369       scale(_hist_eTmiss_SS_B  ,norm*20.);
00370       scale(_hist_mll_SS_2Jet_D,norm*50.);
00371       scale(_hist_mll_SS_2Jet_B,norm*50.);
00372       scale(_hist_njet_SS_D    ,norm    );
00373       scale(_hist_njet_SS_B    ,norm    );
00374       scale(_hist_pT_j1_SS_D   ,norm*20.);
00375       scale(_hist_pT_j1_SS_B   ,norm*20.);
00376       scale(_hist_pT_j2_SS_D   ,norm*20.);
00377       scale(_hist_pT_j2_SS_B   ,norm*20.);
00378       scale(_hist_pT_l1_SS_D   ,norm*5. );
00379       scale(_hist_pT_l1_SS_B   ,norm*5. );
00380       scale(_hist_pT_l2_SS_D   ,norm*5. );
00381       scale(_hist_pT_l2_SS_B   ,norm*5. );
00382 
00383       scale(_hist_mll_OS_D        ,norm*10.);
00384       scale(_hist_mll_OS_B        ,norm*10.);
00385       scale(_hist_eTmiss_OS_D     ,norm*10.);
00386       scale(_hist_eTmiss_OS_B     ,norm*10.);
00387       scale(_hist_eTmiss_3Jet_OS_D,norm*10.);
00388       scale(_hist_eTmiss_3Jet_OS_B,norm*10.);
00389       scale(_hist_eTmiss_4Jet_OS_D,norm*10.);
00390       scale(_hist_eTmiss_4Jet_OS_B,norm*10.);
00391       scale(_hist_njet_OS_D       ,norm    );
00392       scale(_hist_njet_OS_B       ,norm    );
00393       scale(_hist_pT_j1_OS_D      ,norm*20.);
00394       scale(_hist_pT_j1_OS_B      ,norm*20.);
00395       scale(_hist_pT_j2_OS_D      ,norm*20.);
00396       scale(_hist_pT_j2_OS_B      ,norm*20.);
00397       scale(_hist_pT_l1_OS_D      ,norm*20.);
00398       scale(_hist_pT_l1_OS_B      ,norm*20.);
00399       scale(_hist_pT_l2_OS_D      ,norm*20.);
00400       scale(_hist_pT_l2_OS_B      ,norm*20.);
00401     }
00402 
00403   private:
00404 
00405     /// @name Histograms
00406     //@{
00407     Histo1DPtr _count_OS_SR1;
00408     Histo1DPtr _count_OS_SR2;
00409     Histo1DPtr _count_OS_SR3;
00410     Histo1DPtr _count_SS_SR1;
00411     Histo1DPtr _count_SS_SR2;
00412     Histo1DPtr _count_FS_SR1;
00413     Histo1DPtr _count_FS_SR2;
00414     Histo1DPtr _count_FS_SR3;
00415 
00416     Histo1DPtr _hist_mll_SS_D;
00417     Histo1DPtr _hist_mll_SS_B;
00418     Histo1DPtr _hist_eTmiss_SS_D;
00419     Histo1DPtr _hist_eTmiss_SS_B;
00420     Histo1DPtr _hist_mll_SS_2Jet_D;
00421     Histo1DPtr _hist_mll_SS_2Jet_B;
00422     Histo1DPtr _hist_njet_SS_D;
00423     Histo1DPtr _hist_njet_SS_B;
00424     Histo1DPtr _hist_pT_j1_SS_D;
00425     Histo1DPtr _hist_pT_j1_SS_B;
00426     Histo1DPtr _hist_pT_j2_SS_D;
00427     Histo1DPtr _hist_pT_j2_SS_B;
00428     Histo1DPtr _hist_pT_l1_SS_D;
00429     Histo1DPtr _hist_pT_l1_SS_B;
00430     Histo1DPtr _hist_pT_l2_SS_D;
00431     Histo1DPtr _hist_pT_l2_SS_B;
00432 
00433     Histo1DPtr _hist_mll_OS_D;
00434     Histo1DPtr _hist_mll_OS_B;
00435     Histo1DPtr _hist_eTmiss_OS_D;
00436     Histo1DPtr _hist_eTmiss_OS_B;
00437     Histo1DPtr _hist_eTmiss_3Jet_OS_D;
00438     Histo1DPtr _hist_eTmiss_3Jet_OS_B;
00439     Histo1DPtr _hist_eTmiss_4Jet_OS_D;
00440     Histo1DPtr _hist_eTmiss_4Jet_OS_B;
00441     Histo1DPtr _hist_njet_OS_D ;
00442     Histo1DPtr _hist_njet_OS_B ;
00443     Histo1DPtr _hist_pT_j1_OS_D;
00444     Histo1DPtr _hist_pT_j1_OS_B;
00445     Histo1DPtr _hist_pT_j2_OS_D;
00446     Histo1DPtr _hist_pT_j2_OS_B;
00447     Histo1DPtr _hist_pT_l1_OS_D;
00448     Histo1DPtr _hist_pT_l1_OS_B;
00449     Histo1DPtr _hist_pT_l2_OS_D;
00450     Histo1DPtr _hist_pT_l2_OS_B;
00451     //@}
00452   };
00453 
00454   // The hook for the plugin system
00455   DECLARE_RIVET_PLUGIN(ATLAS_2012_I943401);
00456 
00457 }