rivet is hosted by Hepforge, IPPP Durham

Rivet analyses reference

ATLAS_2012_I1095236

$b$-jets search for supersymmetry with 0- and 1-leptons
Experiment: ATLAS (LHC)
Inspire ID: 1095236
Status: UNVALIDATED
Authors:
  • Peter Richardson
References: Beams: p+ p+
Beam energies: (3500.0, 3500.0) GeV
Run details:
  • BSM signal events at 7000 GeV.

Search for supersymmmetric particles by ATLAS at 7 TeV in events with b-jets, large missing energy, and zero or one leptons. Event counts in six zero lepton and two one lepton signal regions are implemented as one-bin histograms. Histograms for missing transverse energy, and effective mass are also implemented for some signal regions.

Source code: ATLAS_2012_I1095236.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
 10namespace Rivet {
 11
 12
 13  /// @author Peter Richardson
 14  class ATLAS_2012_I1095236 : public Analysis {
 15  public:
 16
 17    /// Constructor
 18    ATLAS_2012_I1095236()
 19      : Analysis("ATLAS_2012_I1095236")
 20    {    }
 21
 22
 23    /// @name Analysis methods
 24    //@{
 25
 26    /// Book histograms and initialise projections before the run
 27    void init() {
 28
 29      // Projection to find the electrons
 30      IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 20*GeV);
 31      elecs.acceptIdPair(PID::ELECTRON);
 32      declare(elecs, "elecs");
 33
 34      // Projection to find the muons
 35      IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
 36      muons.acceptIdPair(PID::MUON);
 37      declare(muons, "muons");
 38
 39      // Jet finder
 40      VetoedFinalState vfs;
 41      vfs.addVetoPairId(PID::MUON);
 42      declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
 43
 44      // All tracks (to do deltaR with leptons)
 45      declare(ChargedFinalState(Cuts::abseta < 3.0),"cfs");
 46
 47      // Used for pTmiss
 48      declare(VisibleFinalState((Cuts::etaIn(-4.9,4.9))),"vfs");
 49
 50      // Book histograms
 51      book(_count_SR0_A1 ,"count_SR0_A1", 1, 0., 1.);
 52      book(_count_SR0_B1 ,"count_SR0_B1", 1, 0., 1.);
 53      book(_count_SR0_C1 ,"count_SR0_C1", 1, 0., 1.);
 54      book(_count_SR0_A2 ,"count_SR0_A2", 1, 0., 1.);
 55      book(_count_SR0_B2 ,"count_SR0_B2", 1, 0., 1.);
 56      book(_count_SR0_C2 ,"count_SR0_C2", 1, 0., 1.);
 57      book(_count_SR1_D  ,"count_SR1_D" , 1, 0., 1.);
 58      book(_count_SR1_E  ,"count_SR1_E" , 1, 0., 1.);
 59
 60      book(_hist_meff_SR0_A1   ,"hist_m_eff_SR0_A1", 14, 400., 1800.);
 61      book(_hist_meff_SR0_A2   ,"hist_m_eff_SR0_A2", 14, 400., 1800.);
 62      book(_hist_meff_SR1_D_e  ,"hist_meff_SR1_D_e" , 16, 600., 2200.);
 63      book(_hist_meff_SR1_D_mu ,"hist_meff_SR1_D_mu", 16, 600., 2200.);
 64
 65      book(_hist_met_SR0_A1    ,"hist_met_SR0_A1", 14, 0., 700.);
 66      book(_hist_met_SR0_A2    ,"hist_met_SR0_A2", 14, 0., 700.);
 67      book(_hist_met_SR0_D_e   ,"hist_met_SR1_D_e" , 15, 0., 600.);
 68      book(_hist_met_SR0_D_mu  ,"hist_met_SR1_D_mu", 15, 0., 600.);
 69
 70    }
 71
 72
 73    /// Perform the per-event analysis
 74    void analyze(const Event& event) {
 75      const double weight = 1.0;
 76
 77      Jets cand_jets;
 78      const Jets jets = apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV);
 79      for (const Jet& jet : jets) {
 80        if ( fabs( jet.eta() ) < 2.8 ) {
 81          cand_jets.push_back(jet);
 82        }
 83      }
 84
 85      const Particles cand_e  = apply<IdentifiedFinalState>(event, "elecs").particlesByPt();
 86
 87      const Particles cand_mu = apply<IdentifiedFinalState>(event, "muons").particlesByPt();
 88      // Resolve jet-lepton overlap for jets with |eta| < 2.8
 89      Jets recon_jets;
 90      for ( const Jet& jet : cand_jets ) {
 91        if ( fabs( jet.eta() ) >= 2.8 ) continue;
 92        bool away_from_e = true;
 93        for ( const Particle & e : cand_e ) {
 94          if ( deltaR(e.momentum(),jet.momentum()) <= 0.2 ) {
 95            away_from_e = false;
 96            break;
 97          }
 98        }
 99        if ( away_from_e ) recon_jets.push_back( jet );
100      }
101
102      // get the loose leptons used to define the 0 lepton channel
103      Particles loose_e, loose_mu;
104      for ( const Particle & e  : cand_e ) {
105        bool away = true;
106        for ( const Jet& jet  : recon_jets ) {
107          if ( deltaR(e.momentum(),jet.momentum()) < 0.4 ) {
108            away = false;
109            break;
110          }
111        }
112        if ( away ) loose_e.push_back( e );
113      }
114      for ( const Particle & mu  : cand_mu ) {
115        bool away = true;
116        for ( const Jet& jet  : recon_jets ) {
117          if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
118            away = false;
119            break;
120          }
121        }
122        if ( away ) loose_mu.push_back( mu );
123      }
124      // tight leptons for the 1-lepton channel
125      Particles tight_mu;
126      Particles chg_tracks =
127        apply<ChargedFinalState>(event, "cfs").particles();
128      for ( const Particle & mu  : loose_mu) {
129        if(mu.perp()<20.) continue;
130        double pTinCone = -mu.pT();
131        for ( const Particle & track  : chg_tracks ) {
132          if ( deltaR(mu.momentum(),track.momentum()) <= 0.2 )
133            pTinCone += track.pT();
134        }
135        if ( pTinCone < 1.8*GeV )
136          tight_mu.push_back(mu);
137      }
138      Particles tight_e;
139      for ( const Particle & e  : loose_e ) {
140        if(e.perp()<25.) continue;
141        double pTinCone = -e.perp();
142        for ( const Particle & track  : chg_tracks ) {
143          if ( deltaR(e.momentum(),track.momentum()) <= 0.2 )
144            pTinCone += track.pT();
145        }
146        if (pTinCone/e.perp()<0.1) {
147          tight_e.push_back(e);
148        }
149      }
150
151      // pTmiss
152      Particles vfs_particles =
153        apply<VisibleFinalState>(event, "vfs").particles();
154      FourMomentum pTmiss;
155      for ( const Particle & p : vfs_particles ) {
156        pTmiss -= p.momentum();
157      }
158      double eTmiss = pTmiss.pT();
159
160      // get the number of b-tagged jets
161      unsigned int ntagged=0;
162      for (const Jet & jet : recon_jets ) {
163        if(jet.perp()>50. && abs(jet.eta())<2.5 &&
164           jet.bTagged() && rand()/static_cast<double>(RAND_MAX)<=0.60)
165          ++ntagged;
166      }
167
168      // ATLAS calo problem
169      if(rand()/static_cast<double>(RAND_MAX)<=0.42) {
170        for ( const Jet & jet : recon_jets ) {
171          double eta = jet.rapidity();
172          double phi = jet.azimuthalAngle(MINUSPI_PLUSPI);
173          if(jet.perp()>50 && eta>-0.1&&eta<1.5&&phi>-0.9&&phi<-0.5)
174            vetoEvent;
175        }
176      }
177
178      // at least 1 b tag
179      if(ntagged==0) vetoEvent;
180
181      // minumum Et miss
182      if(eTmiss<80.) vetoEvent;
183
184      // at least 3 jets pT > 50
185      if(recon_jets.size()<3 || recon_jets[2].perp()<50.)
186        vetoEvent;
187
188      // m_eff
189      double m_eff =  eTmiss;
190      for(unsigned int ix=0;ix<3;++ix)
191        m_eff += recon_jets[ix].perp();
192
193      // delta Phi
194      double min_dPhi = 999.999;
195      double pTmiss_phi = pTmiss.phi();
196      for(unsigned int ix=0;ix<3;++ix) {
197        min_dPhi = min( min_dPhi, deltaPhi( pTmiss_phi, recon_jets[ix].phi() ) );
198      }
199
200      // 0-lepton channels
201      if(loose_e.empty() && loose_mu.empty() &&
202         recon_jets[0].perp()>130.  && eTmiss>130. &&
203         eTmiss/m_eff>0.25 && min_dPhi>0.4) {
204        // jet charge cut
205        bool jetCharge = true;
206        for(unsigned int ix=0;ix<3;++ix) {
207          if(fabs(recon_jets[ix].eta())>2.) continue;
208          double trackpT=0;
209          for(const Particle & p : recon_jets[ix].particles()) {
210            if(PID::charge3(p.pid())==0) continue;
211            trackpT += p.perp();
212          }
213          if(trackpT/recon_jets[ix].perp()<0.05)
214            jetCharge = false;
215        }
216        if(jetCharge) {
217          // SR0-A region
218          if(m_eff>500.) {
219            _count_SR0_A1->fill(0.5,weight);
220            _hist_meff_SR0_A1->fill(m_eff,weight);
221            _hist_met_SR0_A1 ->fill(eTmiss,weight);
222            if(ntagged>=2) {
223              _count_SR0_A2->fill(0.5,weight);
224              _hist_meff_SR0_A2->fill(m_eff,weight);
225              _hist_met_SR0_A2 ->fill(eTmiss,weight);
226            }
227          }
228          // SR0-B
229          if(m_eff>700.) {
230            _count_SR0_B1->fill(0.5,weight);
231            if(ntagged>=2) _count_SR0_B2->fill(0.5,weight);
232          }
233          // SR0-C
234          if(m_eff>900.) {
235            _count_SR0_C1->fill(0.5,weight);
236            if(ntagged>=2) _count_SR0_C2->fill(0.5,weight);
237          }
238        }
239      }
240
241      // 1-lepton channels
242      if(tight_e.size() + tight_mu.size() == 1 &&
243         recon_jets.size()>=4 && recon_jets[3].perp()>50.&&
244         recon_jets[0].perp()>60.) {
245        Particle lepton = tight_e.empty() ? tight_mu[0] : tight_e[0];
246        m_eff += lepton.perp() + recon_jets[3].perp();
247        // transverse mass cut
248        double mT = 2.*(lepton.perp()*eTmiss-
249                        lepton.px()*pTmiss.px()-
250                        lepton.py()*pTmiss.py());
251        mT = sqrt(mT);
252        if(mT>100.&&m_eff>700.) {
253          // D region
254          _count_SR1_D->fill(0.5,weight);
255          if(lepton.abspid()==PID::ELECTRON) {
256            _hist_meff_SR1_D_e->fill(m_eff,weight);
257            _hist_met_SR0_D_e->fill(eTmiss,weight);
258          }
259          else {
260            _hist_meff_SR1_D_mu->fill(m_eff,weight);
261            _hist_met_SR0_D_mu->fill(eTmiss,weight);
262          }
263          // E region
264          if(eTmiss>200.) {
265            _count_SR1_E->fill(0.5,weight);
266          }
267        }
268      }
269    }
270
271
272    void finalize() {
273
274      double norm = crossSection()/femtobarn*2.05/sumOfWeights();
275      // these are number of events at 2.05fb^-1 per 100 GeV
276      scale( _hist_meff_SR0_A1   , 100. * norm );
277      scale( _hist_meff_SR0_A2   , 100. * norm );
278      scale( _hist_meff_SR1_D_e  , 100. * norm );
279      scale( _hist_meff_SR1_D_mu , 100. * norm );
280      // these are number of events at 2.05fb^-1 per 50 GeV
281      scale( _hist_met_SR0_A1, 50. * norm );
282      scale( _hist_met_SR0_A2, 40. * norm );
283      // these are number of events at 2.05fb^-1 per 40 GeV
284      scale( _hist_met_SR0_D_e , 40. * norm );
285      scale( _hist_met_SR0_D_mu, 40. * norm );
286      // these are number of events at 2.05fb^-1
287      scale(_count_SR0_A1,norm);
288      scale(_count_SR0_B1,norm);
289      scale(_count_SR0_C1,norm);
290      scale(_count_SR0_A2,norm);
291      scale(_count_SR0_B2,norm);
292      scale(_count_SR0_C2,norm);
293      scale(_count_SR1_D ,norm);
294      scale(_count_SR1_E ,norm);
295    }
296
297    //@}
298
299
300  private:
301
302    Histo1DPtr _count_SR0_A1;
303    Histo1DPtr _count_SR0_B1;
304    Histo1DPtr _count_SR0_C1;
305    Histo1DPtr _count_SR0_A2;
306    Histo1DPtr _count_SR0_B2;
307    Histo1DPtr _count_SR0_C2;
308    Histo1DPtr _count_SR1_D;
309    Histo1DPtr _count_SR1_E;
310
311    Histo1DPtr _hist_meff_SR0_A1;
312    Histo1DPtr _hist_meff_SR0_A2;
313    Histo1DPtr _hist_meff_SR1_D_e;
314    Histo1DPtr _hist_meff_SR1_D_mu;
315    Histo1DPtr _hist_met_SR0_A1;
316    Histo1DPtr _hist_met_SR0_A2;
317    Histo1DPtr _hist_met_SR0_D_e;
318    Histo1DPtr _hist_met_SR0_D_mu;
319
320  };
321
322
323  // This global object acts as a hook for the plugin system
324  RIVET_DECLARE_PLUGIN(ATLAS_2012_I1095236);
325
326}