rivet is hosted by Hepforge, IPPP Durham

Rivet analyses reference

ATLAS_2012_CONF_2012_153

4 or more lepton plus missing transverse energy SUSY search
Experiment: ATLAS (LHC)
Status: PRELIMINARY
Authors:
  • Peter Richardson
References:
  • ATLAS-CONF-2012-153
Beams: p+ p+
Beam energies: (4000.0, 4000.0) GeV
Run details:
  • BSM signal events at 8000 GeV.

Search for SUSY using events with 4 or more leptons in association with missing transverse energy in proton-proton collisions at a centre-of-mass energy of 8 TeV. The data sample has a total integrated luminosity of 13.0 fb$^{-1}$. There is no reference data and in addition to the control plots from the paper the number of events in the two signal regions, correctly normalized to an integrated luminosity 13.0 fb$^{-1}$, are calculated.

Source code: ATLAS_2012_CONF_2012_153.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/VetoedFinalState.hh"
  7#include "Rivet/Projections/IdentifiedFinalState.hh"
  8#include "Rivet/Projections/FastJets.hh"
  9#include "Rivet/Tools/RivetMT2.hh"
 10
 11namespace Rivet {
 12
 13
 14  class ATLAS_2012_CONF_2012_153 : public Analysis {
 15  public:
 16
 17    /// @name Constructors etc.
 18    //@{
 19
 20    /// Constructor
 21    ATLAS_2012_CONF_2012_153()
 22      : Analysis("ATLAS_2012_CONF_2012_153")
 23    {    }
 24
 25    //@}
 26
 27
 28
 29  public:
 30
 31    /// @name Analysis methods
 32    //@{
 33
 34    /// Book histograms and initialise projections before the run
 35    void init() {
 36
 37      // projection to find the electrons
 38      IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 10*GeV);
 39      elecs.acceptIdPair(PID::ELECTRON);
 40      declare(elecs, "elecs");
 41
 42
 43      // projection to find the muons
 44      IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
 45      muons.acceptIdPair(PID::MUON);
 46      declare(muons, "muons");
 47
 48      // for pTmiss
 49      declare(VisibleFinalState(Cuts::abseta < 4.9), "vfs");
 50
 51      VetoedFinalState vfs;
 52      vfs.addVetoPairId(PID::MUON);
 53
 54      /// Jet finder
 55      declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
 56
 57      // all tracks (to do deltaR with leptons)
 58      declare(ChargedFinalState(Cuts::abseta < 3.0), "cfs");
 59
 60      vector<double> edges_meff;
 61      edges_meff.push_back(   0);
 62      edges_meff.push_back( 150);
 63      edges_meff.push_back( 300);
 64      edges_meff.push_back( 500);
 65      edges_meff.push_back(1000);
 66      edges_meff.push_back(1500);
 67
 68      vector<double> edges_eT;
 69      edges_eT.push_back(0);
 70      edges_eT.push_back(50);
 71      edges_eT.push_back(150);
 72      edges_eT.push_back(300);
 73      edges_eT.push_back(500);
 74
 75      // Book histograms
 76      book(_hist_electrons ,"hist_electrons_before", 11, -0.5,10.5);
 77      book(_hist_muons     ,"hist_muons_before"    , 11, -0.5,10.5);
 78      book(_hist_leptons   ,"hist_leptons_before"  , 11, -0.5,10.5);
 79      book(_hist_4leptons  ,"hist_4leptons", 1, 0.,1.);
 80      book(_hist_veto      ,"hist_veto", 1, 0., 1.);
 81      book(_hist_etmiss    ,"hist_etmiss",edges_eT);
 82      book(_hist_meff      ,"hist_m_eff",edges_meff);
 83      book(_count_SR1      ,"count_SR1", 1, 0., 1.);
 84      book(_count_SR2      ,"count_SR2", 1, 0., 1.);
 85
 86    }
 87
 88
 89    /// Perform the per-event analysis
 90    void analyze(const Event& event) {
 91      const double weight = 1.0;
 92      // get the jet candidates
 93      Jets cand_jets;
 94      for (const Jet& jet : apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
 95        if (jet.abseta() < 2.5) cand_jets.push_back(jet);
 96      }
 97
 98      // candidate muons
 99      Particles cand_mu = apply<IdentifiedFinalState>(event, "muons").particlesByPt();
100
101      // candidate electrons
102      // Discard if two electrons are within R=0.1
103      Particles temp = apply<IdentifiedFinalState>(event, "elecs").particles(cmpMomByE);
104      vector<bool> vetoed(temp.size(),false);
105      Particles cand_e;
106      for (size_t ix = 0; ix < temp.size(); ++ix) {
107        if (vetoed[ix]) continue;
108        for (size_t iy = ix+1; iy < temp.size(); ++iy) {
109          if ( deltaR(temp[ix], temp[iy]) < 0.1 ) vetoed[iy] = true;
110        }
111        if (!vetoed[ix]) cand_e.push_back(temp[ix]);
112      }
113
114      // Sort by transverse momentum
115      sortByPt(cand_e);
116
117      // resolve jet/lepton ambiguity
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, jet) <= 0.2) {
123            away_from_e = false;
124            break;
125          }
126        }
127        if (away_from_e) recon_jets.push_back( jet );
128      }
129
130      // only keep electrons more than R=0.4 from jets
131      Particles cand2_e;
132      for (const Particle& e : cand_e) {
133        // at least 0.4 from any jets
134        bool away = true;
135        for ( const Jet& jet : recon_jets ) {
136          if ( deltaR(e, jet) < 0.4 ) {
137            away = false;
138            break;
139          }
140        }
141        // if isolated keep it
142        if ( away )
143          cand2_e.push_back( e );
144      }
145
146      // only keep muons more than R=0.4 from jets
147      Particles cand2_mu;
148      for(const Particle & mu : cand_mu ) {
149        bool away = true;
150        // at least 0.4 from any jets
151        for ( const Jet& jet : recon_jets ) {
152          if ( deltaR(mu, jet) < 0.4 ) {
153            away = false;
154            break;
155          }
156        }
157        if (away) cand2_mu.push_back( mu );
158      }
159
160      // electron and muon more than 0.1 apart
161      Particles cand3_e;
162      for ( const Particle & e : cand2_e ) {
163        bool away = true;
164        for( const Particle & mu : cand2_mu ) {
165          if( deltaR(e, mu) < 0.1) {
166            away = false;
167            break;
168          }
169        }
170        if (away) cand3_e.push_back(e);
171      }
172      Particles cand3_mu;
173      for( const Particle & mu : cand2_mu ) {
174        bool away = true;
175        for ( const Particle & e : cand2_e ) {
176          if( deltaR(e, mu) < 0.1) {
177            away = false;
178            break;
179          }
180        }
181        if (away) cand3_mu.push_back(mu);
182      }
183
184      // pTmiss
185      Particles vfs_particles =
186        apply<VisibleFinalState>(event, "vfs").particles();
187      FourMomentum pTmiss;
188      for ( const Particle & p : vfs_particles ) {
189        pTmiss -= p.momentum();
190      }
191      double eTmiss = pTmiss.pT();
192
193      // apply electron isolation
194      Particles chg_tracks =
195        apply<ChargedFinalState>(event, "cfs").particles();
196      Particles cand4_e;
197      for (const Particle& e : cand3_e) {
198        // charge isolation
199        double pTinCone = -e.pT();
200        for (const Particle& track : chg_tracks) {
201          if (track.pT() > 0.4*GeV && deltaR(e, track) <= 0.3 )
202            pTinCone += track.pT();
203        }
204        if (pTinCone/e.pT() > 0.16) continue;
205        // all particles isolation
206        pTinCone = -e.pT();
207        for (const Particle& p : vfs_particles) {
208          if (p.abspid() != PID::MUON && deltaR(e, p) <= 0.3 )
209            pTinCone += p.pT();
210        }
211        if (pTinCone/e.pT() < 0.18) cand4_e.push_back(e);
212      }
213
214      // apply muon isolation
215      Particles cand4_mu;
216      for ( const Particle & mu : cand3_mu ) {
217        double pTinCone = -mu.perp();
218        for ( const Particle & track : chg_tracks ) {
219          if (track.pT() > 1*GeV && deltaR(mu, track) <= 0.3)
220            pTinCone += track.pT();
221        }
222        if (pTinCone/mu.pT() < 0.12) cand4_mu.push_back(mu);
223      }
224
225      // same SOSF pairs m>12.
226      Particles recon_e;
227      for(const Particle& e : cand4_e) {
228        bool veto = false;
229        for(const Particle& e2 : cand4_e) {
230          if (e.pid()*e2.pid() < 0 && (e.momentum()+e2.momentum()).mass() < 12*GeV) {
231            veto = true;
232            break;
233          }
234        }
235        if (!veto) recon_e.push_back(e);
236      }
237      Particles recon_mu;
238      for(const Particle& mu : cand4_mu) {
239        bool veto = false;
240        for(const Particle& mu2 : cand4_mu) {
241          if (mu.pid()*mu2.pid() < 0 && (mu.momentum()+mu2.momentum()).mass() < 12*GeV) {
242            veto = true;
243            break;
244          }
245        }
246        if (!veto) recon_mu.push_back(mu);
247      }
248
249      // now only use recon_jets, recon_mu, recon_e
250      _hist_electrons->fill(recon_e.size(), weight);
251      _hist_muons->fill(recon_mu.size(), weight);
252      _hist_leptons->fill(recon_mu.size() + recon_e.size(), weight);
253      if (recon_mu.size() + recon_e.size() > 3) {
254        _hist_4leptons->fill(0.5, weight);
255      }
256
257      // reject events with less than 4 electrons and muons
258      if (recon_mu.size() + recon_e.size() < 4) {
259        MSG_DEBUG("To few charged leptons left after selection");
260        vetoEvent;
261      }
262
263
264      // or two lepton trigger
265      bool passDouble =
266        (recon_mu.size()>=2 && ( (recon_mu[1].pT()>14*GeV) ||
267                                 (recon_mu[0].pT()>18*GeV && recon_mu[1].perp() > 10*GeV) )) ||
268        (recon_e.size() >=2 && ( (recon_e [1].pT()>14*GeV) ||
269                                 (recon_e [0].pT()>25*GeV && recon_e [1].perp() > 10*GeV) )) ||
270        (!recon_e.empty() && !recon_mu.empty() &&
271         ( (recon_e[0].pT() > 14*GeV && recon_mu[0].pT() > 10*GeV)||
272           (recon_e[0].pT() > 10*GeV && recon_mu[0].pT() > 18*GeV) ));
273
274      // must pass a trigger
275      if (!passDouble ) {
276        MSG_DEBUG("Hardest lepton fails trigger");
277        _hist_veto->fill(0.5, weight);
278        vetoEvent;
279      }
280
281      // calculate meff
282      double meff = eTmiss;
283      for ( const Particle & e  : recon_e  ) meff += e.perp();
284      for ( const Particle & mu : recon_mu ) meff += mu.perp();
285      for ( const Jet & jet : recon_jets ) {
286        const double pT = jet.pT();
287        if (pT > 40*GeV) meff += pT;
288      }
289
290      // 2/3 leptons --> find 1 SFOS pair in range and veto event
291      // 4+  leptons --> find 2 SFOS pairs and in range veto event
292      for (size_t ix = 0; ix < recon_e.size(); ++ix) {
293        for (size_t iy = ix+1; iy < recon_e.size(); ++iy) {
294          if (recon_e[ix].pid()*recon_e[iy].pid() > 0) continue;
295          const FourMomentum ppair = recon_e[ix].momentum() + recon_e[iy].momentum();
296          if (inRange(ppair.mass(), 81.2*GeV, 101.2*GeV)) vetoEvent;
297
298          // check triplets with electron
299          for (size_t iz = 0; iz < recon_e.size(); ++iz) {
300            if (iz == ix || iz == iy) continue;
301            if (inRange((ppair+recon_e[iz].momentum()).mass(), 81.2*GeV, 101.2*GeV)) vetoEvent;
302          }
303
304          // check triplets with muon
305          for (size_t iz = 0; iz < recon_mu.size(); ++iz) {
306            if (inRange((ppair+recon_mu[iz].momentum()).mass(), 81.2*GeV, 101.2*GeV)) vetoEvent;
307          }
308
309          // check quadruplets with electrons
310          for (size_t iz = 0; iz < recon_e.size(); ++iz) {
311            for (size_t iw = iz+1; iw < recon_e.size(); ++iw) {
312              if (iz==ix || iz==iy || iw==ix || iw==iy) continue;
313              if (recon_e[iz].pid()*recon_e[iw].pid() > 0) continue;
314              if (inRange((ppair+recon_e[iz].momentum()+recon_e[iw].momentum()).mass(), 81.2*GeV, 101.2*GeV)) vetoEvent;
315            }
316          }
317          // check quadruplets with muons
318          for (size_t iz = 0; iz < recon_mu.size(); ++iz) {
319            for (size_t iw = iz+1; iw < recon_mu.size(); ++iw) {
320              if (recon_mu[iz].pid()*recon_mu[iw].pid() > 0) continue;
321              if (inRange((ppair+recon_mu[iz].momentum()+recon_mu[iw].momentum()).mass(), 81.2*GeV, 101.2*GeV)) vetoEvent;
322            }
323          }
324        }
325      }
326
327      // Muon pairs
328      for (size_t ix = 0; ix < recon_mu.size(); ++ix) {
329        for (size_t iy = ix+1; iy < recon_mu.size(); ++iy) {
330          if (recon_mu[ix].pid()*recon_mu[iy].pid()>0) continue;
331          const FourMomentum ppair = recon_mu[ix].momentum()+recon_mu[iy].momentum();
332          if (inRange(ppair.mass(), 81.2*GeV, 101.2*GeV)) vetoEvent;
333
334          // check triplets with muon
335          for (size_t iz = 0; iz < recon_mu.size(); ++iz) {
336            if (iz==ix || iz==iy) continue;
337            if (inRange((ppair+recon_mu[iz].momentum()).mass(), 81.2*GeV, 101.2*GeV)) vetoEvent;
338          }
339
340          // check triplets with electron
341          for (size_t iz = 0; iz < recon_e.size(); ++iz) {
342            if (inRange((ppair+recon_e[iz].momentum()).mass(), 81.2*GeV, 101.2*GeV)) vetoEvent;
343          }
344
345          // check muon quadruplets
346          for (size_t iz = 0; iz < recon_mu.size(); ++iz) {
347            for (size_t iw = iz+1; iy < recon_mu.size(); ++iy) {
348              if (iz==ix || iz==iy || iw==ix || iw==iy) continue;
349              if (recon_mu[iz].pid()*recon_mu[iw].pid() > 0) continue;
350              if (inRange((ppair+recon_mu[iz].momentum()+recon_mu[iw].momentum()).mass(), 81.2*GeV, 101.2*GeV)) vetoEvent;
351            }
352          }
353        }
354      }
355
356      // Make the control plots
357      _hist_etmiss->fill(eTmiss,weight);
358      _hist_meff  ->fill(meff  ,weight);
359      // Finally the counts
360      if (eTmiss > 50*GeV) _count_SR1->fill(0.5,weight);
361      if (meff  >0*GeV) _count_SR2->fill(0.5,weight);
362
363    }
364
365    //@}
366
367    void finalize() {
368      double norm = crossSection()/femtobarn*13./sumOfWeights();
369      scale(_hist_etmiss,norm*20.);
370      scale(_hist_meff  ,norm*20.);
371      scale(_count_SR1,norm);
372      scale(_count_SR2,norm);
373    }
374
375
376  private:
377
378    /// @name Histograms
379    //@{
380    Histo1DPtr _hist_electrons;
381    Histo1DPtr _hist_muons;
382    Histo1DPtr _hist_leptons;
383    Histo1DPtr _hist_4leptons;
384    Histo1DPtr _hist_veto;
385    Histo1DPtr _hist_etmiss;
386    Histo1DPtr _hist_meff;
387    Histo1DPtr _count_SR1;
388    Histo1DPtr _count_SR2;
389    //@}
390
391  };
392
393  // The hook for the plugin system
394  RIVET_DECLARE_PLUGIN(ATLAS_2012_CONF_2012_153);
395
396}