Fixing some warnings
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 17 Mar 2009 11:30:36 +0000 (11:30 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 17 Mar 2009 11:30:36 +0000 (11:30 +0000)
21 files changed:
TUHKMgen/AliGenUHKM.cxx
TUHKMgen/AliGenUHKM.h
TUHKMgen/TUHKMgen.cxx
TUHKMgen/TUHKMgen.h
TUHKMgen/UHKM/DatabasePDG.cxx
TUHKMgen/UHKM/DatabasePDG.h
TUHKMgen/UHKM/DecayChannel.cxx
TUHKMgen/UHKM/DecayChannel.h
TUHKMgen/UHKM/GrandCanonical.cxx
TUHKMgen/UHKM/GrandCanonical.h
TUHKMgen/UHKM/InitialState.h
TUHKMgen/UHKM/InitialStateHydjet.cxx
TUHKMgen/UHKM/InitialStateHydjet.h
TUHKMgen/UHKM/Particle.cxx
TUHKMgen/UHKM/Particle.h
TUHKMgen/UHKM/ParticlePDG.h
TUHKMgen/UHKM/RandArrayFunction.cxx
TUHKMgen/UHKM/RandArrayFunction.h
TUHKMgen/UHKM/StrangeDensity.cxx
TUHKMgen/UHKM/StrangeDensity.h
TUHKMgen/UHKM/StrangePotential.h

index 906e56a..e7cdb27 100755 (executable)
@@ -48,6 +48,8 @@ AliGenUHKM::AliGenUHKM()
   :AliGenMC(),
    fTrials(0),
    fUHKMgen(0),
+   fHydjetParams(),
+   fStableFlagged(0),
    fUseCharmParticles(kFALSE),
    fMinWidth(0.0),
    fMaxWidth(10.0),
@@ -135,6 +137,8 @@ AliGenUHKM::AliGenUHKM(Int_t npart)
   :AliGenMC(npart),
    fTrials(0),
    fUHKMgen(0),
+   fHydjetParams(),
+   fStableFlagged(0),
    fUseCharmParticles(kFALSE),
    fMinWidth(0.0),
    fMaxWidth(10.0),
index 0c676e5..b15af3b 100755 (executable)
@@ -17,30 +17,6 @@ class TParticle;
 
 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);
@@ -155,6 +131,31 @@ class AliGenUHKM : public AliGenMC
   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
index 967f0a9..53650ff 100755 (executable)
@@ -35,6 +35,13 @@ ClassImp(TUHKMgen)
 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),
@@ -204,7 +211,7 @@ void TUHKMgen::SetAllParametersLHC()
   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();
@@ -221,9 +228,8 @@ TObjArray* TUHKMgen::ImportParticles(Option_t *option)
     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
 
@@ -273,13 +279,12 @@ Int_t TUHKMgen::ImportParticles(TClonesArray *particles,Option_t* option)
     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
     
@@ -327,7 +332,7 @@ void TUHKMgen::Initialize()
   cout << "TUHKMgen::Initialize() OUT" << endl;
 }
 
-void TUHKMgen::Print() 
+void TUHKMgen::Print(const Option_t*) const
 {
   cout << "TUHKMgen::Print() method not implemented yet!!" << endl;
 }
index 503daf0..cb25fe8 100755 (executable)
 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();
@@ -180,7 +158,33 @@ class TUHKMgen : public TGenerator {
   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
 };
index 4a559fe..997dbf8 100644 (file)
@@ -25,19 +25,21 @@ using std::strcpy;
 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() {
index 9486751..f0bdda0 100644 (file)
 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();
@@ -87,6 +72,25 @@ class 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
index da9fb13..ca5a392 100644 (file)
 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 &copy) {
-  fMotherPDG = copy.fMotherPDG;
-  fBranchingRatio = copy.fBranchingRatio;
-  fNDaughters = copy.fNDaughters;
+DecayChannel::DecayChannel(const DecayChannel &copy):
+  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;
index c4f966b..4acd372 100644 (file)
@@ -19,12 +19,6 @@ const Int_t kMaxDaughters = 3;
 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);                                                   // copy constructor
@@ -40,6 +34,12 @@ class DecayChannel {
   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
index b3937cf..98ab726 100644 (file)
 #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() {}
index e0dff25..4784e64 100644 (file)
 #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);
@@ -60,6 +47,18 @@ class GrandCanonical {
   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
index 0670a14..4110fc6 100644 (file)
@@ -17,8 +17,6 @@
 #endif
 
 class InitialState {
- protected:
-   DatabasePDG *fDatabase;
  public:
   InitialState() : fDatabase(new DatabasePDG()) {};
   virtual ~InitialState() {
@@ -54,6 +52,11 @@ class 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
index 7b6f5a7..d63e2e2 100644 (file)
@@ -102,9 +102,9 @@ void InitialStateHydjet::Initialize(List_t &source, ParticleAllocator & allocato
     
     //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;
@@ -144,7 +144,6 @@ void InitialStateHydjet::Initialize(List_t &source, ParticleAllocator & allocato
     
     TLorentzVector partPos, partMom, n1, p0;
     TVector3 vec3;
-    const TLorentzVector zeroVec;
     //set maximal hadron energy
     const Double_t eMax = 5.;  
     //-------------------------------------
index 03d93a0..5fc6d09 100644 (file)
@@ -105,14 +105,8 @@ struct InitialParamsHydjet_t {
 };
 
 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;}
@@ -132,6 +126,12 @@ class InitialStateHydjet : public InitialState {
   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
index 6ab7121..124e7f0 100644 (file)
 #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;
 }
 
index abd0f7c..516017e 100644 (file)
 //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);
@@ -134,6 +118,21 @@ class Particle {
   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
 
 };
 
index 534ce07..e4cdd7a 100644 (file)
 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);
@@ -95,6 +77,27 @@ class ParticlePDG {
     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
index 8f66b0f..8e325b9 100644 (file)
 //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) {
index 2f6f736..61cfe27 100644 (file)
 //========================================================================================
 
 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);
@@ -91,6 +85,12 @@ class RandArrayFunction {
   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 {
index 891fb36..620997a 100644 (file)
@@ -2,11 +2,12 @@
 #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) {
index b178595..1661478 100644 (file)
 #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(){};
@@ -55,6 +44,16 @@ class 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
index 51f3d61..1e6c023 100644 (file)
 #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() {};
@@ -61,6 +48,26 @@ class 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