EVGEN/AliGenEMlib.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 /* $Id: AliGenEMlib.cxx 30052 2008-11-25 14:54:18Z morsch $ */
  17
  18 /////////////////////////////////////////////////////////////////////////////
  19 //                                                                         //
  20 // Implementation of AliGenEMlib for electron, di-electron, and photon     //
  21 // cocktail calculations.                                                  //
  22 // It is based on AliGenGSIlib.                                            //
  23 //                                                                         //
  24 // Responsible: R.Averbeck@gsi.de                                          //
  25 //                                                                         //
  26 /////////////////////////////////////////////////////////////////////////////
  27
  28
  29 #include <Riostream.h>
  30 #include "TMath.h"
  31 #include "TRandom.h"
  32 #include "TString.h"
  33 #include "AliGenEMlib.h"
  34
  35
  36 ClassImp(AliGenEMlib)
  37
  38 //Initializers for static members
  39 Int_t AliGenEMlib::fgSelectedPtParam=AliGenEMlib::kPizero7TeVpp;
  40 Int_t AliGenEMlib::fgSelectedCentrality=AliGenEMlib::kpp;
  41 Int_t AliGenEMlib::fgSelectedV2Systematic=AliGenEMlib::kNoV2Sys;
  42
  43 Double_t AliGenEMlib::CrossOverLc(double a, double b, double x){
  44   if(x<b-a/2) return 1.0;
  45   else if(x>b+a/2) return 0.0;
  46   else return cos(((x-b)/a+0.5)*TMath::Pi())/2+0.5;
  47 }
  48 Double_t AliGenEMlib::CrossOverRc(double a, double b, double x){
  49   return 1-CrossOverLc(a,b,x);
  50 }
  51
  52 const Double_t AliGenEMlib::fgkV2param[16][15] = {
  53   // charged pion                                                                                                                        cent, based on: https://twiki.cern.ch/twiki/bin/viewauth/ALICE/FlowPAGQM2012talkIdentified
  54   {  0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // pp no V2
  55   ,{ 6.551541e-02, 1.438274e+00, 4.626379e-02, 2.512477e+00, 1.371824e+00, 2.964543e-02, 4.630670e+00, 4.228889e+00, 6.037970e-02, 1.425269e-03, 1.144124e+00, 0, 1, 9.154016e-04, 1.288285e+00 }  // 0-5
  56   ,{ 1.171360e-01, 1.333046e+00, 4.536752e-02, 3.046448e+00, 3.903714e+00, 4.407124e-02, 9.122534e-01, 4.834519e+00, 1.186237e-01, 2.179274e-03, 8.968478e-01, 0, 1, 1.501201e-03, 9.902785e-01 }  // 5-10
  57   ,{ 1.748423e-01, 1.285211e+00, 4.219624e-02, 4.019148e+00, 4.255047e+00, 7.956751e-03, 1.184731e-01,-9.211391e+00, 5.768716e-01, 3.127110e-03, 6.808650e-01, 0, 1, 2.786807e-03, 6.159338e-01 }  // 10-20
  58   ,{ 2.152937e-01, 1.405391e+00, 5.037925e-02, 3.214458e+00, 3.991894e+00, 3.655882e-02, 1.968766e-01,-1.637650e+01, 7.023397e+00, 4.573453e-03, 6.031381e-01, 0, 1, 3.564348e-03, 5.748053e-01 }  // 20-30
  59   ,{ 2.409800e-01, 1.476557e+00, 5.759362e-02, 3.339713e+00, 3.642386e+00,-1.544366e-02, 1.098611e-01,-1.373154e+01, 1.471955e+00, 5.200180e-03, 6.315474e-01, 0, 1, 3.776112e-03, 6.298605e-01 }  // 30-40
  60   ,{ 2.495087e-01, 1.543711e+00, 6.217817e-02, 3.517101e+00, 4.558221e+00, 6.021316e-02, 1.486822e-01,-5.769155e+00, 5.576843e-01, 5.348029e-03, 7.255976e-01, 0, 1, 3.531350e-03, 7.661694e-01 }  // 40-50
  61   ,{ 2.166449e-01, 1.931014e+00, 8.195656e-02, 2.226742e+00, 3.106472e+00, 1.058786e-01, 8.558786e-01, 4.006680e+00, 2.476313e-01, 5.137623e-03, 9.104401e-01, 0, 1, 2.477450e-03, 1.109649e+00 }  // 50-60
  62   ,{ 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // 0-10
  63   ,{ 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // 20-40
  64   ,{ 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // 40-60
  65   ,{ 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // 60-80
  66   ,{ 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // 0-20
  67   ,{ 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // 0-40
  68   ,{ 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // 20-80
  69   ,{ 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000, 2.0000000000, 0.0000000000, 1.0000000000, 0, 1, 0.0000000000, 1.0000000000 }   // 40-80
  70 };
  71
  72 const Double_t AliGenEMlib::fgkRawPtOfV2Param[16][10] = {
  73   {  0.0000000000, 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000 } // pp no V2
  74   ,{ 2.181446e+08, 9.412925e-01, 1.158774e-01, 3.020303e+01, 6.790828e+00, 9.999996e+01, 2.616827e+00, 3.980492e+00, 1.225169e+07, 5.575243e+00 } // 0-5
  75   ,{ 3.006215e+08, 9.511881e-01, 1.192788e-01, 2.981931e+01, 5.068175e+01, 9.999993e+01, 2.650635e+00, 4.073982e+00, 2.508045e+07, 5.621039e+00 } // 5-10
  76   ,{ 1.643438e+09, 9.604242e-01, 1.218512e-01, 2.912684e+01, 1.164242e+00, 9.999709e+01, 2.662326e+00, 4.027795e+00, 7.020810e+07, 5.696860e+00 } // 10-20
  77   ,{ 8.109985e+08, 9.421935e-01, 1.328020e-01, 2.655910e+01, 1.053677e+00, 9.999812e+01, 2.722949e+00, 3.964547e+00, 6.104096e+07, 5.694703e+00 } // 20-30
  78   ,{ 5.219789e+08, 9.417339e-01, 1.417541e-01, 2.518080e+01, 7.430803e-02, 9.303295e+01, 2.780227e+00, 3.909570e+00, 4.723116e+07, 5.778375e+00 } // 30-40
  79   ,{ 2.547159e+08, 9.481459e-01, 2.364858e-01, 1.689288e+01, 3.858883e+00, 6.352619e+00, 2.742270e+00, 3.855226e+00, 3.120535e+07, 5.878677e+00 } // 40-50
  80   ,{ 9.396097e+07, 9.304491e-01, 3.244940e-01, 1.291696e+01, 2.854367e+00, 6.325908e+00, 2.828258e+00, 4.133699e+00, 1.302739e+07, 5.977896e+00 } // 50-60
  81   ,{ 0.0000000000, 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000 } // 0-10
  82   ,{ 0.0000000000, 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000 } // 20-40
  83   ,{ 0.0000000000, 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000 } // 40-60
  84   ,{ 0.0000000000, 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000 } // 60-80
  85   ,{ 0.0000000000, 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000 } // 0-20
  86   ,{ 0.0000000000, 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000 } // 0-40
  87   ,{ 0.0000000000, 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000 } // 20-80
  88   ,{ 0.0000000000, 0.0000000000, 0.0000000000, 0.0000000000,-1.0000000000, 1.0000000000,-1.0000000000, 1.0000000000, 0.0000000000, 0.0000000000 } // 40-80
  89 };
  90
  91 const Double_t AliGenEMlib::fgkThermPtParam[16][2] = {
  92   {  0.0000000000, 0.0000000000 } // pp no V2
  93   ,{ 0.0000000000, 0.0000000000 } // 0-5
  94   ,{ 0.0000000000, 0.0000000000 } // 5-10
  95   ,{ 3.447105e+01, 3.416818e+00 } // 10-20 //based on: https://aliceinfo.cern.ch/Notes/node/249
  96   ,{ 0.0000000000, 0.0000000000 } // 20-30
  97   ,{ 0.0000000000, 0.0000000000 } // 30-40
  98   ,{ 0.0000000000, 0.0000000000 } // 40-50
  99   ,{ 0.0000000000, 0.0000000000 } // 50-60
 100   ,{ 3.888847e+02, 4.502683e+00 } // 0-10  //based on: https://aliceinfo.cern.ch/Notes/node/249
 101   ,{ 1.766210e+00, 2.473812e+00 } // 20-40 //based on: https://twiki.cern.ch/twiki/pub/ALICE/ALICEDirectPhotonSpectrumPaper/directPbPb.pdf
 102   ,{ 0.0000000000, 0.0000000000 } // 40-60
 103   ,{ 0.0000000000, 0.0000000000 } // 60-80
 104   ,{ 1.576151e+01, 2.841202e+00 } // 0-20  //based on: https://twiki.cern.ch/twiki/pub/ALICE/ALICEDirectPhotonSpectrumPaper/directPbPb.pdf
 105   ,{ 4.263499e+01, 3.249843e+00 } // 0-40  //based on: https://aliceinfo.cern.ch/Figure/node/2866
 106   ,{ 0.0000000000, 0.0000000000 } // 20-80
 107   ,{ 0.0000000000, 0.0000000000 } // 40-80
 108 };
 109
 110 // MASS   0=>PIZERO, 1=>ETA, 2=>RHO, 3=>OMEGA, 4=>ETAPRIME, 5=>PHI, 6=>JPSI
 111 const Double_t AliGenEMlib::fgkHM[8] = {0.13498, 0.54751, 0.7755, 0.78265, 0.95778, 1.01946, 3.0969, 0.0};
 112
 113 const Double_t AliGenEMlib::fgkMtFactor[2][8] = {
 114   // {1.0, 0.5, 1.0, 0.9, 0.4, 0.23, 0.054},  // factor for pp from arXiv:1110.3929
 115   // {1.0, 0.55, 1.0, 0.9, 0.4, 0.25, 0.004}    // factor for PbPb from arXiv:1110.3929
 116   //{1., 0.48, 1.0, 0.9, 0.25, 0.4}, (old values)
 117   //{1., 0.48, 1.0, 0.9, 0.4, 0.25}, (nlo values)
 118   //{1., 0.48, 1.0, 0.8, 0.4, 0.2, 0.06} (combination of nlo and LHC measurements)
 119   //https://aliceinfo.cern.ch/Figure/node/2634
 120   //https://aliceinfo.cern.ch/Figure/node/2788
 121   //https://aliceinfo.cern.ch/Figure/node/4403
 122   //https://aliceinfo.cern.ch/Notes/node/87
 123   //best guess:
 124   {1., 0.48, 1.0, 0.9, 0.4, 0.25, 0., 0.}, //pp
 125   {1., 0.48, 1.0, 0.9, 0.4, 0.25, 0., 0.}  //PbPb
 126 };
 127
 128 //==========================================================================
 129 //
 130 //              Definition of Particle Distributions
 131 //
 132 //==========================================================================
 133
 134 //--------------------------------------------------------------------------
 135 //
 136 //                              General functions
 137 //
 138 //--------------------------------------------------------------------------
 139 Double_t AliGenEMlib::PtModifiedHagedornThermal(Double_t pt,
 140                                                 Double_t c,
 141                                                 Double_t p0,
 142                                                 Double_t p1,
 143                                                 Double_t n,
 144                                                 Double_t cT,
 145                                                 Double_t T)
 146 {
 147   // Modified Hagedorn Thermal fit to Picharged for PbPb:
 148   Double_t invYield;
 149   invYield = c/TMath::Power(p0+pt/p1,n) + cT*exp(-1.0*pt/T);
 150
 151   return invYield*(2*TMath::Pi()*pt);
 152 }
 153
 154
 155
 156 Double_t AliGenEMlib::PtModifiedHagedornExp(Double_t pt,
 157                                             Double_t c,
 158                                             Double_t p1,
 159                                             Double_t p2,
 160                                             Double_t p0,
 161                                             Double_t n)
 162 {
 163   // Modified Hagedorn exponentiel fit to Pizero for PbPb:
 164   Double_t invYield;
 165   invYield = c*TMath::Power(exp(-1*(p1*pt-p2*pt*pt))+pt/p0,-n);
 166
 167   return invYield*(2*TMath::Pi()*pt);
 168 }
 169
 170
 171 Double_t AliGenEMlib::PtModifiedHagedornExp2(Double_t pt,
 172                                              Double_t c,
 173                                              Double_t a,
 174                                              Double_t b,
 175                                              Double_t p0,
 176                                              Double_t p1,
 177                                              Double_t d,
 178                                              Double_t n)
 179 {
 180   // Modified Hagedorn exponential fit to charged pions for pPb:
 181   Double_t invYield;
 182   invYield = c*TMath::Power(exp(-a*pt-b*pt*pt)+pt/p0+TMath::Power(pt/p1,d),-n);
 183
 184   return invYield*(2*TMath::Pi()*pt);
 185 }
 186
 187 Double_t AliGenEMlib::PtTsallis(Double_t pt,
 188                                 Double_t m,
 189                                 Double_t c,
 190                                 Double_t T,
 191                                 Double_t n)
 192 {
 193   // Tsallis fit to Pizero for pp:
 194   Double_t mt;
 195   Double_t invYield;
 196
 197   mt = sqrt(m*m + pt*pt);
 198   invYield = c*((n-1.)*(n-2.))/(n*T*(n*T+m*(n-2.)))*pow(1.+(mt-m)/(n*T),-n);
 199
 200   return invYield*(2*TMath::Pi()*pt);
 201 }
 202
 203 // Exponential
 204 Double_t AliGenEMlib::PtExponential(const Double_t *px, const Double_t *c){
 205   const double &pt=px[0];
 206   Double_t invYield = c[0]*exp(-pt*c[1]);
 207
 208   return invYield*(2*TMath::Pi()*pt);
 209 }
 210
 211 // Hagedorn with additional Powerlaw
 212 Double_t AliGenEMlib::PtModifiedHagedornPowerlaw(const Double_t *px, const Double_t *c){
 213   const double &pt=px[0];
 214   Double_t invYield = c[0]*pow(c[1]+pt*c[2],-c[3])*CrossOverLc(c[5],c[4],pt)+CrossOverRc(c[7],c[6],pt)*c[8]*pow(pt+0.001,-c[9]); //pt+0.001: prevent powerlaw from exploding for pt->0
 215
 216   return invYield*(2*TMath::Pi()*pt);
 217 }
 218
 219 // double powerlaw for J/Psi yield
 220 Double_t AliGenEMlib::PtDoublePowerlaw(const Double_t *px, const Double_t *c){
 221   const double &pt=px[0];
 222   Double_t yield = c[0]*pt*pow(1+pow(pt*c[1],2),-c[2]);
 223
 224   return yield;
 225 }
 226
 227 // integral over krollwada with S=1^2*(1-mee^2/mh^2)^3 from mee=0 up to mee=mh
 228 // approximation is perfect for mh>20MeV
 229 Double_t AliGenEMlib::IntegratedKrollWada(const Double_t *mh, const Double_t *){
 230   if(*mh<0.002941) return 0;
 231   return 2*log(*mh/0.000511/exp(1.75))/411.11/TMath::Pi();
 232 }
 233
 234 //--------------------------------------------------------------------------
 235 //
 236 //                             DirectRealGamma
 237 //
 238 //--------------------------------------------------------------------------
 239 Double_t AliGenEMlib::PtPromptRealGamma( const Double_t *px, const Double_t */*dummy*/ )
 240 {
 241   const static Double_t promptGammaPtParam[10] = { 8.715017e-02, 4.439243e-01, 1.011650e+00, 5.193789e+00, 2.194442e+01, 1.062124e+01, 2.469876e+01, 6.052479e-02, 5.611410e-02, 5.169743e+00 };
 242
 243   return PtModifiedHagedornPowerlaw(px,promptGammaPtParam)*GetTAA(fgSelectedCentrality);
 244 }
 245
 246 Double_t AliGenEMlib::PtThermalRealGamma( const Double_t *px, const Double_t */*dummy*/ )
 247 {
 248   return PtExponential(px,fgkThermPtParam[fgSelectedCentrality]);
 249 }
 250
 251 Double_t AliGenEMlib::PtDirectRealGamma( const Double_t *px, const Double_t */*dummy*/ )
 252 {
 253   return PtPromptRealGamma(px,px)+PtThermalRealGamma(px,px);
 254 }
 255
 256 Int_t AliGenEMlib::IpDirectRealGamma(TRandom *)
 257 {
 258   return 22;
 259 }
 260
 261 Double_t AliGenEMlib::YDirectRealGamma( const Double_t *px, const Double_t */*dummy*/ )
 262 {
 263   return YFlat(*px);
 264 }
 265
 266 Double_t AliGenEMlib::V2DirectRealGamma( const Double_t *px, const Double_t */*dummy*/ )
 267 {
 268   const static Double_t v2Param[3][15] = {
 269     { 1.211795e-01, 9.813671e-01, 0.000000e+00, 3.056960e+00, 2.380183e+00, -7.833212e-02, 5.000000e-01, 3.056960e+00, 1.195000e-01, 1.183293e-02, 1.252249e+00, 0, 1, 4.876263e-03, 1.518526e+00 }  // 00-20, based on: https://aliceinfo.cern.ch/Notes/node/249
 270     ,{ 1.619000e-01, 2.185695e+00, 0.000000e+00, 1.637681e+00, 1.000000e+00, -1.226399e-06, 3.092027e+00, 3.064692e+00, 1.619000e-01, 2.264320e-02, 1.028641e+00, 0, 1, 8.172203e-03, 1.271637e+00 } // 20-40
 271     ,{ 1.335000e-01, 1.331963e+00, 0.000000e+00, 2.252315e+00, 1.198383e+00, -5.861987e-02, 7.132859e-01, 2.252315e+00, 2.934249e-01, 1.571589e-02, 1.001131e+00, 0, 1, 5.179715e-03, 1.329344e+00 } // 00-40
 272   };
 273   switch(fgSelectedCentrality) {
 274   case k0020: return V2Param(px,v2Param[0]); break;
 275   case k2040: return V2Param(px,v2Param[1]); break;
 276   case k0040: return V2Param(px,v2Param[2]); break;
 277   }
 278   return 0;
 279 }
 280
 281
 282 //--------------------------------------------------------------------------
 283 //
 284 //                             DirectVirtGamma
 285 //
 286 //--------------------------------------------------------------------------
 287 Double_t AliGenEMlib::PtPromptVirtGamma( const Double_t *px, const Double_t */*dummy*/ )
 288 {
 289   return IntegratedKrollWada(px,px)*PtPromptRealGamma(px,px);
 290 }
 291
 292 Double_t AliGenEMlib::PtThermalVirtGamma( const Double_t *px, const Double_t */*dummy*/ )
 293 {
 294   return IntegratedKrollWada(px,px)*PtThermalRealGamma(px,px);
 295 }
 296
 297 Double_t AliGenEMlib::PtDirectVirtGamma( const Double_t *px, const Double_t */*dummy*/ )
 298 {
 299   return IntegratedKrollWada(px,px)*(PtPromptRealGamma(px,px)+PtThermalRealGamma(px,px));
 300 }
 301
 302 Int_t AliGenEMlib::IpDirectVirtGamma(TRandom *)
 303 {
 304   return 220000;
 305 }
 306
 307 Double_t AliGenEMlib::YDirectVirtGamma( const Double_t *px, const Double_t */*dummy*/ )
 308 {
 309   return YFlat(*px);
 310 }
 311
 312 Double_t AliGenEMlib::V2DirectVirtGamma( const Double_t *px, const Double_t */*dummy*/ )
 313 {
 314   return V2DirectRealGamma(px,px);
 315 }
 316
 317 //--------------------------------------------------------------------------
 318 //
 319 //                              Pizero
 320 //
 321 //--------------------------------------------------------------------------
 322 Int_t AliGenEMlib::IpPizero(TRandom *)
 323 {
 324   // Return pizero pdg code
 325   return 111;
 326 }
 327
 328 Double_t AliGenEMlib::PtPizero( const Double_t *px, const Double_t */*dummy*/ )
 329 {
 330   // double pigammacorr=1; //misuse pion for direct gammas, tuned for 0040, iteration 0
 331   // pigammacorr*=2.258900e-01*log(*px+0.001)+1.591291e+00;  //iteration 1
 332   // pigammacorr*=6.601943e-03*log(*px+0.001)+9.593698e-01;  //iteration 2
 333   // pigammacorr*=4.019933e-03*log(*px+0.001)+9.843412e-01;  //iteration 3
 334   // pigammacorr*=-4.543991e-03*log(*px+0.001)+1.010886e+00; //iteration 4
 335   // return pigammacorr*PtPromptRealGamma(px,px); //now the gammas from the pi->gg decay have the pt spectrum of prompt real gammas
 336
 337   // fit functions and corresponding parameter of Pizero pT for pp @ 2.76 TeV and @ 7 TeV and for PbPb @ 2.76 TeV
 338
 339   Double_t km=0.;
 340   Double_t kc=0.;
 341   Double_t kn=0.;
 342   Double_t kcT=0.;
 343   Double_t kT=0.;
 344   Double_t kp0=0.;
 345   Double_t kp1=0.;
 346   Double_t kp2=0.;
 347   Double_t ka=0.;
 348   Double_t kb=0.;
 349   Double_t kd=0.;
 350
 351   double n1,n2,n3;
 352   int oldCent;
 353
 354   switch(fgSelectedPtParam|fgSelectedCentrality) {
 355     // fit to pi charged v1
 356     // charged pion from ToF, unidentified hadrons scaled with pion from TPC
 357     // for Pb-Pb @ 2.76 TeV
 358   case kPichargedPbPb|k0005:
 359     kc=1347.5; kp0=0.9393; kp1=2.254; kn=11.294; kcT=0.002537; kT=2.414;
 360     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 361     break;
 362   case kPichargedPbPb|k0510:
 363     kc=1256.1; kp0=0.9545; kp1=2.248; kn=11.291; kcT=0.002662; kT=2.326;
 364     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 365     break;
 366   case kPichargedPbPb|k2030:
 367     kc=7421.6; kp0=1.2059; kp1=1.520; kn=10.220; kcT=0.002150; kT=2.196;
 368     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 369     break;
 370   case kPichargedPbPb|k3040:
 371     kc=1183.2; kp0=1.0478; kp1=1.623; kn=9.8073; kcT=0.00198333; kT=2.073;
 372     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 373     break;
 374     // the following is what went into the Pb-Pb preliminary approval (0-10%)
 375   case kPichargedPbPb|k0010:
 376     kc=1296.0; kp0=0.968; kp1=2.567; kn=12.27; kcT=0.004219; kT=2.207;
 377     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 378     break;
 379   case kPichargedPbPb|k1020:
 380     kc=986.0; kp0=0.9752; kp1=2.376; kn=11.62; kcT=0.003116; kT=2.213;
 381     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 382     break;
 383   case kPichargedPbPb|k2040:
 384     kc=17337.0; kp0=1.337; kp1=1.507; kn=10.629; kcT=0.00184; kT=2.234;
 385     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 386     break;
 387   case kPichargedPbPb|k4050:
 388     kc=6220.0; kp0=1.322; kp1=1.224; kn=9.378; kcT=0.000595; kT=2.383;
 389     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 390     break;
 391   case kPichargedPbPb|k5060:
 392     kc=2319.0; kp0=1.267; kp1=1.188; kn=9.044; kcT=0.000437; kT=2.276;
 393     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 394     break;
 395   case kPichargedPbPb|k4060:
 396     kc=4724.0; kp0=1.319; kp1=1.195; kn=9.255; kcT=0.000511; kT=2.344;
 397     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 398     break;
 399   case kPichargedPbPb|k6080:
 400     kc=2842.0; kp0=1.465; kp1=0.8324; kn=8.167; kcT=0.0001049; kT=2.29;
 401     return PtModifiedHagedornThermal(*px,kc,kp0,kp1,kn,kcT,kT);
 402     break;
 403   case kPichargedPbPb|k0020:
 404     oldCent=fgSelectedCentrality;
 405     fgSelectedCentrality=k0010;
 406     n1=PtPizero(px,px);
 407     fgSelectedCentrality=k1020;
 408     n2=PtPizero(px,px);
 409     fgSelectedCentrality=oldCent;
 410     return (n1+n2)/2;
 411     break;
 412   case kPichargedPbPb|k0040:
 413     oldCent=fgSelectedCentrality;
 414     fgSelectedCentrality=k0010;
 415     n1=PtPizero(px,px);
 416     fgSelectedCentrality=k1020;
 417     n2=PtPizero(px,px);
 418     fgSelectedCentrality=k2040;
 419     n3=PtPizero(px,px);
 420     fgSelectedCentrality=oldCent;
 421     return (n1+n2+2*n3)/4;
 422     break;
 423
 424     // fit to pizero from conversion analysis
 425     // for PbPb @ 2.76 TeV
 426     // Pi0 spectra --> not final results
 427   case kPizeroPbPb|k0005:
 428        kc=1952.832; kp1=0.264; kp2=0.069; kp0=1.206; kn=9.732;
 429        return PtModifiedHagedornExp(*px,kc,kp1,kp2,kp0,kn);
 430        break;
 431   case kPizeroPbPb|k0010:
 432        kc=1810.029; kp1=0.291; kp2=0.059; kp0=1.170; kn=9.447;
 433        return PtModifiedHagedornExp(*px,kc,kp1,kp2,kp0,kn);
 434        break;
 435   case kPizeroPbPb|k0020:
 436        kc=856.241; kp1=-0.409; kp2=-0.127; kp0=1.219; kn=9.030;
 437        return PtModifiedHagedornExp(*px,kc,kp1,kp2,kp0,kn);
 438        break;
 439   case kPizeroPbPb|k1020:
 440        kc=509.781; kp1=-0.784; kp2=-0.120; kp0=0.931; kn=7.299;
 441        return PtModifiedHagedornExp(*px,kc,kp1,kp2,kp0,kn);
 442        break;
 443   case kPizeroPbPb|k2040:
 444        kc=541.049; kp1=0.542; kp2=-0.069; kp0=0.972; kn=7.866;
 445        return PtModifiedHagedornExp(*px,kc,kp1,kp2,kp0,kn);
 446        break;
 447   case kPizeroPbPb|k2080:
 448        kc=222.577; kp1=0.634; kp2=0.009; kp0=0.915; kn=7.431;
 449        return PtModifiedHagedornExp(*px,kc,kp1,kp2,kp0,kn);
 450        break;
 451   case kPizeroPbPb|k4080:
 452        kc=120.153; kp1=0.7; kp2=-0.14; kp0=0.835; kn=6.980;
 453        return PtModifiedHagedornExp(*px,kc,kp1,kp2,kp0,kn);
 454        break;
 455   case kPizeroPbPb|k0040:
 456        kc=560.532; kp1=0.548; kp2=-0.048; kp0=1.055; kn=8.132;
 457        return PtModifiedHagedornExp(*px,kc,kp1,kp2,kp0,kn);
 458        break;
 459
 460
 461     // fit to charged pions for p-Pb @ 5.02TeV
 462   case kPichargedPPb:
 463        kc=235.5; ka=0.6903; kb=0.06864; kp0=2.289; kp1=0.5872; kd=0.6474; kn=7.842;
 464        return PtModifiedHagedornExp2(*px,kc,ka,kb,kp0,kp1,kd,kn);
 465        break;
 466
 467
 468     // Tsallis fit to final pizero (PHOS+PCM) -> used for publication
 469     // for pp @ 7 TeV
 470   case kPizero7TeVpp:
 471   case kPizeroEta7TeVpp:
 472     km=0.13498; kc=28.01; kT=0.139; kn=6.875;
 473     return PtTsallis(*px,km,kc,kT,kn);
 474     break;
 475   case kPizero7TeVpplow:
 476   case kPizeroEta7TeVpplow:
 477     km=0.13498; kc=23.84; kT=0.147; kn=7.025;
 478     return PtTsallis(*px,km,kc,kT,kn);
 479     break;
 480   case kPizero7TeVpphigh:
 481   case kPizeroEta7TeVpphigh:
 482     km=0.13498; kc=32.47; kT=0.132; kn=6.749;
 483     return PtTsallis(*px,km,kc,kT,kn);
 484     break;
 485     // Tsallis fit to pizero: preliminary result from PCM and PHOS (QM'11)
 486     // for pp @ 2.76 TeV
 487   case kPizero2760GeVpp:
 488   case kPizeroEta2760GeVpp:
 489     km = 0.13498; kc = 19.75; kT = 0.130; kn = 7.051;
 490     return PtTsallis(*px,km,kc,kT,kn);
 491     break;
 492   case kPizero2760GeVpplow:
 493   case kPizeroEta2760GeVpplow:
 494     km = 0.13498; kc = 16.12; kT = 0.142; kn = 7.327;
 495     return PtTsallis(*px,km,kc,kT,kn);
 496     break;
 497   case kPizero2760GeVpphigh:
 498   case kPizeroEta2760GeVpphigh:
 499     km = 0.13498; kc = 25.18; kT = 0.118; kn = 6.782;
 500     return PtTsallis(*px,km,kc,kT,kn);
 501     break;
 502
 503   default:
 504     return NULL;
 505   }
 506
 507 }
 508
 509 Double_t AliGenEMlib::YPizero( const Double_t *py, const Double_t */*dummy*/ )
 510 {
 511   return YFlat(*py);
 512
 513 }
 514
 515 Double_t AliGenEMlib::V2Pizero( const Double_t *px, const Double_t */*dummy*/ )
 516 {
 517   double n1,n2,n3,n4,n5;
 518   double v1,v2,v3,v4,v5;
 519   switch(fgSelectedCentrality) {
 520   case k0010:
 521     n1=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k0005]);
 522     v1=V2Param(px,fgkV2param[k0005]);
 523     n2=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k0510]);
 524     v2=V2Param(px,fgkV2param[k0510]);
 525     return (n1*v1+n2*v2)/(n1+n2);
 526     break;
 527   case k0020:
 528     n1=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k0005]);
 529     v1=V2Param(px,fgkV2param[k0005]);
 530     n2=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k0510]);
 531     v2=V2Param(px,fgkV2param[k0510]);
 532     n3=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k1020]);
 533     v3=V2Param(px,fgkV2param[k1020]);
 534     return (n1*v1+n2*v2+2*n3*v3)/(n1+n2+2*n3);
 535     break;
 536   case k2040:
 537     n1=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k2030]);
 538     v1=V2Param(px,fgkV2param[k2030]);
 539     n2=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k3040]);
 540     v2=V2Param(px,fgkV2param[k3040]);
 541     return (n1*v1+n2*v2)/(n1+n2);
 542     break;
 543   case k0040:
 544     n1=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k0005]);
 545     v1=V2Param(px,fgkV2param[k0005]);
 546     n2=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k0510]);
 547     v2=V2Param(px,fgkV2param[k0510]);
 548     n3=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k1020]);
 549     v3=V2Param(px,fgkV2param[k1020]);
 550     n4=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k2030]);
 551     v4=V2Param(px,fgkV2param[k2030]);
 552     n5=PtModifiedHagedornPowerlaw(px,fgkRawPtOfV2Param[k3040]);
 553     v5=V2Param(px,fgkV2param[k3040]);
 554     return (n1*v1+n2*v2+2*n3*v3+2*n4*v4+2*n5*v5)/(n1+n2+2*n3+2*n4+2*n5);
 555     break;
 556
 557   default:
 558     return V2Param(px,fgkV2param[fgSelectedCentrality]);
 559   }
 560 }
 561
 562 //--------------------------------------------------------------------------
 563 //
 564 //                              Eta
 565 //
 566 //--------------------------------------------------------------------------
 567 Int_t AliGenEMlib::IpEta(TRandom *)
 568 {
 569   // Return eta pdg code
 570   return 221;
 571 }
 572
 573 Double_t AliGenEMlib::PtEta( const Double_t *px, const Double_t */*dummy*/ )
 574 {
 575
 576   // fit functions and corresponding parameter of Eta pT for pp @ 2.76 TeV and @ 7 TeV
 577   // and mtscaled pT
 578
 579   Double_t km = 0.;
 580   Double_t kc = 0.;
 581   Double_t kT = 0.;
 582   Double_t kn = 0.;
 583
 584   switch(fgSelectedPtParam){
 585     // Tsallis fit to final eta (PHOS+PCM) -> used for final publication
 586     // for pp @ 7 TeV
 587   case kPizeroEta7TeVpp:
 588     km = 0.547853; kc = 2.496; kT = 0.229; kn = 6.985;
 589     return PtTsallis(*px,km,kc,kT,kn);
 590     break;
 591   case kPizeroEta7TeVpplow:
 592     km = 0.547853; kc = 1.970; kT = 0.253; kn = 7.591;
 593     return PtTsallis(*px,km,kc,kT,kn);
 594     break;
 595   case kPizeroEta7TeVpphigh:
 596     km = 0.547853; kc = 3.060; kT = 0.212; kn = 6.578;
 597     return PtTsallis(*px,km,kc,kT,kn);
 598     break;
 599     // Tsallis fit to preliminary eta (QM'11)
 600     // for pp @ 2.76 TeV
 601   case kPizeroEta2760GeVpp:
 602     km = 0.547853; kc = 1.971; kT = 0.188; kn = 6.308;
 603     return PtTsallis(*px,km,kc,kT,kn);
 604   case kPizeroEta2760GeVpplow:
 605     km = 0.547853; kc = 1.228; kT = 0.220; kn = 7.030;
 606     return PtTsallis(*px,km,kc,kT,kn);
 607     break;
 608   case kPizeroEta2760GeVpphigh:
 609     km = 0.547853; kc = 2.802; kT = 0.164; kn = 5.815;
 610     return PtTsallis(*px,km,kc,kT,kn);
 611     break;
 612
 613   default:
 614   return MtScal(*px,1);
 615     break;
 616
 617   }
 618
 619 }
 620
 621 Double_t AliGenEMlib::YEta( const Double_t *py, const Double_t */*dummy*/ )
 622 {
 623   return YFlat(*py);
 624 }
 625
 626 Double_t AliGenEMlib::V2Eta( const Double_t *px, const Double_t */*dummy*/ )
 627 {
 628   return KEtScal(*px,1); //V2Param(px,fgkV2param[1][fgSelectedV2Param]);
 629 }
 630
 631 //--------------------------------------------------------------------------
 632 //
 633 //                              Rho
 634 //
 635 //--------------------------------------------------------------------------
 636 Int_t AliGenEMlib::IpRho(TRandom *)
 637 {
 638   // Return rho pdg code
 639   return 113;
 640 }
 641
 642 Double_t AliGenEMlib::PtRho( const Double_t *px, const Double_t */*dummy*/ )
 643 {
 644   // Rho pT
 645   return MtScal(*px,2);
 646 }
 647
 648 Double_t AliGenEMlib::YRho( const Double_t *py, const Double_t */*dummy*/ )
 649 {
 650   return YFlat(*py);
 651 }
 652
 653 Double_t AliGenEMlib::V2Rho( const Double_t *px, const Double_t */*dummy*/ )
 654 {
 655   return KEtScal(*px,2);
 656 }
 657
 658 //--------------------------------------------------------------------------
 659 //
 660 //                              Omega
 661 //
 662 //--------------------------------------------------------------------------
 663 Int_t AliGenEMlib::IpOmega(TRandom *)
 664 {
 665   // Return omega pdg code
 666   return 223;
 667 }
 668
 669 Double_t AliGenEMlib::PtOmega( const Double_t *px, const Double_t */*dummy*/ )
 670 {
 671   // Omega pT
 672   return MtScal(*px,3);
 673 }
 674
 675 Double_t AliGenEMlib::YOmega( const Double_t *py, const Double_t */*dummy*/ )
 676 {
 677   return YFlat(*py);
 678 }
 679
 680 Double_t AliGenEMlib::V2Omega( const Double_t *px, const Double_t */*dummy*/ )
 681 {
 682   return KEtScal(*px,3);
 683 }
 684
 685
 686 //--------------------------------------------------------------------------
 687 //
 688 //                              Etaprime
 689 //
 690 //--------------------------------------------------------------------------
 691 Int_t AliGenEMlib::IpEtaprime(TRandom *)
 692 {
 693   // Return etaprime pdg code
 694   return 331;
 695 }
 696
 697 Double_t AliGenEMlib::PtEtaprime( const Double_t *px, const Double_t */*dummy*/ )
 698 {
 699   // Eta pT
 700   return MtScal(*px,4);
 701 }
 702
 703 Double_t AliGenEMlib::YEtaprime( const Double_t *py, const Double_t */*dummy*/ )
 704 {
 705   return YFlat(*py);
 706
 707 }
 708
 709 Double_t AliGenEMlib::V2Etaprime( const Double_t *px, const Double_t */*dummy*/ )
 710 {
 711   return KEtScal(*px,4);
 712 }
 713
 714 //--------------------------------------------------------------------------
 715 //
 716 //                              Phi
 717 //
 718 //--------------------------------------------------------------------------
 719 Int_t AliGenEMlib::IpPhi(TRandom *)
 720 {
 721   // Return phi pdg code
 722   return 333;
 723 }
 724
 725 Double_t AliGenEMlib::PtPhi( const Double_t *px, const Double_t */*dummy*/ )
 726 {
 727   // Phi pT
 728   return MtScal(*px,5);
 729 }
 730
 731 Double_t AliGenEMlib::YPhi( const Double_t *py, const Double_t */*dummy*/ )
 732 {
 733   return YFlat(*py);
 734 }
 735
 736 Double_t AliGenEMlib::V2Phi( const Double_t *px, const Double_t */*dummy*/ )
 737 {
 738   return KEtScal(*px,5);
 739 }
 740
 741 //--------------------------------------------------------------------------
 742 //
 743 //                              Jpsi
 744 //
 745 //--------------------------------------------------------------------------
 746 Int_t AliGenEMlib::IpJpsi(TRandom *)
 747 {
 748   // Return phi pdg code
 749   return 443;
 750 }
 751
 752 Double_t AliGenEMlib::PtJpsi( const Double_t *px, const Double_t */*dummy*/ )
 753 {
 754   // Jpsi pT
 755   // based on: //https://aliceinfo.cern.ch/Notes/node/242, https://aliceinfo.cern.ch/Figure/node/3457, www.sciencedirect.com/science/article/pii/S0370269312011446
 756   const static Double_t jpsiPtParam[2][3] = {
 757     {  9.686337e-03, 2.629441e-01, 4.552044e+00 }
 758     ,{ 3.403549e-03, 2.897061e-01, 3.644278e+00 }
 759   };
 760   const double pt=px[0]*2.28/2.613;
 761   switch(fgSelectedCentrality) {
 762   case k0020: return 2.405*PtDoublePowerlaw(&pt,jpsiPtParam[0]); break;
 763   case k2040: return 2.405*PtDoublePowerlaw(&pt,jpsiPtParam[1]); break;
 764   case k0040: return 0.5*2.405*(PtDoublePowerlaw(&pt,jpsiPtParam[0])+PtDoublePowerlaw(&pt,jpsiPtParam[1])); break;
 765   }
 766   return 0;
 767 }
 768
 769 Double_t AliGenEMlib::YJpsi( const Double_t *py, const Double_t */*dummy*/ )
 770 {
 771   return YFlat(*py);
 772 }
 773
 774 Double_t AliGenEMlib::V2Jpsi( const Double_t *px, const Double_t */*dummy*/ )
 775 {
 776   const int oldSys=fgSelectedV2Systematic;
 777   fgSelectedV2Systematic=kNoV2Sys;
 778   double ret=0;
 779
 780   switch(oldSys){
 781   case kLoV2Sys: ret=0; break;
 782   case kNoV2Sys: ret=KEtScal(*px,6)/2; break;
 783   case kUpV2Sys: ret=KEtScal(*px,6); break;
 784   }
 785
 786   fgSelectedV2Systematic=oldSys;
 787   return ret;
 788 }
 789
 790 Double_t AliGenEMlib::YFlat(Double_t /*y*/)
 791 {
 792   //--------------------------------------------------------------------------
 793   //
 794   //                    flat rapidity distribution
 795   //
 796   //--------------------------------------------------------------------------
 797
 798   Double_t dNdy = 1.;
 799
 800   return dNdy;
 801
 802 }
 803
 804 //=============================================================
 805 //
 806 //                    Mt-scaling
 807 //
 808 //=============================================================
 809 //
 810 Double_t AliGenEMlib::MtScal(Double_t pt, Int_t np)
 811 {
 812   // Function for the calculation of the Pt distribution for a
 813   // given particle np, from the pizero Pt distribution using
 814   // mt scaling.
 815
 816   Double_t scaledPt = sqrt(pt*pt + fgkHM[np]*fgkHM[np] - fgkHM[0]*fgkHM[0]);
 817   Double_t scaledYield = PtPizero(&scaledPt, (Double_t*) 0);
 818
 819   //     VALUE MESON/PI AT 5 GeV/c
 820   Double_t NormPt = 5.;
 821   Double_t scaledNormPt = sqrt(NormPt*NormPt + fgkHM[np]*fgkHM[np] - fgkHM[0]*fgkHM[0]);
 822
 823   Double_t norm = fgkMtFactor[int(bool(fgSelectedCentrality))][np] * (PtPizero(&NormPt, (Double_t*) 0) / PtPizero(&scaledNormPt, (Double_t*) 0));
 824
 825   return norm*(pt/scaledPt)*scaledYield;
 826 }
 827
 828 Double_t AliGenEMlib::KEtScal(Double_t pt, Int_t np)
 829 {
 830   const int nq=2; //number of quarks for particle np, here always 2
 831   Double_t scaledPt = sqrt(pow(2.0/nq*(sqrt(pt*pt+fgkHM[np]*fgkHM[np])-fgkHM[np])+fgkHM[0],2)-fgkHM[0]*fgkHM[0]);
 832   // double val=V2Pizero(&scaledPt, (Double_t*) 0);
 833   // static const double syserr[12]={0., 0.09, 0.07, 0.06, 0.04, 0.04, 0.04, 0.05, 0., 0., 0., 0.}; //based on pi vs kaon
 834   // double sys=fgSelectedV2Systematic*min(fgkV2param[fgSelectedCentrality][0],fgkV2param[fgSelectedCentrality][8])*syserr[fgSelectedCentrality];
 835   // return std::max(val+sys,0.0);
 836   return V2Pizero(&scaledPt, (Double_t*) 0);
 837 }
 838
 839 Double_t AliGenEMlib::V2Param(const Double_t *px, const Double_t *par)
 840 {
 841   // Very general parametrization of the v2
 842
 843   const double &pt=px[0];
 844   double val=CrossOverLc(par[4],par[3],pt)*(2*par[0]/(1+TMath::Exp(par[1]*(par[2]-pt)))-par[0])+CrossOverRc(par[4],par[3],pt)*((par[8]-par[5])/(1+TMath::Exp(par[6]*(pt-par[7])))+par[5]);
 845   double sys=fgSelectedV2Systematic*par[11+fgSelectedV2Systematic*2]*pow(pt,par[12+fgSelectedV2Systematic*2]);
 846   return std::max(val+sys,0.0);
 847 }
 848
 849 Double_t AliGenEMlib::V2Flat(const Double_t */*px*/, const Double_t */*param*/)
 850 {
 851   // Flat v2
 852
 853   return 0.0;
 854 }
 855
 856 Double_t AliGenEMlib::GetTAA(Int_t cent){
 857   const static Double_t taa[16] = { 1.0,    // pp
 858                                     26.32,  // 0-5
 859                                     20.56,  // 5-10
 860                                     14.39,  // 10-20
 861                                     8.70,   // 20-30
 862                                     5.001,  // 30-40
 863                                     2.675,  // 40-50
 864                                     1.317,  // 50-60
 865                                     23.44,  // 0-10
 866                                     6.85,   // 20-40
 867                                     1.996,  // 40-60
 868                                     0.4174, // 60-80
 869                                     18.91,  // 0-20
 870                                     12.88,  // 0-40
 871                                     3.088,  // 20-80
 872                                     1.207}; // 40-80
 873   return taa[cent];
 874 }
 875
 876 //==========================================================================
 877 //
 878 //                     Set Getters
 879 //
 880 //==========================================================================
 881
 882 typedef Double_t (*GenFunc) (const Double_t*,  const Double_t*);
 883
 884 typedef Int_t (*GenFuncIp) (TRandom *);
 885
 886 GenFunc AliGenEMlib::GetPt(Int_t param, const char * tname) const
 887 {
 888   // Return pointer to pT parameterisation
 889    GenFunc func=0;
 890    TString sname(tname);
 891
 892    switch (param)
 893     {
 894      case kDirectRealGamma:
 895        func=PtDirectRealGamma;
 896       break;
 897      case kDirectVirtGamma:
 898        func=PtDirectVirtGamma;
 899       break;
 900     case kPizero:
 901       func=PtPizero;
 902       break;
 903     case kEta:
 904       func=PtEta;
 905       break;
 906     case kRho:
 907       func=PtRho;
 908       break;
 909     case kOmega:
 910       func=PtOmega;
 911       break;
 912     case kEtaprime:
 913       func=PtEtaprime;
 914       break;
 915     case kPhi:
 916       func=PtPhi;
 917       break;
 918     case kJpsi:
 919       func=PtJpsi;
 920       break;
 921
 922     default:
 923       func=0;
 924       printf("<AliGenEMlib::GetPt> unknown parametrisation\n");
 925     }
 926    return func;
 927 }
 928
 929 GenFunc AliGenEMlib::GetY(Int_t param, const char * tname) const
 930 {
 931   // Return pointer to y- parameterisation
 932    GenFunc func=0;
 933    TString sname(tname);
 934
 935    switch (param)
 936     {
 937     case kDirectRealGamma:
 938       func=YDirectRealGamma;
 939       break;
 940     case kDirectVirtGamma:
 941       func=YDirectVirtGamma;
 942       break;
 943     case kPizero:
 944          func=YPizero;
 945          break;
 946     case kEta:
 947          func=YEta;
 948          break;
 949     case kRho:
 950          func=YRho;
 951          break;
 952     case kOmega:
 953          func=YOmega;
 954          break;
 955     case kEtaprime:
 956          func=YEtaprime;
 957          break;
 958     case kPhi:
 959          func=YPhi;
 960          break;
 961     case kJpsi:
 962       func=YJpsi;
 963       break;
 964
 965     default:
 966         func=0;
 967         printf("<AliGenEMlib::GetY> unknown parametrisation\n");
 968     }
 969     return func;
 970 }
 971
 972 GenFuncIp AliGenEMlib::GetIp(Int_t param, const char * tname) const
 973 {
 974   // Return pointer to particle type parameterisation
 975    GenFuncIp func=0;
 976    TString sname(tname);
 977
 978    switch (param)
 979     {
 980     case kDirectRealGamma:
 981       func=IpDirectRealGamma;
 982       break;
 983     case kDirectVirtGamma:
 984       func=IpDirectVirtGamma;
 985       break;
 986     case kPizero:
 987          func=IpPizero;
 988          break;
 989     case kEta:
 990          func=IpEta;
 991          break;
 992     case kRho:
 993          func=IpRho;
 994          break;
 995     case kOmega:
 996          func=IpOmega;
 997          break;
 998     case kEtaprime:
 999          func=IpEtaprime;
1000          break;
1001     case kPhi:
1002          func=IpPhi;
1003          break;
1004     case kJpsi:
1005       func=IpJpsi;
1006       break;
1007
1008     default:
1009         func=0;
1010         printf("<AliGenEMlib::GetIp> unknown parametrisation\n");
1011     }
1012     return func;
1013 }
1014
1015 GenFunc AliGenEMlib::GetV2(Int_t param, const char * tname) const
1016 {
1017   // Return pointer to v2-parameterisation
1018   GenFunc func=0;
1019   TString sname(tname);
1020
1021   switch (param)
1022     {
1023     case kDirectRealGamma:
1024       func=V2DirectRealGamma;
1025       break;
1026     case kDirectVirtGamma:
1027       func=V2DirectVirtGamma;
1028       break;
1029     case kPizero:
1030       func=V2Pizero;
1031       break;
1032     case kEta:
1033       func=V2Eta;
1034       break;
1035     case kRho:
1036       func=V2Pizero;
1037       break;
1038     case kOmega:
1039       func=V2Pizero;
1040       break;
1041     case kEtaprime:
1042       func=V2Pizero;
1043       break;
1044     case kPhi:
1045       func=V2Pizero;
1046       break;
1047     case kJpsi:
1048       func=V2Jpsi;
1049       break;
1050
1051     default:
1052       func=0;
1053       printf("<AliGenEMlib::GetV2> unknown parametrisation\n");
1054     }
1055   return func;
1056 }
1057