rivet is hosted by Hepforge, IPPP Durham

Rivet analyses reference

ATLAS_2011_S9019561

Two-lepton supersymmetry search
Experiment: ATLAS (LHC)
Inspire ID: 894578
Status: VALIDATED
Authors:
  • Angela Chen
References: Beams: p+ p+
Beam energies: (3500.0, 3500.0) GeV
Run details:
  • BSM signal events at 7000 GeV.

2-lepton search for supersymmetric particles by ATLAS at 7 TeV. Event counts in signal regions (3 same sign and 3 opposite sign) are implemented as one bin histograms. Histograms for missing transverse energy are implemented.

Source code: ATLAS_2011_S9019561.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/FastJets.hh"
  8#include "Rivet/Projections/VetoedFinalState.hh"
  9
 10namespace Rivet {
 11
 12
 13  /// Two-lepton supersymmetry search
 14  class ATLAS_2011_S9019561 : public Analysis {
 15  public:
 16
 17    /// Constructor
 18    RIVET_DEFAULT_ANALYSIS_CTOR(ATLAS_2011_S9019561);
 19
 20
 21    /// @name Analysis methods
 22    //@{
 23
 24    /// Book histograms and initialise projections before the run
 25    void init() {
 26
 27      // projection to find the electrons
 28      IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 20*GeV);
 29      elecs.acceptIdPair(PID::ELECTRON);
 30      declare(elecs, "elecs");
 31
 32
 33      // veto region electrons
 34      Cut vetocut = Cuts::absetaIn(1.37, 1.52);
 35      IdentifiedFinalState veto_elecs(vetocut && Cuts::pT > 10*GeV);
 36      veto_elecs.acceptIdPair(PID::ELECTRON);
 37      declare(veto_elecs, "veto_elecs");
 38
 39
 40      // projection to find the muons
 41      IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 20*GeV);
 42      muons.acceptIdPair(PID::MUON);
 43      declare(muons, "muons");
 44
 45
 46      // jet finder
 47      VetoedFinalState vfs;
 48      vfs.addVetoPairId(PID::MUON);
 49      declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
 50
 51
 52      // all tracks (to do deltaR with leptons)
 53      declare(ChargedFinalState(Cuts::abseta < 3 && Cuts::pT > 0.5*GeV), "cfs");
 54
 55
 56      // for pTmiss
 57      declare(VisibleFinalState(Cuts::abseta < 4.9),"vfs");
 58
 59
 60      /// book histograms
 61      book(_count_OS_e_mu ,"count_OS_e+-mu-+", 1, 0., 1.);
 62      book(_count_OS_e_e ,"count_OS_e+e-", 1, 0., 1.);
 63      book(_count_OS_mu_mu ,"count_OS_mu+mu-", 1, 0., 1.);
 64      book(_count_SS_e_mu ,"count_SS_e+-mu+-", 1, 0., 1.);
 65      book(_count_SS_e_e ,"count_SS_e+-e+-", 1, 0., 1.);
 66      book(_count_SS_mu_mu ,"count_SS_mu+-mu+-", 1, 0., 1.);
 67
 68      book(_hist_eTmiss_OS  ,"Et_miss_OS", 20, 0., 400.);
 69      book(_hist_eTmiss_SS  ,"Et_miss_SS", 20, 0., 400.);
 70
 71    }
 72
 73
 74
 75
 76    /// Perform the per-event analysis
 77    void analyze(const Event& event) {
 78
 79      const double weight = 1.0;
 80
 81      Particles veto_e
 82        = apply<IdentifiedFinalState>(event, "veto_elecs").particles();
 83      if ( ! veto_e.empty() ) {
 84        MSG_DEBUG("electrons in veto region");
 85        vetoEvent;
 86      }
 87
 88      Jets cand_jets;
 89      for (const Jet& jet :
 90        apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
 91        if ( fabs( jet.eta() ) < 2.5 ) {
 92          cand_jets.push_back(jet);
 93        }
 94      }
 95
 96      Particles cand_e =
 97        apply<IdentifiedFinalState>(event, "elecs").particlesByPt();
 98
 99      // charged particle for isolation
100      Particles chg_tracks =
101        apply<ChargedFinalState>(event, "cfs").particles();
102
103      // apply muon isolation
104      Particles cand_mu;
105      // pTcone around muon track
106      for ( const Particle & mu :
107                apply<IdentifiedFinalState>(event,"muons").particlesByPt() ) {
108        double pTinCone = -mu.pT();
109        for ( const Particle & track : chg_tracks ) {
110          if ( deltaR(mu.momentum(),track.momentum()) < 0.2 )
111            pTinCone += track.pT();
112        }
113        if ( pTinCone < 1.8*GeV )
114          cand_mu.push_back(mu);
115      }
116
117      // Discard jets that overlap with electrons
118      Jets recon_jets;
119      for ( const Jet& jet : cand_jets ) {
120        bool away_from_e = true;
121        for ( const Particle & e : cand_e ) {
122          if ( deltaR(e.momentum(),jet.momentum()) <= 0.2 ) {
123            away_from_e = false;
124            break;
125          }
126        }
127        if ( away_from_e )
128         recon_jets.push_back( jet );
129      }
130
131      // Leptons far from jet
132      Particles recon_e;
133      for ( const Particle & e : cand_e ) {
134        bool e_near_jet = false;
135        for ( const Jet& jet : recon_jets ) {
136          if ( deltaR(e.momentum(),jet.momentum()) < 0.4 ) {
137            e_near_jet = true;
138            break;
139          }
140        }
141        // Electron isolation criterion
142        if ( ! e_near_jet ) {
143          double EtinCone = -e.Et();
144          for ( const Particle & track : chg_tracks) {
145            if ( deltaR(e.momentum(),track.momentum()) <= 0.2 )
146              EtinCone += track.Et();
147          }
148          if ( EtinCone/e.pT() <= 0.15 )
149            recon_e.push_back( e );
150        }
151      }
152
153      Particles recon_mu;
154      for ( const Particle & mu : cand_mu ) {
155         bool mu_near_jet = false;
156         for ( const Jet& jet : recon_jets ) {
157           if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
158             mu_near_jet = true;
159             break;
160           }
161         }
162         if ( ! mu_near_jet )
163          recon_mu.push_back( mu );
164       }
165
166
167      // pTmiss
168      Particles vfs_particles
169        = apply<VisibleFinalState>(event, "vfs").particles();
170      FourMomentum pTmiss;
171      for ( const Particle & p : vfs_particles ) {
172        pTmiss -= p.momentum();
173      }
174      double eTmiss = pTmiss.pT();
175
176      // Exactly two leptons for each event
177      if ( recon_mu.size() + recon_e.size() != 2)
178        vetoEvent;
179
180      // Lepton pair mass
181      FourMomentum p_leptons;
182      for ( Particle e : recon_e ) {
183        p_leptons +=  e.momentum();
184      }
185      for ( Particle mu : recon_mu) {
186        p_leptons += mu.momentum();
187      }
188
189      if ( p_leptons.mass() <= 5.0 * GeV)
190        vetoEvent;
191
192      // ==================== FILL ====================
193
194
195      // electron, electron
196      if (recon_e.size() == 2 ) {
197
198        // SS ee
199        if ( recon_e[0].pid() * recon_e[1].pid() > 0 ) {
200          _hist_eTmiss_SS->fill(eTmiss, weight);
201          if ( eTmiss > 100 ) {
202            MSG_DEBUG("Hits SS e+/-e+/-");
203            _count_SS_e_e->fill(0.5, weight);
204          }
205        }
206
207        // OS ee
208        else if ( recon_e[0].pid() * recon_e[1].pid() < 0) {
209          _hist_eTmiss_OS->fill(eTmiss, weight);
210          if ( eTmiss > 150 ) {
211            MSG_DEBUG("Hits OS e+e-");
212            _count_OS_e_e->fill(0.5, weight);
213          }
214        }
215      }
216
217
218      // muon, electron
219      else if ( recon_e.size() == 1 ) {
220
221        // SS mu_e
222        if ( recon_e[0].pid() * recon_mu[0].pid() > 0 ) {
223          _hist_eTmiss_SS->fill(eTmiss, weight);
224          if ( eTmiss > 100 ) {
225            MSG_DEBUG("Hits SS e+/-mu+/-");
226            _count_SS_e_mu->fill(0.5, weight);
227          }
228        }
229
230        // OS mu_e
231        else if ( recon_e[0].pid() * recon_mu[0].pid() < 0) {
232          _hist_eTmiss_OS->fill(eTmiss, weight);
233          if ( eTmiss > 150 ) {
234            MSG_DEBUG("Hits OS e+mu-");
235            _count_OS_e_mu->fill(0.5, weight);
236          }
237        }
238      }
239
240
241      // muon, muon
242      else if ( recon_mu.size() == 2 ) {
243
244        // SS mu_mu
245        if ( recon_mu[0].pid() * recon_mu[1].pid() > 0 ) {
246          _hist_eTmiss_SS->fill(eTmiss, weight);
247          if ( eTmiss > 100 ) {
248            MSG_DEBUG("Hits SS mu+/-mu+/-");
249            _count_SS_mu_mu->fill(0.5, weight);
250          }
251        }
252
253        // OS mu_mu
254        else if ( recon_mu[0].pid() * recon_mu[1].pid() < 0) {
255          _hist_eTmiss_OS->fill(eTmiss, weight);
256          if ( eTmiss > 150 ) {
257            MSG_DEBUG("Hits OS mu+mu-");
258            _count_OS_mu_mu->fill(0.5, weight);
259          }
260        }
261      }
262
263
264    }
265
266    //@}
267
268
269    void finalize() {
270      double norm = crossSection()/picobarn*35./sumOfWeights();
271      // event counts
272      scale(_count_OS_e_mu ,norm);
273      scale(_count_OS_e_e  ,norm);
274      scale(_count_OS_mu_mu,norm);
275      scale(_count_SS_e_mu ,norm);
276      scale(_count_SS_e_e  ,norm);
277      scale(_count_SS_mu_mu,norm);
278      scale(_hist_eTmiss_OS,10.*norm);
279      scale(_hist_eTmiss_SS,10.*norm);
280    }
281
282
283  private:
284
285    /// @name Histograms
286    //@{
287    Histo1DPtr _count_OS_e_mu;
288    Histo1DPtr _count_OS_e_e;
289    Histo1DPtr _count_OS_mu_mu;
290    Histo1DPtr _count_SS_e_mu;
291    Histo1DPtr _count_SS_e_e;
292    Histo1DPtr _count_SS_mu_mu;
293    Histo1DPtr _hist_eTmiss_OS;
294    Histo1DPtr _hist_eTmiss_SS;
295    //@}
296
297  };
298
299
300
301  RIVET_DECLARE_ALIASED_PLUGIN(ATLAS_2011_S9019561, ATLAS_2011_I894578);
302
303}