const added.
[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 /*
38 $Log$
39 Revision 1.1  2001/12/04 18:06:39  morsch
40 AliGenSTRANGElib.cxx first commit.
41
42 */
43
44 #include "TMath.h"
45 #include "TRandom.h"
46
47 #include "AliGenSTRANGElib.h"
48
49 ClassImp(AliGenSTRANGElib)
50
51 //============================================================= 
52 //
53  Double_t AliGenSTRANGElib::PtScal(Double_t pt, Int_t np)
54 {
55 // Mt-scaling
56 // Function for the calculation of the Pt distribution for a 
57 // given particle np, from the pion Pt distribution using the 
58 // mt scaling. This function was taken from AliGenMUONlib 
59 // aliroot version 3.01, and was extended for hyperons.
60 // np = 1=>Pions 2=>Kaons 3=>Etas 4=>Omegas 5=>ETA' 6=>PHI
61 //      7=>BARYONS-BARYONBARS
62 //      8=>Lambda-antiLambda
63 //      9=>Xi-antiXi
64 //     10=>Omega-antiOmega
65
66   //    MASS SCALING RESPECT TO PIONS
67   //    MASS                1=>PI,  2=>K, 3=>ETA,4=>OMEGA,5=>ETA',6=>PHI 
68   const Double_t khm[10] = {0.1396, 0.494,0.547, 0.782,   0.957,  1.02, 
69   //    MASS               7=>BARYON-BARYONBAR  
70                                  0.938, 
71   //    MASS               8=>Lambda-antiLambda  
72                                   1.1157,
73   //    MASS               9=>Xi-antiXi  
74                                   1.3213, 
75   //    MASS              10=>Omega-antiOmega  
76                                   1.6725};
77   //     VALUE MESON/PI AT 5 GEV
78   const Double_t kfmax[10]={1., 1., 1., 1., 1., 1., 1., 1., 1., 1.};
79   np--;
80   Double_t f5=TMath::Power(((sqrt(100.018215)+2.)/(sqrt(100.+khm[np]*khm[np])+2.0)),12.3);
81   Double_t kfmax2=f5/kfmax[np];
82   // PIONS
83   Double_t ptpion=100.*PtPion(&pt, (Double_t*) 0);
84   Double_t fmtscal=TMath::Power(((sqrt(pt*pt+0.018215)+2.)/
85                                  (sqrt(pt*pt+khm[np]*khm[np])+2.0)),12.3)/ kfmax2;
86   return fmtscal*ptpion;
87 }
88 //============================================================= 
89 //
90  Double_t AliGenSTRANGElib::PtPion(Double_t *px, Double_t *)
91 {
92 //     Pion transverse momentum distribtuion taken 
93 //     from AliGenMUONlib class, version 3.01 of aliroot
94 //     PT-PARAMETERIZATION CDF, PRL 61(88) 1819
95 //     POWER LAW FOR PT > 500 MEV
96 //     MT SCALING BELOW (T=160 MEV)
97 //
98   const Double_t kp0 = 1.3;
99   const Double_t kxn = 8.28;
100   const Double_t kxlim=0.5;
101   const Double_t kt=0.160;
102   const Double_t kxmpi=0.139;
103   const Double_t kb=1.;
104   Double_t y, y1, kxmpi2, ynorm, a;
105   Double_t x=*px;
106   //
107   y1=TMath::Power(kp0/(kp0+kxlim),kxn);
108   kxmpi2=kxmpi*kxmpi;
109   ynorm=kb*(TMath::Exp(-sqrt(kxlim*kxlim+kxmpi2)/kt));
110   a=ynorm/y1;
111   if (x > kxlim)
112     y=a*TMath::Power(kp0/(kp0+x),kxn);
113   else
114     y=kb*TMath::Exp(-sqrt(x*x+kxmpi2)/kt);
115   return y*x;
116 }
117 // End Scaling
118 //============================================================================
119 //    K  A  O  N  
120  Double_t AliGenSTRANGElib::PtKaon( Double_t *px, Double_t *)
121 {
122 //                kaon
123 //                pt-distribution
124 //____________________________________________________________
125
126   return PtScal(*px,2);  //  2==> Kaon in the PtScal function
127 }
128
129  Double_t AliGenSTRANGElib::YKaon( Double_t *py, Double_t *)
130 {
131 // y-distribution
132 //____________________________________________________________
133
134   const Double_t ka    = 1000.;
135   const Double_t kdy   = 4.;
136
137
138   Double_t y=TMath::Abs(*py);
139   //
140   Double_t ex = y*y/(2*kdy*kdy);
141   return ka*TMath::Exp(-ex);
142 }
143
144  Int_t AliGenSTRANGElib::IpKaon(TRandom *ran)
145 {
146 //                 particle composition
147 //
148
149     Float_t random = ran->Rndm();
150     Float_t random2 = ran->Rndm();
151     if (random2 < 0.5) 
152     {
153       if (random < 0.5) {       
154         return  321;   //   K+
155       } else {
156         return -321;   // K-
157       }
158     }
159     else
160     {  
161       if (random < 0.5) {       
162         return  130;   // K^0 short
163       } else {  
164         return  310;   // K^0 long
165       }
166     }
167 }
168 // End Kaons
169 //============================================================================
170 //============================================================================
171 //    P  H  I   
172  Double_t AliGenSTRANGElib::PtPhi( Double_t *px, Double_t *)
173 {
174 // phi
175 //                pt-distribution
176 //____________________________________________________________
177
178   return PtScal(*px,6);  //  6==> Phi in the PtScal function
179 }
180
181  Double_t AliGenSTRANGElib::YPhi( Double_t *py, Double_t *)
182 {
183 // y-distribution
184 //____________________________________________________________
185
186   const Double_t ka    = 1000.;
187   const Double_t kdy   = 4.;
188
189
190   Double_t y=TMath::Abs(*py);
191   //
192   Double_t ex = y*y/(2*kdy*kdy);
193   return ka*TMath::Exp(-ex);
194 }
195
196  Int_t AliGenSTRANGElib::IpPhi(TRandom *)
197 {
198 //                 particle composition
199 //
200     
201         return  333;   //   Phi      
202 }
203 // End Phis
204 //===================================================================
205 //============================================================================
206 //    Lambda
207  Double_t AliGenSTRANGElib::PtLambda( Double_t *px, Double_t *)
208 {
209 // Lambda
210 //                pt-distribution
211 //____________________________________________________________
212
213   return PtScal(*px,8);  //  8==> Lambda-antiLambda in the PtScal function
214 }
215
216  Double_t AliGenSTRANGElib::YLambda( Double_t *py, Double_t *)
217 {
218 // y-distribution
219 //____________________________________________________________
220
221   const Double_t ka    = 1000.;
222   const Double_t kdy   = 4.;
223
224
225   Double_t y=TMath::Abs(*py);
226   //
227   Double_t ex = y*y/(2*kdy*kdy);
228   return ka*TMath::Exp(-ex);
229 }
230
231  Int_t AliGenSTRANGElib::IpLambda(TRandom *)
232 {
233 //                 particle composition
234 //                 generation of fixed type of particle
235 //
236
237         return  3122; //   Lambda 
238 }
239 // End Lambda
240 //============================================================================
241 //    XIminus
242  Double_t AliGenSTRANGElib::PtXiMinus( Double_t *px, Double_t *)
243 {
244 // Xi
245 //                pt-distribution
246 //____________________________________________________________
247
248   return PtScal(*px,9);  //  9==> Xi-antiXi in the PtScal function
249 }
250
251  Double_t AliGenSTRANGElib::YXiMinus( Double_t *py, Double_t *)
252 {
253 // y-distribution
254 //____________________________________________________________
255
256   const Double_t ka    = 1000.;
257   const Double_t kdy   = 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 *)
267 {
268 //                 particle composition
269 //                 generation of fixed type of particle
270 //
271
272         return  3312; //   Xi- (only)
273 //        return  -3312; //   Xi+
274 }
275 // End Ximinus
276 //============================================================================
277 //    Omegaminus
278  Double_t AliGenSTRANGElib::PtOmegaMinus( Double_t *px, Double_t *)
279 {
280 // Omega
281 //                pt-distribution
282 //____________________________________________________________
283
284   return PtScal(*px,10);  //  10==> Omega-antiOmega in the PtScal function
285 }
286
287  Double_t AliGenSTRANGElib::YOmegaMinus( Double_t *py, Double_t *)
288 {
289 // y-distribution
290 //____________________________________________________________
291
292   const Double_t ka    = 1000.;
293   const Double_t kdy   = 4.;
294
295
296   Double_t y=TMath::Abs(*py);
297   //
298   Double_t ex = y*y/(2*kdy*kdy);
299   return ka*TMath::Exp(-ex);
300 }
301
302  Int_t AliGenSTRANGElib::IpOmegaMinus(TRandom *)
303 {
304 //                 particle composition
305 //                 generation of fixed type of particle
306 //
307
308         return  3334; //   Omega- 
309 }
310 // End Omegaminus
311 //============================================================================
312
313
314 typedef Double_t (*GenFunc) (Double_t*,  Double_t*);
315  GenFunc AliGenSTRANGElib::GetPt(Int_t param, const char* tname) const
316 {
317 // Return pinter to pT parameterisation
318     GenFunc func;
319     
320     switch (param)
321     {
322     case kKaon:
323         func=PtKaon;
324         break;
325     case kPhi:
326         func=PtPhi;
327         break;
328     case kLambda:
329         func=PtLambda;
330         break;
331     case kXiMinus:
332         func=PtXiMinus;
333         break;
334     case kOmegaMinus:
335         func=PtOmegaMinus;
336         break;
337     default:
338         func=0;
339         printf("<AliGenSTRANGElib::GetPt> unknown parametrisationn");
340     }
341     return func;
342 }
343
344  GenFunc AliGenSTRANGElib::GetY(Int_t param, const char* tname) const
345 {
346 // Return pointer to Y parameterisation
347     GenFunc func;
348     switch (param)
349     {
350     case kKaon:
351         func=YKaon;
352         break;
353     case kPhi:
354         func=YPhi;
355         break;
356     case kLambda:
357         func=YLambda;
358         break;
359     case kXiMinus:
360         func=YXiMinus;
361         break;
362     case kOmegaMinus:
363         func=YOmegaMinus;
364         break;
365     default:
366         func=0;
367         printf("<AliGenSTRANGElib::GetY> unknown parametrisationn");
368     }
369     return func;
370 }
371 typedef Int_t (*GenFuncIp) (TRandom *);
372  GenFuncIp AliGenSTRANGElib::GetIp(Int_t param,  const char* tname) const
373 {
374 // Return pointer to particle composition
375     GenFuncIp func;
376     switch (param)
377     {
378     case kKaon:
379         func=IpKaon;
380         break;
381     case kPhi:
382         func=IpPhi;
383         break;
384     case kLambda:
385         func=IpLambda;
386         break;
387     case kXiMinus:
388         func=IpXiMinus;
389         break;
390     case kOmegaMinus:
391         func=IpOmegaMinus;
392         break;
393     default:
394         func=0;
395         printf("<AliGenSTRANGElib::GetIp> unknown parametrisationn");
396     }
397     return func;
398 }
399