6784237ea810526a2c162d7ea27f4e168c608446
[u/mrichter/AliRoot.git] / EVGEN / AliGenSTRANGElib.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 //======================================================================
18 //  AliGenSTRANGElib class contains parameterizations of the
19 //  kaon, phi and hyperon (Lambda, Anti-Lambda, Xi, anti-Xi, Omega,
20 //  anti-Omega)  for the PPR study of the strange particle production. 
21 //  These parameterizations are used by the 
22 //  AliGenParam  class:
23 //  AliGenParam(npar, param,  AliGenSTRANGElib::GetPt(param),
24 //                            AliGenSTRANGElib::GetY(param),
25 //                            AliGenSTRANGElib::GetIp(param) )
26 //  param represents the particle to be simulated. 
27 //  ?????????
28 //  Pt distributions are calculated from the transverse mass scaling 
29 //  with Pions, using the PtScal function taken from AliGenMUONlib 
30 //  version aliroot 3.01
31 //
32 //     Rocco CALIANDRO. Rosa Anna FINI, Tiziano VIRGILI
33 //     Rocco.Caliandro@cern.ch Rosanna.Fini@ba.infn.it, 
34 //     Tiziano.Virgili@roma1.infn.it
35 //======================================================================
36
37 /* $Id$ */
38
39 #include "TMath.h"
40 #include "TRandom.h"
41
42 #include "AliGenSTRANGElib.h"
43
44 ClassImp(AliGenSTRANGElib)
45
46 //============================================================= 
47 //
48  Double_t AliGenSTRANGElib::PtScal(Double_t pt, Int_t np)
49 {
50 // Mt-scaling
51 // Function for the calculation of the Pt distribution for a 
52 // given particle np, from the pion Pt distribution using the 
53 // mt scaling. This function was taken from AliGenMUONlib 
54 // aliroot version 3.01, and was extended for hyperons.
55 // np = 1=>Pions 2=>Kaons 3=>Etas 4=>Omegas 5=>ETA' 6=>PHI
56 //      7=>BARYONS-BARYONBARS
57 //      8=>Lambda-antiLambda
58 //      9=>Xi-antiXi
59 //     10=>Omega-antiOmega
60
61   //    MASS SCALING RESPECT TO PIONS
62   //    MASS                1=>PI,  2=>K, 3=>ETA,4=>OMEGA,5=>ETA',6=>PHI 
63   const Double_t khm[11] = {0.1396, 0.494,0.547, 0.782,   0.957,  1.02, 
64   //    MASS               7=>BARYON-BARYONBAR  
65                                  0.938, 
66   //    MASS               8=>Lambda-antiLambda  
67                                   1.1157,
68   //    MASS               9=>Xi-antiXi  
69                                   1.3213, 
70   //    MASS              10=>Omega-antiOmega  
71                                   1.6725,
72   //    MASS              11=>Lambda(1520)
73                                   1.5195};
74   //     VALUE MESON/PI AT 5 GEV
75   const Double_t kfmax[11]={1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.};
76   np--;
77   Double_t f5=TMath::Power(((sqrt(100.018215)+2.)/(sqrt(100.+khm[np]*khm[np])+2.0)),12.3);
78   Double_t kfmax2=f5/kfmax[np];
79   // PIONS
80   Double_t ptpion=100.*PtPion(&pt, (Double_t*) 0);
81   Double_t fmtscal=TMath::Power(((sqrt(pt*pt+0.018215)+2.)/
82                                  (sqrt(pt*pt+khm[np]*khm[np])+2.0)),12.3)/ kfmax2;
83   return fmtscal*ptpion;
84 }
85 //============================================================= 
86 //
87  Double_t AliGenSTRANGElib::PtPion(const Double_t *px, const Double_t *)
88 {
89 //     Pion transverse momentum distribtuion taken 
90 //     from AliGenMUONlib class, version 3.01 of aliroot
91 //     PT-PARAMETERIZATION CDF, PRL 61(88) 1819
92 //     POWER LAW FOR PT > 500 MEV
93 //     MT SCALING BELOW (T=160 MEV)
94 //
95   const Double_t kp0 = 1.3;
96   const Double_t kxn = 8.28;
97   const Double_t kxlim=0.5;
98   const Double_t kt=0.160;
99   const Double_t kxmpi=0.139;
100   const Double_t kb=1.;
101   Double_t y, y1, kxmpi2, ynorm, a;
102   Double_t x=*px;
103   //
104   y1=TMath::Power(kp0/(kp0+kxlim),kxn);
105   kxmpi2=kxmpi*kxmpi;
106   ynorm=kb*(TMath::Exp(-sqrt(kxlim*kxlim+kxmpi2)/kt));
107   a=ynorm/y1;
108   if (x > kxlim)
109     y=a*TMath::Power(kp0/(kp0+x),kxn);
110   else
111     y=kb*TMath::Exp(-sqrt(x*x+kxmpi2)/kt);
112   return y*x;
113 }
114 // End Scaling
115 //============================================================================
116 //    K  A  O  N  
117  Double_t AliGenSTRANGElib::PtKaon( const Double_t *px, const Double_t *)
118 {
119 //                kaon
120 //                pt-distribution
121 //____________________________________________________________
122
123   return PtScal(*px,2);  //  2==> Kaon in the PtScal function
124 }
125
126  Double_t AliGenSTRANGElib::YKaon( const Double_t *py, const Double_t *)
127 {
128 // y-distribution
129 //____________________________________________________________
130
131   const Double_t ka    = 1000.;
132   const Double_t kdy   = 4.;
133
134
135   Double_t y=TMath::Abs(*py);
136   //
137   Double_t ex = y*y/(2*kdy*kdy);
138   return ka*TMath::Exp(-ex);
139 }
140
141  Int_t AliGenSTRANGElib::IpKaon(TRandom *ran)
142 {
143 //                 particle composition
144 //
145
146     Float_t random = ran->Rndm();
147     Float_t random2 = ran->Rndm();
148     if (random2 < 0.5) 
149     {
150       if (random < 0.5) {       
151         return  321;   //   K+
152       } else {
153         return -321;   // K-
154       }
155     }
156     else
157     {  
158       if (random < 0.5) {       
159         return  130;   // K^0 short
160       } else {  
161         return  310;   // K^0 long
162       }
163     }
164 }
165 // End Kaons
166 //============================================================================
167 //============================================================================
168 //    P  H  I   
169  Double_t AliGenSTRANGElib::PtPhi( const Double_t *px, const Double_t *)
170 {
171 // phi
172 //                pt-distribution
173 //____________________________________________________________
174
175   return PtScal(*px,6);  //  6==> Phi in the PtScal function
176 }
177
178  Double_t AliGenSTRANGElib::YPhi( const Double_t *py, const Double_t *)
179 {
180 // y-distribution
181 //____________________________________________________________
182
183   const Double_t ka    = 1000.;
184   const Double_t kdy   = 4.;
185
186
187   Double_t y=TMath::Abs(*py);
188   //
189   Double_t ex = y*y/(2*kdy*kdy);
190   return ka*TMath::Exp(-ex);
191 }
192
193  Int_t AliGenSTRANGElib::IpPhi(TRandom *)
194 {
195 //                 particle composition
196 //
197     
198         return  333;   //   Phi      
199 }
200 // End Phis
201 //===================================================================
202 //============================================================================
203 //    Lambda
204  Double_t AliGenSTRANGElib::PtLambda( const Double_t *px, const Double_t *)
205 {
206 // Lambda
207 //                pt-distribution
208 //____________________________________________________________
209
210   return PtScal(*px,8);  //  8==> Lambda-antiLambda in the PtScal function
211 }
212
213  Double_t AliGenSTRANGElib::YLambda( const Double_t *py, const Double_t *)
214 {
215 // y-distribution
216 //____________________________________________________________
217
218   const Double_t ka    = 1000.;
219   const Double_t kdy   = 4.;
220
221
222   Double_t y=TMath::Abs(*py);
223   //
224   Double_t ex = y*y/(2*kdy*kdy);
225   return ka*TMath::Exp(-ex);
226 }
227
228  Int_t AliGenSTRANGElib::IpLambda(TRandom *ran)
229 {
230 //                 particle composition
231 //                 generation of fixed type of particle
232 //
233     Float_t random = ran->Rndm();
234     if (random < 0.5) {       
235       return  3122;   //   Lambda 
236     } else {  
237       return -3122;   //   Anti-Lambda
238     }
239 }
240 // End Lambda
241 //============================================================================
242 //    XIminus
243  Double_t AliGenSTRANGElib::PtXiMinus( const Double_t *px, const Double_t *)
244 {
245 // Xi
246 //                pt-distribution
247 //____________________________________________________________
248
249   return PtScal(*px,9);  //  9==> Xi-antiXi in the PtScal function
250 }
251
252  Double_t AliGenSTRANGElib::YXiMinus( const Double_t *py, const Double_t *)
253 {
254 // y-distribution
255 //____________________________________________________________
256
257   const Double_t ka    = 1000.;
258   const Double_t kdy   = 4.;
259
260
261   Double_t y=TMath::Abs(*py);
262   //
263   Double_t ex = y*y/(2*kdy*kdy);
264   return ka*TMath::Exp(-ex);
265 }
266
267  Int_t AliGenSTRANGElib::IpXiMinus(TRandom *ran)
268 {
269 //                 particle composition
270 //                 generation of fixed type of particle
271 //
272     Float_t random = ran->Rndm();
273     if (random < 0.5) {       
274       return  3312;   //   Xi- 
275     } else {  
276       return -3312;   //   Xi+
277     }
278 }
279 // End Ximinus
280 //============================================================================
281 //    Omegaminus
282  Double_t AliGenSTRANGElib::PtOmegaMinus( const Double_t *px, const Double_t *)
283 {
284 // Omega
285 //                pt-distribution
286 //____________________________________________________________
287
288   return PtScal(*px,10);  //  10==> Omega-antiOmega in the PtScal function
289 }
290
291  Double_t AliGenSTRANGElib::YOmegaMinus( const Double_t *py, const Double_t *)
292 {
293 // y-distribution
294 //____________________________________________________________
295
296   const Double_t ka    = 1000.;
297   const Double_t kdy   = 4.;
298
299
300   Double_t y=TMath::Abs(*py);
301   //
302   Double_t ex = y*y/(2*kdy*kdy);
303   return ka*TMath::Exp(-ex);
304 }
305
306  Int_t AliGenSTRANGElib::IpOmegaMinus(TRandom * ran)
307 {
308 //                 particle composition
309 //                 generation of fixed type of particle
310 //
311
312     Float_t random = ran->Rndm();
313     if (random < 0.5) {       
314       return  3334;   //   Omega- 
315     } else {  
316       return -3334;   //   Omega+
317     }
318 }
319 // End Omegaminus
320 //============================================================================
321 //     Lambda(1520)
322 Double_t AliGenSTRANGElib::PtLambda1520( const Double_t *px, const Double_t *)
323 {
324 // Lambda(1520)
325 //                  pt-distribution
326 //____________________________________________________________
327
328   return PtScal(*px,11);   //   11=> Lambda(1520) in the PtScal function
329 }
330
331 Double_t AliGenSTRANGElib::YLambda1520( const Double_t *py, const Double_t *)
332 {
333 // y-distribution
334 //____________________________________________________________
335
336   const Double_t ka   = 1000.;
337   const Double_t kdy  = 4.;
338
339   
340   Double_t y=TMath::Abs(*py);
341   //
342   Double_t ex = y*y/(2*kdy*kdy);
343   return ka*TMath::Exp(-ex);
344 }
345
346 Int_t AliGenSTRANGElib::IpLambda1520(TRandom * ran)
347 {
348 //                 particle composition
349 //                 generation of fixed type of particle
350 //
351
352    Float_t random = ran->Rndm();
353    if (random < 0.5) {       
354      return  3124;   //   Lambda(1520) 
355    } else {  
356      return -3124;   //   antiLambda(1520)
357    }
358 }
359 // End Lambda(1520)
360 //============================================================================
361
362 typedef Double_t (*GenFunc) (const Double_t*,  const Double_t*);
363  GenFunc AliGenSTRANGElib::GetPt(Int_t param, const char* /*tname*/) const
364 {
365 // Return pinter to pT parameterisation
366     GenFunc func;
367     
368     switch (param)
369     {
370     case kKaon:
371         func=PtKaon;
372         break;
373     case kPhi:
374         func=PtPhi;
375         break;
376     case kLambda:
377         func=PtLambda;
378         break;
379     case kXiMinus:
380         func=PtXiMinus;
381         break;
382     case kOmegaMinus:
383         func=PtOmegaMinus;
384         break;
385     case kLambda1520:
386         func=PtLambda1520;
387         break;
388     default:
389         func=0;
390         printf("<AliGenSTRANGElib::GetPt> unknown parametrisationn");
391     }
392     return func;
393 }
394
395  GenFunc AliGenSTRANGElib::GetY(Int_t param, const char* /*tname*/) const
396 {
397 // Return pointer to Y parameterisation
398     GenFunc func;
399     switch (param)
400     {
401     case kKaon:
402         func=YKaon;
403         break;
404     case kPhi:
405         func=YPhi;
406         break;
407     case kLambda:
408         func=YLambda;
409         break;
410     case kXiMinus:
411         func=YXiMinus;
412         break;
413     case kOmegaMinus:
414         func=YOmegaMinus;
415         break;
416     case kLambda1520:
417         func=YLambda1520;
418         break;
419     default:
420         func=0;
421         printf("<AliGenSTRANGElib::GetY> unknown parametrisationn");
422     }
423     return func;
424 }
425 typedef Int_t (*GenFuncIp) (TRandom *);
426  GenFuncIp AliGenSTRANGElib::GetIp(Int_t param,  const char* /*tname*/) const
427 {
428 // Return pointer to particle composition
429     GenFuncIp func;
430     switch (param)
431     {
432     case kKaon:
433         func=IpKaon;
434         break;
435     case kPhi:
436         func=IpPhi;
437         break;
438     case kLambda:
439         func=IpLambda;
440         break;
441     case kXiMinus:
442         func=IpXiMinus;
443         break;
444     case kOmegaMinus:
445         func=IpOmegaMinus;
446         break;
447     case kLambda1520:
448         func=IpLambda1520;
449         break;
450     default:
451         func=0;
452         printf("<AliGenSTRANGElib::GetIp> unknown parametrisationn");
453     }
454     return func;
455 }
456