rivet is hosted by Hepforge, IPPP Durham

Rivet analyses reference

ATLAS_2012_I943401

Search for supersymmetry with 2 leptons and missing transverse energy
Experiment: ATLAS (LHC)
Inspire ID: 943401
Status: VALIDATED
Authors:
  • Peter Richardson
References: Beams: p+ p+
Beam energies: (3500.0, 3500.0) GeV
Run details:
  • BSM signal events at 7000 GeV.

Results of three searches for the production of supersymmetric particles decaying into final states with missing transverse momentum and exactly two isolated leptons, electrons or muons. The analysis uses a data sample collected during the first half of 2011 that corresponds to a total integrated luminosity of 1 $\text{fb}^{-1}$ of $\sqrt{s} = 7$\,TeV proton-proton collisions recorded with the ATLAS detector at the Large Hadron Collider. Opposite-sign and same-sign dilepton events are studied separately. Additionally, in opposite- sign events, a search is made for an excess of same-flavour over different-flavour lepton pairs.

Source code: ATLAS_2012_I943401.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  class ATLAS_2012_I943401 : public Analysis {
 14  public:
 15
 16    /// @name Constructors etc.
 17    //@{
 18
 19    /// Constructor
 20
 21    ATLAS_2012_I943401()
 22      : Analysis("ATLAS_2012_I943401")
 23    {    }
 24
 25    //@}
 26
 27
 28  public:
 29
 30    /// @name Analysis methods
 31    //@{
 32
 33    /// Book histograms and initialise projections before the run
 34    void init() {
 35
 36      // projection to find the electrons
 37      IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 20*GeV);
 38      elecs.acceptIdPair(PID::ELECTRON);
 39      declare(elecs, "elecs");
 40
 41      // projection to find the muons
 42      IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
 43      muons.acceptIdPair(PID::MUON);
 44      declare(muons, "muons");
 45
 46      // jet finder
 47      VetoedFinalState vfs;
 48      vfs.addVetoPairId(PID::MUON);
 49      declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
 50
 51      // all tracks (to do deltaR with leptons)
 52      declare(ChargedFinalState(Cuts::abseta < 3 && Cuts::pT > 0.5*GeV), "cfs");
 53
 54      // for pTmiss
 55      declare(VisibleFinalState(Cuts::abseta < 4.5), "vfs");
 56
 57      // book histograms
 58
 59      // counts in signal regions
 60      book(_count_OS_SR1 ,"count_OS_SR1", 1, 0., 1.);
 61      book(_count_OS_SR2 ,"count_OS_SR2", 1, 0., 1.);
 62      book(_count_OS_SR3 ,"count_OS_SR3", 1, 0., 1.);
 63      book(_count_SS_SR1 ,"count_SS_SR1", 1, 0., 1.);
 64      book(_count_SS_SR2 ,"count_SS_SR2", 1, 0., 1.);
 65      book(_count_FS_SR1 ,"count_FS_SR1", 1, 0., 1.);
 66      book(_count_FS_SR2 ,"count_FS_SR2", 1, 0., 1.);
 67      book(_count_FS_SR3 ,"count_FS_SR3", 1, 0., 1.);
 68
 69      // histograms from paper
 70
 71      book(_hist_mll_SS_D         , 1,1,1);
 72      book(_hist_mll_SS_B         , 1,1,2);
 73      book(_hist_eTmiss_SS_D      , 2,1,1);
 74      book(_hist_eTmiss_SS_B      , 2,1,2);
 75      book(_hist_mll_SS_2Jet_D    , 3,1,1);
 76      book(_hist_mll_SS_2Jet_B    , 3,1,2);
 77      book(_hist_njet_SS_D        , 5,1,1);
 78      book(_hist_njet_SS_B        , 5,1,2);
 79      book(_hist_pT_j1_SS_D       , 6,1,1);
 80      book(_hist_pT_j1_SS_B       , 6,1,2);
 81      book(_hist_pT_j2_SS_D       , 7,1,1);
 82      book(_hist_pT_j2_SS_B       , 7,1,2);
 83      book(_hist_pT_l1_SS_D       , 8,1,1);
 84      book(_hist_pT_l1_SS_B       , 8,1,2);
 85      book(_hist_pT_l2_SS_D       , 9,1,1);
 86      book(_hist_pT_l2_SS_B       , 9,1,2);
 87      book(_hist_mll_OS_D         ,10,1,1);
 88      book(_hist_mll_OS_B         ,10,1,2);
 89      book(_hist_eTmiss_OS_D      ,11,1,1);
 90      book(_hist_eTmiss_OS_B      ,11,1,2);
 91      book(_hist_eTmiss_3Jet_OS_D ,12,1,1);
 92      book(_hist_eTmiss_3Jet_OS_B ,12,1,2);
 93      book(_hist_eTmiss_4Jet_OS_D ,13,1,1);
 94      book(_hist_eTmiss_4Jet_OS_B ,13,1,2);
 95      book(_hist_njet_OS_D        ,14,1,1);
 96      book(_hist_njet_OS_B        ,14,1,2);
 97      book(_hist_pT_j1_OS_D       ,15,1,1);
 98      book(_hist_pT_j1_OS_B       ,15,1,2);
 99      book(_hist_pT_j2_OS_D       ,16,1,1);
100      book(_hist_pT_j2_OS_B       ,16,1,2);
101      book(_hist_pT_l1_OS_D       ,17,1,1);
102      book(_hist_pT_l1_OS_B       ,17,1,2);
103      book(_hist_pT_l2_OS_D       ,18,1,1);
104      book(_hist_pT_l2_OS_B       ,18,1,2);
105      //????
106      //   <dataPointSet name="d04-x01-y01" dimension="2" path="/REF/ATLAS_2011_I943401" title="EVENTS/10 GEV" >
107      //   <dataPointSet name="d04-x01-y02" dimension="2" path="/REF/ATLAS_2011_I943401" title="EVENTS/10 GEV" >
108    }
109
110    /// Perform the event analysis
111    void analyze(const Event& event) {
112      // get the jet candidates
113      Jets cand_jets;
114      for (const Jet& jet :
115        apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
116        if ( fabs( jet.eta() ) < 2.8 ) {
117          cand_jets.push_back(jet);
118        }
119      }
120
121      // electron candidates
122      Particles cand_e =
123        apply<IdentifiedFinalState>(event, "elecs").particlesByPt();
124
125      // Discard jets that overlap with electrons
126      Jets recon_jets;
127      for ( const Jet& jet : cand_jets ) {
128        bool away_from_e = true;
129          for ( const Particle& e : cand_e ) {
130            if ( deltaR(e.momentum(),jet.momentum()) <= 0.2 ) {
131              away_from_e = false;
132              break;
133            }
134          }
135          if ( away_from_e ) recon_jets.push_back( jet );
136      }
137      // get the charged tracks for isolation
138      Particles chg_tracks =
139        apply<ChargedFinalState>(event, "cfs").particles();
140
141      // Reconstructed electrons
142      Particles recon_e;
143      for ( const Particle& e : cand_e ) {
144        // check not near a jet
145        bool e_near_jet = false;
146        for ( const Jet& jet : recon_jets ) {
147          if ( deltaR(e.momentum(),jet.momentum()) < 0.4 ) {
148            e_near_jet = true;
149            break;
150          }
151        }
152        if ( e_near_jet ) continue;
153        // check the isolation
154        double pTinCone = -e.pT();
155        for ( const Particle& track : chg_tracks ) {
156          if ( deltaR(e.momentum(),track.momentum()) < 0.2 )
157            pTinCone += track.pT();
158        }
159        if ( pTinCone < 0.1*e.perp() )
160          recon_e.push_back(e);
161      }
162
163      // Reconstructed Muons
164      Particles recon_mu;
165      Particles cand_mu =
166        apply<IdentifiedFinalState>(event,"muons").particlesByPt();
167      for ( const Particle& mu : cand_mu ) {
168        // check not near a jet
169        bool mu_near_jet = false;
170        for ( const Jet& jet : recon_jets ) {
171          if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
172            mu_near_jet = true;
173            break;
174          }
175        }
176        if ( mu_near_jet ) continue;
177        // isolation
178        double pTinCone = -mu.pT();
179        for ( const Particle& track : chg_tracks ) {
180          if ( deltaR(mu.momentum(),track.momentum()) < 0.2 )
181            pTinCone += track.pT();
182        }
183        if ( pTinCone < 1.8*GeV )
184          recon_mu.push_back(mu);
185      }
186
187      // pTmiss
188      Particles vfs_particles
189        = apply<VisibleFinalState>(event, "vfs").particles();
190      FourMomentum pTmiss;
191      for ( const Particle& p : vfs_particles ) {
192        pTmiss -= p.momentum();
193      }
194      double eTmiss = pTmiss.pT();
195
196      // ATLAS calo problem
197      if(rand()/static_cast<double>(RAND_MAX)<=0.42) {
198        for ( const Particle& e : recon_e ) {
199          double eta = e.eta();
200          double phi = e.azimuthalAngle(MINUSPI_PLUSPI);
201          if (inRange(eta, -0.1, 1.5) && inRange(phi, -0.9, -0.5)) vetoEvent;
202        }
203        for ( const Jet& jet : recon_jets ) {
204          double eta = jet.rapidity();
205          double phi = jet.azimuthalAngle(MINUSPI_PLUSPI);
206          if (jet.pT() > 40*GeV && inRange(eta, -0.1, 1.5) && inRange(phi, -0.9, -0.5)) vetoEvent;
207        }
208      }
209
210      // Exactly two leptons for each event
211      if ( recon_mu.size() + recon_e.size() != 2) vetoEvent;
212      // two electrons highest pT > 25
213      Particles recon_leptons;
214      if (recon_e.size()==2 && recon_e[0].pT()>25*GeV) {
215        recon_leptons = recon_e;
216      }
217      // two muons highest pT > 20
218      else if (recon_mu.size()==2 && recon_mu[0].pT() > 20*GeV) {
219        recon_leptons = recon_mu;
220      } else if (recon_e.size()==1 && recon_mu.size()==1 &&
221                 (recon_e[0].pT() > 25*GeV || recon_mu[0].pT() > 20*GeV )) {
222        if (recon_mu[0].pT() < recon_e[0].pT()) {
223          recon_leptons.push_back(recon_e [0]);
224          recon_leptons.push_back(recon_mu[0]);
225        } else {
226          recon_leptons.push_back(recon_mu[0]);
227          recon_leptons.push_back(recon_e [0]);
228        }
229      }
230      // fails trigger
231      else vetoEvent;
232
233      double mll = (recon_leptons[0].momentum()+recon_leptons[1].momentum()).mass();
234      // lepton pair mass > 12.
235      if (mll < 12*GeV) vetoEvent;
236
237      // same sign or opposite sign event
238      int sign = recon_leptons[0].pid()*recon_leptons[1].pid();
239
240      // same sign leptons
241      if(sign>0) {
242        _hist_mll_SS_D   ->fill(mll   );
243        _hist_mll_SS_B   ->fill(mll   );
244        _hist_eTmiss_SS_D->fill(eTmiss);
245        _hist_eTmiss_SS_B->fill(eTmiss);
246        if(recon_jets.size()>=2) {
247          _hist_mll_SS_2Jet_D   ->fill(mll   );
248          _hist_mll_SS_2Jet_B   ->fill(mll   );
249        }
250        _hist_njet_SS_D ->fill(recon_jets.size());
251        _hist_njet_SS_B ->fill(recon_jets.size());
252        if(!recon_jets.empty()) {
253          _hist_pT_j1_SS_D->fill(recon_jets[0].perp());
254          _hist_pT_j1_SS_B->fill(recon_jets[0].perp());
255        }
256        if(recon_jets.size()>2) {
257          _hist_pT_j2_SS_D->fill(recon_jets[1].perp());
258          _hist_pT_j2_SS_B->fill(recon_jets[1].perp());
259        }
260        _hist_pT_l1_SS_D->fill(recon_leptons[0].perp());
261        _hist_pT_l1_SS_B->fill(recon_leptons[0].perp());
262        _hist_pT_l2_SS_D->fill(recon_leptons[1].perp());
263        _hist_pT_l2_SS_B->fill(recon_leptons[1].perp());
264        // SS-SR1
265        if(eTmiss>100.) {
266          _count_SS_SR1->fill(0.5);
267        }
268        // SS-SR2
269        if(eTmiss>80. && recon_jets.size()>=2 &&
270           recon_jets[1].perp()>50.) {
271          _count_SS_SR2->fill(0.5);
272        }
273      }
274      // opposite sign
275      else {
276        _hist_mll_OS_D->fill(mll   );
277        _hist_mll_OS_B->fill(mll   );
278        _hist_eTmiss_OS_D->fill(eTmiss);
279        _hist_eTmiss_OS_B->fill(eTmiss);
280        if(recon_jets.size()>=3){
281          _hist_eTmiss_3Jet_OS_D->fill(eTmiss);
282          _hist_eTmiss_3Jet_OS_B->fill(eTmiss);
283        }
284        if(recon_jets.size()>=4){
285          _hist_eTmiss_4Jet_OS_D->fill(eTmiss);
286          _hist_eTmiss_4Jet_OS_B->fill(eTmiss);
287        }
288        _hist_njet_OS_D->fill(recon_jets.size());
289        _hist_njet_OS_B->fill(recon_jets.size());
290        if(!recon_jets.empty()) {
291          _hist_pT_j1_OS_D->fill(recon_jets[0].perp());
292          _hist_pT_j1_OS_B->fill(recon_jets[0].perp());
293        }
294        if(recon_jets.size()>2) {
295          _hist_pT_j2_OS_D->fill(recon_jets[1].perp());
296          _hist_pT_j2_OS_B->fill(recon_jets[1].perp());
297        }
298        _hist_pT_l1_OS_D->fill(recon_leptons[0].perp());
299        _hist_pT_l1_OS_B->fill(recon_leptons[0].perp());
300        _hist_pT_l2_OS_D->fill(recon_leptons[1].perp());
301        _hist_pT_l2_OS_B->fill(recon_leptons[1].perp());
302        // different signal regions
303        // OS-SR1
304        if(eTmiss>250.) {
305          _count_OS_SR1->fill(0.5);
306        }
307        // OS-SR2
308        if(eTmiss>220. && recon_jets.size()>=3 &&
309           recon_jets[0].perp()>80. &&
310           recon_jets[2].perp()>40.) {
311          _count_OS_SR2->fill(0.5);
312        }
313        // OS-SR3
314        if(eTmiss>100. && recon_jets.size()>=4 &&
315           recon_jets[0].perp()>100. &&
316           recon_jets[3].perp()>70.) {
317          _count_OS_SR3->fill(0.5);
318        }
319        // same flavour analysis
320        static const double beta   = 0.75;
321        static const double tau_e  = 0.96;
322        static const double tau_mu = 0.816;
323        double fs_weight = 1.0;
324        if (recon_leptons[0].abspid() == PID::ELECTRON && recon_leptons[1].abspid() == PID::ELECTRON) {
325          fs_weight /= beta*(1.-sqr(1.-tau_e));
326        } else if (recon_leptons[0].abspid() == PID::MUON && recon_leptons[1].abspid()==PID::MUON) {
327          fs_weight *= beta/(1.-sqr(1.-tau_mu));
328        } else {
329          fs_weight /= -(1.-(1.-tau_e)*(1.-tau_mu));
330        }
331        // FS-SR1
332        if(eTmiss>80.&& (mll<80.||mll>100.)) {
333          _count_FS_SR1->fill(0.5,fs_weight);
334        }
335        // FS-SR2
336        if(eTmiss>80.&&recon_jets.size()>=2) {
337          _count_FS_SR2->fill(0.5,fs_weight);
338        }
339        // FS-SR3
340        if(eTmiss>250.) {
341          _count_FS_SR3->fill(0.5,fs_weight);
342        }
343      }
344    }
345
346    //@}
347
348
349    void finalize() {
350
351      double norm = crossSection()/femtobarn*1.04/sumOfWeights();
352      // event counts
353      scale(_count_OS_SR1,norm);
354      scale(_count_OS_SR2,norm);
355      scale(_count_OS_SR3,norm);
356      scale(_count_SS_SR1,norm);
357      scale(_count_SS_SR2,norm);
358      scale(_count_FS_SR1,norm);
359      scale(_count_FS_SR2,norm);
360      scale(_count_FS_SR3,norm);
361      // histograms
362      scale(_hist_mll_SS_D     ,norm*20.);
363      scale(_hist_mll_SS_B     ,norm*20.);
364      scale(_hist_eTmiss_SS_D  ,norm*20.);
365      scale(_hist_eTmiss_SS_B  ,norm*20.);
366      scale(_hist_mll_SS_2Jet_D,norm*50.);
367      scale(_hist_mll_SS_2Jet_B,norm*50.);
368      scale(_hist_njet_SS_D    ,norm    );
369      scale(_hist_njet_SS_B    ,norm    );
370      scale(_hist_pT_j1_SS_D   ,norm*20.);
371      scale(_hist_pT_j1_SS_B   ,norm*20.);
372      scale(_hist_pT_j2_SS_D   ,norm*20.);
373      scale(_hist_pT_j2_SS_B   ,norm*20.);
374      scale(_hist_pT_l1_SS_D   ,norm*5. );
375      scale(_hist_pT_l1_SS_B   ,norm*5. );
376      scale(_hist_pT_l2_SS_D   ,norm*5. );
377      scale(_hist_pT_l2_SS_B   ,norm*5. );
378
379      scale(_hist_mll_OS_D        ,norm*10.);
380      scale(_hist_mll_OS_B        ,norm*10.);
381      scale(_hist_eTmiss_OS_D     ,norm*10.);
382      scale(_hist_eTmiss_OS_B     ,norm*10.);
383      scale(_hist_eTmiss_3Jet_OS_D,norm*10.);
384      scale(_hist_eTmiss_3Jet_OS_B,norm*10.);
385      scale(_hist_eTmiss_4Jet_OS_D,norm*10.);
386      scale(_hist_eTmiss_4Jet_OS_B,norm*10.);
387      scale(_hist_njet_OS_D       ,norm    );
388      scale(_hist_njet_OS_B       ,norm    );
389      scale(_hist_pT_j1_OS_D      ,norm*20.);
390      scale(_hist_pT_j1_OS_B      ,norm*20.);
391      scale(_hist_pT_j2_OS_D      ,norm*20.);
392      scale(_hist_pT_j2_OS_B      ,norm*20.);
393      scale(_hist_pT_l1_OS_D      ,norm*20.);
394      scale(_hist_pT_l1_OS_B      ,norm*20.);
395      scale(_hist_pT_l2_OS_D      ,norm*20.);
396      scale(_hist_pT_l2_OS_B      ,norm*20.);
397    }
398
399  private:
400
401    /// @name Histograms
402    //@{
403    Histo1DPtr _count_OS_SR1;
404    Histo1DPtr _count_OS_SR2;
405    Histo1DPtr _count_OS_SR3;
406    Histo1DPtr _count_SS_SR1;
407    Histo1DPtr _count_SS_SR2;
408    Histo1DPtr _count_FS_SR1;
409    Histo1DPtr _count_FS_SR2;
410    Histo1DPtr _count_FS_SR3;
411
412    Histo1DPtr _hist_mll_SS_D;
413    Histo1DPtr _hist_mll_SS_B;
414    Histo1DPtr _hist_eTmiss_SS_D;
415    Histo1DPtr _hist_eTmiss_SS_B;
416    Histo1DPtr _hist_mll_SS_2Jet_D;
417    Histo1DPtr _hist_mll_SS_2Jet_B;
418    Histo1DPtr _hist_njet_SS_D;
419    Histo1DPtr _hist_njet_SS_B;
420    Histo1DPtr _hist_pT_j1_SS_D;
421    Histo1DPtr _hist_pT_j1_SS_B;
422    Histo1DPtr _hist_pT_j2_SS_D;
423    Histo1DPtr _hist_pT_j2_SS_B;
424    Histo1DPtr _hist_pT_l1_SS_D;
425    Histo1DPtr _hist_pT_l1_SS_B;
426    Histo1DPtr _hist_pT_l2_SS_D;
427    Histo1DPtr _hist_pT_l2_SS_B;
428
429    Histo1DPtr _hist_mll_OS_D;
430    Histo1DPtr _hist_mll_OS_B;
431    Histo1DPtr _hist_eTmiss_OS_D;
432    Histo1DPtr _hist_eTmiss_OS_B;
433    Histo1DPtr _hist_eTmiss_3Jet_OS_D;
434    Histo1DPtr _hist_eTmiss_3Jet_OS_B;
435    Histo1DPtr _hist_eTmiss_4Jet_OS_D;
436    Histo1DPtr _hist_eTmiss_4Jet_OS_B;
437    Histo1DPtr _hist_njet_OS_D ;
438    Histo1DPtr _hist_njet_OS_B ;
439    Histo1DPtr _hist_pT_j1_OS_D;
440    Histo1DPtr _hist_pT_j1_OS_B;
441    Histo1DPtr _hist_pT_j2_OS_D;
442    Histo1DPtr _hist_pT_j2_OS_B;
443    Histo1DPtr _hist_pT_l1_OS_D;
444    Histo1DPtr _hist_pT_l1_OS_B;
445    Histo1DPtr _hist_pT_l2_OS_D;
446    Histo1DPtr _hist_pT_l2_OS_B;
447    //@}
448  };
449
450  // The hook for the plugin system
451  RIVET_DECLARE_PLUGIN(ATLAS_2012_I943401);
452
453}