rivet is hosted by Hepforge, IPPP Durham

Rivet analyses reference

ATLAS_2012_CONF_2012_104

Search for supersymmetry at 8 TeV with jets, missing transverse momentum and one lepton
Experiment: ATLAS (LHC)
Status: OBSOLETE
Authors:
  • Peter Richardson
References: Beams: p+ p+
Beam energies: (4000.0, 4000.0) GeV
Run details:
  • BSM signal events at 8000 GeV.

One lepton search for supersymmmetric particles by ATLAS at 8 TeV with $5.8\,\text{fb}^{-1}$ integrated luminosity. Event counts in the signal regions are implemented as one-bin histograms. Histograms for effective mass are implemented for the two signal hard lepton signal regions and the ratio of missing transverse energy to effective mass for the soft lepton region.

Source code: ATLAS_2012_CONF_2012_104.cc
  1// -*- C++ -*-
  2#include "Rivet/Analysis.hh"
  3#include "Rivet/Projections/FinalState.hh"
  4#include "Rivet/Projections/ChargedFinalState.hh"
  5#include "Rivet/Projections/VisibleFinalState.hh"
  6#include "Rivet/Projections/IdentifiedFinalState.hh"
  7#include "Rivet/Projections/VetoedFinalState.hh"
  8#include "Rivet/Projections/FastJets.hh"
  9
 10namespace Rivet {
 11
 12
 13  class ATLAS_2012_CONF_2012_104 : public Analysis {
 14  public:
 15
 16    /// Constructor
 17    ATLAS_2012_CONF_2012_104()
 18      : Analysis("ATLAS_2012_CONF_2012_104")
 19    {    }
 20
 21
 22    /// @name Analysis methods
 23    /// @{
 24
 25    /// Book histograms and initialize projections before the run
 26    void init() {
 27
 28      // projection to find the electrons
 29      IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 10*GeV);
 30      elecs.acceptIdPair(PID::ELECTRON);
 31      declare(elecs, "elecs");
 32
 33      // projection to find the muons
 34      IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
 35      muons.acceptIdPair(PID::MUON);
 36      declare(muons, "muons");
 37
 38      // Jet finder
 39      VetoedFinalState vfs;
 40      vfs.addVetoPairId(PID::MUON);
 41      declare(FastJets(vfs, JetAlg::ANTIKT, 0.4), "AntiKtJets04");
 42
 43      // all tracks (to do deltaR with leptons)
 44      declare(ChargedFinalState(Cuts::abseta < 3 && Cuts::pT > 0.5*GeV), "cfs");
 45
 46      // for pTmiss
 47      declare(VisibleFinalState(Cuts::abseta < 4.9),"vfs");
 48
 49      // Book histograms
 50      book(_count_e  ,"count_e" , 1, 0., 1.);
 51      book(_count_mu ,"count_mu", 1, 0., 1.);
 52
 53      book(_hist_eTmiss_e  ,"hist_eTmiss_e"  , 25, 0., 1000.);
 54      book(_hist_eTmiss_mu ,"hist_eTmiss_mu" , 25, 0., 1000.);
 55
 56    }
 57
 58    /// Perform the per-event analysis
 59    void analyze(const Event& event) {
 60
 61      // get the candiate jets
 62      Jets cand_jets;
 63      for ( const Jet& jet :
 64                apply<FastJets>(event, "AntiKtJets04").jetsByPt(Cuts::pT > 20*GeV && Cuts::abseta < 2.8) ) {
 65        cand_jets.push_back(jet);
 66      }
 67
 68      // get the candidate "medium" leptons without isolation
 69      Particles cand_e;
 70      for( const Particle & e :
 71               apply<IdentifiedFinalState>(event, "elecs").particlesByPt()) {
 72        // remove any leptons within 0.4 of any candidate jets
 73        bool e_near_jet = false;
 74        for ( const Jet& jet : cand_jets ) {
 75          double dR = deltaR(e.momentum(),jet.momentum());
 76          if ( dR < 0.4 && dR > 0.2 ) {
 77            e_near_jet = true;
 78            break;
 79          }
 80        }
 81        if ( ! e_near_jet ) cand_e.push_back(e);
 82      }
 83      Particles cand_mu;
 84      for( const Particle & mu :
 85               apply<IdentifiedFinalState>(event, "muons").particlesByPt()) {
 86        // remove any leptons within 0.4 of any candidate jets
 87        bool mu_near_jet = false;
 88        for ( const Jet& jet : cand_jets ) {
 89          if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
 90            mu_near_jet = true;
 91            break;
 92          }
 93        }
 94        if ( ! mu_near_jet ) cand_mu.push_back(mu);
 95      }
 96      // apply the isolation
 97      Particles chg_tracks =
 98        apply<ChargedFinalState>(event, "cfs").particles();
 99      // pTcone around muon track (hard)
100      Particles recon_mu;
101      for ( const Particle & mu : cand_mu ) {
102        double pTinCone = -mu.pT();
103        if(-pTinCone<25.) continue;
104        for ( const Particle & track : chg_tracks ) {
105          if ( deltaR(mu.momentum(),track.momentum()) < 0.2 )
106            pTinCone += track.pT();
107        }
108        if ( pTinCone < 1.8*GeV ) recon_mu.push_back(mu);
109      }
110      // pTcone around electron track (hard)
111      Particles recon_e;
112      for ( const Particle & e : cand_e ) {
113        double pTinCone = -e.pT();
114        if(-pTinCone<25.) continue;
115        for ( const Particle & track : chg_tracks ) {
116          if ( deltaR(e.momentum(),track.momentum()) < 0.2 )
117            pTinCone += track.pT();
118        }
119        if ( pTinCone < 0.1 * e.pT() ) recon_e.push_back(e);
120      }
121
122      // discard jets that overlap with electrons
123      Jets recon_jets;
124      for ( const Jet& jet : cand_jets ) {
125        if(jet.abseta()>2.5||
126           jet.perp()<25.) continue;
127        bool away_from_e = true;
128        for ( const Particle & e : cand_e ) {
129          if ( deltaR(e.momentum(),jet.momentum()) < 0.2 ) {
130            away_from_e = false;
131            break;
132          }
133        }
134        if ( away_from_e ) recon_jets.push_back( jet );
135      }
136
137      // pTmiss
138      FourMomentum pTmiss;
139      for ( const Particle & p :
140                apply<VisibleFinalState>(event, "vfs").particles() ) {
141        pTmiss -= p.momentum();
142      }
143      double eTmiss = pTmiss.pT();
144
145      // at least 4 jets with pT>80.
146      if(recon_jets.size()<4 || recon_jets[3].perp()<80.) vetoEvent;
147
148      // only 1 signal lepton
149      if( recon_e.size() + recon_mu.size() != 1 )
150        vetoEvent;
151      if( cand_e .size() + cand_mu .size() != 1 )
152        vetoEvent;
153
154      // start of meff calculation
155      double HT=0.;
156      for( const Jet & jet : recon_jets) {
157        double pT = jet.perp();
158        if(pT>40.) HT += pT;
159      }
160
161      // get the lepton
162      Particle lepton = recon_e.empty() ? recon_mu[0] : recon_e[0];
163
164      // lepton variables
165      double pT = lepton.perp();
166
167      double mT  = 2.*(pT*eTmiss -
168                       lepton.px()*pTmiss.px() -
169                       lepton.py()*pTmiss.py());
170      mT = sqrt(mT);
171      HT += pT;
172      double m_eff_inc  = HT + eTmiss + pT;
173      double m_eff_4 = eTmiss + pT;
174      for(unsigned int ix=0;ix<4;++ix)
175        m_eff_4 +=  recon_jets[ix].perp();
176
177      // four jet selecton
178      if(mT>100.&& eTmiss/m_eff_4>0.2 &&
179         m_eff_inc > 800.) {
180        if( eTmiss > 250. ) {
181          if(lepton.abspid()==PID::ELECTRON)
182            _count_e->fill(0.5);
183          else if(lepton.abspid()==PID::MUON)
184            _count_mu->fill(0.5);
185        }
186        if(lepton.abspid()==PID::ELECTRON)
187          _hist_eTmiss_e ->fill(eTmiss);
188        else if(lepton.abspid()==PID::MUON)
189          _hist_eTmiss_mu->fill(eTmiss);
190      }
191    }
192    /// @}
193
194
195    void finalize() {
196
197      double norm = 5.8* crossSection()/sumOfWeights()/femtobarn;
198      scale(_count_e ,norm);
199      scale(_count_mu,norm);
200      scale(_hist_eTmiss_e  ,40.*norm);
201      scale(_hist_eTmiss_mu ,40.*norm);
202
203    }
204
205  private:
206
207    /// @name Histograms
208    /// @{
209    Histo1DPtr _count_e ;
210    Histo1DPtr _count_mu;
211
212    Histo1DPtr _hist_eTmiss_e ;
213    Histo1DPtr _hist_eTmiss_mu;
214    /// @}
215
216  };
217
218  RIVET_DECLARE_PLUGIN(ATLAS_2012_CONF_2012_104);
219
220}