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