- Use new methods from AliQuenchingWeights ("Integral method")

- Correct jet correlations.

diff --git a/PYTHIA6/AliGenPythia.cxx b/PYTHIA6/AliGenPythia.cxx
index c30ce053b6f1f65428d4171bb438fc3b80f05b7c..7ee703a9f663fa5563fab09dfa13c085d78d4d66 100644 (file)
--- a/PYTHIA6/AliGenPythia.cxx
+++ b/PYTHIA6/AliGenPythia.cxx
@@ -288,7 +288,7 @@ void AliGenPythia::Init()
     }
 
     if (fQuench) {
     }
 
     if (fQuench) {

-       fPythia->InitQuenching(0., 0.05, 1.45, 8., 1);
+       fPythia->InitQuenching(0., 0.1, 6.e5, 0);

     }
     
 }
     }
     
 }

diff --git a/PYTHIA6/AliPythia.cxx b/PYTHIA6/AliPythia.cxx
index c0a9fa5a22dad964541dfba9a156091f4df20bea..f83a094bcfd5444968cbd72e2496bb29c5682408 100644 (file)
--- a/PYTHIA6/AliPythia.cxx
+++ b/PYTHIA6/AliPythia.cxx
@@ -653,7 +653,7 @@ void AliPythia::Pyrobo(Int_t imi, Int_t ima, Double_t the, Double_t phi, Double_
 
 
 
 
 
 

-void AliPythia::InitQuenching(Float_t cMin, Float_t cMax, Float_t qTransport, Float_t maxLength, Int_t iECMethod)
+void AliPythia::InitQuenching(Float_t cMin, Float_t cMax, Float_t k, Int_t iECMethod)

 {
 // Initializes 
 // (1) The quenching model using quenching weights according to C. Salgado and U. Wiedemann
 {
 // Initializes 
 // (1) The quenching model using quenching weights according to C. Salgado and U. Wiedemann


@@ -667,11 +667,8 @@ void AliPythia::InitQuenching(Float_t cMin, Float_t cMax, Float_t qTransport, Fl
 
     fQuenchingWeights = new AliQuenchingWeights();
     fQuenchingWeights->InitMult();
 
     fQuenchingWeights = new AliQuenchingWeights();
     fQuenchingWeights->InitMult();

-    fQuenchingWeights->SetQTransport(qTransport);
+    fQuenchingWeights->SetK(k);

     fQuenchingWeights->SetECMethod(AliQuenchingWeights::kECMethod(iECMethod));
     fQuenchingWeights->SetECMethod(AliQuenchingWeights::kECMethod(iECMethod));

-    fQuenchingWeights->SetLengthMax(Int_t(maxLength));
-    fQuenchingWeights->SampleEnergyLoss();
-    

 }
 
 
 }
 
 


@@ -703,13 +700,12 @@ void  AliPythia::Quench()
     Int_t   klast[4] = {-1, -1, -1, -1};
 
     Int_t numpart   = fPyjets->N;
     Int_t   klast[4] = {-1, -1, -1, -1};
 
     Int_t numpart   = fPyjets->N;

-    Double_t px = 0., py = 0., pz = 0., e = 0., m = 0., p = 0., pt = 0., theta = 0.;
+    Double_t px = 0., py = 0., pz = 0., e = 0., m = 0., p = 0., pt = 0., theta = 0., phi = 0.;

     Double_t pxq[4], pyq[4], pzq[4], eq[4], yq[4], mq[4], pq[4], phiq[4], thetaq[4], ptq[4];
     Bool_t  quenched[4];
     Double_t pxq[4], pyq[4], pzq[4], eq[4], yq[4], mq[4], pq[4], phiq[4], thetaq[4], ptq[4];
     Bool_t  quenched[4];

-    Double_t phi;

     Double_t zInitial[4], wjtKick[4];
     Int_t nGluon[4];
     Double_t zInitial[4], wjtKick[4];
     Int_t nGluon[4];

-    
+    Int_t qPdg[4];

     Int_t   imo, kst, pdg;
 //
 //  Sore information about Primary partons
     Int_t   imo, kst, pdg;
 //
 //  Sore information about Primary partons


@@ -755,31 +751,34 @@ void  AliPythia::Quench()
        phiq[j]   = TMath::Pi()+TMath::ATan2(-pyq[j], -pxq[j]);
        ptq[j]    = TMath::Sqrt(pxq[j] * pxq[j] + pyq[j] * pyq[j]);
        thetaq[j] = TMath::ATan2(ptq[j], pzq[j]);
        phiq[j]   = TMath::Pi()+TMath::ATan2(-pyq[j], -pxq[j]);
        ptq[j]    = TMath::Sqrt(pxq[j] * pxq[j] + pyq[j] * pyq[j]);
        thetaq[j] = TMath::ATan2(ptq[j], pzq[j]);

-       phi       = phiq[j];
+       qPdg[j]   =  fPyjets->K[1][i];
+    }
+  
+    Double_t int0[4];
+    Double_t int1[4];
+
+    fGlauber->GetI0I1ForPythia(4, phiq, int0, int1, 15.);
+    
+    for (Int_t j = 0; j < 4; j++) {

        //
        // Quench only central jets and with E > 10.
        //
        //
        // Quench only central jets and with E > 10.
        //

+
+
+       Int_t itype = (qPdg[j] == 21) ? 2 : 1;
+       Double_t eloss = fQuenchingWeights->GetELossRandomKFast(itype, int0[j], int1[j], eq[j]);
+

        if (TMath::Abs(yq[j]) > 2.5 || eq[j] < 10.) {
            zInitial[j] = 0.;
        } else {
        if (TMath::Abs(yq[j]) > 2.5 || eq[j] < 10.) {
            zInitial[j] = 0.;
        } else {

-           pdg =  fPyjets->K[1][i];
-           // Get length in nucleus
-           Double_t l;
-           fGlauber->GetLengthsForPythia(1, &phi, &l, -1.);
-           //
-           // Energy loss for given length and parton type 
-           Int_t itype = (pdg == 21) ? 2 : 1;
-       
-           Double_t eloss   = fQuenchingWeights->GetELossRandom(itype, l, eq[j]);

            if (eq[j] > 40. && TMath::Abs(yq[j]) < 0.5) {
                icall ++;
                eMean += eloss;
            }
            if (eq[j] > 40. && TMath::Abs(yq[j]) < 0.5) {
                icall ++;
                eMean += eloss;
            }

-           

            //
            // Extra pt
            //
            // Extra pt

-           
-           wjtKick[j] = TMath::Sqrt(l *  fQuenchingWeights->GetQTransport());
+           Double_t l =   fQuenchingWeights->CalcLk(int0[j], int1[j]);     
+           wjtKick[j] = TMath::Sqrt(l *  fQuenchingWeights->CalcQk(int0[j], int1[j]));

            //
            // Fractional energy loss
            zInitial[j] = eloss / eq[j];
            //
            // Fractional energy loss
            zInitial[j] = eloss / eq[j];


@@ -789,8 +788,10 @@ void  AliPythia::Quench()
            if (zInitial[j] == 1.) zInitial[j] = 0.95;
            //
            // Some debug printing
            if (zInitial[j] == 1.) zInitial[j] = 0.95;
            //
            // Some debug printing

+
+           

            printf("Initial parton # %3d, Type %3d Energy %10.3f Phi %10.3f Length %10.3f Loss %10.3f Kick %10.3f Mean: %10.3f %10.3f\n", 
            printf("Initial parton # %3d, Type %3d Energy %10.3f Phi %10.3f Length %10.3f Loss %10.3f Kick %10.3f Mean: %10.3f %10.3f\n", 

-                  j, itype, eq[j], phi, l, eloss, wjtKick[j], eMean / Float_t(icall+1), yq[j]);
+                  j, itype, eq[j], phiq[j], l, eloss, wjtKick[j], eMean / Float_t(icall+1), yq[j]);

            
 //         zInitial[j] = 0.8;
 //         while (zInitial[j] >= 0.95)  zInitial[j] = gRandom->Exp(0.2);
            
 //         zInitial[j] = 0.8;
 //         while (zInitial[j] >= 0.95)  zInitial[j] = gRandom->Exp(0.2);

diff --git a/PYTHIA6/AliPythia.h b/PYTHIA6/AliPythia.h
index 3bc3bdb10632e71115234777849fd57f9bfd2ec8..188a77da53c7f0f7aca028074190e101e10bc84e 100644 (file)
--- a/PYTHIA6/AliPythia.h
+++ b/PYTHIA6/AliPythia.h
@@ -56,7 +56,7 @@ class AliPythia : public TPythia6, public AliRndm
     virtual void Pyclus(Int_t& nclus);
     virtual void Pyshow(Int_t ip1, Int_t ip2, Double_t qmax);
     virtual void Pyrobo(Int_t imi, Int_t ima, Double_t the, Double_t phi, Double_t bex, Double_t bey, Double_t bez);
     virtual void Pyclus(Int_t& nclus);
     virtual void Pyshow(Int_t ip1, Int_t ip2, Double_t qmax);
     virtual void Pyrobo(Int_t imi, Int_t ima, Double_t the, Double_t phi, Double_t bex, Double_t bey, Double_t bez);

-    virtual void InitQuenching(Float_t bmin, Float_t bmax, Float_t qTransport, Float_t maxLength, Int_t iECMethod);
+    virtual void InitQuenching(Float_t bmin, Float_t bmax, Float_t k, Int_t iECMethod);

     
     // return instance of the singleton
     static  AliPythia* Instance();
     
     // return instance of the singleton
     static  AliPythia* Instance();