rivet is hosted by Hepforge, IPPP Durham

Rivet analyses reference

TASSO_1984_I195333

Measurements of charged particle multiplicities, $R$ and event shapes between 12 and 43 GeV.
Experiment: TASSO (PETRA)
Inspire ID: 195333
Status: VALIDATED
Authors:
  • Peter Richardson
References:
  • Z.Phys. C22 (1984) 307-340, 1984
Beams: e- e+
Beam energies: (6.0, 6.0); (7.0, 7.0); (11.0, 11.0); (12.5, 12.5); (13.8, 13.8); (15.1, 15.1); (15.2, 15.2); (15.6, 15.6); (16.6, 16.6); (17.0, 17.0); (17.2, 17.2); (17.4, 17.4); (18.1, 18.1); (20.8, 20.8); (21.5, 21.5) GeV
Run details:
  • e+ e- to hadrons and e+ e- to mu+ mu- (for normalization). Beam energy must be specified as analysis option "ENERGY" when rivet-merging samples.

Measurement of $R$, charged particle multiplicites and event shapes in $e^+e^-$ collisions for energies between 12 and 43 GeV. The average charged particle multiplicity, thrust and sphericity are measured for a range of energies. The distributions are available for 12, 22 and 34 GeV. The individual hadronic and muonic cross sections are also outputted to the yoda file so that ratio $R$ can be recalculated if runs are combined. Beam energy must be specified as analysis option "ENERGY" when rivet-merging samples.

Source code: TASSO_1984_I195333.cc
  1// -*- C++ -*-
  2#include "Rivet/Analysis.hh"
  3#include "Rivet/Projections/FinalState.hh"
  4#include "Rivet/Projections/Sphericity.hh"
  5#include "Rivet/Projections/Thrust.hh"
  6
  7namespace Rivet {
  8
  9
 10  /// @brief Charged-particle multiplicities, R, and event shapes between 12 and 43 GeV
 11  class TASSO_1984_I195333 : public Analysis {
 12  public:
 13
 14    /// Constructor
 15    RIVET_DEFAULT_ANALYSIS_CTOR(TASSO_1984_I195333);
 16
 17
 18    /// @name Analysis methods
 19    /// @{
 20
 21    /// Book histograms and initialise projections before the run
 22    void init() {
 23      // Initialise and register projections
 24      const FinalState fs;
 25      declare(fs, "FS");
 26      declare(Sphericity(fs), "Sphericity");
 27      declare(Thrust(fs), "Thrust");
 28
 29      // Counters for R
 30      book(_c_hadrons, "sigma_hadrons");
 31      book(_c_muons, "sigma_muons");
 32      book(_h_weight, "/TMP/HWeight");
 33      unsigned int iloc(0);
 34      sqs = sqrtS();
 35      if (isCompatibleWithSqrtS(14*GeV)) {
 36        iloc = 1;
 37        sqs = 14.;
 38      }
 39      else if (isCompatibleWithSqrtS(22*GeV)) {
 40        iloc = 2;
 41        sqs = 22.;
 42      }
 43      else if (isCompatibleWithSqrtS(34*GeV)) {
 44        iloc = 3;
 45        sqs = 34.;
 46      }
 47      if (iloc!=0) {
 48        book(_h_mult, 3,1,iloc);
 49        book(_h_p,    5,1,iloc);
 50        book(_h_xp,   6,1,iloc);
 51        book(_h_pl,   7,1,iloc);
 52        book(_h_pt,   8,1,iloc);
 53        book(_h_pt2,  9,1,iloc);
 54        book(_h_xl,  10,1,iloc);
 55        book(_h_xT,  11,1,iloc);
 56        book(_h_S,   12,1,iloc);
 57        book(_h_T,   13,1,iloc);
 58        book(_h_y,   14,1,iloc);
 59      }
 60    }
 61
 62
 63    /// Perform the per-event analysis
 64    void analyze(const Event& event) {
 65      const FinalState& fs = apply<FinalState>(event, "FS");
 66
 67      map<long,int> nCount;
 68      double ntotal(0);
 69      unsigned int nCharged(0);
 70      for (const Particle& p : fs.particles()) {
 71        nCount[p.pid()] += 1;
 72        if ((p.pid()!=PID::PHOTON && p.abspid()!=PID::ELECTRON) ||
 73            p.parents().empty() || p.parents()[0].pid()!=PID::PI0) {
 74          ntotal += 1.;
 75        }
 76        else if (p.pid()==PID::PHOTON) {
 77          ntotal += 0.5 ;
 78        }
 79        else {
 80          ntotal += 0.25;
 81          nCharged -=1;
 82        }
 83        if (PID::isCharged(p.pid())) {
 84          ++nCharged;
 85        }
 86      }
 87      // mu+mu- + photons
 88      if (nCount[-13]==1 and nCount[13]==1 && int(fs.particles().size())==2+nCount[22]) {
 89        _c_muons->fill();
 90        return;
 91      }
 92      // everything else
 93      _c_hadrons->fill();
 94      _h_weight->fill();
 95      _n_charged.fill(nCharged);
 96      _n_total.fill(ntotal);
 97      // thrust
 98      const Thrust& thrust = apply<Thrust>(event, "Thrust");
 99      _thrust.fill(thrust.thrust());
100      // sphericity
101      const Sphericity& sphericity = apply<Sphericity>(event, "Sphericity");
102      _sphericity.fill(sphericity.sphericity());
103      // global distributions
104      if (_h_mult)  _h_mult->fill(nCharged);
105      if (_h_S)     _h_S   ->fill(sphericity.sphericity());
106      if (_h_T)     _h_T   ->fill(thrust.thrust());
107      // single particle distributions
108      for (const Particle& p : fs.particles()) {
109        if (!PID::isCharged(p.pid())) continue;
110        const Vector3 mom3 = p.p3();
111        double pp = mom3.mod();
112        _p_total.fill(pp);
113        if (_h_p)  _h_p ->fill(pp);
114        if (_h_xp) _h_xp->fill(2.*pp/sqrtS());
115        const double mom = dot(sphericity.sphericityAxis(), mom3);
116        _p_l.fill(fabs(mom));
117        if (_h_pl)  _h_pl->fill(fabs(mom));
118        if (_h_xl)  _h_xl->fill(2.*fabs(mom)/sqrtS());
119        const double pTin = dot(mom3, sphericity.sphericityMajorAxis());
120        _pt2_in.fill(sqr(pTin));
121        const double pTout = dot(mom3, sphericity.sphericityMinorAxis());
122        _pt2_out.fill(sqr(pTout));
123        double pT = sqr(pTin) + sqr(pTout);
124        _pt2.fill(pT);
125        if (_h_pt2)  _h_pt2->fill(pT);
126        pT=sqrt(pT);
127        _pt.fill(pT);
128        if (_h_pt)  _h_pt->fill(pT);
129        if (_h_xT)  _h_xT->fill(2.*pT/sqrtS());
130        if (_h_y) {
131          const double rap = 0.5 * log((p.E() + mom) / (p.E() - mom));
132          _h_y->fill(fabs(rap));
133        }
134      }
135    }
136
137
138    /// Normalise histograms etc., after the run
139    void finalize() {
140      const double fact = crossSection()/ sumOfWeights() /picobarn;
141      scale({_c_hadrons, _c_muons}, fact);
142
143      Estimate0D R = *_c_hadrons/ *_c_muons;
144      Estimate1DPtr mult;
145      book(mult, 1, 1, 1);
146      size_t idx = 0;
147      if (isCompatibleWithSqrtS(12*GeV))          idx = 1;
148      else if (isCompatibleWithSqrtS(14*GeV))     idx = 2;
149      else if (isCompatibleWithSqrtS(22*GeV))     idx = 3;
150      else if (isCompatibleWithSqrtS(25*GeV))     idx = 4;
151      else if (inRange(sqrtS()/GeV, 27.4, 27.7))  idx = 5;
152      else if (isCompatibleWithSqrtS(30.1*GeV))   idx = 6;
153      else if (inRange(sqrtS()/GeV, 30.5, 31.5))  idx = 7;
154      else if (inRange(sqrtS()/GeV, 32.5, 33.5))  idx = 8;
155      else if (inRange(sqrtS()/GeV, 33.5, 34.5))  idx = 9;
156      else if (inRange(sqrtS()/GeV, 34.5, 35.5))  idx = 10;
157      else if (inRange(sqrtS()/GeV, 35.5, 36.7))  idx = 11;
158      else if (inRange(sqrtS()/GeV, 38.7, 43.1))  idx = 12;
159      mult->bin(idx).set(R.val(), R.errPos());
160
161      // charged particle multiplicity distribution
162      if (_h_mult)  normalize(_h_mult,2.);
163      for (unsigned int iy=1;iy<12;++iy) {
164        double value = 0.0, error = 0.0;
165        if (iy==1) {
166          value = _n_charged.xMean();
167          error = _n_charged.xStdErr();
168        }
169        else if (iy==2) {
170          double num = _n_charged.xMean();
171          double den =   _n_total.xMean();
172          value = num/den;
173          error = value*sqrt(sqr(_n_charged.xStdErr()/num)+sqr(_n_total.xStdErr()/den));
174        }
175        else if (iy==3) {
176          value = _n_charged.xStdDev();
177          error = _n_charged.xStdErr();
178        }
179        else if (iy==4) {
180          value = _sphericity.xMean();
181          error = _sphericity.xStdErr();
182        }
183        else if (iy==5) {
184          value = _thrust.xMean();
185          error = _thrust.xStdErr();
186        }
187        else if (iy==6) {
188          value = _p_total.xMean();
189          error = _p_total.xStdErr();
190        }
191        else if (iy==7) {
192          value = _p_l.xMean();
193          error = _p_l.xStdErr();
194        }
195        else if (iy==8) {
196          value = _pt.xMean();
197          error = _pt.xStdErr();
198        }
199        else if (iy==9) {
200          value = _pt2.xMean();
201          error = _pt2.xStdErr();
202        }
203        else if (iy==10) {
204          value = _pt2_in.xMean();
205          error = _pt2_in.xStdErr();
206        }
207        else if (iy==11) {
208          value = _pt2_out.xMean();
209          error = _pt2_out.xStdErr();
210        }
211        BinnedEstimatePtr<string> mult;
212        book(mult, 4, 1, iy);
213        for (auto& b : mult->bins()) {
214          const double Ecm = std::stod(b.xEdge());
215          if (isCompatibleWithSqrtS(Ecm*GeV)) {
216            b.set(value, error);
217          }
218        }
219      }
220      // scale the distributions
221      scale(_h_p  ,1./_h_weight->sumW());
222      scale(_h_xp ,1./_h_weight->sumW());
223      scale(_h_pl ,1./_h_weight->sumW());
224      scale(_h_pt ,1./_h_weight->sumW());
225      scale(_h_pt2,1./_h_weight->sumW());
226      scale(_h_xl ,1./_h_weight->sumW());
227      scale(_h_xT ,1./_h_weight->sumW());
228      scale(_h_S  ,1./_h_weight->sumW());
229      scale(_h_T  ,1./_h_weight->sumW());
230      scale(_h_y  ,1./_h_weight->sumW());
231    }
232
233    /// @}
234
235
236    /// @name Histograms
237    /// @{
238    Histo1DPtr _h_p,_h_xp,_h_pl,_h_pt,_h_pt2,_h_xl,_h_xT,_h_S,_h_T,_h_y;
239    BinnedHistoPtr<int> _h_mult;
240    CounterPtr _c_hadrons, _c_muons;
241    YODA::Dbn1D _n_charged, _n_total, _sphericity, _thrust, _p_total, _p_l, _pt, _pt2, _pt2_in, _pt2_out;
242    CounterPtr  _h_weight;
243    double sqs;
244    /// @}
245
246  };
247
248
249
250  RIVET_DECLARE_PLUGIN(TASSO_1984_I195333);
251
252}