All paramatrisation libraries derive from the pure virtual base class AliGenLib.
[u/mrichter/AliRoot.git] / EVGEN / AliGenMUONlib.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /*
17 $Log$
18 Revision 1.9  2000/06/14 15:20:56  morsch
19 Include clean-up (IH)
20
21 Revision 1.8  2000/06/09 20:32:11  morsch
22 All coding rule violations except RS3 corrected
23
24 Revision 1.7  2000/05/02 08:12:13  morsch
25 Coding rule violations corrected.
26
27 Revision 1.6  1999/09/29 09:24:14  fca
28 Introduction of the Copyright and cvs Log
29
30 */
31
32 #include "AliGenMUONlib.h"
33 #include "AliMC.h"
34
35 ClassImp(AliGenMUONlib)
36 //
37 //  Pions
38 Double_t AliGenMUONlib::PtPion(Double_t *px, Double_t *dummy)
39 {
40 //
41 //     PT-PARAMETERIZATION CDF, PRL 61(88) 1819
42 //     POWER LAW FOR PT > 500 MEV
43 //     MT SCALING BELOW (T=160 MEV)
44 //
45   const Double_t kp0 = 1.3;
46   const Double_t kxn = 8.28;
47   const Double_t kxlim=0.5;
48   const Double_t kt=0.160;
49   const Double_t kxmpi=0.139;
50   const Double_t kb=1.;
51   Double_t y, y1, xmpi2, ynorm, a;
52   Double_t x=*px;
53   //
54   y1=TMath::Power(kp0/(kp0+kxlim),kxn);
55   xmpi2=kxmpi*kxmpi;
56   ynorm=kb*(TMath::Exp(-sqrt(kxlim*kxlim+xmpi2)/kt));
57   a=ynorm/y1;
58   if (x > kxlim)
59     y=a*TMath::Power(kp0/(kp0+x),kxn);
60   else
61     y=kb*TMath::Exp(-sqrt(x*x+xmpi2)/kt);
62   return y*x;
63 }
64 //
65 // y-distribution
66 //
67 Double_t AliGenMUONlib::YPion( Double_t *py, Double_t *dummy)
68 {
69 // Pion y
70   const Double_t ka    = 7000.;
71   const Double_t kdy   = 4.;
72
73   Double_t y=TMath::Abs(*py);
74   //
75   Double_t ex = y*y/(2*kdy*kdy);
76   return ka*TMath::Exp(-ex);
77 }
78 //                 particle composition
79 //
80 Int_t AliGenMUONlib::IpPion()
81 {
82 // Pion composition 
83     Float_t random[1];
84     gMC->Rndm(random,1);
85     if (random[0] < 0.5) {
86         return  211;
87     } else {
88         return -211;
89     }
90 }
91
92 //____________________________________________________________
93 //
94 // Mt-scaling
95
96 Double_t AliGenMUONlib::PtScal(Double_t pt, Int_t np)
97 {
98   //    SCALING EN MASSE PAR RAPPORT A PTPI
99   //    MASS PI,K,ETA,RHO,OMEGA,ETA',PHI
100   const Double_t khm[10] = {.13957,.493,.5488,.769,.7826,.958,1.02,0,0,0};
101   //     VALUE MESON/PI AT 5 GEV
102   const Double_t kfmax[10]={1.,0.3,0.55,1.0,1.0,1.0,1.0,0,0,0};
103   np--;
104   Double_t f5=TMath::Power(((sqrt(100.018215)+2.)/(sqrt(100.+khm[np]*khm[np])+2.0)),12.3);
105   Double_t fmax2=f5/kfmax[np];
106   // PIONS
107   Double_t ptpion=100.*PtPion(&pt, (Double_t*) 0);
108   Double_t fmtscal=TMath::Power(((sqrt(pt*pt+0.018215)+2.)/
109                                  (sqrt(pt*pt+khm[np]*khm[np])+2.0)),12.3)/ fmax2;
110   return fmtscal*ptpion;
111 }
112 //
113 // kaon
114 //
115 //                pt-distribution
116 //____________________________________________________________
117 Double_t AliGenMUONlib::PtKaon( Double_t *px, Double_t *dummy)
118 {
119 // Kaon pT
120   return PtScal(*px,2);
121 }
122
123 // y-distribution
124 //____________________________________________________________
125 Double_t AliGenMUONlib::YKaon( Double_t *py, Double_t *dummy)
126 {
127 // Kaon y
128   const Double_t ka    = 1000.;
129   const Double_t kdy   = 4.;
130   
131
132   Double_t y=TMath::Abs(*py);
133   //
134   Double_t ex = y*y/(2*kdy*kdy);
135   return ka*TMath::Exp(-ex);
136 }
137
138 //                 particle composition
139 //
140 Int_t AliGenMUONlib::IpKaon()
141 {
142 // Kaon composition
143     Float_t random[1];
144     gMC->Rndm(random,1);
145     if (random[0] < 0.5) {
146         return  321;
147     } else {
148         return -321;
149     }
150 }
151
152 //                    J/Psi 
153 //
154 //
155 //                pt-distribution
156 //____________________________________________________________
157 Double_t AliGenMUONlib::PtJpsi( Double_t *px, Double_t *dummy)
158 {
159 // J/Psi pT
160   const Double_t kpt0 = 4.;
161   const Double_t kxn  = 3.6;
162   Double_t x=*px;
163   //
164   Double_t pass1 = 1.+(x/kpt0)*(x/kpt0);
165   return x/TMath::Power(pass1,kxn);
166 }
167 //
168 //               y-distribution
169 //____________________________________________________________
170 Double_t AliGenMUONlib::YJpsi(Double_t *py, Double_t *dummy)
171 {
172 // J/psi y
173   const Double_t ky0 = 4.;
174   const Double_t kb=1.;
175   Double_t yj;
176   Double_t y=TMath::Abs(*py);
177   //
178   if (y < ky0)
179     yj=kb;
180   else
181     yj=kb*TMath::Exp(-(y-ky0)*(y-ky0)/2);
182   return yj;
183 }
184 //                 particle composition
185 //
186 Int_t AliGenMUONlib::IpJpsi()
187 {
188 // J/Psi composition
189     return 443;
190 }
191
192 //                      Upsilon
193 //
194 //
195 //                  pt-distribution
196 //____________________________________________________________
197 Double_t AliGenMUONlib::PtUpsilon( Double_t *px, Double_t *dummy )
198 {
199 // Upsilon pT
200   const Double_t kpt0 = 5.3;
201   const Double_t kxn  = 2.5;
202   Double_t x=*px;
203   //
204   Double_t pass1 = 1.+(x/kpt0)*(x/kpt0);
205   return x/TMath::Power(pass1,kxn);
206 }
207 //
208 //                    y-distribution
209 //
210 //____________________________________________________________
211 Double_t AliGenMUONlib::YUpsilon(Double_t *py, Double_t *dummy)
212 {
213 // Upsilon y
214   const Double_t ky0 = 3.;
215   const Double_t kb=1.;
216   Double_t yu;
217   Double_t y=TMath::Abs(*py);
218   //
219   if (y < ky0)
220     yu=kb;
221   else
222     yu=kb*TMath::Exp(-(y-ky0)*(y-ky0)/2);
223   return yu;
224 }
225 //                 particle composition
226 //
227 Int_t AliGenMUONlib::IpUpsilon()
228 {
229 // y composition
230     return 553;
231 }
232
233 //
234 //                        Phi
235 //
236 //
237 //    pt-distribution (by scaling of pion distribution)
238 //____________________________________________________________
239 Double_t AliGenMUONlib::PtPhi( Double_t *px, Double_t *dummy)
240 {
241 // Phi pT
242   return PtScal(*px,7);
243 }
244 //    y-distribution
245 Double_t AliGenMUONlib::YPhi( Double_t *px, Double_t *dummy)
246 {
247 // Phi y
248     Double_t *dum=0;
249     return YJpsi(px,dum);
250 }
251 //                 particle composition
252 //
253 Int_t AliGenMUONlib::IpPhi()
254 {
255 // Phi composition
256     return 41;
257 }
258
259 //
260 //                        Charm
261 //
262 //
263 //                    pt-distribution
264 //____________________________________________________________
265 Double_t AliGenMUONlib::PtCharm( Double_t *px, Double_t *dummy)
266 {
267 // Charm pT
268   const Double_t kpt0 = 4.08;
269   const Double_t kxn  = 9.40;
270   Double_t x=*px;
271   //
272   Double_t pass1 = 1.+(x/kpt0)*(x/kpt0);
273   return x/TMath::Power(pass1,kxn);
274 }
275 //                  y-distribution
276 Double_t AliGenMUONlib::YCharm( Double_t *px, Double_t *dummy)
277 {
278 // Charm y
279     Double_t *dum=0;
280     return YJpsi(px,dum);
281 }
282
283 Int_t AliGenMUONlib::IpCharm()
284 {  
285 // Charm composition
286     Float_t random[2];
287     Int_t ip;
288 //    411,421,431,4122
289     gMC->Rndm(random,2);
290     if (random[0] < 0.5) {
291         ip=411;
292     } else if (random[0] < 0.75) {
293         ip=421;
294     } else if (random[0] < 0.90) {
295         ip=431;
296     } else {
297         ip=4122;
298     }
299     if (random[1] < 0.5) {ip=-ip;}
300     
301     return ip;
302 }
303
304
305 //
306 //                        Beauty
307 //
308 //
309 //                    pt-distribution
310 //____________________________________________________________
311 Double_t AliGenMUONlib::PtBeauty( Double_t *px, Double_t *dummy)
312 {
313 // Beauty pT
314   const Double_t kpt0 = 4.;
315   const Double_t kxn  = 3.6;
316   Double_t x=*px;
317   //
318   Double_t pass1 = 1.+(x/kpt0)*(x/kpt0);
319   return x/TMath::Power(pass1,kxn);
320 }
321 //                     y-distribution
322 Double_t AliGenMUONlib::YBeauty( Double_t *px, Double_t *dummy)
323 {
324 // Beauty y
325     Double_t *dum=0;
326     return YJpsi(px,dum);
327 }
328
329 Int_t AliGenMUONlib::IpBeauty()
330 {  
331 // Beauty Composition
332     Float_t random[2];
333     Int_t ip;
334     gMC->Rndm(random,2);
335     if (random[0] < 0.5) {
336         ip=511;
337     } else if (random[0] < 0.75) {
338         ip=521;
339     } else if (random[0] < 0.90) {
340         ip=531;
341     } else {
342         ip=5122;
343     }
344     if (random[1] < 0.5) {ip=-ip;}
345     
346     return ip;
347 }
348
349 typedef Double_t (*GenFunc) (Double_t*,  Double_t*);
350 GenFunc AliGenMUONlib::GetPt(Param_t param,  const char* tname)
351 {
352 // Return pointer to pT parameterisation
353     GenFunc func;
354     switch (param) 
355     {
356     case phi_p:
357         func=PtPhi;
358         break;
359     case jpsi_p:
360         func=PtJpsi;
361         break;
362     case upsilon_p:
363         func=PtUpsilon;
364         break;
365     case charm_p:
366         func=PtCharm;
367         break;
368     case beauty_p:
369         func=PtBeauty;
370         break;
371     case pion_p:
372         func=PtPion;
373         break;
374     case kaon_p:
375         func=PtKaon;
376         break;
377     default:
378         func=0;
379         printf("<AliGenMUONlib::GetPt> unknown parametrisation\n");
380     }
381     return func;
382 }
383
384 GenFunc AliGenMUONlib::GetY(Param_t param, const char* tname)
385 {
386 // Return pointer to y- parameterisation
387     GenFunc func;
388     switch (param) 
389     {
390     case phi_p:
391         func=YPhi;
392         break;
393     case jpsi_p:
394         func=YJpsi;
395         break;
396     case upsilon_p:
397         func=YUpsilon;
398         break;
399     case charm_p:
400         func=YCharm;
401         break;
402     case beauty_p:
403         func=YBeauty;
404         break;
405     case pion_p:
406         func=YPion;
407         break;
408     case kaon_p:
409         func=YKaon;
410         break;
411     default:
412         func=0;
413         printf("<AliGenMUONlib::GetY> unknown parametrisation\n");
414     }
415     return func;
416 }
417 typedef Int_t (*GenFuncIp) ();
418 GenFuncIp AliGenMUONlib::GetIp(Param_t param,  const char* tname)
419 {
420 // Return pointer to particle type parameterisation
421     GenFuncIp func;
422     switch (param) 
423     {
424     case phi_p:
425         func=IpPhi;
426         break;
427     case jpsi_p:
428         func=IpJpsi;
429         break;
430     case upsilon_p:
431         func=IpUpsilon;
432         break;
433     case charm_p:
434         func=IpCharm;
435         break;
436     case beauty_p:
437         func=IpBeauty;
438         break;
439     case pion_p:
440         func=IpPion;
441         break;
442     case kaon_p:
443         func=IpKaon;
444         break;
445     default:
446         func=0;
447         printf("<AliGenMUONlib::GetIp> unknown parametrisation\n");
448     }
449     return func;
450 }
451
452
453
454