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