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