J/Psi and Upsilon pt and y distributions from R. Vogt 2002 added.
authormorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 7 Nov 2002 09:06:10 +0000 (09:06 +0000)
committermorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 7 Nov 2002 09:06:10 +0000 (09:06 +0000)
EVGEN/AliGenMUONlib.cxx
EVGEN/AliGenMUONlib.h

index f44d801..efbe005 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.16  2002/10/14 14:55:35  hristov
+Merging the VirtualMC branch to the main development branch (HEAD)
+
 Revision 1.14.6.1  2002/06/10 14:57:41  hristov
 Merged with v3-08-02
 
@@ -199,6 +202,47 @@ Double_t AliGenMUONlib::PtJpsi( Double_t *px, Double_t *dummy)
   Double_t pass1 = 1.+(x/kpt0)*(x/kpt0);
   return x/TMath::Power(pass1,kxn);
 }
+
+Double_t AliGenMUONlib::PtJpsiPbPb( Double_t *px, Double_t *dummy)
+{
+// J/Psi pT
+//
+// R. Vogt 2002
+// PbPb 5.5 TeV
+// MRST HO
+// mc = 1.4 GeV, pt-kick 1 GeV
+//
+
+    Float_t ptJpsi[100] = {
+        0.0000e-01,  4.5870e+01,  6.5200e+01,  7.1740e+01,  6.5090e+01,
+       5.5070e+01,  4.9420e+01,  3.9780e+01,  3.2390e+01,  2.8120e+01,
+       2.3870e+01,  1.9540e+01,  1.6510e+01,  1.4180e+01,  1.2050e+01,
+       1.0390e+01,  8.7970e+00,  7.8680e+00,  6.7710e+00,  5.9360e+00,
+       5.3460e+00,  4.5670e+00,  4.6500e+00,  3.9360e+00,  3.5070e+00,
+       3.2070e+00,  2.8310e+00,  2.6340e+00,  2.4900e+00,  2.2410e+00,
+       2.1090e+00,  1.9070e+00,  1.7360e+00,  1.6120e+00,  1.5450e+00,
+       1.4350e+00,  1.3890e+00,  1.2610e+00,  1.0880e+00,  1.0930e+00,
+       1.0680e+00,  9.2500e-01,  8.6790e-01,  8.1790e-01,  7.9770e-01,
+       7.4660e-01,  7.3110e-01,  6.5120e-01,  6.8140e-01,  5.7960e-01,
+       5.8210e-01,  5.4640e-01,  5.1700e-01,  5.0760e-01,  4.8280e-01,
+       4.5360e-01,  4.4910e-01,  4.2410e-01,  4.2100e-01,  3.9530e-01,
+       3.7220e-01,  3.4840e-01,  3.4550e-01,  3.3000e-01,  3.1670e-01,
+       3.1470e-01,  2.8920e-01,  2.7650e-01,  2.6860e-01,  2.5390e-01,
+       2.4190e-01,  2.5200e-01,  2.2960e-01,  2.2540e-01,  2.0950e-01,
+       2.0250e-01,  1.8720e-01,  1.8200e-01,  1.7860e-01,  1.8290e-01,
+       1.6970e-01,  1.7130e-01,  1.6310e-01,  1.5500e-01,  1.5100e-01,
+       1.5770e-01,  1.4240e-01,  1.4560e-01,  1.3330e-01,  1.4190e-01,
+       1.2010e-01,  1.2430e-01,  1.2430e-01,  1.1340e-01,  1.1840e-01,
+       1.1380e-01,  1.0330e-01,  1.0130e-01,  1.0390e-01,  9.5810e-02
+    };
+    Float_t x = px[0] * px[0];
+    if (x  < 1.5 || x > 100) {
+       return 0.0;
+    } else {
+       Float_t y =  Interpolate(x, ptJpsi, 0.5, 1., 100, 4);
+       return px[0] * y;
+    }
+}
 //
 //               y-distribution
 //____________________________________________________________
@@ -216,6 +260,40 @@ Double_t AliGenMUONlib::YJpsi(Double_t *py, Double_t *dummy)
     yj=kb*TMath::Exp(-(y-ky0)*(y-ky0)/2);
   return yj;
 }
+
+
+Double_t AliGenMUONlib::YJpsiPbPb( Double_t *px, Double_t *dummy)
+{
+
+//
+// J/Psi y
+//
+//
+// R. Vogt 2002
+// PbPb 5.5 TeV
+// MRST HO
+// mc = 1.4 GeV, pt-kick 1 GeV
+//
+
+    Float_t yJpsi[62] = 
+       {
+         0.3981E-03, 0.1169E-01, 0.6143E-01, 0.3554E+00, 0.1249E+01 
+       , 0.1677E+01, 0.3634E+01, 0.5414E+01, 0.8242E+01, 0.1102E+02
+       , 0.1353E+02, 0.1964E+02, 0.2357E+02, 0.2662E+02, 0.3023E+02 
+       , 0.3250E+02, 0.3137E+02, 0.3243E+02, 0.3120E+02, 0.3249E+02 
+       , 0.3166E+02, 0.3104E+02, 0.3203E+02, 0.3149E+02, 0.3117E+02 
+       , 0.3210E+02, 0.3170E+02, 0.3279E+02, 0.3079E+02, 0.3208E+02 
+       , 0.3218E+02, 0.3218E+02, 0.3208E+02, 0.3079E+02, 0.3279E+02 
+       , 0.3170E+02, 0.3210E+02, 0.3118E+02, 0.3149E+02, 0.3203E+02 
+       , 0.3104E+02, 0.3167E+02, 0.3250E+02, 0.3120E+02, 0.3243E+02 
+       , 0.3137E+02, 0.3250E+02, 0.3022E+02, 0.2662E+02, 0.2357E+02 
+       , 0.1964E+02, 0.1353E+02, 0.1102E+02, 0.8242E+01, 0.5414E+01 
+       , 0.3634E+01, 0.1677E+01, 0.1249E+01, 0.3554E+00, 0.6142E-01
+        , 0.1169E-01, 0.3981E-03};
+
+    return Interpolate(px[0], yJpsi, -7.625, 0.25, 62, 2);
+}
+
 //                 particle composition
 //
 Int_t AliGenMUONlib::IpJpsi(TRandom *)
@@ -239,6 +317,52 @@ Double_t AliGenMUONlib::PtUpsilon( Double_t *px, Double_t *dummy )
   Double_t pass1 = 1.+(x/kpt0)*(x/kpt0);
   return x/TMath::Power(pass1,kxn);
 }
+
+Double_t AliGenMUONlib::PtUpsilonPbPb( Double_t *px, Double_t *dummy)
+{
+
+//
+// Upsilon pT
+//
+//
+// R. Vogt 2002
+// PbPb 5.5 TeV
+// MRST HO
+// mc = 1.4 GeV, pt-kick 1 GeV
+//
+
+    Float_t ptUps[100] = 
+       {   
+           0.0000e-01, -1.5290e-02,  2.6020e-01,  3.4220e-01,  3.3710e-01,
+           3.1880e-01,  3.3420e-01,  2.7740e-01,  2.3730e-01,  2.0640e-01,
+           1.7690e-01,  1.6190e-01,  1.4500e-01,  1.3310e-01,  1.1440e-01,
+           1.0800e-01,  1.0210e-01,  8.4690e-02,  8.0050e-02,  7.0710e-02,
+           6.4160e-02,  6.5200e-02,  6.6890e-02,  6.0600e-02,  5.4030e-02,
+           5.1140e-02,  4.6120e-02,  4.4800e-02,  4.2490e-02,  4.1440e-02,
+           4.0310e-02,  3.7110e-02,  3.5890e-02,  3.5420e-02,  3.0370e-02,
+           2.9970e-02,  3.0770e-02,  2.6380e-02,  2.7740e-02,  2.6690e-02,
+           2.4210e-02,  2.5200e-02,  2.3760e-02,  2.1370e-02,  2.2290e-02,
+           2.2700e-02,  2.0110e-02,  1.9320e-02,  1.8830e-02,  1.9910e-02,
+           1.9740e-02,  1.8460e-02,  1.8240e-02,  1.6740e-02,  1.6140e-02,
+           1.7340e-02,  1.5950e-02,  1.5430e-02,  1.4780e-02,  1.2750e-02,
+           1.4370e-02,  1.2810e-02,  1.2900e-02,  1.1070e-02,  1.1830e-02,
+           1.1150e-02,  1.1260e-02,  1.1610e-02,  1.0700e-02,  1.1600e-02,
+           1.0390e-02,  1.0280e-02,  1.0180e-02,  1.0030e-02,  9.6050e-03,
+           8.8050e-03,  8.9680e-03,  9.0120e-03,  8.4110e-03,  8.6660e-03,
+           8.3060e-03,  8.5850e-03,  8.2600e-03,  8.3800e-03,  8.4200e-03,
+           7.5690e-03,  7.2100e-03,  7.1230e-03,  7.3350e-03,  7.1980e-03,
+           6.7500e-03,  6.6190e-03,  6.3370e-03,  6.6270e-03,  6.8290e-03,
+           6.0880e-03,  6.6310e-03,  6.0490e-03,  5.8900e-03,  5.6100e-03
+       };
+    Float_t x = px[0] * px[0];
+    if (x  < 1.5 || x > 100) {
+       return 0.0;
+    } else {
+       Float_t y =  Interpolate(x, ptUps, 0.5, 1., 100, 4);
+       return px[0] * y;
+    }
+}
+
 //
 //                    y-distribution
 //
@@ -257,6 +381,41 @@ Double_t AliGenMUONlib::YUpsilon(Double_t *py, Double_t *dummy)
     yu=kb*TMath::Exp(-(y-ky0)*(y-ky0)/2);
   return yu;
 }
+
+
+Double_t AliGenMUONlib::YUpsilonPbPb( Double_t *px, Double_t *dummy)
+{
+
+//
+// Upsilon y
+//
+//
+// R. Vogt 2002
+// PbPb 5.5 TeV
+// MRST HO
+// mc = 1.4 GeV, pt-kick 1 GeV
+//
+
+    Float_t yUps[52] = 
+       {
+           0.000000, 0.000065, 0.000767, 0.004332, 0.014790,
+           0.029370, 0.052060, 0.077930, 0.122500, 0.135800,
+           0.184000, 0.207900, 0.228300, 0.258500, 0.269500,
+           0.288500, 0.316200, 0.304100, 0.315800, 0.323300,
+           0.322400, 0.322600, 0.345500, 0.338100, 0.331900,
+           0.343700, 0.343700, 0.331900, 0.338100, 0.345500,
+           0.322600, 0.322400, 0.323300, 0.315800, 0.304100,
+           0.316200, 0.288500, 0.269500, 0.258500, 0.228300,
+           0.207900, 0.184000, 0.135800, 0.122500, 0.077930,
+           0.052060, 0.029380, 0.014780, 0.004332, 0.000767,
+           0.6479E-04, 0.1013E-06       
+       };
+    
+
+
+    return Interpolate(px[0], yUps, -6.5, 0.25, 52, 2);
+}
+
 //                 particle composition
 //
 Int_t AliGenMUONlib::IpUpsilon(TRandom *)
@@ -439,6 +598,7 @@ typedef Double_t (*GenFunc) (Double_t*,  Double_t*);
 GenFunc AliGenMUONlib::GetPt(Int_t param,  const char* tname) const
 {
 // Return pointer to pT parameterisation
+    TString sname = TString(tname);
     GenFunc func;
     switch (param) 
     {
@@ -452,10 +612,18 @@ GenFunc AliGenMUONlib::GetPt(Int_t param,  const char* tname) const
        func=PtEta;
        break;
     case kJpsi:
-       func=PtJpsi;
+       if (sname == "PbPb") {
+           func=PtJpsiPbPb;
+       } else {
+           func=PtJpsi;
+       }
        break;
     case kUpsilon:
-       func=PtUpsilon;
+       if (sname == "PbPb") {
+           func=PtUpsilonPbPb;
+       } else {
+           func=PtUpsilon;
+       }
        break;
     case kCharm:
        func=PtCharm;
@@ -478,6 +646,8 @@ GenFunc AliGenMUONlib::GetPt(Int_t param,  const char* tname) const
 
 GenFunc AliGenMUONlib::GetY(Int_t param, const char* tname) const
 {
+    TString sname = TString(tname);
+    
 // Return pointer to y- parameterisation
     GenFunc func;
     switch (param) 
@@ -492,10 +662,18 @@ GenFunc AliGenMUONlib::GetY(Int_t param, const char* tname) const
        func=YOmega;
        break;
     case kJpsi:
-       func=YJpsi;
+       if (sname == "PbPb") {
+           func=YJpsiPbPb;
+       } else {
+           func=YJpsi;
+       }
        break;
     case kUpsilon:
-       func=YUpsilon;
+       if (sname == "PbPb") {
+           func=YUpsilonPbPb;
+       } else {
+           func=YUpsilon;
+       }
        break;
     case kCharm:
        func=YCharm;
@@ -558,4 +736,54 @@ GenFuncIp AliGenMUONlib::GetIp(Int_t param,  const char* tname) const
 
 
 
+Float_t AliGenMUONlib::Interpolate(Float_t x, Float_t* y, Float_t x0, 
+                                  Float_t dx,
+                                  Int_t n, Int_t no)
+{
+//
+// Neville's alorithm for interpolation
+//
+// x:  x-value
+// y:  Input array
+// x0: minimum x 
+// dx: step size
+//  n: number of data points
+// no: order of polynom 
+//
+    Float_t*  c = new Float_t[n];
+    Float_t*  d = new Float_t[n];
+    Int_t m, i;
+    for (i = 0; i < n; i++) {
+       c[i] = y[i];
+       d[i] = y[i];
+    }
+    
+    Int_t   ns  = int((x - x0)/dx);
+    
+    Float_t y1  = y[ns];
+    ns--;    
+    for (m = 0; m < no; m++) {
+       for (i = 0; i < n-m; i++) {     
+           Float_t ho = x0 + Float_t(i) * dx - x;
+           Float_t hp = x0 + Float_t(i+m+1) * dx - x;
+           Float_t w  = c[i+1] - d[i];
+           Float_t den = ho-hp;
+           den = w/den;
+           d[i] = hp * den;
+           c[i] = ho * den;
+       }
+       Float_t dy;
+       
+       if (2*ns < (n-m-1)) {
+           dy  = c[ns+1];
+       } else {
+           dy  = d[ns--];
+       }
+       y1 += dy;}
+    delete[] c;
+    delete[] d;
+
+    return y1;
+}
+
 
index 997bf4f..2e1d87d 100644 (file)
@@ -17,7 +17,8 @@ class AliGenMUONlib :
   public AliGenLib
 {
  public:
-    enum constants{kPhi, kOmega, kEta, kJpsi, kUpsilon, kCharm, kBeauty, kPion, kKaon};
+    enum constants{kPhi, kOmega, kEta, kJpsi, kUpsilon,
+                  kCharm, kBeauty, kPion, kKaon};
     
     
 // pions
@@ -44,10 +45,14 @@ class AliGenMUONlib :
 // J/Psi     
     static Double_t PtJpsi( Double_t *px, Double_t *dummy);
     static Double_t YJpsi(Double_t *py, Double_t *dummy);
+    static Double_t PtJpsiPbPb( Double_t *px, Double_t *dummy);
+    static Double_t YJpsiPbPb(Double_t *py, Double_t *dummy);
     static Int_t    IpJpsi(TRandom *ran);
 // Upsilon    
     static Double_t PtUpsilon( Double_t *px, Double_t *dummy );
     static Double_t YUpsilon(Double_t *py, Double_t *dummy);
+    static Double_t PtUpsilonPbPb( Double_t *px, Double_t *dummy );
+    static Double_t YUpsilonPbPb(Double_t *py, Double_t *dummy);
     static Int_t    IpUpsilon(TRandom *ran);
 //
 // Charm    
@@ -62,7 +67,13 @@ class AliGenMUONlib :
 //
     GenFunc   GetPt(Int_t param, const char* tname=0) const;
     GenFunc   GetY (Int_t param, const char* tname=0) const;
-    GenFuncIp GetIp(Int_t param, const char* tname=0) const;    
+    GenFuncIp GetIp(Int_t param, const char* tname=0) const;
+ private:
+    
+    static Float_t Interpolate(Float_t x, Float_t* y, Float_t x0, 
+                       Float_t dx,
+                       Int_t n, Int_t no);
+    
     ClassDef(AliGenMUONlib,0) // Library providing y and pT parameterisations
 };
 #endif