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