rivet is hosted by Hepforge, IPPP Durham

Rivet analyses reference

CDF_1994_I374155

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_I374155.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_I374155 : public Analysis {
 16  public:
 17
 18    RIVET_DEFAULT_ANALYSIS_CTOR(CDF_1994_I374155);
 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, JetAlg::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+1).sumW() * (eta3_CDF_sim[i]/eta3_Ideal_sim[i]);
119        const double yerr = _tmphistJet3eta->bin(i+1).errW() * (eta3_CDF_sim_err[i]/eta3_Ideal_sim[i]);
120        _histJet3eta->bin(i+1).set(yval/dbl(*_sumw), yerr/dbl(*_sumw));
121      }
122
123      // R23 correction
124      const double R23_CDF_sim[] =
125        { 0.0005, 0.0161, 0.0570, 0.0762, 0.0723, 0.0705, 0.0598, 0.0563, 0.0557, 0.0579,
126          0.0538, 0.0522, 0.0486, 0.0449, 0.0418, 0.0361, 0.0326, 0.0304, 0.0252, 0.0212,
127          0.0173, 0.0176, 0.0145, 0.0127, 0.0103, 0.0065, 0.0049, 0.0045, 0.0035, 0.0029,
128          0.0024, 0.0014, 0.0011, 0.0010, 0.0009 };
129      const double R23_CDF_sim_err[] =
130        { 0.0013, 0.0009, 0.0022, 0.0029, 0.0026, 0.0024, 0.0022, 0.0025, 0.0023, 0.0024,
131          0.0021, 0.0021, 0.0021, 0.0021, 0.0021, 0.0019, 0.0019, 0.0016, 0.0017, 0.0014,
132          0.0010, 0.0014, 0.0012, 0.0013, 0.0010, 0.0011, 0.0010, 0.0010, 0.0010, 0.0011,
133          0.0011, 0.0009, 0.0008, 0.0008, 0.0009 };
134      const double R23_Ideal_sim[] =
135        { 0.0005, 0.0176, 0.0585, 0.0862, 0.0843, 0.0756, 0.0673, 0.0635, 0.0586, 0.0619,
136          0.0565, 0.0515, 0.0466, 0.0472, 0.0349, 0.0349, 0.0266, 0.0254, 0.0204, 0.0179,
137          0.0142, 0.0134, 0.0101, 0.0090, 0.0080, 0.0034, 0.0030, 0.0033, 0.0027, 0.0021,
138          0.0012, 0.0006, 0.0004, 0.0005, 0.0003 };
139      for (size_t i = 0;  i < 35; ++i) {
140        const double yval = _tmphistR23->bin(i+1).sumW() * (R23_CDF_sim[i]/R23_Ideal_sim[i]);
141        const double yerr = _tmphistR23->bin(i+1).errW() * (R23_CDF_sim_err[i]/R23_Ideal_sim[i]);
142        _histR23->bin(i+1).set(yval/dbl(*_sumw), yerr/dbl(*_sumw));
143      }
144
145      // alpha correction
146      const double alpha_CDF_sim[] =
147        { 0.0517, 0.0461, 0.0490, 0.0452, 0.0451, 0.0435, 0.0317, 0.0287, 0.0294, 0.0261,
148          0.0231, 0.0220, 0.0233, 0.0192, 0.0213, 0.0166, 0.0176, 0.0146, 0.0136, 0.0156,
149          0.0142, 0.0152, 0.0151, 0.0147, 0.0164, 0.0186, 0.0180, 0.0210, 0.0198, 0.0189,
150          0.0197, 0.0211, 0.0270, 0.0236, 0.0243, 0.0269, 0.0257, 0.0276, 0.0246, 0.0286 };
151      const double alpha_CDF_sim_err[] =
152        { 0.0024, 0.0025, 0.0024, 0.0024, 0.0024, 0.0022, 0.0019, 0.0018, 0.0019, 0.0016,
153          0.0017, 0.0017, 0.0019, 0.0013, 0.0017, 0.0014, 0.0016, 0.0013, 0.0012, 0.0009,
154          0.0014, 0.0014, 0.0014, 0.0014, 0.0014, 0.0015, 0.0014, 0.0016, 0.0016, 0.0015,
155          0.0016, 0.0016, 0.0019, 0.0017, 0.0019, 0.0018, 0.0018, 0.0018, 0.0018, 0.0019 };
156      const double alpha_Ideal_sim[] =
157        { 0.0552, 0.0558, 0.0583, 0.0550, 0.0495, 0.0433, 0.0393, 0.0346, 0.0331, 0.0296,
158          0.0258, 0.0196, 0.0171, 0.0179, 0.0174, 0.0141, 0.0114, 0.0096, 0.0076, 0.0087,
159          0.0099, 0.0079, 0.0102, 0.0114, 0.0124, 0.0130, 0.0165, 0.0160, 0.0177, 0.0190,
160          0.0232, 0.0243, 0.0238, 0.0248, 0.0235, 0.0298, 0.0292, 0.0291, 0.0268, 0.0316 };
161      for (size_t i = 0;  i < 40; ++i) {
162        const double yval = _tmphistAlpha->bin(i+1).sumW() * (alpha_CDF_sim[i]/alpha_Ideal_sim[i]);
163        const double yerr = _tmphistAlpha->bin(i+1).errW() * (alpha_CDF_sim_err[i]/alpha_Ideal_sim[i]);
164        _histAlpha->bin(i+1).set(yval/dbl(*_sumw), yerr/dbl(*_sumw));
165      }
166    }
167
168    /// @}
169
170
171  private:
172
173    /// Event weight counter
174    CounterPtr _sumw;
175
176    /// @name Histograms
177    /// @{
178
179    /// Straightforward output histos
180    Histo1DPtr _histJet1Et, _histJet2Et;
181
182    /// Output histos which need to have correction factors applied
183    Estimate1DPtr _histR23, _histJet3eta, _histAlpha;
184
185    /// Temporary histos, to be converted to scatters
186    Histo1DPtr _tmphistR23, _tmphistJet3eta, _tmphistAlpha;
187
188    /// @}
189
190  };
191
192
193
194  RIVET_DECLARE_ALIASED_PLUGIN(CDF_1994_I374155, CDF_1994_S2952106);
195
196}