/* $Id$ */
//
// Utility class to make simple Glauber type calculations
-// for SYMMTRIC collision geometries (AA):
+// for SYMMETRIC collision geometries (AA):
// Impact parameter, production points, reaction plane dependence
//
// The SimulateTrigger method can be used for simple MB and hard-process
TF2* AliFastGlauber::fgWKParticipants = NULL;
TF1* AliFastGlauber::fgWParticipants = NULL;
TF2* AliFastGlauber::fgWAlmondCurrent = NULL;
-TF2 AliFastGlauber::fgWAlmondFixedB[40];
+TF2* AliFastGlauber::fgWAlmondFixedB[40];
const Int_t AliFastGlauber::fgkMCInts = 100000;
Int_t AliFastGlauber::fgCounter = 0;
-AliFastGlauber::AliFastGlauber() : fName()
-{
- // Default Constructor
- //
+AliFastGlauber::AliFastGlauber():
+ fWSr0(0.),
+ fWSd(0.),
+ fWSw(0.),
+ fWSn(0.),
+ fSigmaHard(0.),
+ fSigmaNN(0.),
+ fA(0),
+ fBmin(0.),
+ fBmax(0.),
+ fEllDef(0),
+ fName()
+{
+ // Default Constructor
fgCounter++;
if(fgCounter>1)
- Error("AliFastGlauber","More than more instance (%d) is not supported, check your code!",fgCounter);
+ Error("AliFastGlauber","More than one instance (%d) is not supported, check your code!",fgCounter);
// Defaults for Pb
SetMaxImpact();
SetPbPbLHC();
}
+AliFastGlauber::AliFastGlauber(const AliFastGlauber & gl)
+ :TObject(gl),
+ fWSr0(0.),
+ fWSd(0.),
+ fWSw(0.),
+ fWSn(0.),
+ fSigmaHard(0.),
+ fSigmaNN(0.),
+ fA(0),
+ fBmin(0.),
+ fBmax(0.),
+ fEllDef(0),
+ fName()
+{
+// Copy constructor
+ gl.Copy(*this);
+}
+
AliFastGlauber::~AliFastGlauber()
{
+// Destructor
fgCounter--;
- //if(fgCounter==0) Reset();
+ for(Int_t k=0; k<40; k++) delete fgWAlmondFixedB[k];
}
void AliFastGlauber::SetAuAuRhic()
fgWSb->SetParameter(2, fWSw);
fgWSb->SetParameter(3, fWSn);
- fgWSbz = new TF2("WSbz", WSbz, 0, fgBMax, 4);
+ fgWSbz = new TF2("WSbz", WSbz, 0, fgBMax, 0, fgBMax, 4);
fgWSbz->SetParameter(0, fWSr0);
fgWSbz->SetParameter(1, fWSd);
fgWSbz->SetParameter(2, fWSw);
for(Int_t k=0; k<40; k++) {
sprintf(almondName,"WAlmondFixedB%d",k);
fgWAlmondCurrent = (TF2*)ff->Get(almondName);
- new(&fgWAlmondFixedB[k]) TF2(*fgWAlmondCurrent);
+ fgWAlmondFixedB[k] = fgWAlmondCurrent;
}
delete ff;
}
fgWPathLength->SetParameter(2, 0); //Pathlength definition
}
-void AliFastGlauber::Reset()
+void AliFastGlauber::Reset() const
{
//
// Reset dynamic allocated formulas
TCanvas *c2 = new TCanvas("c2","Overlap",400,10,600,700);
c2->cd();
Double_t max=fgWStaa->GetMaximum(0,fgBMax)*1.01;
- TH2F *h2f=new TH2F("h2ftaa","Overlap function: T_{AB} [mbarn^{-1}]",2,0,fgBMax,2,0,max);
+ TH2F *h2f=new TH2F("h2ftaa","Overlap function: T_{AB} [mbarn^{-1}]",2,0,fgBMax,2,0, max);
h2f->SetStats(0);
h2f->GetXaxis()->SetTitle("b [fm]");
h2f->GetYaxis()->SetTitle("T_{AB} [mbarn^{-1}]");
// MC Integration
//
Double_t y = 0;
+
+
for (Int_t i = 0; i < fgkMCInts; i++)
{
+
const Double_t kphi = TMath::Pi() * gRandom->Rndm();
const Double_t kb1 = fgBMax * gRandom->Rndm();
y += fgWStarfi->Eval(kb1, kphi);
Double_t AliFastGlauber::FractionOfHardCrossSection(Double_t b1, Double_t b2) const
{
//
- // Return raction of hard cross-section integrated from b1 to b2
+ // Return fraction of hard cross-section integrated from b1 to b2
//
return fgWSbinary->Integral(b1, b2)/fgWSbinary->Integral(0., 100.);
}
+Double_t AliFastGlauber::NHard(Double_t b1, Double_t b2) const
+{
+ //
+ // Number of binary hard collisions
+ // as a function of b (nucl/ex/0302016 eq. 19)
+ //
+ const Double_t kshard=HardCrossSection(b1,b2);
+ const Double_t ksgeo=CrossSection(b1,b2);
+ if(ksgeo>0)
+ return kshard/ksgeo;
+ else return -1;
+}
+
Double_t AliFastGlauber::Binaries(Double_t b) const
{
//
return fgWSN->Eval(b)/fgWSN->Eval(1e-4);
}
+Double_t AliFastGlauber::MeanOverlap(Double_t b1, Double_t b2)
+{
+//
+// Calculate the mean overlap for impact parameter range b1 .. b2
+//
+ Double_t sum = 0.;
+ Double_t sumc = 0.;
+ Double_t b = b1;
+
+ while (b < b2-0.005) {
+ Double_t nc = GetNumberOfCollisions(b);
+ sum += 10. * fgWStaa->Eval(b) * fgWSgeo->Eval(b) * 0.01 / (1. - TMath::Exp(-nc));
+ sumc += 10. * fgWSgeo->Eval(b) * 0.01;
+ b += 0.01;
+ }
+ return (sum / CrossSection(b1, b2));
+}
+
+
+Double_t AliFastGlauber::MeanNumberOfCollisionsPerEvent(Double_t b1, Double_t b2)
+{
+//
+// Calculate the mean number of collisions per event for impact parameter range b1 .. b2
+//
+ Double_t sum = 0.;
+ Double_t sumc = 0.;
+ Double_t b = b1;
+
+ while (b < b2-0.005) {
+ Double_t nc = GetNumberOfCollisions(b);
+ sum += nc / (1. - TMath::Exp(-nc)) * 10. * fgWSgeo->Eval(b) * 0.01;
+ sumc += 10. * fgWSgeo->Eval(b) * 0.01;
+ b += 0.01;
+ }
+ return (sum / CrossSection(b1, b2));
+}
+
+
Double_t AliFastGlauber::GetNumberOfBinaries(Double_t b) const
{
//
return (fgWStaa->Eval(b)*fSigmaNN);
}
+Double_t AliFastGlauber::GetNumberOfCollisionsPerEvent(Double_t b) const
+{
+ //
+ // Return the number of collisions per event (at least one collision)
+ // for impact parameter b
+ //
+ Double_t n = GetNumberOfCollisions(b);
+ if (n > 0.) {
+ return (n / (1. - TMath::Exp(- n)));
+ } else {
+ return (0.);
+ }
+}
+
void AliFastGlauber::SimulateTrigger(Int_t n)
{
//
b = fgWSbinary->GetRandom();
Int_t bin = 2*(Int_t)b;
if( (b-(Int_t)b) > 0.5) bin++;
- fgWAlmondCurrent = &fgWAlmondFixedB[bin];
+ fgWAlmondCurrent = fgWAlmondFixedB[bin];
return;
}
}
}
-void AliFastGlauber::GetLength(Double_t& ell,Double_t b)
+void AliFastGlauber::GetLengthAndPhi(Double_t& ell,Double_t& phi,Double_t b)
{
//
// Return length from random b, x0, y0, phi0
+ // Return also phi0
//
Double_t x0,y0,phi0;
if(b<0.) GetRandomBHard(b);
GetRandomXY(x0,y0);
GetRandomPhi(phi0);
+ phi = phi0;
ell = CalculateLength(b,x0,y0,phi0);
return;
}
-void AliFastGlauber::GetLengthsBackToBack(Double_t& ell1,Double_t& ell2,Double_t b)
+void AliFastGlauber::GetLength(Double_t& ell,Double_t b)
{
//
- // Return 2 lengths back to back from random b, x0, y0, phi0
+ // Return length from random b, x0, y0, phi0
+ //
+ Double_t phi;
+ GetLengthAndPhi(ell,phi,b);
+ return;
+}
+
+void AliFastGlauber::GetLengthsBackToBackAndPhi(Double_t& ell1,Double_t& ell2,Double_t &phi,Double_t b)
+{
//
+ // Return 2 lengths back to back from random b, x0, y0, phi0
+ // Return also phi0
+ //
Double_t x0,y0,phi0;
if(b<0.) GetRandomBHard(b);
GetRandomXY(x0,y0);
GetRandomPhi(phi0);
const Double_t kphi0plusPi = phi0+TMath::Pi();
+ phi = phi0;
ell1 = CalculateLength(b,x0,y0,phi0);
ell2 = CalculateLength(b,x0,y0,kphi0plusPi);
return;
}
+void AliFastGlauber::GetLengthsBackToBack(Double_t& ell1,Double_t& ell2,
+ Double_t b)
+{
+ //
+ // Return 2 lengths back to back from random b, x0, y0, phi0
+ //
+ Double_t phi;
+ GetLengthsBackToBackAndPhi(ell1,ell2,phi,b);
+ return;
+}
+
void AliFastGlauber::GetLengthsForPythia(Int_t n,Double_t* phi,Double_t* ell, Double_t b)
{
//
return;
}
-void AliFastGlauber::PlotLengthDistr(Int_t n,Bool_t save,Char_t *fname)
+void AliFastGlauber::PlotLengthDistr(Int_t n,Bool_t save,const char *fname)
{
//
// Plot length distribution
return;
}
-void AliFastGlauber::PlotLengthB2BDistr(Int_t n,Bool_t save,Char_t *fname)
+void AliFastGlauber::PlotLengthB2BDistr(Int_t n,Bool_t save,const char *fname)
{
//
// Plot lengths back-to-back distributions
gStyle->SetPalette(1,0);
c->Divide(2,2);
c->cd(1);
- fgWAlmondFixedB[0].Draw("cont1");
+ fgWAlmondFixedB[0]->Draw("cont1");
c->cd(2);
- fgWAlmondFixedB[10].Draw("cont1");
+ fgWAlmondFixedB[10]->Draw("cont1");
c->cd(3);
- fgWAlmondFixedB[20].Draw("cont1");
+ fgWAlmondFixedB[20]->Draw("cont1");
c->cd(4);
- fgWAlmondFixedB[30].Draw("cont1");
+ fgWAlmondFixedB[30]->Draw("cont1");
return;
}
{
//
// Calculate integrals:
- // integral0 = \int_0^ellCut dl*(T_A*T_B)(x0+l*ux,y0+l*uy)
- // integral1 = \int_0^ellCut dl*l*(T_A*T_B)(x0+l*ux,y0+l*uy)
+ // integral0 = \int_0^ellCut dl*(T_A*T_B)(x0+l*ux,y0+l*uy)
+ // integral1 = \int_0^ellCut dl*l*(T_A*T_B)(x0+l*ux,y0+l*uy)
//
// for a parton with production point (x0,y0)
// and propagation direction (ux=cos(phi0),uy=sin(phi0))
return;
}
+void AliFastGlauber::GetI0I1AndPhi(Double_t& integral0,Double_t& integral1,
+ Double_t& phi,
+ Double_t ellCut,Double_t b)
+{
+ //
+ // Return I0 and I1 from random b, x0, y0, phi0
+ // Return also phi
+ //
+ Double_t x0,y0,phi0;
+ if(b<0.) GetRandomBHard(b);
+ GetRandomXY(x0,y0);
+ GetRandomPhi(phi0);
+ phi = phi0;
+ CalculateI0I1(integral0,integral1,b,x0,y0,phi0,ellCut);
+ return;
+}
+
void AliFastGlauber::GetI0I1(Double_t& integral0,Double_t& integral1,
Double_t ellCut,Double_t b)
{
//
// Return I0 and I1 from random b, x0, y0, phi0
//
+ Double_t phi;
+ GetI0I1AndPhi(integral0,integral1,phi,ellCut,b);
+ return;
+}
+
+void AliFastGlauber::GetI0I1BackToBackAndPhi(Double_t& integral01,Double_t& integral11,
+ Double_t& integral02,Double_t& integral12,
+ Double_t& phi,
+ Double_t ellCut,Double_t b)
+{
+ //
+ // Return 2 pairs of I0 and I1 back to back from random b, x0, y0, phi0
+ // Return also phi0
+ //
Double_t x0,y0,phi0;
if(b<0.) GetRandomBHard(b);
GetRandomXY(x0,y0);
GetRandomPhi(phi0);
- CalculateI0I1(integral0,integral1,b,x0,y0,phi0,ellCut);
+ phi = phi0;
+ const Double_t kphi0plusPi = phi0+TMath::Pi();
+ CalculateI0I1(integral01,integral11,b,x0,y0,phi0,ellCut);
+ CalculateI0I1(integral02,integral12,b,x0,y0,kphi0plusPi,ellCut);
return;
}
-void AliFastGlauber::GetI0I1BackToBack(Double_t& integral01,Double_t& integral11,
- Double_t& integral02,Double_t& integral12,
- Double_t ellCut,Double_t b)
+void AliFastGlauber::GetI0I1BackToBackAndPhiAndXY(Double_t& integral01,Double_t& integral11,
+ Double_t& integral02,Double_t& integral12,
+ Double_t& phi,Double_t &x,Double_t &y,
+ Double_t ellCut,Double_t b)
{
//
// Return 2 pairs of I0 and I1 back to back from random b, x0, y0, phi0
+ // Return also phi0
//
Double_t x0,y0,phi0;
if(b<0.) GetRandomBHard(b);
GetRandomXY(x0,y0);
GetRandomPhi(phi0);
+ phi = phi0; x=x0; y=y0;
const Double_t kphi0plusPi = phi0+TMath::Pi();
CalculateI0I1(integral01,integral11,b,x0,y0,phi0,ellCut);
CalculateI0I1(integral02,integral12,b,x0,y0,kphi0plusPi,ellCut);
return;
}
+void AliFastGlauber::GetI0I1BackToBack(Double_t& integral01,Double_t& integral11,
+ Double_t& integral02,Double_t& integral12,
+ Double_t ellCut,Double_t b)
+{
+ //
+ // Return 2 pairs of I0 and I1 back to back from random b, x0, y0, phi0
+ //
+ Double_t phi;
+ GetI0I1BackToBackAndPhi(integral01,integral11,integral02,integral12,
+ phi,ellCut,b);
+ return;
+}
+
void AliFastGlauber::GetI0I1ForPythia(Int_t n,Double_t* phi,
Double_t* integral0,Double_t* integral1,
Double_t ellCut,Double_t b)
return;
}
+void AliFastGlauber::GetI0I1ForPythiaAndXY(Int_t n,Double_t* phi,
+ Double_t* integral0,Double_t* integral1,
+ Double_t &x,Double_t& y,
+ Double_t ellCut,Double_t b)
+{
+ //
+ // Returns I0 and I1 pairs for n partons with azimuthal angles phi[n]
+ // from random b, x0, y0 and return x0,y0
+ //
+ Double_t x0,y0;
+ if(b<0.) GetRandomBHard(b);
+ GetRandomXY(x0,y0);
+ for(Int_t i=0; i<n; i++)
+ CalculateI0I1(integral0[i],integral1[i],b,x0,y0,phi[i],ellCut);
+ x=x0;
+ y=y0;
+ return;
+}
+
void AliFastGlauber::PlotI0I1Distr(Int_t n,Double_t ellCut,
- Bool_t save,Char_t *fname)
+ Bool_t save,const char *fname)
{
//
// Plot I0-I1 distribution
}
void AliFastGlauber::PlotI0I1B2BDistr(Int_t n,Double_t ellCut,
- Bool_t save,Char_t *fname)
+ Bool_t save,const char *fname)
{
//
// Plot I0-I1 back-to-back distributions
return;
}
+AliFastGlauber& AliFastGlauber::operator=(const AliFastGlauber& rhs)
+{
+// Assignment operator
+ rhs.Copy(*this);
+ return *this;
+}
+
+void AliFastGlauber::Copy(TObject&) const
+{
+ //
+ // Copy
+ //
+ Fatal("Copy","Not implemented!\n");
+}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff