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