Rivet analyses referenceSLD_1999_S3743934Production of $\pi^+$, $K^+$, $K^0$, $K^{*0}$, $\Phi$, $p$ and $\Lambda^0$ in hadronic $Z^0$ decayExperiment: SLD (SLC) Inspire ID: 469925 Status: VALIDATED Authors:
Beam energies: (45.6, 45.6) GeV Run details:
Measurement of scaled momentum distributions and fragmentation functions in flavour tagged events at SLC. SLD measured these observables in uds-, c-, and b-events separately. An inclusive measurement is also included. Source code: SLD_1999_S3743934.cc 1// -*- C++ -*-
2#include "Rivet/Analysis.hh"
3#include "Rivet/Projections/Beam.hh"
4#include "Rivet/Projections/FinalState.hh"
5#include "Rivet/Projections/UnstableParticles.hh"
6#include "Rivet/Projections/ChargedFinalState.hh"
7#include "Rivet/Projections/Thrust.hh"
8
9#define I_KNOW_THE_INITIAL_QUARKS_PROJECTION_IS_DODGY_BUT_NEED_TO_USE_IT
10#include "Rivet/Projections/InitialQuarks.hh"
11
12namespace Rivet {
13
14
15 /// @brief SLD flavour-dependent fragmentation paper
16 ///
17 /// @author Peter Richardson
18 class SLD_1999_S3743934 : public Analysis {
19 public:
20
21 /// Constructor
22 SLD_1999_S3743934()
23 : Analysis("SLD_1999_S3743934"),
24 _multPiPlus(4),_multKPlus(4),_multK0(4),
25 _multKStar0(4),_multPhi(4),
26 _multProton(4),_multLambda(4)
27 { }
28
29
30 /// @name Analysis methods
31 //@{
32
33 void analyze(const Event& e) {
34 // First, veto on leptonic events by requiring at least 4 charged FS particles
35 const FinalState& fs = apply<FinalState>(e, "FS");
36 const size_t numParticles = fs.particles().size();
37
38 // Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
39 if (numParticles < 2) {
40 MSG_DEBUG("Failed ncharged cut");
41 vetoEvent;
42 }
43 MSG_DEBUG("Passed ncharged cut");
44
45 // Get beams and average beam momentum
46 const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
47 const double meanBeamMom = ( beams.first.p3().mod() +
48 beams.second.p3().mod() ) / 2.0;
49 MSG_DEBUG("Avg beam momentum = " << meanBeamMom);
50 int flavour = 0;
51 const InitialQuarks& iqf = apply<InitialQuarks>(e, "IQF");
52
53 // If we only have two quarks (qqbar), just take the flavour.
54 // If we have more than two quarks, look for the highest energetic q-qbar pair.
55 /// @todo Can we make this based on hadron flavour instead?
56 Particles quarks;
57 if (iqf.particles().size() == 2) {
58 flavour = iqf.particles().front().abspid();
59 quarks = iqf.particles();
60 } else {
61 map<int, Particle > quarkmap;
62 for (const Particle& p : iqf.particles()) {
63 if (quarkmap.find(p.pid()) == quarkmap.end()) quarkmap[p.pid()] = p;
64 else if (quarkmap[p.pid()].E() < p.E()) quarkmap[p.pid()] = p;
65 }
66 double maxenergy = 0.;
67 for (int i = 1; i <= 5; ++i) {
68 double energy(0.);
69 if (quarkmap.find( i) != quarkmap.end())
70 energy += quarkmap[ i].E();
71 if (quarkmap.find(-i) != quarkmap.end())
72 energy += quarkmap[-i].E();
73 if (energy > maxenergy)
74 flavour = i;
75 }
76 if (quarkmap.find(flavour) != quarkmap.end())
77 quarks.push_back(quarkmap[flavour]);
78 if (quarkmap.find(-flavour) != quarkmap.end())
79 quarks.push_back(quarkmap[-flavour]);
80 }
81 switch (flavour) {
82 case PID::DQUARK:
83 case PID::UQUARK:
84 case PID::SQUARK:
85 _SumOfudsWeights->fill();
86 break;
87 case PID::CQUARK:
88 _SumOfcWeights->fill();
89 break;
90 case PID::BQUARK:
91 _SumOfbWeights->fill();
92 break;
93 }
94 // thrust axis for projections
95 Vector3 axis = apply<Thrust>(e, "Thrust").thrustAxis();
96 double dot(0.);
97 if (!quarks.empty()) {
98 dot = quarks[0].p3().dot(axis);
99 if (quarks[0].pid() < 0) dot *= -1;
100 }
101
102 for (const Particle& p : fs.particles()) {
103 const double xp = p.p3().mod()/meanBeamMom;
104 // if in quark or antiquark hemisphere
105 bool quark = p.p3().dot(axis)*dot > 0.;
106 _h_XpChargedN->fill(xp);
107 _temp_XpChargedN1->fill(xp);
108 _temp_XpChargedN2->fill(xp);
109 _temp_XpChargedN3->fill(xp);
110 int id = p.abspid();
111 // charged pions
112 if (id == PID::PIPLUS) {
113 _h_XpPiPlusN->fill(xp);
114 _multPiPlus[0]->fill();
115 switch (flavour) {
116 case PID::DQUARK:
117 case PID::UQUARK:
118 case PID::SQUARK:
119 _multPiPlus[1]->fill();
120 _h_XpPiPlusLight->fill(xp);
121 if( ( quark && p.pid()>0 ) || ( !quark && p.pid()<0 ))
122 _h_RPiPlus->fill(xp);
123 else
124 _h_RPiMinus->fill(xp);
125 break;
126 case PID::CQUARK:
127 _multPiPlus[2]->fill();
128 _h_XpPiPlusCharm->fill(xp);
129 break;
130 case PID::BQUARK:
131 _multPiPlus[3]->fill();
132 _h_XpPiPlusBottom->fill(xp);
133 break;
134 }
135 }
136 else if (id == PID::KPLUS) {
137 _h_XpKPlusN->fill(xp);
138 _multKPlus[0]->fill();
139 switch (flavour) {
140 case PID::DQUARK:
141 case PID::UQUARK:
142 case PID::SQUARK:
143 _multKPlus[1]->fill();
144 _temp_XpKPlusLight->fill(xp);
145 _h_XpKPlusLight->fill(xp);
146 if( ( quark && p.pid()>0 ) || ( !quark && p.pid()<0 ))
147 _h_RKPlus->fill(xp);
148 else
149 _h_RKMinus->fill(xp);
150 break;
151 break;
152 case PID::CQUARK:
153 _multKPlus[2]->fill();
154 _h_XpKPlusCharm->fill(xp);
155 _temp_XpKPlusCharm->fill(xp);
156 break;
157 case PID::BQUARK:
158 _multKPlus[3]->fill();
159 _h_XpKPlusBottom->fill(xp);
160 break;
161 }
162 }
163 else if (id == PID::PROTON) {
164 _h_XpProtonN->fill(xp);
165 _multProton[0]->fill();
166 switch (flavour) {
167 case PID::DQUARK:
168 case PID::UQUARK:
169 case PID::SQUARK:
170 _multProton[1]->fill();
171 _temp_XpProtonLight->fill(xp);
172 _h_XpProtonLight->fill(xp);
173 if( ( quark && p.pid()>0 ) || ( !quark && p.pid()<0 ))
174 _h_RProton->fill(xp);
175 else
176 _h_RPBar ->fill(xp);
177 break;
178 break;
179 case PID::CQUARK:
180 _multProton[2]->fill();
181 _temp_XpProtonCharm->fill(xp);
182 _h_XpProtonCharm->fill(xp);
183 break;
184 case PID::BQUARK:
185 _multProton[3]->fill();
186 _h_XpProtonBottom->fill(xp);
187 break;
188 }
189 }
190 }
191
192 const UnstableParticles& ufs = apply<UnstableParticles>(e, "UFS");
193 for (const Particle& p : ufs.particles()) {
194 const double xp = p.p3().mod()/meanBeamMom;
195 // if in quark or antiquark hemisphere
196 bool quark = p.p3().dot(axis)*dot>0.;
197 int id = p.abspid();
198 if (id == PID::LAMBDA) {
199 _multLambda[0]->fill();
200 _h_XpLambdaN->fill(xp);
201 switch (flavour) {
202 case PID::DQUARK:
203 case PID::UQUARK:
204 case PID::SQUARK:
205 _multLambda[1]->fill();
206 _h_XpLambdaLight->fill(xp);
207 if( ( quark && p.pid()>0 ) || ( !quark && p.pid()<0 ))
208 _h_RLambda->fill(xp);
209 else
210 _h_RLBar ->fill(xp);
211 break;
212 case PID::CQUARK:
213 _multLambda[2]->fill();
214 _h_XpLambdaCharm->fill(xp);
215 break;
216 case PID::BQUARK:
217 _multLambda[3]->fill();
218 _h_XpLambdaBottom->fill(xp);
219 break;
220 }
221 }
222 else if (id == 313) {
223 _multKStar0[0]->fill();
224 _h_XpKStar0N->fill(xp);
225 switch (flavour) {
226 case PID::DQUARK:
227 case PID::UQUARK:
228 case PID::SQUARK:
229 _multKStar0[1]->fill();
230 _temp_XpKStar0Light->fill(xp);
231 _h_XpKStar0Light->fill(xp);
232 if ( ( quark && p.pid()>0 ) || ( !quark && p.pid()<0 ))
233 _h_RKS0 ->fill(xp);
234 else
235 _h_RKSBar0->fill(xp);
236 break;
237 break;
238 case PID::CQUARK:
239 _multKStar0[2]->fill();
240 _temp_XpKStar0Charm->fill(xp);
241 _h_XpKStar0Charm->fill(xp);
242 break;
243 case PID::BQUARK:
244 _multKStar0[3]->fill();
245 _h_XpKStar0Bottom->fill(xp);
246 break;
247 }
248 }
249 else if (id == 333) {
250 _multPhi[0]->fill();
251 _h_XpPhiN->fill(xp);
252 switch (flavour) {
253 case PID::DQUARK:
254 case PID::UQUARK:
255 case PID::SQUARK:
256 _multPhi[1]->fill();
257 _h_XpPhiLight->fill(xp);
258 break;
259 case PID::CQUARK:
260 _multPhi[2]->fill();
261 _h_XpPhiCharm->fill(xp);
262 break;
263 case PID::BQUARK:
264 _multPhi[3]->fill();
265 _h_XpPhiBottom->fill(xp);
266 break;
267 }
268 }
269 else if (id == PID::K0S || id == PID::K0L) {
270 _multK0[0]->fill();
271 _h_XpK0N->fill(xp);
272 switch (flavour) {
273 case PID::DQUARK:
274 case PID::UQUARK:
275 case PID::SQUARK:
276 _multK0[1]->fill();
277 _h_XpK0Light->fill(xp);
278 break;
279 case PID::CQUARK:
280 _multK0[2]->fill();
281 _h_XpK0Charm->fill(xp);
282 break;
283 case PID::BQUARK:
284 _multK0[3]->fill();
285 _h_XpK0Bottom->fill(xp);
286 break;
287 }
288 }
289 }
290 }
291
292
293 void init() {
294 // Projections
295 declare(Beam(), "Beams");
296 declare(ChargedFinalState(), "FS");
297 declare(UnstableParticles(), "UFS");
298 declare(InitialQuarks(), "IQF");
299 declare(Thrust(FinalState()), "Thrust");
300
301 book(_temp_XpChargedN1 ,"TMP/XpChargedN1", refData( 1, 1, 1));
302 book(_temp_XpChargedN2 ,"TMP/XpChargedN2", refData( 2, 1, 1));
303 book(_temp_XpChargedN3 ,"TMP/XpChargedN3", refData( 3, 1, 1));
304
305 book(_h_XpPiPlusN , 1, 1, 2);
306 book(_h_XpKPlusN , 2, 1, 2);
307 book(_h_XpProtonN , 3, 1, 2);
308 book(_h_XpChargedN , 4, 1, 1);
309 book(_h_XpK0N , 5, 1, 1);
310 book(_h_XpLambdaN , 7, 1, 1);
311 book(_h_XpKStar0N , 8, 1, 1);
312 book(_h_XpPhiN , 9, 1, 1);
313
314 book(_h_XpPiPlusLight ,10, 1, 1);
315 book(_h_XpPiPlusCharm ,10, 1, 2);
316 book(_h_XpPiPlusBottom ,10, 1, 3);
317 book(_h_XpKPlusLight ,12, 1, 1);
318 book(_h_XpKPlusCharm ,12, 1, 2);
319 book(_h_XpKPlusBottom ,12, 1, 3);
320 book(_h_XpKStar0Light ,14, 1, 1);
321 book(_h_XpKStar0Charm ,14, 1, 2);
322 book(_h_XpKStar0Bottom ,14, 1, 3);
323 book(_h_XpProtonLight ,16, 1, 1);
324 book(_h_XpProtonCharm ,16, 1, 2);
325 book(_h_XpProtonBottom ,16, 1, 3);
326 book(_h_XpLambdaLight ,18, 1, 1);
327 book(_h_XpLambdaCharm ,18, 1, 2);
328 book(_h_XpLambdaBottom ,18, 1, 3);
329 book(_h_XpK0Light ,20, 1, 1);
330 book(_h_XpK0Charm ,20, 1, 2);
331 book(_h_XpK0Bottom ,20, 1, 3);
332 book(_h_XpPhiLight ,22, 1, 1);
333 book(_h_XpPhiCharm ,22, 1, 2);
334 book(_h_XpPhiBottom ,22, 1, 3);
335
336 book(_temp_XpKPlusCharm ,"TMP/XpKPlusCharm", refData(13, 1, 1));
337 book(_temp_XpKPlusLight ,"TMP/XpKPlusLight", refData(13, 1, 1));
338 book(_temp_XpKStar0Charm ,"TMP/XpKStar0Charm", refData(15, 1, 1));
339 book(_temp_XpKStar0Light ,"TMP/XpKStar0Light", refData(15, 1, 1));
340 book(_temp_XpProtonCharm ,"TMP/XpProtonCharm", refData(17, 1, 1));
341 book(_temp_XpProtonLight ,"TMP/XpProtonLight", refData(17, 1, 1));
342
343 book(_h_RPiPlus , 26, 1, 1);
344 book(_h_RPiMinus , 26, 1, 2);
345 book(_h_RKS0 , 28, 1, 1);
346 book(_h_RKSBar0 , 28, 1, 2);
347 book(_h_RKPlus , 30, 1, 1);
348 book(_h_RKMinus , 30, 1, 2);
349 book(_h_RProton , 32, 1, 1);
350 book(_h_RPBar , 32, 1, 2);
351 book(_h_RLambda , 34, 1, 1);
352 book(_h_RLBar , 34, 1, 2);
353
354 book(_s_Xp_PiPl_Ch , 1, 1, 1);
355 book(_s_Xp_KPl_Ch , 2, 1, 1);
356 book(_s_Xp_Pr_Ch , 3, 1, 1);
357 book(_s_Xp_PiPlCh_PiPlLi, 11, 1, 1);
358 book(_s_Xp_PiPlBo_PiPlLi, 11, 1, 2);
359 book(_s_Xp_KPlCh_KPlLi , 13, 1, 1);
360 book(_s_Xp_KPlBo_KPlLi , 13, 1, 2);
361 book(_s_Xp_KS0Ch_KS0Li , 15, 1, 1);
362 book(_s_Xp_KS0Bo_KS0Li , 15, 1, 2);
363 book(_s_Xp_PrCh_PrLi , 17, 1, 1);
364 book(_s_Xp_PrBo_PrLi , 17, 1, 2);
365 book(_s_Xp_LaCh_LaLi , 19, 1, 1);
366 book(_s_Xp_LaBo_LaLi , 19, 1, 2);
367 book(_s_Xp_K0Ch_K0Li , 21, 1, 1);
368 book(_s_Xp_K0Bo_K0Li , 21, 1, 2);
369 book(_s_Xp_PhiCh_PhiLi , 23, 1, 1);
370 book(_s_Xp_PhiBo_PhiLi , 23, 1, 2);
371
372 book(_s_PiM_PiP , 27, 1, 1);
373 book(_s_KSBar0_KS0, 29, 1, 1);
374 book(_s_KM_KP , 31, 1, 1);
375 book(_s_Pr_PBar , 33, 1, 1);
376 book(_s_Lam_LBar , 35, 1, 1);
377
378 book(_SumOfudsWeights, "_SumOfudsWeights");
379 book(_SumOfcWeights, "_SumOfcWeights");
380 book(_SumOfbWeights, "_SumOfbWeights");
381
382 for ( size_t i=0; i<4; ++i) {
383 book(_multPiPlus[i], "_multPiPlus_"+to_str(i));
384 book(_multKPlus[i], "_multKPlus_"+to_str(i));
385 book(_multK0[i], "_multK0_"+to_str(i));
386 book(_multKStar0[i], "_multKStar0_"+to_str(i));
387 book(_multPhi[i], "_multPhi_"+to_str(i));
388 book(_multProton[i], "_multProton_"+to_str(i));
389 book(_multLambda[i], "_multLambda_"+to_str(i));
390 }
391
392 book(tmp1, 24, 1, 1, true);
393 book(tmp2, 24, 1, 2, true);
394 book(tmp3, 24, 1, 3, true);
395 book(tmp4, 24, 1, 4, true);
396 book(tmp5, 25, 1, 1, true);
397 book(tmp6, 25, 1, 2, true);
398 book(tmp7, 24, 2, 1, true);
399 book(tmp8, 24, 2, 2, true);
400 book(tmp9, 24, 2, 3, true);
401 book(tmp10, 24, 2, 4, true);
402 book(tmp11, 25, 2, 1, true);
403 book(tmp12, 25, 2, 2, true);
404 book(tmp13, 24, 3, 1, true);
405 book(tmp14, 24, 3, 2, true);
406 book(tmp15, 24, 3, 3, true);
407 book(tmp16, 24, 3, 4, true);
408 book(tmp17, 25, 3, 1, true);
409 book(tmp18, 25, 3, 2, true);
410 book(tmp19, 24, 4, 1, true);
411 book(tmp20, 24, 4, 2, true);
412 book(tmp21, 24, 4, 3, true);
413 book(tmp22, 24, 4, 4, true);
414 book(tmp23, 25, 4, 1, true);
415 book(tmp24, 25, 4, 2, true);
416 book(tmp25, 24, 5, 1, true);
417 book(tmp26, 24, 5, 2, true);
418 book(tmp27, 24, 5, 3, true);
419 book(tmp28, 24, 5, 4, true);
420 book(tmp29, 25, 5, 1, true);
421 book(tmp30, 25, 5, 2, true);
422 book(tmp31, 24, 6, 1, true);
423 book(tmp32, 24, 6, 2, true);
424 book(tmp33, 24, 6, 3, true);
425 book(tmp34, 24, 6, 4, true);
426 book(tmp35, 25, 6, 1, true);
427 book(tmp36, 25, 6, 2, true);
428 book(tmp37, 24, 7, 1, true);
429 book(tmp38, 24, 7, 2, true);
430 book(tmp39, 24, 7, 3, true);
431 book(tmp40, 24, 7, 4, true);
432 book(tmp41, 25, 7, 1, true);
433 book(tmp42, 25, 7, 2, true);
434 }
435
436
437 /// Finalize
438 void finalize() {
439 // Get the ratio plots sorted out first
440 divide(_h_XpPiPlusN, _temp_XpChargedN1, _s_Xp_PiPl_Ch);
441 divide(_h_XpKPlusN, _temp_XpChargedN2, _s_Xp_KPl_Ch);
442 divide(_h_XpProtonN, _temp_XpChargedN3, _s_Xp_Pr_Ch);
443 divide(_h_XpPiPlusCharm, _h_XpPiPlusLight, _s_Xp_PiPlCh_PiPlLi);
444 _s_Xp_PiPlCh_PiPlLi->scaleY(dbl(*_SumOfudsWeights / *_SumOfcWeights));
445 divide(_h_XpPiPlusBottom, _h_XpPiPlusLight, _s_Xp_PiPlBo_PiPlLi);
446 _s_Xp_PiPlBo_PiPlLi->scaleY(dbl(*_SumOfudsWeights / *_SumOfbWeights));
447 divide(_temp_XpKPlusCharm , _temp_XpKPlusLight, _s_Xp_KPlCh_KPlLi);
448 _s_Xp_KPlCh_KPlLi->scaleY(dbl(*_SumOfudsWeights / *_SumOfcWeights));
449 divide(_h_XpKPlusBottom, _h_XpKPlusLight, _s_Xp_KPlBo_KPlLi);
450 _s_Xp_KPlBo_KPlLi->scaleY(dbl(*_SumOfudsWeights / *_SumOfbWeights));
451 divide(_temp_XpKStar0Charm, _temp_XpKStar0Light, _s_Xp_KS0Ch_KS0Li);
452 _s_Xp_KS0Ch_KS0Li->scaleY(dbl(*_SumOfudsWeights / *_SumOfcWeights));
453 divide(_h_XpKStar0Bottom, _h_XpKStar0Light, _s_Xp_KS0Bo_KS0Li);
454 _s_Xp_KS0Bo_KS0Li->scaleY(dbl(*_SumOfudsWeights / *_SumOfbWeights));
455 divide(_temp_XpProtonCharm, _temp_XpProtonLight, _s_Xp_PrCh_PrLi);
456 _s_Xp_PrCh_PrLi->scaleY(dbl(*_SumOfudsWeights / *_SumOfcWeights));
457 divide(_h_XpProtonBottom, _h_XpProtonLight, _s_Xp_PrBo_PrLi);
458 _s_Xp_PrBo_PrLi->scaleY(dbl(*_SumOfudsWeights / *_SumOfbWeights));
459 divide(_h_XpLambdaCharm, _h_XpLambdaLight, _s_Xp_LaCh_LaLi);
460 _s_Xp_LaCh_LaLi->scaleY(dbl(*_SumOfudsWeights / *_SumOfcWeights));
461 divide(_h_XpLambdaBottom, _h_XpLambdaLight, _s_Xp_LaBo_LaLi);
462 _s_Xp_LaBo_LaLi->scaleY(dbl(*_SumOfudsWeights / *_SumOfbWeights));
463 divide(_h_XpK0Charm, _h_XpK0Light, _s_Xp_K0Ch_K0Li);
464 _s_Xp_K0Ch_K0Li->scaleY(dbl(*_SumOfudsWeights / *_SumOfcWeights));
465 divide(_h_XpK0Bottom, _h_XpK0Light, _s_Xp_K0Bo_K0Li);
466 _s_Xp_K0Bo_K0Li->scaleY(dbl(*_SumOfudsWeights / *_SumOfbWeights));
467 divide(_h_XpPhiCharm, _h_XpPhiLight, _s_Xp_PhiCh_PhiLi);
468 _s_Xp_PhiCh_PhiLi->scaleY(dbl(*_SumOfudsWeights / *_SumOfcWeights));
469 divide(_h_XpPhiBottom, _h_XpPhiLight, _s_Xp_PhiBo_PhiLi);
470 _s_Xp_PhiBo_PhiLi->scaleY(dbl(*_SumOfudsWeights / *_SumOfbWeights));
471
472 // Then the leading particles
473 divide(*_h_RPiMinus - *_h_RPiPlus, *_h_RPiMinus + *_h_RPiPlus, _s_PiM_PiP);
474 divide(*_h_RKSBar0 - *_h_RKS0, *_h_RKSBar0 + *_h_RKS0, _s_KSBar0_KS0);
475 divide(*_h_RKMinus - *_h_RKPlus, *_h_RKMinus + *_h_RKPlus, _s_KM_KP);
476 divide(*_h_RProton - *_h_RPBar, *_h_RProton + *_h_RPBar, _s_Pr_PBar);
477 divide(*_h_RLambda - *_h_RLBar, *_h_RLambda + *_h_RLBar, _s_Lam_LBar);
478
479 // Then the rest
480 scale(_h_XpPiPlusN, 1/sumOfWeights());
481 scale(_h_XpKPlusN, 1/sumOfWeights());
482 scale(_h_XpProtonN, 1/sumOfWeights());
483 scale(_h_XpChargedN, 1/sumOfWeights());
484 scale(_h_XpK0N, 1/sumOfWeights());
485 scale(_h_XpLambdaN, 1/sumOfWeights());
486 scale(_h_XpKStar0N, 1/sumOfWeights());
487 scale(_h_XpPhiN, 1/sumOfWeights());
488 scale(_h_XpPiPlusLight, 1 / *_SumOfudsWeights);
489 scale(_h_XpPiPlusCharm, 1 / *_SumOfcWeights);
490 scale(_h_XpPiPlusBottom, 1 / *_SumOfbWeights);
491 scale(_h_XpKPlusLight, 1 / *_SumOfudsWeights);
492 scale(_h_XpKPlusCharm, 1 / *_SumOfcWeights);
493 scale(_h_XpKPlusBottom, 1 / *_SumOfbWeights);
494 scale(_h_XpKStar0Light, 1 / *_SumOfudsWeights);
495 scale(_h_XpKStar0Charm, 1 / *_SumOfcWeights);
496 scale(_h_XpKStar0Bottom, 1 / *_SumOfbWeights);
497 scale(_h_XpProtonLight, 1 / *_SumOfudsWeights);
498 scale(_h_XpProtonCharm, 1 / *_SumOfcWeights);
499 scale(_h_XpProtonBottom, 1 / *_SumOfbWeights);
500 scale(_h_XpLambdaLight, 1 / *_SumOfudsWeights);
501 scale(_h_XpLambdaCharm, 1 / *_SumOfcWeights);
502 scale(_h_XpLambdaBottom, 1 / *_SumOfbWeights);
503 scale(_h_XpK0Light, 1 / *_SumOfudsWeights);
504 scale(_h_XpK0Charm, 1 / *_SumOfcWeights);
505 scale(_h_XpK0Bottom, 1 / *_SumOfbWeights);
506 scale(_h_XpPhiLight, 1 / *_SumOfudsWeights);
507 scale(_h_XpPhiCharm , 1 / *_SumOfcWeights);
508 scale(_h_XpPhiBottom, 1 / *_SumOfbWeights);
509 scale(_h_RPiPlus, 1 / *_SumOfudsWeights);
510 scale(_h_RPiMinus, 1 / *_SumOfudsWeights);
511 scale(_h_RKS0, 1 / *_SumOfudsWeights);
512 scale(_h_RKSBar0, 1 / *_SumOfudsWeights);
513 scale(_h_RKPlus, 1 / *_SumOfudsWeights);
514 scale(_h_RKMinus, 1 / *_SumOfudsWeights);
515 scale(_h_RProton, 1 / *_SumOfudsWeights);
516 scale(_h_RPBar, 1 / *_SumOfudsWeights);
517 scale(_h_RLambda, 1 / *_SumOfudsWeights);
518 scale(_h_RLBar, 1 / *_SumOfudsWeights);
519
520 // Multiplicities
521 double avgNumPartsAll, avgNumPartsLight,avgNumPartsCharm, avgNumPartsBottom;
522 // pi+/-
523 // all
524 avgNumPartsAll = dbl(*_multPiPlus[0])/sumOfWeights();
525 tmp1->point(0).setY(avgNumPartsAll);
526 // light
527 avgNumPartsLight = dbl(*_multPiPlus[1] / *_SumOfudsWeights);
528 tmp2->point(0).setY(avgNumPartsLight);
529 // charm
530 avgNumPartsCharm = dbl(*_multPiPlus[2] / *_SumOfcWeights);
531 tmp3->point(0).setY(avgNumPartsCharm);
532 // bottom
533 avgNumPartsBottom = dbl(*_multPiPlus[3] / *_SumOfbWeights);
534 tmp4->point(0).setY(avgNumPartsBottom);
535 // charm-light
536 tmp5->point(0).setY(avgNumPartsCharm - avgNumPartsLight);
537 // bottom-light
538 tmp6->point(0).setY(avgNumPartsBottom - avgNumPartsLight);
539 // K+/-
540 // all
541 avgNumPartsAll = dbl(*_multKPlus[0])/sumOfWeights();
542 tmp7->point(0).setY(avgNumPartsAll);
543 // light
544 avgNumPartsLight = dbl(*_multKPlus[1] / *_SumOfudsWeights);
545 tmp8->point(0).setY(avgNumPartsLight);
546 // charm
547 avgNumPartsCharm = dbl(*_multKPlus[2] / *_SumOfcWeights);
548 tmp9->point(0).setY(avgNumPartsCharm);
549 // bottom
550 avgNumPartsBottom = dbl(*_multKPlus[3] / *_SumOfbWeights);
551 tmp10->point(0).setY(avgNumPartsBottom);
552 // charm-light
553 tmp11->point(0).setY(avgNumPartsCharm - avgNumPartsLight);
554 // bottom-light
555 tmp12->point(0).setY(avgNumPartsBottom - avgNumPartsLight);
556 // K0
557 // all
558 avgNumPartsAll = dbl(*_multK0[0])/sumOfWeights();
559 tmp13->point(0).setY(avgNumPartsAll);
560 // light
561 avgNumPartsLight = dbl(*_multK0[1] / *_SumOfudsWeights);
562 tmp14->point(0).setY(avgNumPartsLight);
563 // charm
564 avgNumPartsCharm = dbl(*_multK0[2] / *_SumOfcWeights);
565 tmp15->point(0).setY(avgNumPartsCharm);
566 // bottom
567 avgNumPartsBottom = dbl(*_multK0[3] / *_SumOfbWeights);
568 tmp16->point(0).setY(avgNumPartsBottom);
569 // charm-light
570 tmp17->point(0).setY(avgNumPartsCharm - avgNumPartsLight);
571 // bottom-light
572 tmp18->point(0).setY(avgNumPartsBottom - avgNumPartsLight);
573 // K*0
574 // all
575 avgNumPartsAll = dbl(*_multKStar0[0])/sumOfWeights();
576 tmp19->point(0).setY(avgNumPartsAll);
577 // light
578 avgNumPartsLight = dbl(*_multKStar0[1] / *_SumOfudsWeights);
579 tmp20->point(0).setY(avgNumPartsLight);
580 // charm
581 avgNumPartsCharm = dbl(*_multKStar0[2] / *_SumOfcWeights);
582 tmp21->point(0).setY(avgNumPartsCharm);
583 // bottom
584 avgNumPartsBottom = dbl(*_multKStar0[3] / *_SumOfbWeights);
585 tmp22->point(0).setY(avgNumPartsBottom);
586 // charm-light
587 tmp23->point(0).setY(avgNumPartsCharm - avgNumPartsLight);
588 // bottom-light
589 tmp24->point(0).setY(avgNumPartsBottom - avgNumPartsLight);
590 // phi
591 // all
592 avgNumPartsAll = dbl(*_multPhi[0])/sumOfWeights();
593 tmp25->point(0).setY(avgNumPartsAll);
594 // light
595 avgNumPartsLight = dbl(*_multPhi[1] / *_SumOfudsWeights);
596 tmp26->point(0).setY(avgNumPartsLight);
597 // charm
598 avgNumPartsCharm = dbl(*_multPhi[2] / *_SumOfcWeights);
599 tmp27->point(0).setY(avgNumPartsCharm);
600 // bottom
601 avgNumPartsBottom = dbl(*_multPhi[3] / *_SumOfbWeights);
602 tmp28->point(0).setY(avgNumPartsBottom);
603 // charm-light
604 tmp29->point(0).setY(avgNumPartsCharm - avgNumPartsLight);
605 // bottom-light
606 tmp30->point(0).setY(avgNumPartsBottom - avgNumPartsLight);
607 // p
608 // all
609 avgNumPartsAll = dbl(*_multProton[0])/sumOfWeights();
610 tmp31->point(0).setY(avgNumPartsAll);
611 // light
612 avgNumPartsLight = dbl(*_multProton[1] / *_SumOfudsWeights);
613 tmp32->point(0).setY(avgNumPartsLight);
614 // charm
615 avgNumPartsCharm = dbl(*_multProton[2] / *_SumOfcWeights);
616 tmp33->point(0).setY(avgNumPartsCharm);
617 // bottom
618 avgNumPartsBottom = dbl(*_multProton[3] / *_SumOfbWeights);
619 tmp34->point(0).setY(avgNumPartsBottom);
620 // charm-light
621 tmp35->point(0).setY(avgNumPartsCharm - avgNumPartsLight);
622 // bottom-light
623 tmp36->point(0).setY(avgNumPartsBottom - avgNumPartsLight);
624 // Lambda
625 // all
626 avgNumPartsAll = dbl(*_multLambda[0])/sumOfWeights();
627 tmp37->point(0).setY(avgNumPartsAll);
628 // light
629 avgNumPartsLight = dbl(*_multLambda[1] / *_SumOfudsWeights);
630 tmp38->point(0).setY(avgNumPartsLight);
631 // charm
632 avgNumPartsCharm = dbl(*_multLambda[2] / *_SumOfcWeights);
633 tmp39->point(0).setY(avgNumPartsCharm);
634 // bottom
635 avgNumPartsBottom = dbl(*_multLambda[3] / *_SumOfbWeights);
636 tmp40->point(0).setY(avgNumPartsBottom);
637 // charm-light
638 tmp41->point(0).setY(avgNumPartsCharm - avgNumPartsLight);
639 // bottom-light
640 tmp42->point(0).setY(avgNumPartsBottom - avgNumPartsLight);
641 }
642
643 //@}
644
645
646 private:
647
648 /// Store the weighted sums of numbers of charged / charged+neutral
649 /// particles. Used to calculate average number of particles for the
650 /// inclusive single particle distributions' normalisations.
651 CounterPtr _SumOfudsWeights, _SumOfcWeights, _SumOfbWeights;
652 vector<CounterPtr> _multPiPlus, _multKPlus, _multK0,
653 _multKStar0, _multPhi, _multProton, _multLambda;
654
655 Histo1DPtr _h_XpPiPlusSig, _h_XpPiPlusN;
656 Histo1DPtr _h_XpKPlusSig, _h_XpKPlusN;
657 Histo1DPtr _h_XpProtonSig, _h_XpProtonN;
658 Histo1DPtr _h_XpChargedN;
659 Histo1DPtr _h_XpK0N, _h_XpLambdaN;
660 Histo1DPtr _h_XpKStar0N, _h_XpPhiN;
661 Histo1DPtr _h_XpPiPlusLight, _h_XpPiPlusCharm, _h_XpPiPlusBottom;
662 Histo1DPtr _h_XpKPlusLight, _h_XpKPlusCharm, _h_XpKPlusBottom;
663 Histo1DPtr _h_XpKStar0Light, _h_XpKStar0Charm, _h_XpKStar0Bottom;
664 Histo1DPtr _h_XpProtonLight, _h_XpProtonCharm, _h_XpProtonBottom;
665 Histo1DPtr _h_XpLambdaLight, _h_XpLambdaCharm, _h_XpLambdaBottom;
666 Histo1DPtr _h_XpK0Light, _h_XpK0Charm, _h_XpK0Bottom;
667 Histo1DPtr _h_XpPhiLight, _h_XpPhiCharm, _h_XpPhiBottom;
668
669 Histo1DPtr _temp_XpChargedN1, _temp_XpChargedN2, _temp_XpChargedN3;
670 Histo1DPtr _temp_XpKPlusCharm , _temp_XpKPlusLight;
671 Histo1DPtr _temp_XpKStar0Charm, _temp_XpKStar0Light;
672 Histo1DPtr _temp_XpProtonCharm, _temp_XpProtonLight;
673
674 Histo1DPtr _h_RPiPlus, _h_RPiMinus;
675 Histo1DPtr _h_RKS0, _h_RKSBar0;
676 Histo1DPtr _h_RKPlus, _h_RKMinus;
677 Histo1DPtr _h_RProton, _h_RPBar;
678 Histo1DPtr _h_RLambda, _h_RLBar;
679
680 Scatter2DPtr _s_Xp_PiPl_Ch, _s_Xp_KPl_Ch, _s_Xp_Pr_Ch;
681 Scatter2DPtr _s_Xp_PiPlCh_PiPlLi, _s_Xp_PiPlBo_PiPlLi;
682 Scatter2DPtr _s_Xp_KPlCh_KPlLi, _s_Xp_KPlBo_KPlLi;
683 Scatter2DPtr _s_Xp_KS0Ch_KS0Li, _s_Xp_KS0Bo_KS0Li;
684 Scatter2DPtr _s_Xp_PrCh_PrLi, _s_Xp_PrBo_PrLi;
685 Scatter2DPtr _s_Xp_LaCh_LaLi, _s_Xp_LaBo_LaLi;
686 Scatter2DPtr _s_Xp_K0Ch_K0Li, _s_Xp_K0Bo_K0Li;
687 Scatter2DPtr _s_Xp_PhiCh_PhiLi, _s_Xp_PhiBo_PhiLi;
688
689 Scatter2DPtr _s_PiM_PiP, _s_KSBar0_KS0, _s_KM_KP, _s_Pr_PBar, _s_Lam_LBar;
690
691 //@}
692 Scatter2DPtr tmp1;
693 Scatter2DPtr tmp2;
694 Scatter2DPtr tmp3;
695 Scatter2DPtr tmp4;
696 Scatter2DPtr tmp5;
697 Scatter2DPtr tmp6;
698 Scatter2DPtr tmp7;
699 Scatter2DPtr tmp8;
700 Scatter2DPtr tmp9;
701 Scatter2DPtr tmp10;
702 Scatter2DPtr tmp11;
703 Scatter2DPtr tmp12;
704 Scatter2DPtr tmp13;
705 Scatter2DPtr tmp14;
706 Scatter2DPtr tmp15;
707 Scatter2DPtr tmp16;
708 Scatter2DPtr tmp17;
709 Scatter2DPtr tmp18;
710 Scatter2DPtr tmp19;
711 Scatter2DPtr tmp20;
712 Scatter2DPtr tmp21;
713 Scatter2DPtr tmp22;
714 Scatter2DPtr tmp23;
715 Scatter2DPtr tmp24;
716 Scatter2DPtr tmp25;
717 Scatter2DPtr tmp26;
718 Scatter2DPtr tmp27;
719 Scatter2DPtr tmp28;
720 Scatter2DPtr tmp29;
721 Scatter2DPtr tmp30;
722 Scatter2DPtr tmp31;
723 Scatter2DPtr tmp32;
724 Scatter2DPtr tmp33;
725 Scatter2DPtr tmp34;
726 Scatter2DPtr tmp35;
727 Scatter2DPtr tmp36;
728 Scatter2DPtr tmp37;
729 Scatter2DPtr tmp38;
730 Scatter2DPtr tmp39;
731 Scatter2DPtr tmp40;
732 Scatter2DPtr tmp41;
733 Scatter2DPtr tmp42;
734 };
735
736
737
738 RIVET_DECLARE_ALIASED_PLUGIN(SLD_1999_S3743934, SLD_1999_I469925);
739
740}
|