rivet is hosted by Hepforge, IPPP Durham

Rivet analyses reference

CDF_1994_S2952106

CDF Run I color coherence analysis.
Experiment: CDF (Tevatron Run 1)
Inspire ID: 374155
Status: VALIDATED
Authors:
  • Lars Sonnenschein
  • Andy Buckley
References: Beams: p- p+
Beam energies: (900.0, 900.0) GeV
Run details:
  • QCD events at $\sqrt{s} = 1800$ GeV. Leading jet $p_\perp_\text{min} = 100$ GeV.

CDF Run I color coherence analysis. Events with $\ge 3$ jets are selected and Et distributions of the three highest-pT jets are obtained. The plotted quantities are the $\Delta{R}$ between the 2nd and 3rd leading jets in the pT and pseudorapidity of the 3rd jet, and $\alpha = \mathrm{d}{\eta}/\mathrm{d}{\phi}$, where $\mathrm{d}{\eta}$ is the pseudorapidity difference between the 2nd and 3rd jets and $\mathrm{d}{\phi}$ is their azimuthal angle difference. Since the data has not been detector-corrected, a bin by bin correction is applied, based on the distributions with ideal and CDF simulation as given in the publication.

Source code: CDF_1994_S2952106.cc
  1// -*- C++ -*-
  2#include "Rivet/Analysis.hh"
  3#include "Rivet/Projections/FastJets.hh"
  4#include "Rivet/Projections/VetoedFinalState.hh"
  5#include "Rivet/Projections/VisibleFinalState.hh"
  6#include "Rivet/Projections/MissingMomentum.hh"
  7
  8namespace Rivet {
  9
 10
 11  /// @brief CDF Run I color coherence analysis
 12  ///
 13  /// @author Andy Buckley
 14  /// @author Lars Sonnenschein
 15  class CDF_1994_S2952106 : public Analysis {
 16  public:
 17
 18    RIVET_DEFAULT_ANALYSIS_CTOR(CDF_1994_S2952106);
 19
 20
 21    /// @name Analysis methods
 22    //@{
 23
 24    void init() {
 25      const FinalState fs(Cuts::abseta < 4.2);
 26      declare(fs, "FS");
 27      declare(FastJets(fs, FastJets::CDFJETCLU, 0.7), "Jets");
 28
 29      // Zero passed-cuts event weight counters
 30      book(_sumw, "sumW");
 31
 32      // Output histograms
 33      book(_histJet1Et  ,1,1,1);
 34      book(_histJet2Et  ,2,1,1);
 35      book(_histJet3eta, 3,1,1);
 36      book(_histR23    , 4,1,1);
 37      book(_histAlpha  , 5,1,1);
 38
 39      // Temporary histos: these are the ones we actually fill for the plots which require correction
 40      book(_tmphistJet3eta, "TMP/Jet3eta", refData(3,1,1));
 41      book(_tmphistR23, "TMP/R23",     refData(4,1,1));
 42      book(_tmphistAlpha, "TMP/Alpha",   refData(5,1,1));
 43    }
 44
 45
 46    // Do the analysis
 47    void analyze(const Event & event) {
 48      const Jets jets = apply<FastJets>(event, "Jets").jets(cmpMomByEt);
 49      MSG_DEBUG("Jet multiplicity before any cuts = " << jets.size());
 50
 51      // ETs only from jets:
 52      double et_sinphi_sum = 0;
 53      double et_cosphi_sum = 0;
 54      double et_sum = 0;
 55      for (size_t i = 0; i< jets.size(); ++i) {
 56        et_sinphi_sum += jets[i].Et() * sin(jets[i].phi());
 57        et_cosphi_sum += jets[i].Et() * cos(jets[i].phi());
 58        et_sum += jets[i].Et();
 59      }
 60
 61      // ET requirement
 62      if (sqrt(sqr(et_sinphi_sum) + sqr(et_cosphi_sum))/et_sum > 6.0) vetoEvent;
 63
 64      // Check jet requirements
 65      if (jets.size() < 3) vetoEvent;
 66      if (jets[0].pT() < 110*GeV) vetoEvent;
 67      if (jets[2].pT() < 10*GeV) vetoEvent;
 68
 69      // More jet 1,2,3 checks
 70      FourMomentum pj1(jets[0].momentum()), pj2(jets[1].momentum()), pj3(jets[2].momentum());
 71      if (fabs(pj1.eta()) > 0.7 || fabs(pj2.eta()) > 0.7) vetoEvent;
 72      MSG_DEBUG("Jet 1 & 2 eta, pT requirements fulfilled");
 73
 74      // Require that jets are back-to-back within 20 degrees in phi
 75      if ((PI - deltaPhi(pj1.phi(), pj2.phi())) > (20/180.0)*PI) vetoEvent;
 76      MSG_DEBUG("Jet 1 & 2 phi requirement fulfilled");
 77
 78      _sumw->fill();
 79
 80      // Fill histos
 81      _histJet1Et->fill(pj1.pT());
 82      _histJet2Et->fill(pj2.pT());
 83      _tmphistJet3eta->fill(pj3.eta());
 84      _tmphistR23->fill(deltaR(pj2, pj3));
 85
 86      // Calc and plot alpha
 87      const double dPhi = deltaPhi(pj3.phi(), pj2.phi());
 88      const double dH = sign(pj2.eta()) * (pj3.eta() - pj2.eta());
 89      const double alpha = atan(dH/dPhi);
 90      _tmphistAlpha->fill(alpha*180./PI);
 91    }
 92
 93
 94    /// Apply bin-wise detector correction factors
 95    void finalize() {
 96
 97      // Normal scalings
 98      normalize(_histJet1Et, 12.3);
 99      normalize(_histJet2Et, 12.3);
100
101      // eta3 correction
102      const double eta3_CDF_sim[] =
103        { 0.0013, 0.0037, 0.0047, 0.0071, 0.0093, 0.0117, 0.0151, 0.0149, 0.0197, 0.0257,
104          0.0344, 0.0409, 0.0481, 0.0454, 0.0394, 0.0409, 0.0387, 0.0387, 0.0322, 0.0313,
105          0.0290, 0.0309, 0.0412, 0.0417, 0.0412, 0.0397, 0.0417, 0.0414, 0.0376, 0.0316,
106          0.0270, 0.0186, 0.0186, 0.0132, 0.0127, 0.0106, 0.0071, 0.0040, 0.0020, 0.0013 };
107      const double eta3_CDF_sim_err[] =
108        { 0.0009, 0.0009, 0.0007, 0.0007, 0.0007, 0.0010, 0.0012, 0.0012, 0.0013, 0.0016,
109          0.0017, 0.0020, 0.0020, 0.0022, 0.0020, 0.0020, 0.0018, 0.0018, 0.0016, 0.0017,
110          0.0017, 0.0019, 0.0020, 0.0021, 0.0020, 0.0020, 0.0019, 0.0020, 0.0018, 0.0017,
111          0.0017, 0.0014, 0.0014, 0.0009, 0.0010, 0.0009, 0.0009, 0.0008, 0.0008, 0.0009 };
112      const double eta3_Ideal_sim[] =
113        { 0.0017, 0.0030, 0.0033, 0.0062, 0.0062, 0.0112, 0.0177, 0.0164, 0.0196, 0.0274,
114          0.0351, 0.0413, 0.0520, 0.0497, 0.0448, 0.0446, 0.0375, 0.0329, 0.0291, 0.0272,
115          0.0233, 0.0288, 0.0384, 0.0396, 0.0468, 0.0419, 0.0459, 0.0399, 0.0355, 0.0329,
116          0.0274, 0.0230, 0.0201, 0.0120, 0.0100, 0.0080, 0.0051, 0.0051, 0.0010, 0.0010 };
117      for (size_t i = 0;  i < 40; ++i) {
118        const double yval = _tmphistJet3eta->bin(i).area() * (eta3_CDF_sim[i]/eta3_Ideal_sim[i]);
119        const double yerr = _tmphistJet3eta->bin(i).areaErr() * (eta3_CDF_sim_err[i]/eta3_Ideal_sim[i]);
120        _histJet3eta->addPoint(_tmphistJet3eta->bin(i).xMid(), yval/dbl(*_sumw),
121                               _tmphistJet3eta->bin(i).xWidth()/2.0, yerr/dbl(*_sumw));
122      }
123
124      // R23 correction
125      const double R23_CDF_sim[] =
126        { 0.0005, 0.0161, 0.0570, 0.0762, 0.0723, 0.0705, 0.0598, 0.0563, 0.0557, 0.0579,
127          0.0538, 0.0522, 0.0486, 0.0449, 0.0418, 0.0361, 0.0326, 0.0304, 0.0252, 0.0212,
128          0.0173, 0.0176, 0.0145, 0.0127, 0.0103, 0.0065, 0.0049, 0.0045, 0.0035, 0.0029,
129          0.0024, 0.0014, 0.0011, 0.0010, 0.0009 };
130      const double R23_CDF_sim_err[] =
131        { 0.0013, 0.0009, 0.0022, 0.0029, 0.0026, 0.0024, 0.0022, 0.0025, 0.0023, 0.0024,
132          0.0021, 0.0021, 0.0021, 0.0021, 0.0021, 0.0019, 0.0019, 0.0016, 0.0017, 0.0014,
133          0.0010, 0.0014, 0.0012, 0.0013, 0.0010, 0.0011, 0.0010, 0.0010, 0.0010, 0.0011,
134          0.0011, 0.0009, 0.0008, 0.0008, 0.0009 };
135      const double R23_Ideal_sim[] =
136        { 0.0005, 0.0176, 0.0585, 0.0862, 0.0843, 0.0756, 0.0673, 0.0635, 0.0586, 0.0619,
137          0.0565, 0.0515, 0.0466, 0.0472, 0.0349, 0.0349, 0.0266, 0.0254, 0.0204, 0.0179,
138          0.0142, 0.0134, 0.0101, 0.0090, 0.0080, 0.0034, 0.0030, 0.0033, 0.0027, 0.0021,
139          0.0012, 0.0006, 0.0004, 0.0005, 0.0003 };
140      for (size_t i = 0;  i < 35; ++i) {
141        const double yval = _tmphistR23->bin(i).area() * (R23_CDF_sim[i]/R23_Ideal_sim[i]);
142        const double yerr = _tmphistR23->bin(i).areaErr() * (R23_CDF_sim_err[i]/R23_Ideal_sim[i]);
143        _histR23->addPoint(_tmphistR23->bin(i).xMid(), yval/dbl(*_sumw),
144                           _tmphistR23->bin(i).xWidth()/2.0, yerr/dbl(*_sumw));
145      }
146
147      // alpha correction
148      const double alpha_CDF_sim[] =
149        { 0.0517, 0.0461, 0.0490, 0.0452, 0.0451, 0.0435, 0.0317, 0.0287, 0.0294, 0.0261,
150          0.0231, 0.0220, 0.0233, 0.0192, 0.0213, 0.0166, 0.0176, 0.0146, 0.0136, 0.0156,
151          0.0142, 0.0152, 0.0151, 0.0147, 0.0164, 0.0186, 0.0180, 0.0210, 0.0198, 0.0189,
152          0.0197, 0.0211, 0.0270, 0.0236, 0.0243, 0.0269, 0.0257, 0.0276, 0.0246, 0.0286 };
153      const double alpha_CDF_sim_err[] =
154        { 0.0024, 0.0025, 0.0024, 0.0024, 0.0024, 0.0022, 0.0019, 0.0018, 0.0019, 0.0016,
155          0.0017, 0.0017, 0.0019, 0.0013, 0.0017, 0.0014, 0.0016, 0.0013, 0.0012, 0.0009,
156          0.0014, 0.0014, 0.0014, 0.0014, 0.0014, 0.0015, 0.0014, 0.0016, 0.0016, 0.0015,
157          0.0016, 0.0016, 0.0019, 0.0017, 0.0019, 0.0018, 0.0018, 0.0018, 0.0018, 0.0019 };
158      const double alpha_Ideal_sim[] =
159        { 0.0552, 0.0558, 0.0583, 0.0550, 0.0495, 0.0433, 0.0393, 0.0346, 0.0331, 0.0296,
160          0.0258, 0.0196, 0.0171, 0.0179, 0.0174, 0.0141, 0.0114, 0.0096, 0.0076, 0.0087,
161          0.0099, 0.0079, 0.0102, 0.0114, 0.0124, 0.0130, 0.0165, 0.0160, 0.0177, 0.0190,
162          0.0232, 0.0243, 0.0238, 0.0248, 0.0235, 0.0298, 0.0292, 0.0291, 0.0268, 0.0316 };
163      for (size_t i = 0;  i < 40; ++i) {
164        const double yval = _tmphistAlpha->bin(i).area() * (alpha_CDF_sim[i]/alpha_Ideal_sim[i]);
165        const double yerr = _tmphistAlpha->bin(i).areaErr() * (alpha_CDF_sim_err[i]/alpha_Ideal_sim[i]);
166        _histAlpha->addPoint(_tmphistAlpha->bin(i).xMid(), yval/dbl(*_sumw),
167                             _tmphistAlpha->bin(i).xWidth()/2.0, yerr/dbl(*_sumw));
168      }
169    }
170
171    //@}
172
173
174  private:
175
176    /// Event weight counter
177    CounterPtr _sumw;
178
179    /// @name Histograms
180    //@{
181
182    /// Straightforward output histos
183    Histo1DPtr _histJet1Et, _histJet2Et;
184
185    /// Output histos which need to have correction factors applied
186    Scatter2DPtr _histR23, _histJet3eta, _histAlpha;
187
188    /// Temporary histos, to be converted to scatters
189    Histo1DPtr _tmphistR23, _tmphistJet3eta, _tmphistAlpha;
190
191    //@}
192
193  };
194
195
196
197  RIVET_DECLARE_ALIASED_PLUGIN(CDF_1994_S2952106, CDF_1994_I374155);
198
199}