ROOT logo
AliRoot » FASTSIM » AliFastGlauber

class AliFastGlauber: public TObject

Function Members (Methods)

public:
virtual~AliFastGlauber()
voidTObject::AbstractMethod(const char* method) const
virtual voidTObject::AppendPad(Option_t* option = "")
Double_tBinaries(Double_t b) const
virtual voidTObject::Browse(TBrowser* b)
voidCalculateI0I1(Double_t& integral0, Double_t& integral1, Double_t b = 0., Double_t x0 = 0., Double_t y0 = 0., Double_t phi0 = 0., Double_t ellCut = 20.) const
Double_tCalculateLength(Double_t b = 0., Double_t x0 = 0., Double_t y0 = 0., Double_t phi0 = 0.)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTObject::Clear(Option_t* = "")
virtual TObject*TObject::Clone(const char* newname = "") const
virtual Int_tTObject::Compare(const TObject* obj) const
virtual voidCopy(TObject&) const
Double_tCrossSection(Double_t b1, Double_t b2) const
virtual voidTObject::Delete(Option_t* option = "")MENU
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTObject::Draw(Option_t* option = "")
voidDrawAlmond(Double_t b = 0.) const
voidDrawBinary() const
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
voidDrawEnergyDensity() const
voidDrawGeo() const
voidDrawIntRadius(Double_t b = 0.) const
voidDrawKernel(Double_t b = 0.) const
voidDrawN() const
voidDrawOverlap() const
voidDrawParticipants() const
voidDrawPathLength(Double_t b, Int_t ni = 1000, Int_t iopt = 0) const
voidDrawPathLength0(Double_t b = 0., Int_t iopt = 0) const
voidDrawThickness() const
voidDrawWSb() const
virtual voidTObject::Dump() constMENU
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
Double_tFractionOfHardCrossSection(Double_t b1, Double_t b2) const
Int_tGetA() const
Float_tGetBmax() const
Float_tGetBmin() const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
const TString*GetFileName() const
voidGetI0I1(Double_t& integral0, Double_t& integral1, Double_t ellCut = 20., Double_t b = -1.)
voidGetI0I1AndPhi(Double_t& integral0, Double_t& integral1, Double_t& phi, Double_t ellCut = 20., Double_t b = -1.)
voidGetI0I1BackToBack(Double_t& integral01, Double_t& integral11, Double_t& integral02, Double_t& integral12, Double_t ellCut = 20., Double_t b = -1.)
voidGetI0I1BackToBackAndPhi(Double_t& integral01, Double_t& integral11, Double_t& integral02, Double_t& integral12, Double_t& phi, Double_t ellCut = 20., Double_t b = -1.)
voidGetI0I1BackToBackAndPhiAndXY(Double_t& integral01, Double_t& integral11, Double_t& integral02, Double_t& integral12, Double_t& phi, Double_t& x, Double_t& y, Double_t ellCut = 20., Double_t b = -1.)
voidGetI0I1ForPythia(Int_t n, Double_t* phi, Double_t* integral0, Double_t* integral1, Double_t ellCut = 20., Double_t b = -1.)
voidGetI0I1ForPythiaAndXY(Int_t n, Double_t* phi, Double_t* integral0, Double_t* integral1, Double_t& x, Double_t& y, Double_t ellCut = 20., Double_t b = -1.)
virtual const char*TObject::GetIconName() const
voidGetLength(Double_t& ell, Double_t b = -1.)
voidGetLengthAndPhi(Double_t& ell, Double_t& phi, Double_t b = -1.)
Int_tGetLengthDef() const
voidGetLengthsBackToBack(Double_t& ell1, Double_t& ell2, Double_t b = -1.)
voidGetLengthsBackToBackAndPhi(Double_t& ell1, Double_t& ell2, Double_t& phi, Double_t b = -1.)
voidGetLengthsForPythia(Int_t n, Double_t *const phi, Double_t* ell, Double_t b = -1.)
virtual const char*TObject::GetName() const
Double_tGetNumberOfBinaries(Double_t b) const
Double_tGetNumberOfCollisions(Double_t b) const
Double_tGetNumberOfCollisionsPerEvent(Double_t b) const
Double_tGetNumberOfParticipants(Double_t b) const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
voidGetRandom(Int_t& bin, Bool_t& hard)
voidGetRandom(Float_t& b, Float_t& p, Float_t& mult)
voidGetRandomBHard(Double_t& b)
Double_tGetRandomImpactParameter(Double_t bmin, Double_t bmax)
voidGetRandomPhi(Double_t& phi)
voidGetRandomXY(Double_t& x, Double_t& y)
const TF1*GetRWSB() const
voidGetSavedI0I1(Double_t* i0i1) const
voidGetSavedXY(Double_t* xy) const
Float_tGetSigmaHard() const
Float_tGetSigmaNN() const
virtual const char*TObject::GetTitle() const
virtual UInt_tTObject::GetUniqueID() const
const TF2*GetWAlmond() const
const TF2*GetWAlmondFixedB(Int_t i) const
const TF1*GetWEnergyDensity() const
const TF1*GetWIntRadius() const
const TF2*GetWKParticipants() const
const TF1*GetWParticipants() const
const TF1*GetWPathLength() const
const TF1*GetWPathLength0() const
Float_tGetWr0() const
const TF1*GetWSB() const
const TF1*GetWSbinary() const
const TF2*GetWSbz() const
Float_tGetWSd() const
const TF1*GetWSgeo() const
const TF1*GetWSN() const
Float_tGetWSn() const
const TF1*GetWSta() const
const TF1*GetWStaa() const
const TF2*GetWStarfi() const
Float_tGetWSw() const
const TF1*GetWSz() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
Double_tHardCrossSection(Double_t b1, Double_t b2) const
virtual ULong_tTObject::Hash() const
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
voidInit(Int_t mode = 0)
virtual voidTObject::Inspect() constMENU
static AliFastGlauber*Instance()
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTObject::IsSortable() const
Bool_tTObject::IsZombie() const
const TF2*Kernel() const
virtual voidTObject::ls(Option_t* option = "") const
voidTObject::MayNotUse(const char* method) const
Double_tMeanNumberOfCollisionsPerEvent(Double_t b1, Double_t b2)
Double_tMeanOverlap(Double_t b1, Double_t b2)
Double_tNHard(Double_t b1, Double_t b2) const
virtual Bool_tTObject::Notify()
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
AliFastGlauber&operator=(const AliFastGlauber& rhs)
const TF1*Overlap() const
virtual voidTObject::Paint(Option_t* option = "")
Double_tParticipants(Double_t b) const
voidPlotAlmonds() const
voidPlotBDistr(Int_t n = 1000)
voidPlotI0I1B2BDistr(Int_t n = 1000, Double_t ellCut = 20., Bool_t save = kFALSE, const char* fname = "i0i1B2B.root")
voidPlotI0I1Distr(Int_t n = 1000, Double_t ellCut = 20., Bool_t save = kFALSE, const char* fname = "i0i1.root")
voidPlotLengthB2BDistr(Int_t n = 1000, Bool_t save = kFALSE, const char* fname = "lengthB2B.root")
voidPlotLengthDistr(Int_t n = 1000, Bool_t save = kFALSE, const char* fname = "length.root")
virtual voidTObject::Pop()
virtual voidTObject::Print(Option_t* option = "") const
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTObject::ResetBit(UInt_t f)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
voidSaveI0I1(Double_t i0, Double_t i1)
virtual voidTObject::SavePrimitive(basic_ostream<char,char_traits<char> >& out, Option_t* option = "")
voidSaveXY(Double_t x, Double_t y)
voidSetAuAuRhic()
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidSetCentralityClass(Double_t xsecFrLow = 0.0, Double_t xsecFrUp = 0.1)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidSetFileName(const TString& fn)
voidSetFileName(const char* fn = "$(ALICE_ROOT)/FASTSIM/data/glauberPbPb.root")
voidSetHardCrossSection(Float_t xs = 1.0)
voidSetLengthDefinition(Int_t def = 1)
voidSetMaxImpact(Float_t bmax = 20.)
voidSetNNCrossSection(Float_t xs = 55.6)
voidSetNucleus(Int_t n = 208)
static voidTObject::SetObjectStat(Bool_t stat)
voidSetPbPbLHC()
virtual voidTObject::SetUniqueID(UInt_t uid)
voidSetWoodSaxonParameters(Double_t r0, Double_t d, Double_t w, Double_t n)
voidSetWoodSaxonParametersAu()
voidSetWoodSaxonParametersPb()
virtual voidShowMembers(TMemberInspector&)
voidSimulateTrigger(Int_t n)
voidStoreAlmonds() const
voidStoreFunctions() const
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual voidTObject::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
protected:
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidTObject::MakeZombie()
voidReset() const
static Double_tRWSb(const Double_t* xx, const Double_t* par)
static Double_tWAlmond(const Double_t* xx, const Double_t* par)
static Double_tWEnergyDensity(const Double_t* xx, const Double_t* par)
static Double_tWIntRadius(const Double_t* xx, const Double_t* par)
static Double_tWKParticipants(const Double_t* xx, const Double_t* par)
static Double_tWParticipants(const Double_t* xx, const Double_t* par)
static Double_tWPathLength(const Double_t* xx, const Double_t* par)
static Double_tWPathLength0(const Double_t* xx, const Double_t* par)
static Double_tWSb(const Double_t* xx, const Double_t* par)
static Double_tWSbinary(const Double_t* xx, const Double_t* par)
static Double_tWSbz(const Double_t* xx, const Double_t* par)
static Double_tWSgeo(const Double_t* xx, const Double_t* par)
static Double_tWSN(const Double_t* xx, const Double_t* par)
static Double_tWSta(const Double_t* xx, const Double_t* par)
static Double_tWStaa(const Double_t* xx, const Double_t* par)
static Double_tWStarfi(const Double_t* xx, const Double_t* par)
static Double_tWSz(const Double_t* xx, const Double_t* par)
private:
AliFastGlauber()
AliFastGlauber(const AliFastGlauber& glauber)

Data Members

private:
Int_tfANucleon number of nucleus A
Float_tfBmaxCoresponding maximum b
Float_tfBminMinimum b (set through centrality selection)
Int_tfEllDefdefinition of length (see CalculateLength())
Double_tfI0I1[2]Current integrals I0 and I1
TStringfNamefilename of stored distributions
Float_tfSigmaHardHard Cross Section [mbarn]
Float_tfSigmaNNNN Cross Section [mbarn]
Float_tfWSdWood-Saxon Parameter d
Float_tfWSnWood-Saxon Parameter n
Float_tfWSr0Wood-Saxon Parameter r0
Float_tfWSwWood-Saxon Parameter w
Double_tfXY[2]Current generated production point
static Float_tfgBMaxMaximum Impact Parameter
static AliFastGlauber*fgGlauberSingleton instance
static TF1*fgRWSbWood-Saxon Function (b) with phase space factor
static TF2*fgWAlmondInteraction Almond
static TF2*fgWAlmondCurrentInteraction Almond used for length
static TF2*fgWAlmondFixedB[40]Interaction Almonds read from file
static TF1*fgWEnergyDensityEnergy density as a function of impact parameter
static TF1*fgWIntRadiusInteraction Radius
static TF2*fgWKParticipantsKernel for number of participants
static TF1*fgWParticipantsNumber of participants
static TF1*fgWPathLengthPath Length as a function of phi
static TF1*fgWPathLength0Path Length as a function of phi
static TF1*fgWSNdN/db binary
static TF1*fgWSbWood-Saxon Function (b)
static TF1*fgWSbinarydSigma/db binary
static TF2*fgWSbzWood-Saxon Function (b, z)
static TF1*fgWSgeodSigma/db geometric
static TF1*fgWStaThickness Function
static TF1*fgWStaaOverlap Function
static TF2*fgWStarfiKernel for Overlap Function
static TF1*fgWSzWood-Saxon Function (b = b0, z)
static const Int_tfgkMCIntsNumber of MC integrations

Class Charts

Inheritance Chart:
TObject
AliFastGlauber

Function documentation

AliFastGlauber()
  Default Constructor
  Defaults for Pb
AliFastGlauber(const AliFastGlauber& glauber)
 Copy constructor
AliFastGlauber* Instance()
 Set random number generator
~AliFastGlauber()
 Destructor
void SetAuAuRhic()
Set all parameters for RHIC
void SetPbPbLHC()
Set all parameters for LHC
void Init(Int_t mode = 0)
 Initialisation
    mode = 0; all functions are calculated
    mode = 1; overlap function is read from file (for Pb-Pb only)
    mode = 2; interaction almond functions are read from file
              USE THIS FOR PATH LENGTH CALC.!

void Reset() const
 Reset dynamic allocated formulas
 in case init is called twice
void DrawWSb() const
  Draw Wood-Saxon Nuclear Density Function

void DrawOverlap() const
  Draw Overlap Function

void DrawParticipants() const
  Draw Number of Participants Npart

void DrawThickness() const
  Draw Thickness Function

void DrawGeo() const
  Draw Geometrical Cross-Section

void DrawBinary() const
  Draw Binary Cross-Section

void DrawN() const
  Draw Binaries per event (Ncoll)

void DrawKernel(Double_t b = 0.) const
void DrawAlmond(Double_t b = 0.) const
  Draw Interaction Almond

void DrawEnergyDensity() const
  Draw energy density

void DrawPathLength0(Double_t b = 0., Int_t iopt = 0) const
  Draw Path Length

void DrawPathLength(Double_t b, Int_t ni = 1000, Int_t iopt = 0) const
  Draw Path Length

void DrawIntRadius(Double_t b = 0.) const
  Draw Interaction Radius

Double_t WSb(const Double_t* xx, const Double_t* par)
  Woods-Saxon Parameterisation
  as a function of radius (xx)

Double_t RWSb(const Double_t* xx, const Double_t* par)
  Woods-Saxon Parameterisation
  as a function of radius (xx)
  times r**2
Double_t WSbz(const Double_t* xx, const Double_t* par)
  Wood Saxon Parameterisation
  as a function of z and  b

Double_t WSz(const Double_t* xx, const Double_t* par)
  Wood Saxon Parameterisation
  as a function of z for fixed b

Double_t WSta(const Double_t* xx, const Double_t* par)
  Thickness function T_A
  as a function of b

Double_t WStarfi(const Double_t* xx, const Double_t* par)
  Kernel for overlap function: T_A(s)*T_A(s-b)
  as a function of r and phi
Double_t WStaa(const Double_t* xx, const Double_t* par)
  Overlap function
  T_{AB}=Int d2s T_A(s)*T_B(s-b)
  as a function of b
 (normalized to fA*fB)

Double_t WKParticipants(const Double_t* xx, const Double_t* par)
  Kernel for number of participants
  as a function of r and phi

Double_t WParticipants(const Double_t* xx, const Double_t* par)
  Number of Participants as
  a function of b

Double_t WSgeo(const Double_t* xx, const Double_t* par)
  Geometrical Cross-Section
  as a function of b

Double_t WSbinary(const Double_t* xx, const Double_t* par)
  Number of binary hard collisions
  as a function of b

Double_t WSN(const Double_t* xx, const Double_t* par)
  Number of hard processes per event
  as a function of b
Double_t WEnergyDensity(const Double_t* xx, const Double_t* par)
  Initial energy density
  as a function of the impact parameter

Double_t WAlmond(const Double_t* xx, const Double_t* par)
  Almond shaped interaction region
  as a function of cartesian x,y.

Double_t WIntRadius(const Double_t* xx, const Double_t* par)
  Average interaction density over radius
  at which interaction takes place
  as a function of radius

Double_t WPathLength0(const Double_t* xx, const Double_t* par)
  Path Length as a function of phi
  for interaction point fixed at (0,0)
  as a function of phi-direction

  Phi direction in Almond
Double_t WPathLength(const Double_t* xx, const Double_t* par)
  Path Length as a function of phi
  Interaction point from random distribution
  as a function of the phi-direction
Double_t CrossSection(Double_t b1, Double_t b2) const
 Return the geometrical cross-section integrated from b1 to b2

Double_t HardCrossSection(Double_t b1, Double_t b2) const
 Return the hard cross-section integrated from b1 to b2

Double_t FractionOfHardCrossSection(Double_t b1, Double_t b2) const
 Return fraction of hard cross-section integrated from b1 to b2

Double_t NHard(Double_t b1, Double_t b2) const
  Number of binary hard collisions
  as a function of b (nucl/ex/0302016 eq. 19)

Double_t Binaries(Double_t b) const
 Return number of binary hard collisions normalized to 1 at b=0

Double_t MeanOverlap(Double_t b1, Double_t b2)
 Calculate the mean overlap for impact parameter range b1 .. b2

Double_t MeanNumberOfCollisionsPerEvent(Double_t b1, Double_t b2)
 Calculate the mean number of collisions per event for impact parameter range b1 .. b2

Double_t GetNumberOfBinaries(Double_t b) const
 Return number of binary hard collisions at b

Double_t Participants(Double_t b) const
 Return the number of participants normalized to 1 at b=0

Double_t GetNumberOfParticipants(Double_t b) const
 Return the number of participants for impact parameter b

Double_t GetNumberOfCollisions(Double_t b) const
 Return the number of collisions for impact parameter b

Double_t GetNumberOfCollisionsPerEvent(Double_t b) const
 Return the number of collisions per event (at least one collision)
 for impact parameter b

void SimulateTrigger(Int_t n)
  Simulates Trigger

void GetRandom(Float_t& b, Float_t& p, Float_t& mult)
 Gives back a random impact parameter, hard trigger probability and multiplicity

void GetRandom(Int_t& bin, Bool_t& hard)
 Gives back a random impact parameter bin, and hard trigger decission

Double_t GetRandomImpactParameter(Double_t bmin, Double_t bmax)
 Gives back a random impact parameter in the range bmin .. bmax

void StoreFunctions() const
 Store in file functions

void StoreAlmonds() const
 Store in file
 40 almonds for b = (0.25+k*0.5) fm (k=0->39)

void SetCentralityClass(Double_t xsecFrLow = 0.0, Double_t xsecFrUp = 0.1)
 Set limits of centrality class as fractions
 of the geomtrical cross section

void GetRandomBHard(Double_t& b)
 Get random impact parameter according to distribution of
 hard (binary) cross-section, in the range defined by the centrality class

void GetRandomXY(Double_t& x, Double_t& y)
 Get random position of parton production point according to
 product of thickness functions

void GetRandomPhi(Double_t& phi)
 Get random parton azimuthal propagation direction

Double_t CalculateLength(Double_t b = 0., Double_t x0 = 0., Double_t y0 = 0., Double_t phi0 = 0.)
 Calculate path length for a parton with production point (x0,y0)
 and propagation direction (ux=cos(phi0),uy=sin(phi0))
 in a collision with impact parameter b

void GetLengthAndPhi(Double_t& ell, Double_t& phi, Double_t b = -1.)
 Return length from random b, x0, y0, phi0
 Return also phi0

void GetLength(Double_t& ell, Double_t b = -1.)
 Return length from random b, x0, y0, phi0

void GetLengthsBackToBackAndPhi(Double_t& ell1, Double_t& ell2, Double_t& phi, Double_t b = -1.)
 Return 2 lengths back to back from random b, x0, y0, phi0
 Return also phi0

void GetLengthsBackToBack(Double_t& ell1, Double_t& ell2, Double_t b = -1.)
 Return 2 lengths back to back from random b, x0, y0, phi0

void GetLengthsForPythia(Int_t n, Double_t *const phi, Double_t* ell, Double_t b = -1.)
 Returns lenghts for n partons with azimuthal angles phi[n]
 from random b, x0, y0

void PlotBDistr(Int_t n = 1000)
 Plot distribution of n impact parameters

void PlotLengthDistr(Int_t n = 1000, Bool_t save = kFALSE, const char* fname = "length.root")
 Plot length distribution

void PlotLengthB2BDistr(Int_t n = 1000, Bool_t save = kFALSE, const char* fname = "lengthB2B.root")
 Plot lengths back-to-back distributions

void PlotAlmonds() const
 Plot almonds for some impact parameters

void CalculateI0I1(Double_t& integral0, Double_t& integral1, Double_t b = 0., Double_t x0 = 0., Double_t y0 = 0., Double_t phi0 = 0., Double_t ellCut = 20.) const
 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)

 for a parton with production point (x0,y0)
 and propagation direction (ux=cos(phi0),uy=sin(phi0))
 in a collision with impact parameter b

void GetI0I1AndPhi(Double_t& integral0, Double_t& integral1, Double_t& phi, Double_t ellCut = 20., Double_t b = -1.)
 Return I0 and I1 from random b, x0, y0, phi0
 Return also phi

void GetI0I1(Double_t& integral0, Double_t& integral1, Double_t ellCut = 20., Double_t b = -1.)
 Return I0 and I1 from random b, x0, y0, phi0

void GetI0I1BackToBackAndPhi(Double_t& integral01, Double_t& integral11, Double_t& integral02, Double_t& integral12, Double_t& phi, Double_t ellCut = 20., Double_t b = -1.)
 Return 2 pairs of I0 and I1 back to back from random b, x0, y0, phi0
 Return also phi0

void 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 = 20., Double_t b = -1.)
 Return 2 pairs of I0 and I1 back to back from random b, x0, y0, phi0
 Return also phi0

void GetI0I1BackToBack(Double_t& integral01, Double_t& integral11, Double_t& integral02, Double_t& integral12, Double_t ellCut = 20., Double_t b = -1.)
 Return 2 pairs of I0 and I1 back to back from random b, x0, y0, phi0

void GetI0I1ForPythia(Int_t n, Double_t* phi, Double_t* integral0, Double_t* integral1, Double_t ellCut = 20., Double_t b = -1.)
 Returns I0 and I1 pairs for n partons with azimuthal angles phi[n]
 from random b, x0, y0

void GetI0I1ForPythiaAndXY(Int_t n, Double_t* phi, Double_t* integral0, Double_t* integral1, Double_t& x, Double_t& y, Double_t ellCut = 20., Double_t b = -1.)
 Returns I0 and I1 pairs for n partons with azimuthal angles phi[n]
 from random b, x0, y0 and return x0,y0

void PlotI0I1Distr(Int_t n = 1000, Double_t ellCut = 20., Bool_t save = kFALSE, const char* fname = "i0i1.root")
 Plot I0-I1 distribution

void PlotI0I1B2BDistr(Int_t n = 1000, Double_t ellCut = 20., Bool_t save = kFALSE, const char* fname = "i0i1B2B.root")
 Plot I0-I1 back-to-back distributions

AliFastGlauber& operator=(const AliFastGlauber& rhs)
 Assignment operator
void Copy(TObject& ) const
void SetWoodSaxonParameters(Double_t r0, Double_t d, Double_t w, Double_t n)
{fWSr0 = r0; fWSd = d; fWSw = w; fWSn = n;}
void SetWoodSaxonParametersAu()
{fWSr0 = 6.38; fWSd = 0.535; fWSw = 0.; fWSn = 8.59e-4;}
void SetWoodSaxonParametersPb()
{fWSr0 = 6.78; fWSd = 0.54; fWSw = 0.; fWSn = 7.14e-4;}
void SetMaxImpact(Float_t bmax = 20.)
{fgBMax = bmax;}
void SetHardCrossSection(Float_t xs = 1.0)
{fSigmaHard = xs;}
void SetNNCrossSection(Float_t xs = 55.6)
{fSigmaNN = xs;}
void SetNucleus(Int_t n = 208)
{fA=n;}
void SetFileName(const TString& fn)
{fName=fn;}
void SetFileName(const char* fn = "$(ALICE_ROOT)/FASTSIM/data/glauberPbPb.root")
{fName=fn;}
const TF1* GetWSB() const
{return fgWSb;}
const TF1* GetRWSB() const
{return fgRWSb;}
const TF2* GetWSbz() const
{return fgWSbz;}
const TF1* GetWSz() const
{return fgWSz;}
const TF1* GetWSta() const
{return fgWSta;}
const TF2* Kernel() const
{return fgWStarfi;}
const TF2* GetWStarfi() const
{return fgWStarfi;}
const TF2* GetWKParticipants() const
const TF1* GetWParticipants() const
{return fgWParticipants;}
const TF1* Overlap() const
{return fgWStaa;}
const TF1* GetWStaa() const
{return fgWStaa;}
const TF2* GetWAlmond() const
{return fgWAlmond;}
const TF1* GetWPathLength0() const
{return fgWPathLength0;}
const TF1* GetWPathLength() const
{return fgWPathLength;}
const TF1* GetWIntRadius() const
{return fgWIntRadius;}
const TF1* GetWSgeo() const
{return fgWSgeo;}
const TF1* GetWSbinary() const
{return fgWSbinary;}
const TF1* GetWSN() const
{return fgWSN;}
const TF1* GetWEnergyDensity() const
const TF2* GetWAlmondFixedB(Int_t i) const
{return fgWAlmondFixedB[i];}
Float_t GetWr0() const
{return fWSr0;}
Float_t GetWSd() const
{return fWSd;}
Float_t GetWSw() const
{return fWSw;}
Float_t GetWSn() const
{return fWSn;}
Float_t GetSigmaHard() const
{return fSigmaHard;}
Float_t GetSigmaNN() const
{return fSigmaNN;}
Int_t GetA() const
{return fA;}
const TString* GetFileName() const
{return &fName;}
Float_t GetBmin() const
{return fBmin;}
Float_t GetBmax() const
{return fBmax;}
void SetLengthDefinition(Int_t def = 1)
{fEllDef=def;}
Int_t GetLengthDef() const
{return fEllDef;}
void GetSavedXY(Double_t* xy) const
{xy[0] = fXY[0]; xy[1] = fXY[1];}
void GetSavedI0I1(Double_t* i0i1) const
{i0i1[0] = fI0I1[0]; i0i1[1] = fI0I1[1];}
void SaveXY(Double_t x, Double_t y)
{fXY[0] = x; fXY[1] = y;}
void SaveI0I1(Double_t i0, Double_t i1)
{fI0I1[0] = i0; fI0I1[1] = i1;}