:AliGenMC(),
fTrials(0),
fUHKMgen(0),
+ fHydjetParams(),
+ fStableFlagged(0),
fUseCharmParticles(kFALSE),
fMinWidth(0.0),
fMaxWidth(10.0),
:AliGenMC(npart),
fTrials(0),
fUHKMgen(0),
+ fHydjetParams(),
+ fStableFlagged(0),
fUseCharmParticles(kFALSE),
fMinWidth(0.0),
fMaxWidth(10.0),
class AliGenUHKM : public AliGenMC
{
- protected:
- Int_t fTrials; // Number of trials
- TUHKMgen *fUHKMgen; // UHKM
-
- InitialParamsHydjet_t fHydjetParams; // list of parameters for the initial state
- // details for the PDG database
- Char_t fParticleFilename[256]; // particle list filename
- Char_t fDecayFilename[256]; // decay table filename
- Int_t fStableFlagPDG[500]; // array of PDG codes flagged
- Bool_t fStableFlagStatus[500]; // array of decay flag status
- Int_t fStableFlagged; // number of toggled decay flags
- Bool_t fUseCharmParticles; // flag to turn on/off the use of charm particles
- Double_t fMinWidth; // minimum decay width for the particles to be used from the PDG database
- Double_t fMaxWidth; // maximum ----
- Double_t fMinMass; // minimum mass for the particles to be used from the PDG database
- Double_t fMaxMass; // maximum ----
-
- void SetAllParameters();
- void CheckPDGTable();
-
- private:
- void Copy(TObject &rhs) const;
- AliGenUHKM & operator = (const AliGenUHKM &);
-
public:
AliGenUHKM();
AliGenUHKM(Int_t npart);
Double_t GetMinimumMass() {return fMinMass;}
Double_t GetMaximumMass() {return fMaxMass;}
+ protected:
+ Int_t fTrials; // Number of trials
+ TUHKMgen *fUHKMgen; // UHKM
+
+ InitialParamsHydjet_t fHydjetParams; // list of parameters for the initial state
+ // details for the PDG database
+ Char_t fParticleFilename[256]; // particle list filename
+ Char_t fDecayFilename[256]; // decay table filename
+ Int_t fStableFlagPDG[500]; // array of PDG codes flagged
+ Bool_t fStableFlagStatus[500]; // array of decay flag status
+ Int_t fStableFlagged; // number of toggled decay flags
+ Bool_t fUseCharmParticles; // flag to turn on/off the use of charm particles
+ Double_t fMinWidth; // minimum decay width for the particles to be used from the PDG database
+ Double_t fMaxWidth; // maximum ----
+ Double_t fMinMass; // minimum mass for the particles to be used from the PDG database
+ Double_t fMaxMass; // maximum ----
+
+ void SetAllParameters();
+ void CheckPDGTable();
+
+ private:
+ void Copy(TObject &rhs) const;
+ AliGenUHKM(const AliGenUHKM&);
+ AliGenUHKM & operator = (const AliGenUHKM &);
+
ClassDef(AliGenUHKM, 6) // AliGenerator interface to UHKM
};
#endif
TUHKMgen::TUHKMgen() :
TGenerator("UHKM","UHKM"),
fInitialState(0x0),
+ fAllocator(),
+ fSourceList(),
+ fSecondariesList(),
+ fNPprim(0),
+ fNPsec(0),
+ fHydjetParams(),
+ fStableFlagged(0),
fUseCharmParticles(kFALSE),
fMinWidth(0.0),
fMaxWidth(10.0),
SetPyquenIanglu(0); // small gluon angular distribution
}
-TObjArray* TUHKMgen::ImportParticles(Option_t *option)
+TObjArray* TUHKMgen::ImportParticles(Option_t *)
{
cout << "TObjArray* TUHKMgen::ImportParticles(Option_t) IN" << endl;
fParticles->Clear();
Int_t im2 = -1;
Int_t id1 = -1;
Int_t id2 = -1;
- Int_t id3 = -1;
- Int_t nd = it->GetNDaughters();
+ // Int_t nd = it->GetNDaughters();
Int_t type = it->GetType(); // 0-hydro, 1-jets
TVector3 mom(it->Mom().Vect());
Float_t m1 = it->TableMass();
Int_t im1 = it->GetMother();
- Int_t nd = 0;
+ // Int_t nd = 0;
Int_t im2 = -1;
Int_t id1 = -1;
Int_t id2 = -1;
- Int_t id3 = -1;
- nd = it->GetNDaughters();
+ // nd = it->GetNDaughters();
Int_t type = it->GetType(); // 0-hydro, 1-jets
cout << "TUHKMgen::Initialize() OUT" << endl;
}
-void TUHKMgen::Print()
+void TUHKMgen::Print(const Option_t*) const
{
cout << "TUHKMgen::Print() method not implemented yet!!" << endl;
}
using namespace std;
class TUHKMgen : public TGenerator {
- protected:
- InitialStateHydjet *fInitialState;
- ParticleAllocator fAllocator;
- List_t fSourceList;
- List_t fSecondariesList;
- Int_t fNPprim;
- Int_t fNPsec;
- InitialParamsHydjet_t fHydjetParams; // list of parameters for the initial state
- // details for the PDG database
- Char_t fParticleFilename[256]; // particle list filename
- Char_t fDecayFilename[256]; // decay table filename
- Int_t fStableFlagPDG[500]; // array of PDG codes flagged to be stable
- Bool_t fStableFlagStatus[500]; // array of decay flag status
- Int_t fStableFlagged; // number of toggled decay flags
- Bool_t fUseCharmParticles; // flag to turn on/off the use of charm particles
- Double_t fMinWidth; // minimum decay width for the particles to be used from the PDG database
- Double_t fMaxWidth; // maximum ----
- Double_t fMinMass; // minimum mass for the particles to be used from the PDG database
- Double_t fMaxMass; // maximum ----
-
- void SetAllParameters();
-
public:
TUHKMgen();
virtual ~TUHKMgen();
Double_t GetMinimumMass() {return fMinMass;}
Double_t GetMaximumMass() {return fMaxMass;}
- void Print();
+ void Print(const Option_t* opt="") const;
+
+ protected:
+ InitialStateHydjet *fInitialState;
+ ParticleAllocator fAllocator;
+ List_t fSourceList;
+ List_t fSecondariesList;
+ Int_t fNPprim;
+ Int_t fNPsec;
+ InitialParamsHydjet_t fHydjetParams; // list of parameters for the initial state
+ // details for the PDG database
+ Char_t fParticleFilename[256]; // particle list filename
+ Char_t fDecayFilename[256]; // decay table filename
+ Int_t fStableFlagPDG[500]; // array of PDG codes flagged to be stable
+ Bool_t fStableFlagStatus[500]; // array of decay flag status
+ Int_t fStableFlagged; // number of toggled decay flags
+ Bool_t fUseCharmParticles; // flag to turn on/off the use of charm particles
+ Double_t fMinWidth; // minimum decay width for the particles to be used from the PDG database
+ Double_t fMaxWidth; // maximum ----
+ Double_t fMinMass; // minimum mass for the particles to be used from the PDG database
+ Double_t fMaxMass; // maximum ----
+
+ void SetAllParameters();
+
+ private:
+ TUHKMgen(const TUHKMgen&);
+ TUHKMgen& operator=(const TUHKMgen&);
ClassDef(TUHKMgen, 3) //Interface to FASTMC Event Generator
};
using std::ifstream;
using std::ios;
-DatabasePDG::DatabasePDG() {
- fNParticles = 0;
+DatabasePDG::DatabasePDG():
+ fNParticles(0),
+ fUseCharmParticles(kTRUE),
+ fMinimumWidth(0.),
+ fMaximumWidth(10.),
+ fMinimumMass(0.),
+ fMaximumMass(10.)
+{
+
strcpy(fParticleFilename, "particles.data");
strcpy(fDecayFilename, "tabledecay.txt");
for(Int_t i=0; i<kMaxParticles; i++) {
fParticles[i] = new ParticlePDG();
fStatus[i] = kFALSE;
}
- fUseCharmParticles = kTRUE;
- fMinimumWidth = 0.;
- fMaximumWidth = 10.;
- fMinimumMass = 0.;
- fMaximumMass = 10.;
}
DatabasePDG::~DatabasePDG() {
const Int_t kMaxParticles = 500;
class DatabasePDG {
- private:
- Int_t fNParticles; // no. of particles in database
- ParticlePDG *fParticles[kMaxParticles]; // array of particle pointers
- Bool_t fStatus[kMaxParticles]; // status of each particle
- Char_t fParticleFilename[256]; // particle list filename
- Char_t fDecayFilename[256]; // decay channels filename
- Bool_t fUseCharmParticles; // flag for using (or not) charm particles
- Double_t fMinimumWidth; // minimum allowed width for resonances
- Double_t fMaximumWidth; // maximum allowed width for resonances
- Double_t fMinimumMass; // minimum allowed mass for resonances
- Double_t fMaximumMass; // maximum allowed mass for resonances
-
- Bool_t LoadParticles();
- Bool_t LoadDecays();
- void SortParticles(); // put the good status particles at the beggining of the list
public:
DatabasePDG();
~DatabasePDG();
Int_t GetNAllowedChannels(ParticlePDG *particle, Double_t motherMass);
void SetStable(Int_t pdg, Bool_t value) {GetPDGParticle(pdg)->SetStable(value);}
Bool_t GetStableStatus(Int_t pdg) {return GetPDGParticle(pdg)->GetStableStatus();}
+
+ private:
+ DatabasePDG(const DatabasePDG&);
+ DatabasePDG& operator=(const DatabasePDG&);
+
+ Int_t fNParticles; // no. of particles in database
+ ParticlePDG *fParticles[kMaxParticles]; // array of particle pointers
+ Bool_t fStatus[kMaxParticles]; // status of each particle
+ Char_t fParticleFilename[256]; // particle list filename
+ Char_t fDecayFilename[256]; // decay channels filename
+ Bool_t fUseCharmParticles; // flag for using (or not) charm particles
+ Double_t fMinimumWidth; // minimum allowed width for resonances
+ Double_t fMaximumWidth; // maximum allowed width for resonances
+ Double_t fMinimumMass; // minimum allowed mass for resonances
+ Double_t fMaximumMass; // maximum allowed mass for resonances
+
+ Bool_t LoadParticles();
+ Bool_t LoadDecays();
+ void SortParticles(); // put the good status particles at the beggining of the list
};
#endif
using std::cout;
using std::endl;
-DecayChannel::DecayChannel() {
- fMotherPDG = kNonsensePDG;
- fBranchingRatio = 0.0;
- fNDaughters = 0;
+DecayChannel::DecayChannel() :
+ fMotherPDG(kNonsensePDG),
+ fBranchingRatio(0.0),
+ fNDaughters(0)
+{
for(Int_t i=0; i<kMaxDaughters; i++)
fDaughtersPDG[i] = kNonsensePDG;
}
-DecayChannel::DecayChannel(const DecayChannel ©) {
- fMotherPDG = copy.fMotherPDG;
- fBranchingRatio = copy.fBranchingRatio;
- fNDaughters = copy.fNDaughters;
+DecayChannel::DecayChannel(const DecayChannel ©):
+ fMotherPDG(copy.fMotherPDG),
+ fBranchingRatio(copy.fBranchingRatio),
+ fNDaughters(copy.fNDaughters)
+{
for(Int_t i=0; i<fNDaughters; i++)
fDaughtersPDG[i] = copy.fDaughtersPDG[i];
}
-DecayChannel::DecayChannel(Int_t mother, Double_t branching, Int_t nDaughters, Int_t *daughters) {
- fMotherPDG = mother;
- fBranchingRatio = branching;
- fNDaughters = 0;
+DecayChannel::DecayChannel(Int_t mother, Double_t branching, Int_t nDaughters, Int_t *daughters):
+ fMotherPDG(mother),
+ fBranchingRatio(branching),
+ fNDaughters(0)
+{
for(Int_t i=0; i<nDaughters; i++) {
if(i >= kMaxDaughters) {
cout << "ERROR in DecayChannel explicit constructor: " << endl;
const Int_t kNonsensePDG = 1000000000;
class DecayChannel {
- private:
- Int_t fMotherPDG;
- Double_t fBranchingRatio;
- Int_t fNDaughters;
- Int_t fDaughtersPDG[kMaxDaughters];
-
public:
DecayChannel(); // default constructor
DecayChannel(const DecayChannel ©); // copy constructor
Int_t GetNDaughters() {return fNDaughters;}
Int_t* GetDaughters() {return fDaughtersPDG;}
Int_t GetDaughterPDG(Int_t i); // i --> must be the zero-based index of daughter
+
+ private:
+ Int_t fMotherPDG;
+ Double_t fBranchingRatio;
+ Int_t fNDaughters;
+ Int_t fDaughtersPDG[kMaxDaughters];
};
#endif
#include "UKUtility.h"
#endif
-GrandCanonical::GrandCanonical() {
- fInitialized = kFALSE;
- fNMax = -1111;
- fTemperature = -1111;
- fBaryonPotential = -1111;
- fStrangePotential = -1111;
- fElectroPotential = -1111;
+GrandCanonical::GrandCanonical():
+ fTemperature(-1111),
+ fBaryonPotential(-1111),
+ fStrangePotential(-1111),
+ fElectroPotential(-1111),
+ fNMax(-1111),
+ fInitialized(kFALSE)
+{
}
-GrandCanonical::GrandCanonical(Int_t nmax, Double_t temperature, Double_t baryonPotential, Double_t strangePotential, Double_t electroPotential) {
- fNMax = nmax;
- fTemperature = temperature;
- fBaryonPotential = baryonPotential;
- fStrangePotential = strangePotential;
- fElectroPotential = electroPotential;
- fInitialized = kTRUE;
+GrandCanonical::GrandCanonical(Int_t nmax, Double_t temperature, Double_t baryonPotential, Double_t strangePotential, Double_t electroPotential):
+ fTemperature(temperature),
+ fBaryonPotential(baryonPotential),
+ fStrangePotential(strangePotential),
+ fElectroPotential(electroPotential),
+ fNMax(nmax),
+ fInitialized(kTRUE)
+{
}
GrandCanonical::~GrandCanonical() {}
#endif
class GrandCanonical {
-
- private:
-
- Double_t fTemperature;
- Double_t fBaryonPotential;
- Double_t fStrangePotential;
- Double_t fElectroPotential;
-
- // Number of terms for summation, if fNMax = 1 then
- // Maxwell-Boltzmann distribution will be recovered
- Int_t fNMax;
- Bool_t fInitialized;
-
public:
GrandCanonical();
GrandCanonical(Int_t nmax, Double_t temperature, Double_t baryonPotential, Double_t strangePotential, Double_t electroPotential);
Double_t ParticleNumberDensity(ParticlePDG* particle);
// compute the particle energy density
Double_t ParticleEnergyDensity(ParticlePDG* particle);
+
+ private:
+
+ Double_t fTemperature;
+ Double_t fBaryonPotential;
+ Double_t fStrangePotential;
+ Double_t fElectroPotential;
+
+ // Number of terms for summation, if fNMax = 1 then
+ // Maxwell-Boltzmann distribution will be recovered
+ Int_t fNMax;
+ Bool_t fInitialized;
};
#endif
#endif
class InitialState {
- protected:
- DatabasePDG *fDatabase;
public:
InitialState() : fDatabase(new DatabasePDG()) {};
virtual ~InitialState() {
virtual Double_t GetWeakDecayLimit() = 0;
virtual void Evolve(List_t &source, List_t &secondaries, ParticleAllocator &allocator, Double_t weakDecayLimit);
+ protected:
+ DatabasePDG *fDatabase;
+ private:
+ InitialState(const InitialState&);
+ InitialState& operator=(const InitialState&);
};
#endif
//get number of particles in jets
Int_t numbJetPart = HYPART.njp;
- Double_t Bgen = HYFPAR.bgen;
- Int_t Njet = HYJPAR.njet;
- Int_t Nbcol = HYFPAR.nbcol;
+// Double_t Bgen = HYFPAR.bgen;
+// Int_t Njet = HYJPAR.njet;
+// Int_t Nbcol = HYFPAR.nbcol;
// std::cout<<"in InitialStateHydjet::Initialize bgen "<<Bgen<<" njet "<<Njet<<" "<<" Nbcol "<<Nbcol<<std::endl;
// std::cout<<"in InitialStateHydjet::Initialize numb jet part"<<numbJetPart<<std::endl;
TLorentzVector partPos, partMom, n1, p0;
TVector3 vec3;
- const TLorentzVector zeroVec;
//set maximal hadron energy
const Double_t eMax = 5.;
//-------------------------------------
};
class InitialStateHydjet : public InitialState {
- private:
- Double_t fVolEff; // the effective volume
-
- public:
- InitialParamsHydjet_t fParams; // the list of initial state parameters
-
public:
- InitialStateHydjet() {};
+ InitialStateHydjet() : fParams(), fVolEff(0){};
~InitialStateHydjet() {};
void SetVolEff(Double_t value) {fVolEff = value;}
Double_t SimpsonIntegrator(Double_t, Double_t, Double_t);
Double_t SimpsonIntegrator2(Double_t, Double_t);
Double_t MidpointIntegrator2(Double_t, Double_t);
+ public:
+ InitialParamsHydjet_t fParams; // the list of initial state parameters
+
+ private:
+ Double_t fVolEff; // the effective volume
+
};
#endif
#include "Particle.h"
#endif
-Particle::Particle(ParticlePDG *prop)
- : fParticleProperties(prop),
- fLastInteractionTime(0.),
- fInteractionNumber(0),
- fLastMotherPdg(0),
- fType(0),
- fIndex(-1),
- fMotherIndex(-1),
- fNDaughters(0)
+Particle::Particle(ParticlePDG *prop):
+ fPosition(),
+ fMomentum(),
+ fLastMotherDecayCoor(),
+ fLastMotherDecayMom(),
+ fParticleProperties(prop),
+ fLastInteractionTime(0.),
+ fInteractionNumber(0),
+ fLastMotherPdg(0),
+ fType(0),
+ fIndex(-1),
+ fMotherIndex(-1),
+ fNDaughters(0)
{
for(Int_t i=0; i<3; i++) fDaughterIndex[i] = -1;
}
Particle::Particle(ParticlePDG *prop, const TLorentzVector &pos,
- const TLorentzVector &mom, Double_t lit, Int_t lin, Int_t type)
- : fPosition(pos), fMomentum(mom), fIndex(-1), fMotherIndex(-1), fNDaughters(0)
+ const TLorentzVector &mom, Double_t lit, Int_t lin, Int_t type):
+ fPosition(pos),
+ fMomentum(mom),
+ fLastMotherDecayCoor(),
+ fLastMotherDecayMom(),
+ fParticleProperties(prop),
+ fLastInteractionTime(lit),
+ fInteractionNumber(lin),
+ fLastMotherPdg(0),
+ fType(type),
+ fIndex(-1),
+ fMotherIndex(-1),
+ fNDaughters(0)
{
- fLastInteractionTime = lit;
- fInteractionNumber = lin;
- fParticleProperties = prop;
- fType = type;
for(Int_t i=0; i<3; i++) fDaughterIndex[i] = -1;
}
Particle::Particle(ParticlePDG *prop, const TLorentzVector &pos, const TLorentzVector &mom,
Double_t t, Int_t n, Int_t ty, Int_t motherPdg, const TLorentzVector &mPos,
- const TLorentzVector &mMom)
- : fPosition(pos), fMomentum(mom),
- fLastMotherDecayCoor(mPos),
- fLastMotherDecayMom(mMom),
- fIndex(-1), fMotherIndex(-1), fNDaughters(0)
+ const TLorentzVector &mMom):
+ fPosition(pos),
+ fMomentum(mom),
+ fLastMotherDecayCoor(mPos),
+ fLastMotherDecayMom(mMom),
+ fParticleProperties(prop),
+ fLastInteractionTime(t),
+ fInteractionNumber(n),
+ fLastMotherPdg(motherPdg),
+ fType(ty),
+ fIndex(-1),
+ fMotherIndex(-1),
+ fNDaughters(0)
{
- fParticleProperties = prop;
- fLastInteractionTime = t;
- fInteractionNumber = n;
- fType = ty;
- fLastMotherPdg = motherPdg;
for(Int_t i=0; i<3; i++) fDaughterIndex[i] = -1;
}
//class ParticlePDG;
class Particle {
- protected:
- TLorentzVector fPosition;
- TLorentzVector fMomentum;
- TLorentzVector fLastMotherDecayCoor;
- TLorentzVector fLastMotherDecayMom;
- ParticlePDG *fParticleProperties;
- Double_t fLastInteractionTime;
- Int_t fInteractionNumber;
- Int_t fLastMotherPdg;
- Int_t fType; //0-hydro, 1-jets
- Int_t fIndex; // index (0 based) of particle in the final particle list which will contain both primaries and secondaries
- Int_t fMotherIndex; // index of the mother (-1 if its a primary particle)
- Int_t fNDaughters; // number of daughter particles (0 if the particle had not decayed)
- Int_t fDaughterIndex[3]; // array of indexes for the daughter particles (the indexes are -1 for non-existing daughters)
- static Int_t fLastIndex; // the last index assigned
-
public:
Particle(const TLorentzVector &, const TLorentzVector &);
Particle(ParticlePDG *pdg = 0);
void SetType(Int_t value){fType = value;}
Int_t GetType()const{return fType;}
+ protected:
+ TLorentzVector fPosition;
+ TLorentzVector fMomentum;
+ TLorentzVector fLastMotherDecayCoor;
+ TLorentzVector fLastMotherDecayMom;
+ ParticlePDG *fParticleProperties;
+ Double_t fLastInteractionTime;
+ Int_t fInteractionNumber;
+ Int_t fLastMotherPdg;
+ Int_t fType; //0-hydro, 1-jets
+ Int_t fIndex; // index (0 based) of particle in the final particle list which will contain both primaries and secondaries
+ Int_t fMotherIndex; // index of the mother (-1 if its a primary particle)
+ Int_t fNDaughters; // number of daughter particles (0 if the particle had not decayed)
+ Int_t fDaughterIndex[3]; // array of indexes for the daughter particles (the indexes are -1 for non-existing daughters)
+ static Int_t fLastIndex; // the last index assigned
};
const Int_t kMaxDecayChannels = 20;
class ParticlePDG {
- private:
- Char_t fName[9];
- Int_t fPDG;
- Double_t fMass;
- Double_t fWidth;
- Double_t fSpin; // J
- Double_t fIsospin; // I
- Double_t fIsospinZ; // I3
- Double_t fLightQuarkNumber; // u, d quark number
- Double_t fAntiLightQuarkNumber; // u-, d- quark number
- Double_t fStrangeQuarkNumber; // s quark number
- Double_t fAntiStrangeQuarkNumber; // s- quark number
- Double_t fCharmQuarkNumber; // c quark number
- Double_t fAntiCharmQuarkNumber; // c- quark number
- Int_t fNDecayChannels;
- Bool_t fStable; // flag to turn on/off decay
- DecayChannel* fDecayChannels[kMaxDecayChannels];
-
public:
ParticlePDG();
ParticlePDG(Char_t* name, Int_t pdg, Double_t mass, Double_t width);
else
return 0x0;
}
+
+ private:
+ ParticlePDG(const ParticlePDG&);
+ ParticlePDG& operator=(const ParticlePDG&);
+
+ Char_t fName[9];
+ Int_t fPDG;
+ Double_t fMass;
+ Double_t fWidth;
+ Double_t fSpin; // J
+ Double_t fIsospin; // I
+ Double_t fIsospinZ; // I3
+ Double_t fLightQuarkNumber; // u, d quark number
+ Double_t fAntiLightQuarkNumber; // u-, d- quark number
+ Double_t fStrangeQuarkNumber; // s quark number
+ Double_t fAntiStrangeQuarkNumber; // s- quark number
+ Double_t fCharmQuarkNumber; // c quark number
+ Double_t fAntiCharmQuarkNumber; // c- quark number
+ Int_t fNDecayChannels;
+ Bool_t fStable; // flag to turn on/off decay
+ DecayChannel* fDecayChannels[kMaxDecayChannels];
};
#endif
//This class is taken from the GEANT4 tool kit and changed!!!!!
-RandArrayFunction::RandArrayFunction(const Double_t *aProbFunc, Int_t theProbSize, Int_t intType)
- : fNBins(theProbSize),
- fInterpolationType(intType)
+RandArrayFunction::RandArrayFunction(const Double_t *aProbFunc, Int_t theProbSize, Int_t intType):
+ fIntegralPdf(),
+ fNBins(theProbSize),
+ fOneOverNbins(0),
+ fInterpolationType(intType)
{
PrepareTable(aProbFunc);
}
-RandArrayFunction::RandArrayFunction(Int_t theProbSize, Int_t intType)
- : fNBins(theProbSize),
- fInterpolationType(intType)
+RandArrayFunction::RandArrayFunction(Int_t theProbSize, Int_t intType):
+ fIntegralPdf(),
+ fNBins(theProbSize),
+ fOneOverNbins(0),
+ fInterpolationType(intType)
{}
void RandArrayFunction::PrepareTable(const Double_t* aProbFunc) {
//========================================================================================
class RandArrayFunction {
- private:
- std::vector<Double_t> fIntegralPdf;
- Int_t fNBins;
- Double_t fOneOverNbins;
- Int_t fInterpolationType;
-
public:
RandArrayFunction(const Double_t *aProbFunc, Int_t theProbSize, Int_t interpolationType = 0);
RandArrayFunction(Int_t probSize, Int_t interpolationType = 0);
void UseFlatDistribution();
Double_t MapRandom(Double_t rand)const;
Double_t StandardRand()const;
+
+ std::vector<Double_t> fIntegralPdf;
+ Int_t fNBins;
+ Double_t fOneOverNbins;
+ Int_t fInterpolationType;
+
};
inline Double_t RandArrayFunction::StandardRand() const {
#include "StrangeDensity.h"
#endif
-NAStrangeDensity::NAStrangeDensity() {
- fTemperature = 0.*GeV;
- fBaryonPotential = 0.*GeV;
- fStrangePotential = 0.*GeV;
- fNMax = 5;
+NAStrangeDensity::NAStrangeDensity():
+ fTemperature(0.*GeV),
+ fBaryonPotential(0.*GeV),
+ fStrangePotential(0.*GeV),
+ fNMax(5)
+{
}
// compute hadron system strangeness density
Double_t NAStrangeDensity::StrangenessDensity(DatabasePDG* database) {
#endif
class NAStrangeDensity {
-
- private:
- //input
- Double_t fTemperature;
- Double_t fBaryonPotential;
- Double_t fStrangePotential;
- Int_t fNMax; //number of terms for summation, if nMax = 1 then
- //Maxwell-Boltzmann distribution will be recovered
-
- Double_t ParticleNumberDensity(ParticlePDG* particle);
-
public:
NAStrangeDensity();
~NAStrangeDensity(){};
}
// compute hadron system strangeness density
Double_t StrangenessDensity(DatabasePDG* database);
+
+ private:
+ //input
+ Double_t fTemperature;
+ Double_t fBaryonPotential;
+ Double_t fStrangePotential;
+ Int_t fNMax; //number of terms for summation, if nMax = 1 then
+ //Maxwell-Boltzmann distribution will be recovered
+
+ Double_t ParticleNumberDensity(ParticlePDG* particle);
};
#endif
#endif
class NAStrangePotential {
- private:
- Double_t fTemperature;
- Double_t fBaryonPotential;
- Double_t fStrangeDensity;
- Double_t fMinStrangePotential;//initial min value of strange potential
- Double_t fMaxStrangePotential;//initial max value of strange potential
- Int_t fNIteration; //to find proper [minStrangePotential, maxStrangePotential] interval
- Int_t fNSolverIteration; //to find root in [minStrangePotential,maxStrangePotential] interval
- Double_t fTolerance;//to find root
- DatabasePDG* fDatabase;
- NAStrangeDensity fGc;
- //compute hadron system strange density through strange potential
- Double_t CalculateStrangeDensity(const Double_t strangePotential);
- //default constructor is not accesible
- NAStrangePotential(){};
-
public:
- NAStrangePotential(const Double_t initialStrangeDensity, DatabasePDG* database) :
+ NAStrangePotential(const Double_t initialStrangeDensity=0, DatabasePDG* database=0x0) :
+ fTemperature(0),
+ fBaryonPotential(0),
fStrangeDensity(initialStrangeDensity),
fMinStrangePotential(0.0001*GeV),
fMaxStrangePotential(0.9*GeV),
fNIteration(100),
fNSolverIteration(100),
fTolerance(1.e-8),
- fDatabase(database)
+ fDatabase(database),
+ fGc()
{};
~NAStrangePotential() {};
void SetMinStrangePotential(Double_t value) {fMinStrangePotential = value;}
void SetMaxStrangePotential(Double_t value) {fMaxStrangePotential = value;}
Double_t CalculateStrangePotential();
+
+ private:
+ NAStrangePotential(const NAStrangePotential&);
+ NAStrangePotential& operator=(const NAStrangePotential&);
+
+ Double_t fTemperature;
+ Double_t fBaryonPotential;
+ Double_t fStrangeDensity;
+ Double_t fMinStrangePotential;//initial min value of strange potential
+ Double_t fMaxStrangePotential;//initial max value of strange potential
+ Int_t fNIteration; //to find proper [minStrangePotential, maxStrangePotential] interval
+ Int_t fNSolverIteration; //to find root in [minStrangePotential,maxStrangePotential] interval
+ Double_t fTolerance;//to find root
+ DatabasePDG* fDatabase;
+ NAStrangeDensity fGc;
+ //compute hadron system strange density through strange potential
+ Double_t CalculateStrangeDensity(const Double_t strangePotential);
+ //default constructor is not accesible
+ NAStrangePotential();
+
};
#endif
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff