rivet is hosted by Hepforge, IPPP Durham

Rivet analyses reference

LHCB_2013_I1208105

LHCb measurement of energy flow from $pp$ collisions at $\sqrt{s} = 7$ TeV
Experiment: LHCb (LHC)
Inspire ID: 1208105
Status: VALIDATED
Authors:
  • Alex Grecu
  • Dmytro Volyanskyy
  • Michael Schmelling
References:
  • arXiv: 1212.4755
  • Eur. Phys. J. C 73 (2012) 2421
Beams: p+ p+
Beam energies: (3500.0, 3500.0) GeV
Run details:
  • Minimum bias events from $pp$ collisions at sqrt(s) = 7 TeV.

The energy flow created in $pp$ collisions at 7 TeV within the fiducial pseudorapidity range of the LHCb detector ($1.9 < \eta < 4.9$) is measured for inclusive minimum bias interactions, hard scattering processes and events with enhanced or suppressed diffractive contribution. Plots for these four event classes are shown separately for all and charged only final state particles, respectively. The total energy flow is measured by combining the charged energy flow and a data-constrained MC estimate of the neutral component. For the two highest eta bins the data-constrained measurements of the neutral energy were extrapolated from the more central region as the LHCb electromagnetic calorimeter has no detection coverage in that phase space domain.

Source code: LHCB_2013_I1208105.cc
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
// -*- C++ -*-
#include "Rivet/Analysis.hh"
#include "Rivet/Projections/FinalState.hh"
#include "Rivet/Projections/ChargedFinalState.hh"

namespace Rivet {


  class LHCB_2013_I1208105 : public Analysis {
  public:

    LHCB_2013_I1208105()
      : Analysis("LHCB_2013_I1208105")
    {   }


    void init() {
      // Projections
      declare(FinalState(1.9, 4.9), "forwardFS");
      declare(FinalState(-3.5,-1.5), "backwardFS");
      declare(ChargedFinalState(1.9, 4.9), "forwardCFS");
      declare(ChargedFinalState(-3.5,-1.5), "backwardCFS");

      // Histos
      _s_chEF_minbias = bookScatter2D(1, 1, 1, true);
      _s_chEF_hard = bookScatter2D(2, 1, 1, true);
      _s_chEF_diff = bookScatter2D(3, 1, 1, true);
      _s_chEF_nondiff = bookScatter2D(4, 1, 1, true);
      _s_totEF_minbias = bookScatter2D(5, 1, 1, true);
      _s_totEF_hard = bookScatter2D(6, 1, 1, true);
      _s_totEF_diff = bookScatter2D(7, 1, 1, true);
      _s_totEF_nondiff = bookScatter2D(8, 1, 1, true);

      // Temporary profiles and histos
      /// @todo Convert to declared/registered temp histos
      _tp_chEF_minbias.reset(new YODA::Profile1D(refData(1,1,1)));
      _tp_chEF_hard.reset(new YODA::Profile1D(refData(2,1,1)));
      _tp_chEF_diff.reset(new YODA::Profile1D(refData(3,1,1)));
      _tp_chEF_nondiff.reset(new YODA::Profile1D(refData(4,1,1)));
      _tp_totEF_minbias.reset(new YODA::Profile1D(refData(5,1,1)));
      _tp_totEF_hard.reset(new YODA::Profile1D(refData(6,1,1)));
      _tp_totEF_diff.reset(new YODA::Profile1D(refData(7,1,1)));
      _tp_totEF_nondiff.reset(new YODA::Profile1D(refData(8,1,1)));
      //
      _th_chN_minbias.reset(new YODA::Histo1D(refData(1,1,1)));
      _th_chN_hard.reset(new YODA::Histo1D(refData(2,1,1)));
      _th_chN_diff.reset(new YODA::Histo1D(refData(3,1,1)));
      _th_chN_nondiff.reset(new YODA::Histo1D(refData(4,1,1)));
      _th_totN_minbias.reset(new YODA::Histo1D(refData(5,1,1)));
      _th_totN_hard.reset(new YODA::Histo1D(refData(6,1,1)));
      _th_totN_diff.reset(new YODA::Histo1D(refData(7,1,1)));
      _th_totN_nondiff.reset(new YODA::Histo1D(refData(8,1,1)));

      // Counters
      _mbSumW = 0.0; _hdSumW = 0.0; _dfSumW = 0.0; _ndSumW = 0.0;
      _mbchSumW = 0.0; _hdchSumW = 0.0; _dfchSumW = 0.0; _ndchSumW = 0.0;
    }


    /// Perform the per-event analysis
    void analyze(const Event& event) {
      const double weight = event.weight();

      const FinalState& ffs = apply<FinalState>(event, "forwardFS");
      const FinalState& bfs = apply<FinalState>(event, "backwardFS");
      const ChargedFinalState& fcfs = apply<ChargedFinalState>(event, "forwardCFS");
      const ChargedFinalState& bcfs = apply<ChargedFinalState>(event, "backwardCFS");

      // Veto this event completely if there are no forward *charged* particles
      if (fcfs.empty()) vetoEvent;

      // Charged and neutral version
      {
        // Decide empirically if this is a "hard" or "diffractive" event
        bool ishardEvt = false;
        foreach (const Particle& p, ffs.particles()) {
          if (p.pT() > 3.0*GeV) { ishardEvt = true; break; }
        }
        // Decide empirically if this is a "diffractive" event
        /// @todo Can be "diffractive" *and* "hard"?
        bool isdiffEvt = (bfs.size() == 0);

        // Update event-type weight counters
        _mbSumW += weight;
        (isdiffEvt ? _dfSumW : _ndSumW) += weight;
        if (ishardEvt) _hdSumW += weight;

        // Plot energy flow
        foreach (const Particle& p, ffs.particles()) {
          const double eta = p.eta();
          const double energy = p.E();
          _tp_totEF_minbias->fill(eta, energy, weight);
          _th_totN_minbias->fill(eta, weight);
          if (ishardEvt) {
            _tp_totEF_hard->fill(eta, energy, weight);
            _th_totN_hard->fill(eta, weight);
          }
          if (isdiffEvt) {
            _tp_totEF_diff->fill(eta, energy, weight);
            _th_totN_diff->fill(eta, weight);
          } else {
            _tp_totEF_nondiff->fill(eta, energy, weight);
            _th_totN_nondiff->fill(eta, weight);
          }
        }
      }


      // Charged-only version
      {
        bool ishardEvt = false;
        foreach (const Particle& p, fcfs.particles()) {
          if (p.pT() > 3.0*GeV) { ishardEvt = true; break; }
        }
        // Decide empirically if this is a "diffractive" event
        /// @todo Can be "diffractive" *and* "hard"?
        bool isdiffEvt = (bcfs.size() == 0);

        // Update event-type weight counters
        _mbchSumW += weight;
        (isdiffEvt ? _dfchSumW : _ndchSumW) += weight;
        if (ishardEvt) _hdchSumW += weight;

        // Plot energy flow
        foreach (const Particle& p, fcfs.particles()) {
          const double eta = p.eta();
          const double energy = p.E();
          _tp_chEF_minbias->fill(eta, energy, weight);
          _th_chN_minbias->fill(eta, weight);
          if (ishardEvt) {
            _tp_chEF_hard->fill(eta, energy, weight);
            _th_chN_hard->fill(eta, weight);
          }
          if (isdiffEvt) {
            _tp_chEF_diff->fill(eta, energy, weight);
            _th_chN_diff->fill(eta, weight);
          } else {
            _tp_chEF_nondiff->fill(eta, energy, weight);
            _th_chN_nondiff->fill(eta, weight);
          }
        }
      }

    }


    void finalize() {
      for (size_t i = 0; i < _s_totEF_minbias->numPoints(); ++i) {
        const double val = _tp_totEF_minbias->bin(i).mean() * _th_totN_minbias->bin(i).height();
        const double err = (_tp_totEF_minbias->bin(i).mean() * _th_totN_minbias->bin(i).heightErr() +
                            _tp_totEF_minbias->bin(i).stdErr() * _th_totN_minbias->bin(i).height());
        _s_totEF_minbias->point(i).setY(val/_mbSumW, err/_mbSumW);
      }
      for (size_t i = 0; i < _s_totEF_hard->numPoints(); ++i) {
        const double val = _tp_totEF_hard->bin(i).mean() * _th_totN_hard->bin(i).height();
        const double err = (_tp_totEF_hard->bin(i).mean() * _th_totN_hard->bin(i).heightErr() +
                            _tp_totEF_hard->bin(i).stdErr() * _th_totN_hard->bin(i).height());
        _s_totEF_hard->point(i).setY(val/_hdSumW, err/_hdSumW);
      }
      for (size_t i = 0; i < _s_totEF_diff->numPoints(); ++i) {
        const double val = _tp_totEF_diff->bin(i).mean() * _th_totN_diff->bin(i).height();
        const double err = (_tp_totEF_diff->bin(i).mean() * _th_totN_diff->bin(i).heightErr() +
                                   _tp_totEF_diff->bin(i).stdErr() * _th_totN_diff->bin(i).height());
        _s_totEF_diff->point(i).setY(val/_dfSumW, err/_dfSumW);
      }
      for (size_t i = 0; i < _s_totEF_nondiff->numPoints(); ++i) {
        const double val = _tp_totEF_nondiff->bin(i).mean() * _th_totN_nondiff->bin(i).height();
        const double err = (_tp_totEF_nondiff->bin(i).mean() * _th_totN_nondiff->bin(i).heightErr() +
                            _tp_totEF_nondiff->bin(i).stdErr() * _th_totN_nondiff->bin(i).height());
        _s_totEF_nondiff->point(i).setY(val/_ndSumW, err/_ndSumW);
      }
      for (size_t i = 0; i < _s_chEF_minbias->numPoints(); ++i) {
        const double val = _tp_chEF_minbias->bin(i).mean() * _th_chN_minbias->bin(i).height();
        const double err = (_tp_chEF_minbias->bin(i).mean() * _th_chN_minbias->bin(i).heightErr() +
                            _tp_chEF_minbias->bin(i).stdErr() * _th_chN_minbias->bin(i).height());
        _s_chEF_minbias->point(i).setY(val/_mbchSumW, err/_mbchSumW);
      }
      for (size_t i = 0; i < _s_chEF_hard->numPoints(); ++i) {
        const double val = _tp_chEF_hard->bin(i).mean() * _th_chN_hard->bin(i).height();
        const double err = (_tp_chEF_hard->bin(i).mean() * _th_chN_hard->bin(i).heightErr() +
                            _tp_chEF_hard->bin(i).stdErr() * _th_chN_hard->bin(i).height());
        _s_chEF_hard->point(i).setY(val/_hdchSumW, err/_hdchSumW);
      }
      for (size_t i = 0; i < _s_chEF_diff->numPoints(); ++i) {
        const double val = _tp_chEF_diff->bin(i).mean() * _th_chN_diff->bin(i).height();
        const double err = (_tp_chEF_diff->bin(i).mean() * _th_chN_diff->bin(i).heightErr() +
                            _tp_chEF_diff->bin(i).stdErr() * _th_chN_diff->bin(i).height());
        _s_chEF_diff->point(i).setY(val/_dfchSumW, err/_dfchSumW);
      }
      for (size_t i = 0; i < _s_chEF_nondiff->numPoints(); ++i) {
        const double val = _tp_chEF_nondiff->bin(i).mean() * _th_chN_nondiff->bin(i).height();
        const double err = (_tp_chEF_nondiff->bin(i).mean() * _th_chN_nondiff->bin(i).heightErr() +
                            _tp_chEF_nondiff->bin(i).stdErr() * _th_chN_nondiff->bin(i).height());
        _s_chEF_nondiff->point(i).setY(val/_ndchSumW, err/_ndchSumW);
      }
    }


  private:

    /// @name Histograms and counters
    ///
    /// @note Histograms correspond to charged and total EF for each class of events:
    ///  minimum bias, hard scattering, diffractive enriched and non-diffractive enriched.
    //@{

    // Scatters to be filled in finalize with 1/d_eta <N(eta)><E(eta)>
    Scatter2DPtr _s_totEF_minbias, _s_totEF_hard, _s_totEF_diff, _s_totEF_nondiff;
    Scatter2DPtr _s_chEF_minbias, _s_chEF_hard, _s_chEF_diff, _s_chEF_nondiff;

    // Temp profiles containing <E(eta)>
    std::shared_ptr<YODA::Profile1D> _tp_totEF_minbias, _tp_totEF_hard, _tp_totEF_diff, _tp_totEF_nondiff;
    std::shared_ptr<YODA::Profile1D> _tp_chEF_minbias, _tp_chEF_hard, _tp_chEF_diff, _tp_chEF_nondiff;

    // Temp profiles containing <N(eta)>
    std::shared_ptr<YODA::Histo1D> _th_totN_minbias, _th_totN_hard, _th_totN_diff, _th_totN_nondiff;
    std::shared_ptr<YODA::Histo1D> _th_chN_minbias, _th_chN_hard, _th_chN_diff, _th_chN_nondiff;

    // Sums of weights (~ #events) in each event class
    double _mbSumW, _hdSumW, _dfSumW, _ndSumW;
    double _mbchSumW, _hdchSumW, _dfchSumW, _ndchSumW;

    //@}

  };


  // Hook for the plugin system
  DECLARE_RIVET_PLUGIN(LHCB_2013_I1208105);

}