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
 14  /// @author Peter Richardson
 15  class ATLAS_2012_I1125961 : public Analysis {
 16  public:
 17
 18    /// Constructor
 19    ATLAS_2012_I1125961()
 20      : Analysis("ATLAS_2012_I1125961")
 21    {    }
 22
 23
 24    /// @name Analysis methods
 25    //@{
 26
 27    /// Book histograms and initialise projections before the run
 28    void init() {
 29
 30      // Projection to find the electrons
 31      IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 20*GeV);
 32      elecs.acceptIdPair(PID::ELECTRON);
 33      declare(elecs, "elecs");
 34
 35      // Projection to find the muons
 36      IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
 37      muons.acceptIdPair(PID::MUON);
 38      declare(muons, "muons");
 39
 40      // Jet finder
 41      VetoedFinalState vfs;
 42      vfs.addVetoPairId(PID::MUON);
 43      declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
 44
 45      // All tracks (to do deltaR with leptons)
 46      declare(ChargedFinalState(Cuts::abseta < 3.0), "cfs");
 47
 48      // Used for pTmiss (N.B. the real 'vfs' extends beyond 4.5 to |eta| = 4.9)
 49      declare(VisibleFinalState(Cuts::abseta < 4.5), "vfs");
 50
 51      // Book histograms
 52      book(_count_A_tight   ,"count_A_tight"   , 1, 0., 1.);
 53      book(_count_A_medium  ,"count_A_medium"  , 1, 0., 1.);
 54      book(_count_Ap_medium ,"count_Ap_medium" , 1, 0., 1.);
 55      book(_count_B_tight   ,"count_B_tight"   , 1, 0., 1.);
 56      book(_count_C_tight   ,"count_C_tight"   , 1, 0., 1.);
 57      book(_count_C_medium  ,"count_C_medium"  , 1, 0., 1.);
 58      book(_count_C_loose   ,"count_C_loose"   , 1, 0., 1.);
 59      book(_count_D_tight   ,"count_D_tight"   , 1, 0., 1.);
 60      book(_count_E_tight   ,"count_E_tight"   , 1, 0., 1.);
 61      book(_count_E_medium  ,"count_E_medium"  , 1, 0., 1.);
 62      book(_count_E_loose   ,"count_E_loose"   , 1, 0., 1.);
 63
 64      book(_hist_meff_A  ,"hist_m_eff_A" , 30, 0., 3000.);
 65      book(_hist_meff_Ap ,"hist_m_eff_Ap", 30, 0., 3000.);
 66      book(_hist_meff_B  ,"hist_m_eff_B" , 30, 0., 3000.);
 67      book(_hist_meff_C  ,"hist_m_eff_C" , 30, 0., 3000.);
 68      book(_hist_meff_D  ,"hist_m_eff_D" , 30, 0., 3000.);
 69      book(_hist_meff_E  ,"hist_m_eff_E" , 30, 0., 3000.);
 70
 71    }
 72
 73
 74    /// Perform the per-event analysis
 75    void analyze(const Event& event) {
 76      const double weight = 1.0;
 77
 78      Jets cand_jets;
 79      const Jets jets = apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV);
 80      for (const Jet& jet : jets) {
 81        if ( fabs( jet.eta() ) < 4.9 ) {
 82          cand_jets.push_back(jet);
 83        }
 84      }
 85
 86      const Particles cand_e  = apply<IdentifiedFinalState>(event, "elecs").particlesByPt();
 87
 88      // Muon isolation not mentioned in hep-exp 1109.6572 but assumed to still be applicable
 89      Particles cand_mu;
 90      const Particles chg_tracks = apply<ChargedFinalState>(event, "cfs").particles();
 91      const Particles muons = apply<IdentifiedFinalState>(event, "muons").particlesByPt();
 92      for (const Particle& mu : muons) {
 93        double pTinCone = -mu.pT();
 94        for (const Particle& track : chg_tracks) {
 95          if ( deltaR(mu.momentum(),track.momentum()) <= 0.2 ) {
 96            pTinCone += track.pT();
 97          }
 98        }
 99        if ( pTinCone < 1.8*GeV ) cand_mu.push_back(mu);
100      }
101
102      // Resolve jet-lepton overlap for jets with |eta| < 2.8
103      Jets recon_jets;
104      for ( const Jet& jet : cand_jets ) {
105        if ( fabs( jet.eta() ) >= 2.8 ) continue;
106        bool away_from_e = true;
107        for ( const Particle & e : cand_e ) {
108          if ( deltaR(e.momentum(),jet.momentum()) <= 0.2 ) {
109            away_from_e = false;
110            break;
111          }
112        }
113        if ( away_from_e ) recon_jets.push_back( jet );
114      }
115
116      Particles recon_e, recon_mu;
117
118      for ( const Particle & e : cand_e ) {
119        bool away = true;
120        for ( const Jet& jet : recon_jets ) {
121          if ( deltaR(e.momentum(),jet.momentum()) < 0.4 ) {
122            away = false;
123            break;
124          }
125        }
126        if ( away ) recon_e.push_back( e );
127      }
128
129      for ( const Particle & mu : cand_mu ) {
130        bool away = true;
131        for ( const Jet& jet : recon_jets ) {
132          if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
133            away = false;
134            break;
135          }
136        }
137        if ( away ) recon_mu.push_back( mu );
138      }
139
140      // pTmiss
141      // Based on all candidate electrons, muons and jets, plus everything else with |eta| < 4.5
142      // i.e. everything in our projection "vfs" plus the jets with |eta| > 4.5
143      Particles vfs_particles = apply<VisibleFinalState>(event, "vfs").particles();
144      FourMomentum pTmiss;
145      for ( const Particle & p : vfs_particles ) {
146        pTmiss -= p.momentum();
147      }
148      for ( const Jet& jet : cand_jets ) {
149        if ( fabs( jet.eta() ) > 4.5 ) pTmiss -= jet.momentum();
150      }
151      double eTmiss = pTmiss.pT();
152
153      // no electron pT> 20 or muons pT>10
154      if ( !recon_mu.empty() || !recon_e.empty() ) {
155        MSG_DEBUG("Charged leptons left after selection");
156        vetoEvent;
157      }
158
159      if ( eTmiss <= 160 * GeV ) {
160        MSG_DEBUG("Not enough eTmiss: " << eTmiss << " < 130");
161        vetoEvent;
162      }
163
164      if ( recon_jets.size()<2 ||
165           recon_jets[0].pT() <= 130.0 * GeV ||
166           recon_jets[0].pT() <=  60.0 * GeV ) {
167        MSG_DEBUG("No hard leading jet in " << recon_jets.size() << " jets");
168        vetoEvent;
169      }
170
171      // ==================== observables ====================
172
173      int Njets = 0;
174      double min_dPhi_All = 999.999;
175      double min_dPhi_2   = 999.999;
176      double min_dPhi_3   = 999.999;
177      double pTmiss_phi = pTmiss.phi();
178      for ( const Jet& jet : recon_jets ) {
179        if ( jet.pT() < 40 * GeV ) continue;
180        if ( Njets < 2 ) {
181          min_dPhi_2 = min( min_dPhi_2, deltaPhi( pTmiss_phi, jet.phi() ) );
182        }
183        if( Njets < 3) {
184          min_dPhi_3 = min( min_dPhi_3, deltaPhi( pTmiss_phi, jet.phi() ) );
185        }
186        min_dPhi_All = min( min_dPhi_All, deltaPhi( pTmiss_phi, jet.phi() ) );
187        ++Njets;
188      }
189
190      // inclusive meff
191      double m_eff_inc =  eTmiss;
192      for ( const Jet& jet : recon_jets ) {
193        double perp =  jet.pT();
194        if(perp>40.) m_eff_inc += perp;
195      }
196
197      // region A
198      double m_eff_Nj = eTmiss + recon_jets[0].pT() + recon_jets[1].pT();
199      if( min_dPhi_2 > 0.4 && eTmiss/m_eff_Nj > 0.3 ) {
200        _hist_meff_A->fill(m_eff_inc,weight);
201        if(m_eff_inc>1900.) _count_A_tight ->fill(0.5,weight);
202        if(m_eff_inc>1400.) _count_A_medium->fill(0.5,weight);
203      }
204
205      // region A'
206      if( min_dPhi_2 > 0.4 && eTmiss/m_eff_Nj > 0.4 ) {
207        _hist_meff_Ap->fill(m_eff_inc,weight);
208        if(m_eff_inc>1200.) _count_Ap_medium->fill(0.5,weight);
209      }
210
211      // for rest of regions 3 jets pT> 60 needed
212      if(recon_jets.size()<3 || recon_jets[2].perp()<60.)
213        vetoEvent;
214
215      // region B
216      m_eff_Nj +=  recon_jets[2].perp();
217      if( min_dPhi_3 > 0.4 && eTmiss/m_eff_Nj > 0.25 ) {
218        _hist_meff_B->fill(m_eff_inc,weight);
219        if(m_eff_inc>1900.) _count_B_tight ->fill(0.5,weight);
220      }
221
222      // for rest of regions 4 jets pT> 60 needed
223      if(recon_jets.size()<4 || recon_jets[3].perp()<60.)
224        vetoEvent;
225
226      // region C
227      m_eff_Nj +=  recon_jets[3].perp();
228      if( min_dPhi_3 > 0.4 && min_dPhi_All > 0.2 && eTmiss/m_eff_Nj > 0.25 ) {
229        _hist_meff_C->fill(m_eff_inc,weight);
230        if(m_eff_inc>1500.) _count_C_tight ->fill(0.5,weight);
231        if(m_eff_inc>1200.) _count_C_medium->fill(0.5,weight);
232        if(m_eff_inc> 900.) _count_C_loose ->fill(0.5,weight);
233      }
234
235      // for rest of regions 5 jets pT> 40 needed
236      if(recon_jets.size()<5 || recon_jets[4].perp()<40.)
237        vetoEvent;
238
239      // region D
240      m_eff_Nj +=  recon_jets[4].perp();
241      if( min_dPhi_3 > 0.4 && min_dPhi_All > 0.2 && eTmiss/m_eff_Nj > 0.2 ) {
242        _hist_meff_D->fill(m_eff_inc,weight);
243        if(m_eff_inc>1500.) _count_D_tight ->fill(0.5,weight);
244      }
245
246      // for rest of regions 6 jets pT> 40 needed
247      if(recon_jets.size()<6 || recon_jets[5].perp()<40.)
248        vetoEvent;
249
250      // region E
251      m_eff_Nj +=  recon_jets[5].perp();
252      if( min_dPhi_3 > 0.4 && min_dPhi_All > 0.2 && eTmiss/m_eff_Nj > 0.15 ) {
253        _hist_meff_E->fill(m_eff_inc,weight);
254        if(m_eff_inc>1400.) _count_E_tight ->fill(0.5,weight);
255        if(m_eff_inc>1200.) _count_E_medium->fill(0.5,weight);
256        if(m_eff_inc> 900.) _count_E_loose ->fill(0.5,weight);
257      }
258    }
259
260
261    void finalize() {
262
263      double norm = crossSection()/femtobarn*4.7/sumOfWeights();
264      // these are number of events at 4.7fb^-1 per 100 GeV
265      scale( _hist_meff_A , 100. * norm );
266      scale( _hist_meff_Ap, 100. * norm );
267      scale( _hist_meff_B , 100. * norm );
268      scale( _hist_meff_C , 100. * norm );
269      scale( _hist_meff_D , 100. * norm );
270      scale( _hist_meff_E , 100. * norm );
271      // these are number of events at 4.7fb^-1
272      scale(_count_A_tight  ,norm);
273      scale(_count_A_medium ,norm);
274      scale(_count_Ap_medium,norm);
275      scale(_count_B_tight  ,norm);
276      scale(_count_C_tight  ,norm);
277      scale(_count_C_medium ,norm);
278      scale(_count_C_loose  ,norm);
279      scale(_count_D_tight  ,norm);
280      scale(_count_E_tight  ,norm);
281      scale(_count_E_medium ,norm);
282      scale(_count_E_loose  ,norm);
283    }
284
285    //@}
286
287
288  private:
289
290    Histo1DPtr _count_A_tight;
291    Histo1DPtr _count_A_medium;
292    Histo1DPtr _count_Ap_medium;
293    Histo1DPtr _count_B_tight;
294    Histo1DPtr _count_C_tight;
295    Histo1DPtr _count_C_medium;
296    Histo1DPtr _count_C_loose;
297    Histo1DPtr _count_D_tight;
298    Histo1DPtr _count_E_tight;
299    Histo1DPtr _count_E_medium;
300    Histo1DPtr _count_E_loose;
301
302    Histo1DPtr _hist_meff_A ;
303    Histo1DPtr _hist_meff_Ap;
304    Histo1DPtr _hist_meff_B ;
305    Histo1DPtr _hist_meff_C ;
306    Histo1DPtr _hist_meff_D ;
307    Histo1DPtr _hist_meff_E ;
308
309  };
310
311
312  // This global object acts as a hook for the plugin system
313  RIVET_DECLARE_PLUGIN(ATLAS_2012_I1125961);
314
315}