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 Add a short analysis description here
 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, "/TMP/sigma_hadrons");
 31      book(_c_muons, "/TMP/sigma_muons");
 32      book(_h_weight, "/TMP/HWeight");
 33      unsigned int iloc(0);
 34      sqs = sqrtS();
 35      if(isCompatibleWithSqrtS(14)) {
 36	iloc = 1;
 37	sqs = 14.;
 38      }
 39      else if(isCompatibleWithSqrtS(22)) {
 40	iloc = 2;
 41	sqs = 22.;
 42      }
 43      else if(isCompatibleWithSqrtS(34)) {
 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 &&
 89	 int(fs.particles().size())==2+nCount[22]) {
 90	_c_muons->fill();
 91	return;
 92      }
 93      // everything else
 94      _c_hadrons->fill();
 95      _h_weight->fill();
 96      _n_charged.fill(nCharged);
 97      _n_total.fill(ntotal);
 98      // thrust
 99      const Thrust& thrust = apply<Thrust>(event, "Thrust");
100      _thrust.fill(thrust.thrust());
101      // sphericity
102      const Sphericity& sphericity = apply<Sphericity>(event, "Sphericity");
103      _sphericity.fill(sphericity.sphericity());
104      // global distributions
105      if(_h_mult) _h_mult->fill(nCharged);
106      if(_h_S)    _h_S   ->fill(sphericity.sphericity());
107      if(_h_T)    _h_T   ->fill(thrust.thrust());
108      // single particle distributions
109      for (const Particle& p : fs.particles()) {
110	if(!PID::isCharged(p.pid())) continue;
111	const Vector3 mom3 = p.p3();
112	double pp = mom3.mod();
113	_p_total.fill(pp);
114	if(_h_p)  _h_p ->fill(pp);
115	if(_h_xp) _h_xp->fill(2.*pp/sqrtS());
116        const double mom = dot(sphericity.sphericityAxis(), mom3);
117	_p_l.fill(fabs(mom));
118	if(_h_pl) _h_pl->fill(fabs(mom));
119	if(_h_xl) _h_xl->fill(2.*fabs(mom)/sqrtS());
120        const double pTin = dot(mom3, sphericity.sphericityMajorAxis());
121	_pt2_in.fill(sqr(pTin));
122        const double pTout = dot(mom3, sphericity.sphericityMinorAxis());
123	_pt2_out.fill(sqr(pTout));
124        double pT = sqr(pTin) + sqr(pTout);
125	_pt2.fill(pT);
126	if(_h_pt2) _h_pt2->fill(pT);
127	pT=sqrt(pT);
128	_pt.fill(pT);
129	if(_h_pt) _h_pt->fill(pT);
130	if(_h_xT) _h_xT->fill(2.*pT/sqrtS());
131	if(_h_y) {
132	  const double rap = 0.5 * log((p.E() + mom) /
133				       (p.E() - mom));
134	  _h_y->fill(fabs(rap));
135	}
136      }
137    }
138
139
140    /// Normalise histograms etc., after the run
141    void finalize() {
142      Scatter1D R = *_c_hadrons/ *_c_muons;
143      double              rval = R.point(0).x();
144      pair<double,double> rerr = R.point(0).xErrs();
145      double fact = crossSection()/ sumOfWeights() /picobarn;
146      double sig_h = _c_hadrons->val()*fact;
147      double err_h = _c_hadrons->err()*fact;
148      double sig_m = _c_muons  ->val()*fact;
149      double err_m = _c_muons  ->err()*fact;
150      Scatter2D temphisto(refData(1, 1, 1));
151      Scatter2DPtr hadrons;
152      book(hadrons, "sigma_hadrons");
153      Scatter2DPtr muons;
154      book(muons, "sigma_muons"  );
155      Scatter2DPtr mult;
156      book(mult, 1, 1, 1);
157      for (size_t b = 0; b < temphisto.numPoints(); b++) {
158	const double x  = temphisto.point(b).x();
159	pair<double,double> ex = temphisto.point(b).xErrs();
160	pair<double,double> ex2 = ex;
161	if(ex2.first ==0.) ex2. first=0.0001;
162	if(ex2.second==0.) ex2.second=0.0001;
163	if (inRange(sqs, x-ex2.first, x+ex2.second)) {
164	  mult   ->addPoint(x, rval, ex, rerr);
165	  hadrons->addPoint(x, sig_h, ex, make_pair(err_h,err_h));
166	  muons  ->addPoint(x, sig_m, ex, make_pair(err_m,err_m));
167	}
168	else {
169	  mult   ->addPoint(x, 0., ex, make_pair(0.,.0));
170	  hadrons->addPoint(x, 0., ex, make_pair(0.,.0));
171	  muons  ->addPoint(x, 0., ex, make_pair(0.,.0));
172	}
173      }
174      // charged particle multiplicity distribution
175      if(_h_mult) normalize(_h_mult,2.);
176      for(unsigned int iy=1;iy<12;++iy) {
177	double value = 0.0, error = 0.0;
178	if(iy==1) {
179	  value = _n_charged.xMean();
180	  error = _n_charged.xStdErr();
181	}
182	else if(iy==2) {
183	  double num = _n_charged.xMean();
184	  double den =   _n_total.xMean();
185	  value = num/den;
186	  error = value*sqrt(sqr(_n_charged.xStdErr()/num)+sqr(_n_total.xStdErr()/den));
187	}
188	else if(iy==3) {
189	  value = _n_charged.xStdDev();
190	  error = _n_charged.xStdErr();
191	}
192	else if(iy==4) {
193	  value = _sphericity.xMean();
194	  error = _sphericity.xStdErr();
195	}
196	else if(iy==5) {
197	  value = _thrust.xMean();
198	  error = _thrust.xStdErr();
199	}
200	else if(iy==6) {
201	  value = _p_total.xMean();
202	  error = _p_total.xStdErr();
203	}
204	else if(iy==7) {
205	  value = _p_l.xMean();
206	  error = _p_l.xStdErr();
207	}
208	else if(iy==8) {
209	  value = _pt.xMean();
210	  error = _pt.xStdErr();
211	}
212	else if(iy==9) {
213	  value = _pt2.xMean();
214	  error = _pt2.xStdErr();
215	}
216	else if(iy==10) {
217	  value = _pt2_in.xMean();
218	  error = _pt2_in.xStdErr();
219	}
220	else if(iy==11) {
221	  value = _pt2_out.xMean();
222	  error = _pt2_out.xStdErr();
223	}
224	Scatter2D temphisto(refData(4, 1, iy));
225	Scatter2DPtr mult;
226	book(mult, 4, 1, iy);
227	for (size_t b = 0; b < temphisto.numPoints(); b++) {
228	  const double x  = temphisto.point(b).x();
229	  pair<double,double> ex = temphisto.point(b).xErrs();
230	  pair<double,double> ex2 = ex;
231	  if(ex2.first ==0.) ex2. first=0.0001;
232	  if(ex2.second==0.) ex2.second=0.0001;
233	  if (inRange(sqs, x-ex2.first, x+ex2.second)) {
234	    mult   ->addPoint(x, value, ex, make_pair(error,error));
235	  }
236	  else {
237	    mult   ->addPoint(x, 0., ex, make_pair(0.,.0));
238	  }
239	}
240      }
241      // scale the distributions
242      scale(_h_p  ,1./_h_weight->sumW());
243      scale(_h_xp ,1./_h_weight->sumW());
244      scale(_h_pl ,1./_h_weight->sumW());
245      scale(_h_pt ,1./_h_weight->sumW());
246      scale(_h_pt2,1./_h_weight->sumW());
247      scale(_h_xl ,1./_h_weight->sumW());
248      scale(_h_xT ,1./_h_weight->sumW());
249      scale(_h_S  ,1./_h_weight->sumW());
250      scale(_h_T  ,1./_h_weight->sumW());
251      scale(_h_y  ,1./_h_weight->sumW());
252    }
253
254    //@}
255
256
257    /// @name Histograms
258    //@{
259    Histo1DPtr _h_mult,_h_p,_h_xp,_h_pl,_h_pt,_h_pt2,_h_xl,_h_xT,_h_S,_h_T,_h_y;
260    CounterPtr _c_hadrons, _c_muons;
261    YODA::Dbn1D _n_charged,_n_total,_sphericity,_thrust,_p_total,
262      _p_l,_pt,_pt2,_pt2_in,_pt2_out;
263    CounterPtr  _h_weight;
264    double sqs;
265    //@}
266
267  };
268
269  // The hook for the plugin system
270  RIVET_DECLARE_PLUGIN(TASSO_1984_I195333);
271
272}