Coding conventions (Ionut)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 12 May 2010 15:13:21 +0000 (15:13 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 12 May 2010 15:13:21 +0000 (15:13 +0000)
38 files changed:
TUHKMgen/AliGenUHKM.cxx
TUHKMgen/AliGenUHKM.h
TUHKMgen/TUHKMgen.h
TUHKMgen/UHKM/DatabasePDG.h
TUHKMgen/UHKM/DecayChannel.cxx
TUHKMgen/UHKM/DecayChannel.h
TUHKMgen/UHKM/EquationSolver.cxx
TUHKMgen/UHKM/EquationSolver.h
TUHKMgen/UHKM/EquationSolver.icc
TUHKMgen/UHKM/GrandCanonical.cxx
TUHKMgen/UHKM/GrandCanonical.h
TUHKMgen/UHKM/HYJET_COMMONS.h
TUHKMgen/UHKM/HadronDecayer.cxx
TUHKMgen/UHKM/HadronDecayer.h
TUHKMgen/UHKM/HankelFunction.cxx
TUHKMgen/UHKM/HankelFunction.h
TUHKMgen/UHKM/InitialState.cxx
TUHKMgen/UHKM/InitialState.h
TUHKMgen/UHKM/InitialStateHydjet.cxx
TUHKMgen/UHKM/InitialStateHydjet.h
TUHKMgen/UHKM/MathUtil.h [deleted file]
TUHKMgen/UHKM/Particle.cxx
TUHKMgen/UHKM/Particle.h
TUHKMgen/UHKM/ParticlePDG.cxx
TUHKMgen/UHKM/ParticlePDG.h
TUHKMgen/UHKM/ParticleTable.cxx [deleted file]
TUHKMgen/UHKM/ParticleTable.h [deleted file]
TUHKMgen/UHKM/RandArrayFunction.cxx
TUHKMgen/UHKM/RandArrayFunction.h
TUHKMgen/UHKM/RunHadronSource.cxx [deleted file]
TUHKMgen/UHKM/RunHadronSourceHISTO.cxx [deleted file]
TUHKMgen/UHKM/StrangeDensity.cxx
TUHKMgen/UHKM/StrangeDensity.h
TUHKMgen/UHKM/StrangePotential.cxx
TUHKMgen/UHKM/StrangePotential.h
TUHKMgen/UHKM/StrangePotential1.h [deleted file]
TUHKMgen/UHKM/UKUtility.cxx
TUHKMgen/UHKM/UKUtility.h

index 69ba897..e5c829a 100755 (executable)
@@ -14,6 +14,9 @@
 //                                                                         //
 ////////////////////////////////////////////////////////////////////////////
 
+#include <iostream>
+#include <string>
+
 #include "TUHKMgen.h"
 #ifndef DATABASE_PDG
 #include "DatabasePDG.h"
@@ -26,8 +29,8 @@
 #include <TParticle.h>
 #include <TClonesArray.h>
 #include <TMCProcess.h>
-#include "TDatabasePDG.h"
-#include "TSystem.h"
+#include <TDatabasePDG.h>
+#include <TSystem.h>
 
 #include "AliGenUHKM.h"
 #include "AliRun.h"
@@ -37,8 +40,6 @@
 #include "AliGenHijingEventHeader.h"
 #include "AliLog.h"
 
-#include <iostream>
-#include <string>
 using namespace std;
 
 
index 546a8ce..de55ff9 100755 (executable)
@@ -6,40 +6,23 @@
 #ifndef ALIGENUHKM_H
 #define ALIGENUHKM_H
 
+#include <string>
+
+//#include <TString.h>
+//#include <TParticle.h>
+
 #include "AliGenMC.h"
-#include <TString.h>
 #include "TUHKMgen.h"
 #ifndef INITIALSTATEHYDJET_H
 #include "InitialStateHydjet.h"
 #endif
-#include "TParticle.h"
 
-#include <string>
 using namespace std;
 
 
 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
-
-  void SetAllParameters();
-  void CheckPDGTable();
-  
- private:
-  void Copy(TObject &rhs) const;
-  AliGenUHKM(const AliGenUHKM&);
-  AliGenUHKM & operator = (const AliGenUHKM &);
-  
+   
  public:
   AliGenUHKM();
   AliGenUHKM(Int_t npart);
@@ -142,6 +125,26 @@ class AliGenUHKM : public AliGenMC
   const Char_t*  GetPDGParticleFile() const {return fParticleFilename;}
   const Char_t*  GetPDGDecayFile() const {return fDecayFilename;}
 
+ 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
+
+  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 3f1c582..25efeb9 100755 (executable)
@@ -24,31 +24,7 @@ using namespace std;
 //class DatabasePDG;
 
 class TUHKMgen : public TGenerator {
- protected:
-  InitialStateHydjet *fInitialState;     // HYDJET++ main class which handles the entire Monte-Carlo simulation
-  ParticleAllocator fAllocator;       // object which allocates/deallocates memory for the lists of particles
-  List_t fSecondariesList; // list holding the initial particles and the final state particles generated in resonance decays
-  Int_t  fNPprim;          // number of primary particles
-  Int_t  fNPsec;           // secondary particles
-  InitialParamsHydjet_t fHydjetParams;  // struct holding the 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&);
-
  public:   
   TUHKMgen();
   virtual      ~TUHKMgen();
@@ -186,6 +162,31 @@ class TUHKMgen : public TGenerator {
   
   void Print(const Option_t* opt="") const;
 
+ protected:
+  InitialStateHydjet *fInitialState;     // HYDJET++ main class which handles the entire Monte-Carlo simulation
+  ParticleAllocator fAllocator;       // object which allocates/deallocates memory for the lists of particles
+  List_t fSecondariesList; // list holding the initial particles and the final state particles generated in resonance decays
+  Int_t  fNPprim;          // number of primary particles
+  Int_t  fNPsec;           // secondary particles
+  InitialParamsHydjet_t fHydjetParams;  // struct holding the 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
 };
 #endif
index 89efc3d..c7c9104 100644 (file)
@@ -17,7 +17,7 @@
 #ifndef DATABASEPDG_H
 #define DATABASEPDG_H
 
-#include "Rtypes.h"
+#include <Rtypes.h>
 #ifndef PARTICLE_PDG
 #include "ParticlePDG.h"
 #endif
@@ -56,8 +56,8 @@ class DatabasePDG {
   // calling all the width, mass and charmness criteria functions.
   void UseThisListOfParticles(Char_t *filename, Bool_t exclusive = kTRUE);
   
-  Char_t* GetParticleFilename() {return fParticleFilename;}
-  Char_t* GetDecayFilename() {return fDecayFilename;}
+  const Char_t* GetParticleFilename() const {return fParticleFilename;}
+  const Char_t* GetDecayFilename() const {return fDecayFilename;}
   Int_t GetNParticles(Bool_t all = kFALSE) const;      // true - no. of all particles; false - no. of good status particles
   ParticlePDG* GetPDGParticleByIndex(Int_t index) const;
   Bool_t GetPDGParticleStatusByIndex(Int_t index) const;
index ca5a392..d04ce52 100644 (file)
@@ -1,46 +1,55 @@
-/*
-  Copyright   : The FASTMC and SPHMC Collaboration
-  Author      : Ionut Cristian Arsene 
-  Affiliation : Oslo University, Norway & Institute for Space Sciences, Bucharest, Romania
-  e-mail      : i.c.arsene@fys.uio.no
-  Date        : 2007/05/30
-
-  This class is using the particle and decay lists provided by the 
-  THERMINATOR (Computer Physics Communications 174 669 (2006)) and
-  SHARE (Computer Physics Communications 167 229 (2005)) collaborations.
-*/
-
-#ifndef DECAY_CHANNEL
-#include "DecayChannel.h"
-#endif
-
+////////////////////////////////////////////////////////////////////////////////////////////////
+//  Copyright   : The FASTMC and SPHMC Collaboration                                          //
+//  Author      : Ionut Cristian Arsene                                                       //
+//  Affiliation : Oslo University, Norway & Institute for Space Sciences, Bucharest, Romania  //
+//  e-mail      : i.c.arsene@fys.uio.no                                                       //
+//  Date        : 2007/05/30                                                                  //
+//                                                                                            //
+//  This class is using the particle and decays lists provided by the                         //
+//  THERMINATOR (Computer Physics Communications 174 669 (2006)) and                          //
+//  SHARE (Computer Physics Communications 167 229 (2005)) collaborations.                    //
+////////////////////////////////////////////////////////////////////////////////////////////////
 #include <iostream>
 using std::cout;
 using std::endl;
 
+#include "DecayChannel.h"
+
+//_______________________________________________________________________________
 DecayChannel::DecayChannel() :
   fMotherPDG(kNonsensePDG),
   fBranchingRatio(0.0),
   fNDaughters(0)
 {
+  //
+  //  default constructor
+  //
   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)
 {
+  //
+  // copy constructor
+  //
   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):
+//_______________________________________________________________________________
+DecayChannel::DecayChannel(Int_t mother, Double_t branching, Int_t nDaughters, const Int_t *daughters):
   fMotherPDG(mother),
   fBranchingRatio(branching),
   fNDaughters(0)
 {
+  //
+  // constructor
+  //
   for(Int_t i=0; i<nDaughters; i++) {
     if(i >= kMaxDaughters) {
       cout << "ERROR in DecayChannel explicit constructor: " << endl;
@@ -50,7 +59,11 @@ DecayChannel::DecayChannel(Int_t mother, Double_t branching, Int_t nDaughters, I
   }
 }
 
-void DecayChannel::SetDaughters(Int_t *daughters, Int_t n) {
+//_______________________________________________________________________________
+void DecayChannel::SetDaughters(const Int_t *daughters, Int_t n) {
+  //
+  // set the daughter PDGs
+  //
   for(Int_t i=0; i<n; i++) {
     if(i >= kMaxDaughters) {
       cout << "ERROR in DecayChannel::SetDaughters() :" << endl;
@@ -60,7 +73,11 @@ void DecayChannel::SetDaughters(Int_t *daughters, Int_t n) {
   }
 }
 
+//_______________________________________________________________________________
 void DecayChannel::AddDaughter(Int_t pdg) {
+  //
+  // add a daughter to this channel
+  //
   if(fNDaughters >= kMaxDaughters) {
     cout << "ERROR in DecayChannel::AddDaughter() :" << endl;
     cout << "Number of daughters is already >= than the maximum allowed one (" << kMaxDaughters << ") !!" << endl;
@@ -68,7 +85,12 @@ void DecayChannel::AddDaughter(Int_t pdg) {
   fDaughtersPDG[fNDaughters++] = pdg;
 }
 
+
+//_______________________________________________________________________________
 Int_t DecayChannel::GetDaughterPDG(Int_t i) {
+  //
+  // get the PDG of the i'th daughter
+  //
   if((i >= fNDaughters) || (i<0)) {
     cout << "ERROR in DecayChannel::GetDaughterPDG() :" << endl;
     cout << "Daughter index required is too big or less than zero!! There are only " << fNDaughters << " secondaries in this channel !!" << endl;
index 4acd372..16c5f67 100644 (file)
@@ -1,19 +1,19 @@
-/*
-  Copyright   : The FASTMC and SPHMC Collaboration
-  Author      : Ionut Cristian Arsene 
-  Affiliation : Oslo University, Norway & Institute for Space Sciences, Bucharest, Romania
-  e-mail      : i.c.arsene@fys.uio.no
-  Date        : 2007/05/30
+////////////////////////////////////////////////////////////////////////////////////////////////
+//  Copyright   : The FASTMC and SPHMC Collaboration                                          //
+//  Author      : Ionut Cristian Arsene                                                       //
+//  Affiliation : Oslo University, Norway & Institute for Space Sciences, Bucharest, Romania  //
+//  e-mail      : i.c.arsene@fys.uio.no                                                       //
+//  Date        : 2007/05/30                                                                  //
+//                                                                                            //
+//  This class is using the particle and decays lists provided by the                         //
+//  THERMINATOR (Computer Physics Communications 174 669 (2006)) and                          //
+//  SHARE (Computer Physics Communications 167 229 (2005)) collaborations.                    //
+////////////////////////////////////////////////////////////////////////////////////////////////
 
-  This class is using the particle and decays lists provided by the 
-  THERMINATOR (Computer Physics Communications 174 669 (2006)) and
-  SHARE (Computer Physics Communications 167 229 (2005)) collaborations.
-*/
+#ifndef DECAYCHANNEL_H
+#define DECAYCHANNEL_H
 
-#ifndef DECAY_CHANNEL
-#define DECAY_CHANNEL
-
-#include "Rtypes.h"
+#include <Rtypes.h>
 
 const Int_t kMaxDaughters = 3;
 const Int_t kNonsensePDG = 1000000000;
@@ -22,24 +22,24 @@ class DecayChannel {
  public:
   DecayChannel();                                                                           // default constructor
   DecayChannel(const DecayChannel &copy);                                                   // copy constructor
-  DecayChannel(Int_t mother, Double_t branching, Int_t nDaughters, Int_t *daughters);       // explicit constructor
+  DecayChannel(Int_t mother, Double_t branching, Int_t nDaughters, const Int_t *daughters); // explicit constructor
   ~DecayChannel() {};                                                                       // destructor
   
   void     SetMotherPDG(Int_t value)              {fMotherPDG = value;}
   void     SetBranching(Double_t value)           {fBranchingRatio = value;}
-  void     SetDaughters(Int_t *values, Int_t n);
+  void     SetDaughters(const Int_t *values, Int_t n);
   void     AddDaughter(Int_t pdg);
-  Int_t    GetMotherPDG()                         {return fMotherPDG;}
-  Double_t GetBranching()                         {return fBranchingRatio;}
-  Int_t    GetNDaughters()                        {return fNDaughters;}
-  Int_t*   GetDaughters()                         {return fDaughtersPDG;}
+  Int_t    GetMotherPDG() const                   {return fMotherPDG;}
+  Double_t GetBranching() const                   {return fBranchingRatio;}
+  Int_t    GetNDaughters() const                  {return fNDaughters;}
+  const Int_t*   GetDaughters() const                   {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];  
+  Int_t    fMotherPDG;                          // PDG code of the mother particle
+  Double_t fBranchingRatio;                     // branching ratio
+  Int_t    fNDaughters;                         // number of daughter particles
+  Int_t    fDaughtersPDG[kMaxDaughters];        // array with daughters PDG
 };
 
 #endif
index 67a17f2..ac290af 100644 (file)
@@ -1,18 +1,16 @@
-/*                                                                            
-                                                                            
-        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
-      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
-                           November. 2, 2006                                
+//////////////////////////////////////////////////////////////////////////////////       
+//                                                                              //
+//        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna     //
+//      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru  //
+//                           November. 2, 2005                                  //
+//                                                                              //
+//           This equation solver class is taken from GEANT4 and modified!!     //
+//////////////////////////////////////////////////////////////////////////////////
 
-*/
-//This equation solver class is taken from GEANT4 and modified!!
-
-#ifndef NAEquationSolver_h
 #include "EquationSolver.h"
-#endif
 
 template <class Function> 
-NAEquationSolver<Function>::NAEquationSolver(const NAEquationSolver & right) {
+EquationSolver<Function>::EquationSolver(const EquationSolver & right) {
   fMaxIter = right.GetMaxIterations();
   fTolerance = right.GetTolerance();
   fA = right.GetIntervalLowerLimit();
@@ -22,7 +20,7 @@ NAEquationSolver<Function>::NAEquationSolver(const NAEquationSolver & right) {
 
 // operators
 template <class Function> 
-NAEquationSolver<Function> & NAEquationSolver<Function>::operator=(const NAEquationSolver & right) {
+EquationSolver<Function> & EquationSolver<Function>::operator=(const EquationSolver & right) {
   fMaxIter = right.GetMaxIterations();
   fTolerance = right.GetTolerance();
   fA = right.GetIntervalLowerLimit();
@@ -32,13 +30,13 @@ NAEquationSolver<Function> & NAEquationSolver<Function>::operator=(const NAEquat
 }
 
 template <class Function> 
-Bool_t NAEquationSolver<Function>::operator==(const NAEquationSolver & right) const {
+Bool_t EquationSolver<Function>::operator==(const EquationSolver & right) const {
   if (this == &right) return true;
   else return false;
 }
 
 template <class Function> 
-Bool_t NAEquationSolver<Function>::operator!=(const NAEquationSolver & right) const {
+Bool_t EquationSolver<Function>::operator!=(const EquationSolver & right) const {
   return !operator==(right);
 }
 
index f0c383a..4c0395a 100644 (file)
@@ -1,55 +1,40 @@
-
-#ifndef NAEquationSolver_h
-#define NAEquationSolver_h 1
+//////////////////////////////////////////////////////////////////////////////////       
+//                                                                              //
+//        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna     //
+//      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru  //
+//                           November. 2, 2005                                  //
+//                                                                              //
+//           This equation solver class is taken from GEANT4 and modified!!     //
+//////////////////////////////////////////////////////////////////////////////////
+#ifndef EQUATIONSOLVER_H
+#define EQUATIONSOLVER_H
 #include <Rtypes.h>
-#include "MathUtil.h"
-/*                                                                            
-                                                                            
-        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
-      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
-                           November. 2, 2005                                
-
-*/
-//This equation solver class is taken from GEANT4 and modified!!
-
 
 #define DefaultTolerance 5.0e-14
 
 template <class Function> 
-class NAEquationSolver {
+class EquationSolver {
 
  public:
-  enum {DefaultMaxIter = 100};
-       
- private:
-  // Maximum number of iterations
-  Int_t fMaxIter;
-  Double_t fTolerance;
-  // interval limits [a,b] which should bracket the root
-  Double_t fA;
-  Double_t fB;
-  // root
-  Double_t fRoot;
-
- public:    
+  enum {kDefaultMaxIter = 100};  
   // default constructor
-  NAEquationSolver() : fMaxIter(DefaultMaxIter), fTolerance(DefaultTolerance),
+  EquationSolver() : fMaxIter(kDefaultMaxIter), fTolerance(DefaultTolerance),
     fA(0.0), fB(0.0), fRoot(0.0) {};
        
-  NAEquationSolver(const Int_t iterations, const Double_t tol) :
+  EquationSolver(const Int_t iterations, const Double_t tol) :
     fMaxIter(iterations), fTolerance(tol),
     fA(0.0), fB(0.0), fRoot(0.0) {};
 
   // copy constructor  
-  NAEquationSolver(const NAEquationSolver & right);
+  EquationSolver(const EquationSolver & right);
 
   // destructor
-  ~NAEquationSolver() {};
+  ~EquationSolver() {};
        
   // operators
-  NAEquationSolver & operator=(const NAEquationSolver & right);
-  Bool_t operator==(const NAEquationSolver & right) const;
-  Bool_t operator!=(const NAEquationSolver & right) const;
+  EquationSolver & operator=(const EquationSolver & right);
+  Bool_t operator==(const EquationSolver & right) const;
+  Bool_t operator!=(const EquationSolver & right) const;
                
   Int_t GetMaxIterations(void) const {return fMaxIter;}
   void SetMaxIterations(const Int_t iterations) {fMaxIter=iterations;}
@@ -66,6 +51,13 @@ class NAEquationSolver {
        
   // Calculates the root by the Brent's method
   Bool_t Brent(Function& theFunction);
+
+ private:
+  Int_t fMaxIter;         // Maximum number of iterations
+  Double_t fTolerance;    // tolerance (precision)
+  Double_t fA;            // interval limits [a,b] which should bracket the root
+  Double_t fB;            // interval limits [a,b] which should bracket the root
+  Double_t fRoot;         // the equation's root
 };
 
 #include "EquationSolver.icc"
index 7534713..b794e5c 100644 (file)
@@ -6,21 +6,23 @@
 \r
 */ \r
 //This equation solver class is taken from GEANT4 and modified!!\r
\r
+\r
+#include <iostream>\r
+#include <TMath.h>\r
 \r
 template <class Function>\r
-Bool_t NAEquationSolver<Function>::Brent(Function& theFunction) {\r
+Bool_t EquationSolver<Function>::Brent(Function& theFunction) {\r
   const Double_t precision = 3.0e-8;\r
 \r
   // Check the interval before start\r
-  if(fA > fB || Abs(fA-fB) <= fTolerance) {\r
-    std::cerr << "NAEquationSolver::Brent: The interval must be properly set." << std::endl;\r
+  if(fA > fB || TMath::Abs(fA-fB) <= fTolerance) {\r
+    std::cerr << "EquationSolver::Brent: The interval must be properly set." << std::endl;\r
     return false;\r
   }\r
   Double_t fa = theFunction(fA);\r
   Double_t fb = theFunction(fB);\r
   if(fa*fb > 0.0) {\r
-    std::cerr << "NAEquationSolver::Brent: The interval must include a root." << std::endl;\r
+    std::cerr << "EquationSolver::Brent: The interval must include a root." << std::endl;\r
     return false;\r
   }\r
     \r
@@ -39,7 +41,7 @@ Bool_t NAEquationSolver<Function>::Brent(Function& theFunction) {
       d = fB - fA;\r
       e = d;\r
     }\r
-    if(Abs(fc) < Abs(fb)) {\r
+    if(TMath::Abs(fc) < TMath::Abs(fb)) {\r
       fA = fB;\r
       fB = c;\r
       c = fA;\r
@@ -47,14 +49,14 @@ Bool_t NAEquationSolver<Function>::Brent(Function& theFunction) {
       fb = fc;\r
       fc = fa;\r
     }\r
-    Double_t Tol1 = 2.0*precision*Abs(fB) + 0.5*fTolerance;\r
+    Double_t Tol1 = 2.0*precision*TMath::Abs(fB) + 0.5*fTolerance;\r
     Double_t xm = 0.5*(c-fB);\r
-    if(Abs(xm) <= Tol1 || fb == 0.0) {\r
+    if(TMath::Abs(xm) <= Tol1 || fb == 0.0) {\r
       fRoot = fB;\r
       return true;\r
     }\r
     // Inverse quadratic interpolation\r
-    if(Abs(e) >= Tol1 && Abs(fa) > Abs(fb)) {\r
+    if(TMath::Abs(e) >= Tol1 && TMath::Abs(fa) > TMath::Abs(fb)) {\r
       Double_t s = fb/fa;\r
       Double_t p = 0.0;\r
       Double_t q = 0.0;\r
@@ -70,10 +72,10 @@ Bool_t NAEquationSolver<Function>::Brent(Function& theFunction) {
       }\r
       // Check bounds\r
       if(p > 0.0) q = -q;\r
-      p = Abs(p);\r
-      Double_t min1 = 3.0*xm*q-Abs(Tol1*q);\r
-      Double_t min2 = Abs(e*q);\r
-      if (2.0*p < Min(min1,min2)) {\r
+      p = TMath::Abs(p);\r
+      Double_t min1 = 3.0*xm*q-TMath::Abs(Tol1*q);\r
+      Double_t min2 = TMath::Abs(e*q);\r
+      if (2.0*p < TMath::Min(min1,min2)) {\r
         // Interpolation\r
         e = d;\r
         d = p/q;\r
@@ -92,21 +94,21 @@ Bool_t NAEquationSolver<Function>::Brent(Function& theFunction) {
     // Move last guess to a \r
     fA = fB;\r
     fa = fb;\r
-    if (Abs(d) > Tol1) fB += d;\r
+    if (TMath::Abs(d) > Tol1) fB += d;\r
     else {\r
-      if (xm >= 0.0) fB += Abs(Tol1);\r
-      else fB -= Abs(Tol1);\r
+      if (xm >= 0.0) fB += TMath::Abs(Tol1);\r
+      else fB -= TMath::Abs(Tol1);\r
     }\r
     fb = theFunction(fB);\r
   }\r
-  std::cerr << "NAEquationSolver::Brent: Number of iterations exceeded." << std::endl;\r
+  std::cerr << "EquationSolver::Brent: Number of iterations exceeded." << std::endl;\r
   return false;\r
 }\r
 \r
 template <class Function>   \r
-void NAEquationSolver<Function>::SetIntervalLimits(const Double_t Limit1, const Double_t Limit2) {\r
-  if(Abs(Limit1-Limit2) <= fTolerance) {\r
-    std::cerr << "NAEquationSolver::SetIntervalLimits: Interval must be wider than tolerance." << std::endl;\r
+void EquationSolver<Function>::SetIntervalLimits(const Double_t Limit1, const Double_t Limit2) {\r
+  if(TMath::Abs(Limit1-Limit2) <= fTolerance) {\r
+    std::cerr << "EquationSolver::SetIntervalLimits: Interval must be wider than tolerance." << std::endl;\r
     return;\r
   }\r
   if(Limit1 < Limit2) {\r
index b0c15bb..2a8f457 100644 (file)
@@ -1,30 +1,22 @@
-/*                                                                            
-                                                                            
-        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
-      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
-                           November. 2, 2005                                
-
-*/
+//////////////////////////////////////////////////////////////////////////////////       
+//                                                                              //
+//        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna     //
+//      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru  //
+//                           November. 2, 2005                                  //
+//                                                                              //
+//////////////////////////////////////////////////////////////////////////////////
 #include <iostream>
 
 #include <TError.h>
 #include <TMath.h>
-#ifndef GRANDCANONICAL_INCLUDED
 #include "GrandCanonical.h"
-#endif
-#ifndef HANKELFUNCTION_INCLUDED
 #include "HankelFunction.h"
-#endif
-#ifndef UKUTILITY_INCLUDED
 #include "UKUtility.h"
-#endif
-#ifndef PARTICLE_PDG
 #include "ParticlePDG.h"
-#endif
-#ifndef DATABASEPDG_H
 #include "DatabasePDG.h"
-#endif
 
+
+//_______________________________________________________________________________
 GrandCanonical::GrandCanonical():
   fTemperature(-1111),
   fBaryonPotential(-1111),
@@ -33,8 +25,12 @@ GrandCanonical::GrandCanonical():
   fNMax(-1111),
   fInitialized(kFALSE)
 {
+  //
+  // default constructor
+  //
 }
 
+//_______________________________________________________________________________
 GrandCanonical::GrandCanonical(Int_t nmax, Double_t temperature, Double_t baryonPotential, Double_t strangePotential, Double_t electroPotential):
   fTemperature(temperature),
   fBaryonPotential(baryonPotential),
@@ -43,42 +39,79 @@ GrandCanonical::GrandCanonical(Int_t nmax, Double_t temperature, Double_t baryon
   fNMax(nmax),
   fInitialized(kTRUE)
 {
+  //
+  // constructor
+  //
 }
 
-GrandCanonical::~GrandCanonical() {}
-
+//_______________________________________________________________________________
+GrandCanonical::~GrandCanonical() {
+//
+// destructor
+//
+}
 
+//_______________________________________________________________________________
 void GrandCanonical::Temperature(Double_t value) {
+  //
+  // set temperature
+  //
   fTemperature = value;
-  if(fNMax!=-1111 && fBaryonPotential!=-1111 && fStrangePotential!=-1111 && fElectroPotential!=-1111)
+  if(fNMax!=-1111 && TMath::Abs(fBaryonPotential+1111)>1.e-10 && 
+    TMath::Abs(fStrangePotential+1111)>1.e-10 && TMath::Abs(fElectroPotential+1111)>1.e-10)
     fInitialized = kTRUE;
 }
 
+//_______________________________________________________________________________
 void GrandCanonical::BaryonPotential(Double_t value) {
+  //
+  // set baryo chemical potential
+  //
   fBaryonPotential = value;
-  if(fNMax!=-1111 && fTemperature!=-1111 && fStrangePotential!=-1111 && fElectroPotential!=-1111)
+  if(fNMax!=-1111 && TMath::Abs(fTemperature+1111)>1.e-10 && 
+    TMath::Abs(fStrangePotential+1111)>1.e-10 && TMath::Abs(fElectroPotential+1111)>1.e-10)
     fInitialized = kTRUE;
 }
 
+//_______________________________________________________________________________
 void GrandCanonical::StrangePotential(Double_t value) {
+  //
+  // set strange potential
+  //
   fStrangePotential = value;
-  if(fNMax!=-1111 && fTemperature!=-1111 && fBaryonPotential!=-1111 && fElectroPotential!=-1111)
+  if(fNMax!=-1111 && TMath::Abs(fTemperature+1111)>1.e-10 &&
+     TMath::Abs(fBaryonPotential+1111)>1.e-10 && TMath::Abs(fElectroPotential+1111)>1.e-10)
     fInitialized = kTRUE;
 }
 
+//_______________________________________________________________________________
 void GrandCanonical::ElectroPotential(Double_t value) {
+  //
+  // set electro chemical potential
+  //
   fElectroPotential = value;
-  if(fNMax!=-1111 && fTemperature!=-1111 && fBaryonPotential!=-1111 && fStrangePotential!=-1111)
+  if(fNMax!=-1111 && TMath::Abs(fTemperature+1111)>1.e-10 &&
+     TMath::Abs(fBaryonPotential+1111)>1.e-10 && TMath::Abs(fStrangePotential+1111)>1.e-10)
     fInitialized = kTRUE;
 }
 
+//_______________________________________________________________________________
 void GrandCanonical::NMax(Int_t value) {
+  //
+  // set the number of iterations
+  //
   fNMax = value;
   if(fTemperature!=-1111 && fBaryonPotential!=-1111 && fStrangePotential!=-1111 && fElectroPotential!=-1111)
+    if(fNMax!=-1111 && TMath::Abs(fBaryonPotential+1111)>1.e-10 && 
+    TMath::Abs(fStrangePotential+1111)>1.e-10 && TMath::Abs(fElectroPotential+1111)>1.e-10)
     fInitialized = kTRUE;
 }
 
+//_______________________________________________________________________________
 Double_t GrandCanonical::ParticleEnergyDensity(ParticlePDG *const particle) {
+  //
+  // compute the energy density for a given particle
+  //
   // Check if all the thermodinamic parameters are set
   if(!fInitialized)
     Fatal("GrandCanonical::ParticleEnergyDensity", "GrandCanonical object not fully initialized!!");
@@ -87,7 +120,7 @@ Double_t GrandCanonical::ParticleEnergyDensity(ParticlePDG *const particle) {
   Double_t degFactor = 2.*particle->GetSpin() + 1.;                                    // degeneracy factor
   Double_t mass = particle->GetMass();                                                // PDG table mass
   Double_t d = Int_t(2.*particle->GetSpin()) & 1 ? 1. : -1;                                   // Bose-Einstein/Fermi-Dirac factor
-  Double_t preFactor = (degFactor*mass*mass*fTemperature*fTemperature/hbarc/hbarc/hbarc)/(2.*TMath::Pi()*TMath::Pi()); 
+  Double_t preFactor = (degFactor*mass*mass*fTemperature*fTemperature/kHbarc/kHbarc/kHbarc)/(2.*TMath::Pi()*TMath::Pi()); 
 
   Double_t postFactor = 0.;
   //compute chemical potential
@@ -103,7 +136,11 @@ Double_t GrandCanonical::ParticleEnergyDensity(ParticlePDG *const particle) {
   return preFactor * postFactor;
 }
 
+//_______________________________________________________________________________
 Double_t GrandCanonical::ParticleNumberDensity(ParticlePDG *const particle) {
+  //
+  // compute the particle number density
+  //
   // Check if all the thermodinamic parameters are set
   if(!fInitialized)
     Fatal("GrandCanonical::ParticleNumberDensity", "GrandCanonical object not fully initialized!!");
@@ -111,7 +148,7 @@ Double_t GrandCanonical::ParticleNumberDensity(ParticlePDG *const particle) {
   Double_t degFactor = 2.*particle->GetSpin() + 1.;
   Double_t mass = particle->GetMass();     
   Double_t d = Int_t(2*particle->GetSpin()) & 1 ? 1. : -1.;
-  Double_t preFactor = (degFactor*mass*mass*fTemperature/hbarc/hbarc/hbarc)/(2.*TMath::Pi()*TMath::Pi());
+  Double_t preFactor = (degFactor*mass*mass*fTemperature/kHbarc/kHbarc/kHbarc)/(2.*TMath::Pi()*TMath::Pi());
 
   Double_t postFactor = 0.;
   Double_t potential = fBaryonPotential * particle->GetBaryonNumber() + 
@@ -126,8 +163,11 @@ Double_t GrandCanonical::ParticleNumberDensity(ParticlePDG *const particle) {
   return preFactor * postFactor;
 }
 
-
+//_______________________________________________________________________________
 Double_t GrandCanonical::EnergyDensity(DatabasePDG *const database) {
+  //
+  // compute the total energy density
+  //
   // Check if all the thermodinamic parameters are set
   if(!fInitialized)
     Fatal("GrandCanonical::EnergyDensity", "GrandCanonical object not fully initialized!!");
@@ -142,7 +182,11 @@ Double_t GrandCanonical::EnergyDensity(DatabasePDG *const database) {
   return meanEnergyDensity;
 }
 
+//_______________________________________________________________________________
 Double_t GrandCanonical::BaryonDensity(DatabasePDG *const database) {
+  //
+  // compute the baryon density
+  //
   // Check if all the thermodinamic parameters are set
   if(!fInitialized)
     Fatal("GrandCanonical::BaryonDensity", "GrandCanonical object not fully initialized!!");
@@ -156,7 +200,11 @@ Double_t GrandCanonical::BaryonDensity(DatabasePDG *const database) {
   return meanBaryonDensity;
 }
 
+//_______________________________________________________________________________
 Double_t GrandCanonical::StrangeDensity(DatabasePDG *const database) {
+  //
+  // compute the strangeness density
+  //
   // Check if all the thermodinamic parameters are set
   if(!fInitialized)
     Fatal("GrandCanonical::StrangeDensity", "GrandCanonical object not fully initialized!!");
@@ -171,7 +219,11 @@ Double_t GrandCanonical::StrangeDensity(DatabasePDG *const database) {
   return meanStrangeDensity;
 }
 
+//_______________________________________________________________________________
 Double_t GrandCanonical::ElectroDensity(DatabasePDG *const database) {
+  //
+  // compute the electro number density
+  //
   // Check if all the thermodinamic parameters are set
   if(!fInitialized)
     Fatal("GrandCanonical::ElectroDensity", "GrandCanonical object not fully initialized!!");
index 7f7e45b..a68f7d8 100644 (file)
@@ -1,10 +1,10 @@
-/*                                                                        
-                                                                            
-        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
-      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
-                           November. 2, 2005                                
-
-*/
+//////////////////////////////////////////////////////////////////////////////////       
+//                                                                              //
+//        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna     //
+//      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru  //
+//                           November. 2, 2005                                  //
+//                                                                              //
+//////////////////////////////////////////////////////////////////////////////////
 
 #ifndef GRANDCANONICAL_H
 #define GRANDCANONICAL_H
@@ -46,15 +46,13 @@ 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;
+  Double_t    fTemperature;        // temperature
+  Double_t    fBaryonPotential;           // baryon chemical potential
+  Double_t    fStrangePotential;   // strangeness chemical potential
+  Double_t    fElectroPotential;   // electro chemical potential
+  
+  Int_t       fNMax;               //  Number of terms for summation, if fNMax = 1 then
+  Bool_t fInitialized;             // flag
 };
 
 #endif
index b13c50d..aeec7b8 100644 (file)
@@ -97,12 +97,12 @@ extern "C" {
   //  common /hyfpar/ bgen,nbcol,npart,npyt,nhyd,npart0        
   typedef struct // for HYFPAR common block
   {
-    Double_t bgen;
-    Int_t nbcol;
-    Double_t npart;
-    Double_t npart0;
-    Int_t npyt;
-    Int_t nhyd;
+    Double_t bgen;        // impact parameter 
+    Int_t nbcol;          // number of binary collisions
+    Double_t npart;       // n participants
+    Double_t npart0;      // n participants
+    Int_t npyt;           // number of pythia particles
+    Int_t nhyd;           // number of hydjet particles
   }HYFPARCommon;
   
 #define HYFPAR COMMON_BLOCK(HYFPAR,hyfpar)
@@ -112,9 +112,9 @@ extern "C" {
   typedef struct //for HYPART common block
   {
     Double_t ppart[50000][10];   // particle information
-    Double_t bmin;
-    Double_t bmax;
-    Int_t njp;
+    Double_t bmin;               // min impact parameter
+    Double_t bmax;               // max impact parameter
+    Int_t njp;                   // 
   }HYPARTCommon;
   
 #define HYPART COMMON_BLOCK(HYPART,hypart)
index 2e04bfd..4a7b4af 100644 (file)
@@ -1,13 +1,12 @@
-/*
-
-       July 2008 BW mass is limited by "PYTHIA method", by I. Lokhtin and L. Malinina
-                                                                            
-                                                                            
-        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
-      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
-                           November. 2, 2005                                
-
-*/
+///////////////////////////////////////////////////////////////////////////////////// 
+//                                                                                 //
+//  July 2008 BW mass is limited by "PYTHIA method", by I. Lokhtin and L. Malinina //
+//                                                                                 //
+//        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna        //
+//      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru     //
+//                           November. 2, 2005                                     //
+//                                                                                 //
+/////////////////////////////////////////////////////////////////////////////////////
 
 #include <functional>
 #include <algorithm>
 #include <TError.h>
 #include <TMath.h>
 
-#ifndef DATABASEPDG_H
 #include "DatabasePDG.h"
-#endif
-#ifndef PARTICLE_PDG
 #include "ParticlePDG.h"
-#endif
-#ifndef DECAY_CHANNEL
 #include "DecayChannel.h"
-#endif
-#ifndef HADRONDECAYER_INCLUDED
-#include "HadronDecayer.h"
-#endif
-#ifndef UKUTILITY_INCLUDED
 #include "UKUtility.h"
-#endif
-#ifndef PARTICLE_INCLUDED
 #include "Particle.h"
-#endif
 #include "HYJET_COMMONS.h"
+#include "HadronDecayer.h"
 
 //calculates decay time in fm/c
 //calculates 1,2 and 3 body decays
@@ -44,6 +31,10 @@ using std::cout;
 using std::endl;
 
 Double_t GetDecayTime(const Particle &parent, Double_t weakDecayLimit) {
+  //
+  // return a random decay time according to the particle's width
+  //
+  
   ParticlePDG *pDef = parent.Def(); 
   Double_t width = pDef->GetWidth(); //GeV
 
@@ -63,8 +54,11 @@ Double_t GetDecayTime(const Particle &parent, Double_t weakDecayLimit) {
 extern "C" void mydelta_();
 extern SERVICEEVCommon SERVICEEV;
 
-void Decay(List_t &output, Particle &parent, ParticleAllocator &allocator, DatabasePDG* database) {
-
+void Decay(List_t &output, Particle &parent, ParticleAllocator &allocator, const DatabasePDG* database) {
+  //
+  // perform the decay
+  //
+  
   // Get the PDG properties of the particle
   ParticlePDG *pDef = parent.Def();
 
@@ -79,9 +73,9 @@ void Decay(List_t &output, Particle &parent, ParticleAllocator &allocator, Datab
     return;
 
   // get the PDG mass of the specie  
-  Double_t PDGmass = pDef->GetMass();
-  Int_t ComprCodePyth=0;
-  Float_t Delta =0;
+  Double_t pdgMass = pDef->GetMass();
+  Int_t comprCodePyth=0;
+  Float_t delta =0;
 
   Bool_t success = kFALSE;
   Int_t iterations = 0;
@@ -96,42 +90,42 @@ void Decay(List_t &output, Particle &parent, ParticleAllocator &allocator, Datab
     }
     
     // get a random mass using the Breit Wigner distribution 
-    Double_t BWmass = gRandom->BreitWigner(PDGmass, pDef->GetWidth());     
-    //      BWmass = PDGmass;
+    Double_t bwMass = gRandom->BreitWigner(pdgMass, pDef->GetWidth());     
+    //      bwMass = pdgMass;
     // Try to cut the Breit Wigner tail of the particle using the cuts from pythia
-    // The Delta variable is obtained from pythia based on the specie
+    // The delta variable is obtained from pythia based on the specie
     int encoding =pDef->GetPDG();
     SERVICEEV.ipdg = encoding;
     mydelta_();      
-    ComprCodePyth=SERVICEEV.KC;
-    Delta = SERVICEEV.delta;// PYDAT2.PMAS[KC][3];
+    comprCodePyth=SERVICEEV.KC;
+    delta = SERVICEEV.delta;// PYDAT2.PMAS[KC][3];
 
-    //if there are no such particle in PYTHIA particle table, we take Delta=0.4
-    if(ComprCodePyth==0){
-      BWmass=PDGmass; 
-      Delta=0.0;
+    //if there are no such particle in PYTHIA particle table, we take delta=0.4
+    if(comprCodePyth==0){
+      bwMass=pdgMass; 
+      delta=0.0;
     } 
 
     //bad delta - an exception
-    if(ComprCodePyth==254){
-      BWmass=PDGmass; 
-      Delta=0.0;
+    if(comprCodePyth==254){
+      bwMass=pdgMass; 
+      delta=0.0;
     } 
       
     // K0 decay into K0s or K0l
     if(TMath::Abs(encoding)==311) {
-      BWmass=PDGmass;
-      Delta=0.0;
+      bwMass=pdgMass;
+      delta=0.0;
     }
 
     //for particles from PYTHIA table only, if the BW mass is outside the cut range then quit this iteration and generate another BW mass
-    if(ComprCodePyth!=0 && Delta>0 && (BWmass<PDGmass-Delta || BWmass>PDGmass+Delta)){
+    if(comprCodePyth!=0 && delta>0 && (bwMass<pdgMass-delta || bwMass>pdgMass+delta)){
       iterations++;
       continue;
     }    
     
     // check how many decay channels are allowed with the generated mass
-    Int_t nAllowedChannels = database->GetNAllowedChannels(pDef, BWmass);
+    Int_t nAllowedChannels = database->GetNAllowedChannels(pDef, bwMass);
     // if no decay channels are posible with this mass, then generate another BW mass
     if(nAllowedChannels==0) {    
       iterations++;
@@ -153,7 +147,7 @@ void Decay(List_t &output, Particle &parent, ParticleAllocator &allocator, Datab
     while(!found) {
       for(Int_t nChannel = 0; nChannel < nDecayChannel; nChannel++) {
        randValue -= pDef->GetDecayChannel(nChannel)->GetBranching();
-       if(randValue <= 0. && database->IsChannelAllowed(pDef->GetDecayChannel(nChannel), BWmass)) {
+       if(randValue <= 0. && database->IsChannelAllowed(pDef->GetDecayChannel(nChannel), bwMass)) {
          chosenChannel = nChannel;
          found = kTRUE;
          break;
@@ -169,14 +163,14 @@ void Decay(List_t &output, Particle &parent, ParticleAllocator &allocator, Datab
     // Adjust the parent momentum four-vector for the MC generated Breit-Wigner mass
     Particle parentBW(database->GetPDGParticle(parent.Encoding()));
     parentBW.Pos(parent.Pos());
-    Double_t BWenergy = TMath::Sqrt(parent.Mom().X()*parent.Mom().X() + 
+    Double_t bwEnergy = TMath::Sqrt(parent.Mom().X()*parent.Mom().X() + 
                                    parent.Mom().Y()*parent.Mom().Y() +
                                    parent.Mom().Z()*parent.Mom().Z() +
-                                   BWmass*BWmass);
+                                   bwMass*bwMass);
 
-    Int_t NB = (Int_t)parent.GetType(); //particle from jets
+    Int_t nb = (Int_t)parent.GetType(); //particle from jets
 
-    TLorentzVector MomparentBW(parent.Mom().X(), parent.Mom().Y(), parent.Mom().Z(), BWenergy); 
+    TLorentzVector MomparentBW(parent.Mom().X(), parent.Mom().Y(), parent.Mom().Z(), bwEnergy); 
     parentBW.Mom(MomparentBW);
     // take into account BW when calculating boost velocity (for wide resonances it matters)
     TVector3 velocityBW(parentBW.Mom().BoostVector());
@@ -191,7 +185,7 @@ void Decay(List_t &output, Particle &parent, ParticleAllocator &allocator, Datab
       p1.SetLastMotherPdg(parentBW.Encoding());
       p1.SetLastMotherDecayCoor(parentBW.Pos());
       p1.SetLastMotherDecayMom(parentBW.Mom());
-      p1.SetType(NB);
+      p1.SetType(nb);
 
       // add the daughter to the list of secondaries
       Int_t parentIndex = parent.GetIndex();
@@ -211,7 +205,7 @@ void Decay(List_t &output, Particle &parent, ParticleAllocator &allocator, Datab
       p2.Pos(parentBW.Pos());
       
       // calculate the momenta in rest frame of mother for the two particles (theta and phi are isotropic)
-      MomAntiMom(p1.Mom(), p1.TableMass(), p2.Mom(), p2.TableMass(), BWmass);
+      MomAntiMom(p1.Mom(), p1.TableMass(), p2.Mom(), p2.TableMass(), bwMass);
     
       // boost to the laboratory system (to the mother velocity)
       p1.Mom().Boost(velocityBW);
@@ -225,8 +219,8 @@ void Decay(List_t &output, Particle &parent, ParticleAllocator &allocator, Datab
       p2.SetLastMotherDecayCoor(parentBW.Pos());
       p2.SetLastMotherDecayMom(parentBW.Mom());
       //set to daughters the same type as has mother
-      p1.SetType(NB);
-      p2.SetType(NB);
+      p1.SetType(nb);
+      p2.SetType(nb);
 
 
       // check the kinematics in the lab system
@@ -267,7 +261,7 @@ void Decay(List_t &output, Particle &parent, ParticleAllocator &allocator, Datab
       Double_t pAbs1 = 0., pAbs2 = 0., pAbs3 = 0., sumPabs = 0., maxPabs = 0.;
       Double_t mass1 = p1.TableMass(), mass2 = p2.TableMass(), mass3 = p3.TableMass();
       TLorentzVector &mom1 = p1.Mom(), &mom2 = p2.Mom(), &mom3 = p3.Mom(); 
-      Double_t deltaMass = BWmass - mass1 - mass2 - mass3;
+      Double_t deltaMass = bwMass - mass1 - mass2 - mass3;
 
       do {
        Double_t rd1 = gRandom->Rndm();
@@ -342,9 +336,9 @@ void Decay(List_t &output, Particle &parent, ParticleAllocator &allocator, Datab
       p3.SetLastMotherDecayMom(parentBW.Mom());
 
       //set to daughters the same type as has mother  
-      p1.SetType(NB);
-      p2.SetType(NB);
-      p3.SetType(NB);
+      p1.SetType(nb);
+      p2.SetType(nb);
+      p3.SetType(nb);
 
       // energy conservation check in the lab system
       Double_t deltaS = TMath::Sqrt((parentBW.Mom().X()-p1.Mom().X()-p2.Mom().X()-p3.Mom().X())*(parentBW.Mom().X()-p1.Mom().X()-p2.Mom().X()-p3.Mom().X()) +
index 0630039..0aa299c 100644 (file)
@@ -1,21 +1,19 @@
+//////////////////////////////////////////////////////////////////////////////////       
+//                                                                              //
+//        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna     //
+//      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru  //
+//                           November. 2, 2005                                  //
+//                                                                              //
+//////////////////////////////////////////////////////////////////////////////////
+
 #ifndef HADRONDECAYER_INCLUDED
 #define HADRONDECAYER_INCLUDED
 
-/*                                                                            
-                                                                           
-        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
-      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
-                           November. 2, 2005                                
-
-*/
-#ifndef DATABASEPDG_H
 #include "DatabasePDG.h"
-#endif
-#ifndef PARTICLE_INCLUDED
 #include "Particle.h"
-#endif
+
 
 Double_t GetDecayTime(const Particle &p, Double_t weakDecayLimit);
-void Decay(List_t &output, Particle &p, ParticleAllocator &allocator, DatabasePDG* database);
+void Decay(List_t &output, Particle &p, ParticleAllocator &allocator, const DatabasePDG* database);
 
 #endif
index 79c3446..c9c6d84 100644 (file)
@@ -1,16 +1,14 @@
-/*                                                                            
-                                                                            
-        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
-      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
-                           November. 2, 2005                                
-
-*/
+//////////////////////////////////////////////////////////////////////////////////       
+//                                                                              //
+//        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna     //
+//      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru  //
+//                           November. 2, 2005                                  //
+//                                                                              //
+//////////////////////////////////////////////////////////////////////////////////
 
 #include <TMath.h>
 
-#ifndef HANKELFUNCTION_INCLUDED
 #include "HankelFunction.h"
-#endif
 
 //compute Hankel function of zeroth order
 enum {kNe = 2, kNCoeff = 9};
@@ -147,6 +145,8 @@ Double_t BesselI1(Double_t x) {
 }
 
 Double_t HankelK0(Double_t x) { 
+  //  (C) Copr. 1986-92 Numerical Recipes Software +7.
+  // compute modified Hankel function of the first order
   const Double_t p1 = k0Coefficient[0][0];
   const Double_t p2 = k0Coefficient[1][0];
   const Double_t p3 = k0Coefficient[2][0];
index ed9028e..200b38f 100644 (file)
@@ -1,10 +1,10 @@
-/*                                                                          
-                                                                            
-        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
-      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
-                           November. 2, 2005                                
-
-*/
+//////////////////////////////////////////////////////////////////////////////////       
+//                                                                              //
+//        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna     //
+//      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru  //
+//                           November. 2, 2005                                  //
+//                                                                              //
+//////////////////////////////////////////////////////////////////////////////////
 
 #ifndef HANKELFUNCTION_INCLUDED
 #define HANKELFUNCTION_INCLUDED
index 0e55891..ff242a2 100644 (file)
@@ -1,22 +1,15 @@
-/*
-  Ludmila Malinina  malinina@lav01.sinp.msu.ru,   SINP MSU/Moscow and JINR/Dubna
-  Ionut Arsene  i.c.arsene@fys.uio.no,            Oslo University and ISS-Bucharest
-  Date        : 2007/05/30
-*/
-
-#include "TVector3.h"
-#ifndef INITIAL_STATE
-#include "InitialState.h"
-#endif
-#ifndef HADRONDECAYER_INCLUDED
-#include "HadronDecayer.h"
-#endif
+//
+//  Ludmila Malinina  malinina@lav01.sinp.msu.ru,   SINP MSU/Moscow and JINR/Dubna
+//  Ionut Arsene  i.c.arsene@fys.uio.no,            Oslo University and ISS-Bucharest
+//  Date        : 2007/05/30
+//
 #include <iostream> 
 #include <fstream>
 using namespace std;
 
-// aic(2008/08/08): define the fLastIndex static variable 
-//Int_t Particle::fLastIndex;
+#include <TVector3.h>
+#include "HadronDecayer.h"
+#include "InitialState.h"
 
 void InitialState::Evolve(List_t &secondaries, ParticleAllocator &allocator, Double_t weakDecayLimit) {
   // Particle indexes are set for primaries already from InitialStateHydjet::Initialize()
index f52db7b..e7fe619 100644 (file)
@@ -1,20 +1,17 @@
-/*
-  Ludmila Malinina  malinina@lav01.sinp.msu.ru,   SINP MSU/Moscow and JINR/Dubna
-  Ionut Arsene  i.c.arsene@fys.uio.no,            Oslo University and ISS-Bucharest
-  Date        : 2007/05/30
-  Updated     : 2008/08/11
-*/
-
-#ifndef INITIAL_STATE
-#define INITIAL_STATE
+//
+//  Ludmila Malinina  malinina@lav01.sinp.msu.ru,   SINP MSU/Moscow and JINR/Dubna
+//  Ionut Arsene  i.c.arsene@fys.uio.no,            Oslo University and ISS-Bucharest
+//  Date        : 2007/05/30
+//  Updated     : 2008/08/11
+//
 // Virtual class for the initial state classes
 // Include here common methods, but always declare them as virtual
-#ifndef PARTICLE_INCLUDED
+
+#ifndef INITIALSTATE_H
+#define INITIALSTATE_H
+
 #include "Particle.h"
-#endif
-#ifndef DATABASEPDG_H
 #include "DatabasePDG.h"
-#endif
 
 class InitialState {
  public:
@@ -54,7 +51,7 @@ class InitialState {
   //  virtual void Evolve(List_t &source, List_t &secondaries, ParticleAllocator &allocator, Double_t weakDecayLimit);
   virtual void Evolve(List_t &secondaries, ParticleAllocator &allocator, Double_t weakDecayLimit);
  protected:
-   DatabasePDG *fDatabase;
+   DatabasePDG *fDatabase;        // PDG database
  private:
    InitialState(const InitialState&);
    InitialState& operator=(const InitialState&);
index 64e9106..eb4efcf 100644 (file)
@@ -1,55 +1,44 @@
 //expanding localy equilibated fireball with volume hadron radiation
 //thermal part: Blast wave model, Bjorken-like parametrization
 //hyght-pt: PYTHIA + jet quenching model PYQUEN
+//                                                                           
+//         HYDJET++ 
+//         version 1.0:  
+//         InitialStateHydjet is the modified InitialStateBjorken 
+//         The high-pt part related with PYTHIA-PYQUEN is included       
+//         InitialStateBjorken (FASTMC) was used.
+//
+//
+//         
+//         InitialStateBjorken           
+//         version 2.0: 
+//         Ludmila Malinina  malinina@lav01.sinp.msu.ru,   SINP MSU/Moscow and JINR/Dubna
+//         Ionut Arsene  i.c.arsene@fys.uio.no,            Oslo University                                                
+//                     June 2007
+//        
+//         version 1.0:                                                               
+//         Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
+//         amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
+//                           November. 2, 2005 
 
-/*                                                                           
-         HYDJET++ 
-         version 1.0:  
-         InitialStateHydjet is the modified InitialStateBjorken 
-         The high-pt part related with PYTHIA-PYQUEN is included       
-         InitialStateBjorken (FASTMC) was used.
-
+                     
 
-         
-         InitialStateBjorken           
-         version 2.0: 
-         Ludmila Malinina  malinina@lav01.sinp.msu.ru,   SINP MSU/Moscow and JINR/Dubna
-         Ionut Arsene  i.c.arsene@fys.uio.no,            Oslo University                                                
-                     June 2007
-        
-         version 1.0:                                                               
-         Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
-         amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
-                           November. 2, 2005 
 
-                     
-*/
+#include <iostream> 
+#include <fstream>
 
 #include <TLorentzVector.h>
 #include <TVector3.h>
 #include <TMath.h>
 
-#ifndef INITIALSTATEHYDJET_H
 #include "InitialStateHydjet.h"
-#endif
-#ifndef RANDARRAYFUNCTION_INCLUDED
 #include "RandArrayFunction.h"
-#endif
-#ifndef GRANDCANONICAL_INCLUDED
 #include "GrandCanonical.h"
-#endif
-#ifndef NAStrangePotential_h
 #include "StrangePotential.h"
-#endif
-#ifndef PARTICLE_INCLUDED
 #include "Particle.h"
-#endif
-#ifndef PARTICLE_PDG
 #include "ParticlePDG.h"
-#endif
-#include <iostream> 
-#include <fstream>
 #include "HYJET_COMMONS.h"
+
 extern "C" void  hyevnt_();
 extern "C" void  myini_();
 extern HYIPARCommon HYIPAR;
@@ -65,8 +54,9 @@ class ParticleAllocator;
 class TRandom3;
 
 // declaration of the static member fLastIndex
-Int_t Particle::fLastIndex;
+Int_t Particle::fgLastIndex;
 
+//_________________________________________________________________________________
 void InitialStateHydjet::Initialize(List_t &source, ParticleAllocator & allocator) {
   // Generate initial particles from the soft and hard components
 
@@ -153,7 +143,7 @@ void InitialStateHydjet::Initialize(List_t &source, ParticleAllocator & allocato
          continue;
        }
        //no charm now !
-       if(partDef->GetCharmQNumber()!=0 || partDef->GetCharmAQNumber()!=0){
+       if(TMath::Abs(partDef->GetCharmQNumber())>0 || TMath::Abs(partDef->GetCharmAQNumber())>0){
          continue;
        }
 
@@ -267,6 +257,7 @@ void InitialStateHydjet::Initialize(List_t &source, ParticleAllocator & allocato
   
 }
 
+//_________________________________________________________________________________
 Bool_t InitialStateHydjet::ReadParams() {     
   // Read parameters from an input file in ascii 
  
@@ -377,6 +368,7 @@ Bool_t InitialStateHydjet::ReadParams() {
   return kTRUE; 
 }
 
+//_________________________________________________________________________________
 Bool_t InitialStateHydjet::MultIni() {
   // Calculate average multiplicities, chemical potentials (if necessary),
   // initialize pyquen 
@@ -396,7 +388,7 @@ Bool_t InitialStateHydjet::MultIni() {
     fParams.fMuI3 = 0.;
     fParams.fMuS = 0.;
     //create strange potential object and set strangeness density 0
-    NAStrangePotential* psp = new NAStrangePotential(0., fDatabase);
+    StrangePotential* psp = new StrangePotential(0., fDatabase);
     psp->SetBaryonPotential(fParams.fMuB);
     psp->SetTemperature(fParams.fT);
     //compute strangeness potential
@@ -521,6 +513,7 @@ Bool_t InitialStateHydjet::MultIni() {
   return kTRUE;
 }
 
+//_________________________________________________________________________________
 Double_t InitialStateHydjet::SimpsonIntegrator2(Double_t a, Double_t b) {
   // Simpson integration
   Int_t nsubIntervals=10000;
@@ -539,19 +532,20 @@ Double_t InitialStateHydjet::SimpsonIntegrator2(Double_t a, Double_t b) {
   
 }
 
+//_________________________________________________________________________________
 Double_t InitialStateHydjet::SimpsonIntegrator(Double_t a, Double_t b, Double_t phi) {
   // Simpson integration
   Int_t nsubIntervals=100;
   Double_t h = (b - a)/nsubIntervals;
-  Double_t s = f2(phi,a + 0.5*h);
-  Double_t t = 0.5*(f2(phi,a) + f2(phi,b));
+  Double_t s = F2(phi,a + 0.5*h);
+  Double_t t = 0.5*(F2(phi,a) + F2(phi,b));
   Double_t x = a;
   Double_t y = a + 0.5*h;
   for(Int_t i = 1; i < nsubIntervals; i++) {
     x += h;
     y += h;
-    s += f2(phi,y);
-    t += f2(phi,x);
+    s += F2(phi,y);
+    t += F2(phi,x);
   }    
   t += 2.0*s;
   return t*h/3.0;
@@ -559,7 +553,8 @@ Double_t InitialStateHydjet::SimpsonIntegrator(Double_t a, Double_t b, Double_t
 
 
 //f2=f(phi,r)
-Double_t InitialStateHydjet::f2(Double_t x, Double_t y) {
+//_________________________________________________________________________________
+Double_t InitialStateHydjet::F2(Double_t x, Double_t y) {
   // formula
   Double_t rSB = fParams.fR; //test: podstavit' *coefff_RB
   Double_t rhou =  fParams.fUmax * y / rSB;
@@ -569,7 +564,7 @@ Double_t InitialStateHydjet::f2(Double_t x, Double_t y) {
   return ff;
 }
 
-
+//_________________________________________________________________________________
 Double_t InitialStateHydjet::MidpointIntegrator2(Double_t a, Double_t b) {
   // Perform integration through the mid-point method
   Int_t nsubIntervals=2000; 
@@ -578,7 +573,7 @@ Double_t InitialStateHydjet::MidpointIntegrator2(Double_t a, Double_t b) {
   Double_t h2 = (fParams.fR)/nsubIntervals; //0-R maximal rB ?
   Double_t x = a + 0.5*h;
   Double_t y = 0;
-  Double_t t = f2(x,y);                    
+  Double_t t = F2(x,y);                    
   Double_t e = fParams.fEpsilon;
   for(Int_t j = 1; j < nsubIntervals; j++) {
     x += h; // integr  phi
@@ -588,7 +583,7 @@ Double_t InitialStateHydjet::MidpointIntegrator2(Double_t a, Double_t b) {
     // integr R 
     y=0;
     for(Int_t i = 1; i < nsubIntervals2; i++) 
-      t += f2(x,(y += h2));
+      t += F2(x,(y += h2));
   }
   return t*h*h2;
 }
index 520e17a..bfae21d 100644 (file)
 #ifndef INITIALSTATEHYDJET_H
 #define INITIALSTATEHYDJET_H
 
-//#ifndef DATABASE_PDG
-//#include "DatabasePDG.h"
-//#endif
-//#ifndef PARTICLE_INCLUDED
-//#include "Particle.h"
-//#endif
-#ifndef INITIAL_STATE
 #include "InitialState.h"
-#endif
 
 class ParticleAllocator;
 
@@ -116,11 +108,7 @@ struct InitialParamsHydjet_t {
 
 class InitialStateHydjet : public InitialState {
  public:
-  InitialParamsHydjet_t fParams;             // the list of initial state parameters
- private:
-  Double_t fVolEff;                           // the effective volume
-
- public:
+   
   InitialStateHydjet() : fParams(), fVolEff(0){};
   ~InitialStateHydjet() {};
   
@@ -135,13 +123,16 @@ class InitialStateHydjet : public InitialState {
   virtual Bool_t ReadParams();
   virtual Bool_t MultIni();
   Bool_t IniOfThFreezeoutParameters();
-  Double_t f(Double_t x);
-  Double_t f2(Double_t x, Double_t y);
+  
+  InitialParamsHydjet_t fParams;             // the list of initial state parameters
+  
+  private:
+   Double_t fVolEff;                           // the effective volume
+   Double_t F2(Double_t x, Double_t y);
    
-  Double_t SimpsonIntegrator(Double_t a, Double_t b, Double_t phi);
-  Double_t SimpsonIntegrator2(Double_t a, Double_t b);
-  Double_t MidpointIntegrator2(Double_t a, Double_t b);
+   Double_t SimpsonIntegrator(Double_t a, Double_t b, Double_t phi);
+   Double_t SimpsonIntegrator2(Double_t a, Double_t b);
+   Double_t MidpointIntegrator2(Double_t a, Double_t b);
 };
 
 #endif
diff --git a/TUHKMgen/UHKM/MathUtil.h b/TUHKMgen/UHKM/MathUtil.h
deleted file mode 100644 (file)
index e641cea..0000000
+++ /dev/null
@@ -1,76 +0,0 @@
-#ifndef NAMathUtil_h
-#define NAMathUtil_h 1
-
-#include <iostream>
-#include <math.h>
-#include <Rtypes.h>
-//
-//##############################################################################
-//
-//            Nikolai Amelin (C) JINR/Dubna 1999
-//
-//##############################################################################
-//
-
-const Double_t GeV   = 1.;
-const Double_t fermi = 1.;
-const Double_t hbarc = 0.197*GeV*fermi;
-const Double_t N_PI  = 3.14159265359;
-
-const Double_t N_INFINITY = 9.0E99;
-const Double_t N_SMALL = 1.E-10;
-   
-
-template <class T> inline void SwapObj(T* a, T* b)
-{
-   T tmp= *a;
-   *a = *b;
-   *b = tmp;
-}
-
-template <class T> inline void Swap(T& a, T& b)
-{
-   T tmp = a;
-   a = b;
-   b = tmp;
-}
-
-template <class T> inline T Min(T a, T b)
-{
-   return (a < b) ? a : b;
-}
-
-template <class T> inline T Max(T a, T b)
-{
-   return (a > b) ? a : b;
-}
-
-template <class T> inline T Abs(T a)
-{
-   return (a > 0) ? a : -a;
-}
-
-template <class T> inline T Sign(T A, T B)
-{
-   return (B > 0) ? Abs(A) : -Abs(A);
-}
-template <class T> inline T min(T a, T b) 
-  {
-  return (a < b)?a:b;
-  }
-
-template <class T> inline T max(T a, T b) 
-  {
-  return (a > b)?a:b;
-  }
-/*
-inline Double_t Rand(void)
-{
-   return ((Double_t)(rand() + 1))/(Double_t)(RAND_MAX + 2);//Visual C++
-//   return ((Double_t)(-rand() + 1))/(Double_t)(RAND_MAX + 2);// Linux
-}
-
-
-inline Double_t sqr(Double_t Value) { return Value*Value;}
-*/
-#endif
index a0c4670..99a35e3 100644 (file)
@@ -1,19 +1,17 @@
-/*                                                                           
-                                                                            
-        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
-      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
-                           November. 2, 2005                                
-
-*/
+//                                                                            
+//                                                                            
+//        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
+//      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
+//                           November. 2, 2005                                
+//
+//   Implementation of class Particle
+//   Contains particle PDG, 4-coordinates and 4-momentum vectors, history information
 
 #include <TMath.h>
-#ifndef PARTICLE_PDG
 #include "ParticlePDG.h"
-#endif
-#ifndef PARTICLE_INCLUDED
 #include "Particle.h"
-#endif
 
+//___________________________________________________________________
 Particle::Particle(ParticlePDG *prop): 
   fPosition(),
   fMomentum(),
@@ -32,9 +30,12 @@ Particle::Particle(ParticlePDG *prop):
   fLastDaughterIndex(-1),
   fDecayed(kFALSE)
 {
-
+//
+// constructor
+//
 }
 
+//___________________________________________________________________
 Particle::Particle(ParticlePDG *prop, const TLorentzVector &pos, 
                   const TLorentzVector &mom, Double_t lit, Int_t lin, Int_t type):
   fPosition(pos),
@@ -54,8 +55,12 @@ Particle::Particle(ParticlePDG *prop, const TLorentzVector &pos,
   fLastDaughterIndex(-1),
   fDecayed(kFALSE)
 {
+  //
+  // constructor
+  //
 }
 
+//___________________________________________________________________
 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):
@@ -76,8 +81,12 @@ Particle::Particle(ParticlePDG *prop, const TLorentzVector &pos, const TLorentzV
   fLastDaughterIndex(-1),
   fDecayed(kFALSE)
 {
+  //
+  // constructor
+  //
 }
 
+//___________________________________________________________________
 Particle::Particle(const Particle& copy) :
   fPosition(copy.Pos()),
   fMomentum(copy.Mom()),
@@ -96,56 +105,102 @@ Particle::Particle(const Particle& copy) :
   fLastDaughterIndex(copy.GetLastDaughterIndex()),
   fDecayed(copy.GetDecayed())
 {
+  //
+  // copy constructor
+  //
 }
 
+//___________________________________________________________________
 Particle & Particle::operator=(const Particle& /*copy*/) {
+  //
+  // assignment operator
+  //
   return *this;
 }
 
-
+//___________________________________________________________________
 Int_t Particle::Encoding() const {
+  //
+  // particle code
+  //
   return fParticleProperties->GetPDG();
 }
 
+//___________________________________________________________________
 Double_t Particle::TableMass() const {
+  //
+  // particle mass
+  //
   return fParticleProperties->GetMass();
 }
 
+//___________________________________________________________________
 Double_t Particle::Eta() const {
+  //
+  // pseudo-rapidity
+  //
   if(fMomentum.P() != fMomentum.Pz())
     return 0.5 * TMath::Log((fMomentum.P() + fMomentum.Pz()) / (fMomentum.P()-fMomentum.Pz()));
   else return 1.e30;
 }
 
+//___________________________________________________________________
 Double_t Particle::Rapidity() const {
+  //
+  // rapidity
+  //
   if (fMomentum.E() != fMomentum.Pz())
     return 0.5 * TMath::Log((fMomentum.E() + fMomentum.Pz()) / (fMomentum.E() - fMomentum.Pz()));
   else return 1.e30;
 }
 
+//___________________________________________________________________
 Double_t Particle::Phi() const {
+  //
+  // azimuthal angle
+  //
   return TMath::Pi()+TMath::ATan2(-fMomentum.Py(), -fMomentum.Px());
 }
 
+//___________________________________________________________________
 Double_t Particle::Theta() const {
+  //
+  // polar angle
+  //
   return !fMomentum.Pz() ? TMath::Pi() / 2 : TMath::ACos(fMomentum.Pz() / fMomentum.P());
 }
 
+//___________________________________________________________________
 Double_t Particle::Pt() const {
+  //
+  // pt
+  //
   return TMath::Sqrt(fMomentum.Px() * fMomentum.Px() + fMomentum.Py() * fMomentum.Py());
 }
 
+//___________________________________________________________________
 Double_t S(const TLorentzVector &v1, const TLorentzVector &v2) {
+  //
+  // Mandelstam s
+  //
   return TMath::Power(v1.T() + v2.T(), 2) - TMath::Power(v1.X() + v2.X(), 2) -
     TMath::Power(v1.Y() + v2.Y(), 2) - TMath::Power(v1.Z() + v2.Z(), 2);
 }
 
+//___________________________________________________________________
 Double_t T(const TLorentzVector & v1, const TLorentzVector & v2) {
+  //
+  //  Mandelstam t
+  //
   return TMath::Power(v1.T() - v2.T(), 2) - TMath::Power(v1.X() - v2.X(), 2) - 
     TMath::Power(v1.Y() - v2.Y(), 2) - TMath::Power(v1.Z() - v2.Z(), 2);
 }
 
+//___________________________________________________________________
 void ParticleAllocator::AddParticle(const Particle & p, List_t &list) {
+  //
+  // Add a particle to the list
+  //
   if(fFreeNodes.empty())
     list.push_back(p);
   else {
@@ -154,10 +209,18 @@ void ParticleAllocator::AddParticle(const Particle & p, List_t &list) {
   }
 }
 
+//___________________________________________________________________
 void ParticleAllocator::FreeListNode(List_t & list, LPIT_t it) {
+  //
+  // remove a particle from list
+  //
   fFreeNodes.splice(fFreeNodes.end(), list, it);      
 }
 
+//___________________________________________________________________
 void ParticleAllocator::FreeList(List_t & list) {
+  //
+  // free all list
+  //
   fFreeNodes.splice(fFreeNodes.end(), list);
 }
index 7a1d519..3e676e9 100644 (file)
@@ -1,25 +1,22 @@
-/*                                                                            
-                                                                            
-        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
-      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
-                           November. 2, 2005                                
+//                                                                            
+//                                                                            
+//        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
+//      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
+//                           November. 2, 2005                                
+//
+//
 
-*/
-
-#ifndef PARTICLE_INCLUDED
-#define PARTICLE_INCLUDED
+#ifndef PARTICLE_H
+#define PARTICLE_H
 
 #include <list>
+#include <iostream>
+using namespace std;
 
 #include <TLorentzRotation.h>
 #include <TLorentzVector.h>
 #include <TVector3.h>
-#ifndef PARTICLE_PDG
 #include "ParticlePDG.h"
-#endif
-#include <iostream>
-using namespace std;
-//class ParticlePDG;
 
 class Particle {
  public:
@@ -77,8 +74,8 @@ class Particle {
 
   Int_t Encoding() const;
   Double_t TableMass() const;
-  ParticlePDG *Def() const {return fParticleProperties;}
-  ParticlePDG *Def(ParticlePDG *newProp) {return fParticleProperties = newProp;}
+  ParticlePDG* Def() const {return fParticleProperties;}
+  void Def(ParticlePDG *newProp) {fParticleProperties = newProp;}
   //mother   
   void SetLastMotherPdg(Int_t value){fLastMotherPdg = value;}
   Int_t GetLastMotherPdg() const {return fLastMotherPdg;}
@@ -86,13 +83,13 @@ class Particle {
   // aic(2008/08/08): functions added in order to enable tracking of mother/daughter particles by a unique index
   // The index coincides with the position of the particle in the secondaries list.
   Int_t SetIndex() {
-    fIndex = ++fLastIndex; 
+    fIndex = ++fgLastIndex; 
     return fIndex;
   }
   Int_t GetIndex() const {return fIndex;}
-  static Int_t GetLastIndex() {return fLastIndex;}
+  static Int_t GetLastIndex() {return fgLastIndex;}
   static void InitIndexing() {
-    fLastIndex = -1;
+    fgLastIndex = -1;
   }
   void SetMother(Int_t value) {fMotherIndex = value;}
   Int_t GetMother() const {return fMotherIndex;}
@@ -101,12 +98,9 @@ class Particle {
   void SetPythiaStatusCode(Int_t code) {fPythiaStatusCode = code;}
   Int_t GetPythiaStatusCode() const {return fPythiaStatusCode;}
 
-  //  Int_t GetNDaughters() const {return fNDaughters;}
   Int_t GetNDaughters() const {
-    if(fFirstDaughterIndex==-1 || fLastDaughterIndex==-1) 
-      return 0;
-    else
-      return fLastDaughterIndex-fFirstDaughterIndex+1;
+    if(fFirstDaughterIndex==-1 || fLastDaughterIndex==-1) return 0;
+    else return fLastDaughterIndex-fFirstDaughterIndex+1;
   }
   Int_t GetFirstDaughterIndex() const {return fFirstDaughterIndex;}
   Int_t GetLastDaughterIndex() const {return fLastDaughterIndex;}
@@ -126,23 +120,23 @@ class Particle {
   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            fPythiaStatusCode;
-  Int_t            fLastMotherPdg;
-  Int_t            fType; //0-hydro, 1-jets
+  TLorentzVector   fPosition;               // 4-position vector
+  TLorentzVector   fMomentum;               // 4-momentum vector
+  TLorentzVector   fLastMotherDecayCoor;    // 4-position vector of mother 
+  TLorentzVector   fLastMotherDecayMom;     // 4-momentum vector of mother
+  ParticlePDG     *fParticleProperties;     // particle PDG properties
+  Double_t         fLastInteractionTime;    // last interaction time
+  Int_t            fInteractionNumber;      // interaction number
+  Int_t            fPythiaStatusCode;       // PYTHIA status code
+  Int_t            fLastMotherPdg;          // mother's PDG code
+  Int_t            fType;                   // particle type: 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            fFirstDaughterIndex;       // index for the first daughter particle (-1 if non-existing)
   Int_t            fLastDaughterIndex;        // index for the last daughter particle (-1 if non-existing)
   Bool_t           fDecayed;                  // true if the decay procedure already applied
-  static Int_t     fLastIndex;                // the last index assigned
+  static Int_t     fgLastIndex;                // the last index assigned
 };
 
 Double_t S(const TLorentzVector &, const TLorentzVector &);
@@ -159,7 +153,7 @@ class ParticleAllocator {
   void FreeList(List_t & list);
 
  private:
-  List_t fFreeNodes;
+  List_t fFreeNodes;          // list
 };
 
 #endif
index 2a82d42..c7cb2db 100644 (file)
@@ -1,23 +1,21 @@
-/*
-  Copyright   : The FASTMC and SPHMC Collaboration
-  Author      : Ionut Cristian Arsene 
-  Affiliation : Oslo University, Norway & Institute for Space Sciences, Bucharest, Romania
-  e-mail      : i.c.arsene@fys.uio.no
-  Date        : 2007/05/30
-
-  This class is using the particle and decay lists provided by the 
-  THERMINATOR (Computer Physics Communications 174 669 (2006)) and
-  SHARE (Computer Physics Communications 167 229 (2005)) collaborations.
-*/
-
-#ifndef PARTICLE_PDG
-#include "ParticlePDG.h"
-#endif
+//
+//  Copyright   : The FASTMC and SPHMC Collaboration
+//  Author      : Ionut Cristian Arsene 
+//  Affiliation : Oslo University, Norway & Institute for Space Sciences, Bucharest, Romania
+//  e-mail      : i.c.arsene@fys.uio.no
+//  Date        : 2007/05/30
+//
+//  This class is using the particle and decay lists provided by the 
+//  THERMINATOR (Computer Physics Communications 174 669 (2006)) and
+//  SHARE (Computer Physics Communications 167 229 (2005)) collaborations.
+//
 
 #include <iostream>
 using std::cout;
 using std::endl;
+#include "ParticlePDG.h"
 
+//________________________________________________________________________
 ParticlePDG::ParticlePDG() :
   fPDG(kNonsensePDG),
   fMass(-1.0),
@@ -34,10 +32,14 @@ ParticlePDG::ParticlePDG() :
   fNDecayChannels(0),
   fStable(0.0)
 {
+//
+// default constructor
+//
   for(Int_t i=0; i<kMaxDecayChannels; i++)
     fDecayChannels[i] = new DecayChannel();
 }
 
+//________________________________________________________________________
 ParticlePDG::ParticlePDG(const Char_t * const name, Int_t pdg, Double_t mass, Double_t width) :
   fPDG(pdg),
   fMass(mass),
@@ -54,6 +56,9 @@ ParticlePDG::ParticlePDG(const Char_t * const name, Int_t pdg, Double_t mass, Do
   fNDecayChannels(0),
   fStable(0.0)
 {
+  //
+  // constructor
+  //
   for(Int_t i=0; i<9; i++)
     if(*(name+i) != '\0') fName[i] = *(name+i);
     else break;
@@ -61,19 +66,31 @@ ParticlePDG::ParticlePDG(const Char_t * const name, Int_t pdg, Double_t mass, Do
     fDecayChannels[i] = new DecayChannel();
 }
 
+//________________________________________________________________________
 ParticlePDG::~ParticlePDG() {
+  //
+  // destructor
+  //
   for(Int_t i=0; i<kMaxDecayChannels; i++)
     delete fDecayChannels[i];
 }
 
+//________________________________________________________________________
 Double_t ParticlePDG::GetFullBranching() {
+  //
+  // calculate the sum of branching ratios from all decay channels (should add up to 1)
+  //
   Double_t fullBranching = 0.0;
   for(Int_t i=0; i<fNDecayChannels; i++)
     fullBranching += fDecayChannels[i]->GetBranching();
   return fullBranching;
 }
 
+//________________________________________________________________________
 void ParticlePDG::AddChannel(DecayChannel* channel) {
+  //
+  // add a decay channel
+  //
   if(channel->GetMotherPDG() != fPDG) {
     cout << "ERROR in ParticlePDG::AddChannel() : You try to add a channel which has a different mother PDG" << endl;
     return;
index 6c4350f..7ca4934 100644 (file)
@@ -1,23 +1,20 @@
+//
+//  Copyright   : The FASTMC and SPHMC Collaboration
+//  Author      : Ionut Cristian Arsene 
+//  Affiliation : Oslo University, Norway & Institute for Space Sciences, Bucharest, Romania
+//  e-mail      : i.c.arsene@fys.uio.no
+//  Date        : 2007/05/30
+//
+//  This class is using the particle and decay lists provided by the 
+//  THERMINATOR (Computer Physics Communications 174 669 (2006)) and
+//  SHARE (Computer Physics Communications 167 229 (2005)) collaborations.
+//
+
 #ifndef PARTICLEPDG_H
 #define PARTICLEPDG_H
-/*
-  Copyright   : The FASTMC and SPHMC Collaboration
-  Author      : Ionut Cristian Arsene 
-  Affiliation : Oslo University, Norway & Institute for Space Sciences, Bucharest, Romania
-  e-mail      : i.c.arsene@fys.uio.no
-  Date        : 2007/05/30
-
-  This class is using the particle and decay lists provided by the 
-  THERMINATOR (Computer Physics Communications 174 669 (2006)) and
-  SHARE (Computer Physics Communications 167 229 (2005)) collaborations.
-*/
-
 
-#include "Rtypes.h"
-
-#ifndef DECAY_CHANNEL
+#include <Rtypes.h>
 #include "DecayChannel.h"
-#endif
 
 const Int_t kMaxDecayChannels = 100;
 
@@ -72,20 +69,18 @@ class ParticlePDG {
 
   Double_t GetFullBranching();
   DecayChannel* GetDecayChannel(Int_t i) const {
-    if(0<=i && i<fNDecayChannels) 
-      return fDecayChannels[i];
-    else
-      return 0x0;
+    if(0<=i && i<fNDecayChannels) return fDecayChannels[i];
+    else return 0x0;
   }
 
  private:
   ParticlePDG(const ParticlePDG&);
   ParticlePDG& operator=(const ParticlePDG&);
 
-  Char_t        fName[9];
-  Int_t         fPDG;
-  Double_t      fMass;
-  Double_t      fWidth;
+  Char_t        fName[9];                      // particle name
+  Int_t         fPDG;                          // PDG code
+  Double_t      fMass;                         // mass
+  Double_t      fWidth;                        // width
   Double_t      fSpin;                         // J
   Double_t      fIsospin;                      // I
   Double_t      fIsospinZ;                     // I3
@@ -95,9 +90,9 @@ class ParticlePDG {
   Double_t      fAntiStrangeQuarkNumber;       // s- quark number
   Double_t      fCharmQuarkNumber;             // c quark number
   Double_t      fAntiCharmQuarkNumber;         // c- quark number
-  Int_t         fNDecayChannels;
+  Int_t         fNDecayChannels;               // number of decay channels
   Bool_t        fStable;                       // flag to turn on/off decay
-  DecayChannel* fDecayChannels[kMaxDecayChannels];   
+  DecayChannel* fDecayChannels[kMaxDecayChannels];   // array of decay channels
 };
 
 #endif
diff --git a/TUHKMgen/UHKM/ParticleTable.cxx b/TUHKMgen/UHKM/ParticleTable.cxx
deleted file mode 100644 (file)
index 06c3453..0000000
+++ /dev/null
@@ -1,407 +0,0 @@
-/*                                                                            
-                                                                            
-        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
-      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
-                           November. 2, 2005                                
-
-*/
-
-#include "ParticleTable.h"
-
-//This table is an additional table to describe the particle properties
-// that are missing in the ROOT pdg table
-//There are the particles and resonances from ROOT pdg-table.
-//Only wellknown and consisting of u,d,s quarks states are included.
-// 
-//code: Baryon number, Strangeness, 2*Isospin, 2*Spin, Charge 
-
-typedef std::pair<const Int_t, ParticleInfo> Part_t;
-
-const Part_t gTableInitializer[] = 
-  {
-    //     pdg                 B  S  2I 2Sp Ch         mass   width   name  
-    Part_t(10331, ParticleInfo(0, 0, 0, 0, 0)),   //   1.715, 0.125, f01710zer 
-    Part_t(3334,  ParticleInfo(1, -3, 0, 3, -1)), //   1.67245, 8.003e-16, UM1672min
-    Part_t(-3334, ParticleInfo(-1, 3, 0, 3, 1)),  //   1.67245, 8.003e-16, UM1672mnb
-    Part_t(3324,  ParticleInfo(1, -2, 1, 3, -1)), //   1.535, 0.0099, Xi1530min
-    Part_t(-3324, ParticleInfo(-1, 2, 1, 3, 1)),  //   1.535, 0.0099, Xi1530mnb
-    Part_t(3314,  ParticleInfo(1, -2, 1, 3, 0)),  //   1.5318, 0.0091, Xi1530zer
-    Part_t(-3314, ParticleInfo(-1, 2, 1, 3, 0)),  //   1.5318, 0.0091, Xi1530zrb
-    Part_t(335,   ParticleInfo(0, 0, 0, 4, 0)),   //   1.525, 0.076, f21525zer
-    Part_t(10211, ParticleInfo(0, 0, 2, 0, 1)),   //   1.474, 0.265, a01450plu
-    Part_t(-10211,ParticleInfo(0, 0, 2, 0, -1)),  //   1.474, 0.265, a01450min
-    Part_t(10111, ParticleInfo(0, 0, 2, 0, 0)),   //   1.474, 0.265, a01450zer
-    Part_t(20333, ParticleInfo(0, 0, 0, 2, 0)),   //   1.4263, 0.0555, f11420zer
-    Part_t(10311, ParticleInfo(0, 1, 1, 4, 0)),   //   1.4256, 0.0985, Ka1430zer
-    Part_t(-10311,ParticleInfo(0, -1, 1, 4, 0)),  //   1.4256, 0.0985, Ka1430zrb
-    Part_t(10321, ParticleInfo(0, 1, 1, 4, 1)),   //   1.4256, 0.0985, Ka1430plu
-    Part_t(-10321,ParticleInfo(0, -1, 1, 4, -1)), //   1.4256, 0.0985, Ka1430min
-    Part_t(20313, ParticleInfo(0, 1, 1, 2, 0)),   //   1.414, 0.232, Ka1410zer
-    Part_t(-20313,ParticleInfo(0, -1, 1, 2, 0)),  //   1.414, 0.232, Ka1410zrb
-    Part_t(20313, ParticleInfo(0, 1, 1, 2, 0)),   //   1.402, 0.174, Ka1400zer
-    Part_t(-20313,ParticleInfo(0, -1, 1, 2, 0)),  //   1.402, 0.174, Ka1400zrb
-    Part_t(20323, ParticleInfo(0, 1, 1, 2, 1)),   //   1.402, 0.174, Ka1400plu
-    Part_t(-20323,ParticleInfo(0, -1, 1, 2, -1)), //   1.402, 0.174, Ka1400min
-    Part_t(3114,  ParticleInfo(1, -1, 2, 3, -1)), //   1.3872, 0.0394, Sg1385min
-    Part_t(-3114, ParticleInfo(-1, 1, 2, 3, 1)),  //   1.3872, 0.0394, Sg1385mnb
-    Part_t(3214,  ParticleInfo(1, -1, 2, 3, 0)),  //   1.3837, 0.036, Sg1385zer
-    Part_t(-3214, ParticleInfo(-1, 1, 2, 3, 0)),  //   1.3837, 0.036, Sg1385zrb
-    Part_t(3224,  ParticleInfo(1, -1, 2, 3, 1)),  //   1.3828, 0.0358, Sg1385plu
-    Part_t(-3224, ParticleInfo(-1, 1, 2, 3, -1)), //   1.3828, 0.0358, Sg1385plb
-    Part_t(10221, ParticleInfo(0, 0, 0, 0, 0)),   //   1.35, 0.35, f01370zer
-    Part_t(3312,  ParticleInfo(1, -2, 1, 1, -1)), //   1.32131, 4.009e-16, Xi1321min
-    Part_t(-3312, ParticleInfo(-1, 2, 1, 1, 1)),  //   1.32131, 4.009e-16, Xi1321mnb
-    Part_t(3322,  ParticleInfo(1, -2, 1, 1, 0)),  //   1.31483, 2.265e-16, Xi1321zer
-    Part_t(-3322, ParticleInfo(-1, 2, 1, 1, 0)),  //   1.31483, 2.265e-16, Xi1321zrb
-    Part_t(215,   ParticleInfo(0, 0, 2, 4, 1)),   //   1.318, 0.107, a21320plu
-    Part_t(115,   ParticleInfo(0, 0, 2, 4, 0)),   //   1.318, 0.107, a21320zer
-    Part_t(20223, ParticleInfo(0, 0, 0, 2, 0)),   //   1.2819, 0.024, f11285zer
-    Part_t(225,   ParticleInfo(0, 0, 0, 4, 0)),   //   1.2754, 0.185, f21270zer
-    Part_t(10313, ParticleInfo(0, 1, 1, 2, 0)),   //   1.273, 0.09, Ka1270zer
-    Part_t(-10313,ParticleInfo(0, -1, 1, 2, 0)),  //   1.273, 0.09, Ka1270zrb
-    Part_t(10323, ParticleInfo(0, 1, 1, 2, 1)),   //   1.273, 0.09, Ka1270plu
-    Part_t(-10323,ParticleInfo(0, -1, 1, 2, -1)), //   1.273, 0.09, Ka1270min
-    Part_t(2224,  ParticleInfo(1, 0, 3, 3, 2)),   //   1.232, 0.12, Dl1232plp
-    Part_t(2214,  ParticleInfo(1, 0, 3, 3, 1)),   //   1.232, 0.12, Dl1232plu
-    Part_t(2114,  ParticleInfo(1, 0, 3, 3, 0)),   //   1.232, 0.12, Dl1232zer
-    Part_t(1114,  ParticleInfo(1, 0, 3, 3, -1)),  //   1.232, 0.12, Dl1232min
-    Part_t(-2224, ParticleInfo(-1, 0, 3, 3, -2)), //   1.232, 0.12, Dl1232ppb
-    Part_t(-2214, ParticleInfo(-1, 0, 3, 3, -1)), //   1.232, 0.12, Dl1232plb
-    Part_t(-2114, ParticleInfo(-1, 0, 3, 3, 0)),  //   1.232, 0.12, Dl1232zrb
-    Part_t(-1114, ParticleInfo(-1, 0, 3, 3, 1)),  //   1.232, 0.12, Dl1232mnb
-    Part_t(20213, ParticleInfo(0, 0, 2, 2, 1)),   //   1.23, 0.425, a11260plu
-    Part_t(-20213,ParticleInfo(0, 0, 2, 2, -1)),  //   1.23, 0.425, a11260min
-    Part_t(20113, ParticleInfo(0, 0, 2, 2, 0)),   //   1.23, 0.425, a11260zer
-    Part_t(10213, ParticleInfo(0, 0, 2, 2, 0)),   //   1.2295, 0.142, b11235zer
-    Part_t(3112,  ParticleInfo(1, -1, 2, 1, -1)), //   1.197, 4.442e-16, Sg1189min
-    Part_t(-3112, ParticleInfo(-1, 1, 2, 1, 1)),  //   1.197, 4.442e-16, Sg1189mnb
-    Part_t(3212,  ParticleInfo(1, -1, 2, 1, 0)),  //   1.193, 8.879e-07, Sg1192zer
-    Part_t(-3212, ParticleInfo(-1, 1, 2, 1, 0)),  //   1.193, 8.879e-07, Sg1192zrb
-    Part_t(3222,  ParticleInfo(1, -1, 2, 1, 1)),  //   1.189, 8.195e-16, Sg1189plu
-    Part_t(-3222, ParticleInfo(-1, 1, 2, 1, -1)), //   1.189, 8.195e-16, Sg1189plb
-    Part_t(10223, ParticleInfo(0, 0, 0, 2, 0)),   //   1.17, 0.36, h11170zer
-    Part_t(3122,  ParticleInfo(1, -1, 0, 1, 0)),  //   1.11568, 2.496e-16, Lm1115zer
-    Part_t(-3122, ParticleInfo(-1, 1, 0, 1, 0)),  //   1.11568, 2.496e-16, Lm1115zrb
-    Part_t(333,   ParticleInfo(0, 0, 0, 2, 0)),   //   1.01942, 0.004458, ph1020zer
-    Part_t(331,   ParticleInfo(0, 0, 0, 0, 0)),   //   0.95778, 0.000202, eta0prime
-    Part_t(2112,  ParticleInfo(1, 0, 1, 1, 0)),   //   0.939565, 0, ne0939zer
-    Part_t(-2112, ParticleInfo(-1, 0, 1, 1, 0)),  //   0.939565, 0, ne0939zrb
-    Part_t(2212,  ParticleInfo(1, 0, 1, 1, 1)),   //   0.938272, 0, pr0938plu
-    Part_t(-2212, ParticleInfo(-1, 0, 1, 1, -1)), //   0.938272, 0, pr0938plb
-    Part_t(313,   ParticleInfo(0, 1, 1, 2, 0)),   //   0.8961, 0.0507, Ka0892zer
-    Part_t(-313,  ParticleInfo(0, -1, 1, 2, 0)),  //   0.8961, 0.0507, Ka0892zrb
-    Part_t(323,   ParticleInfo(0, 1, 1, 2, 1)),   //   0.89166, 0.0508, Ka0892plu
-    Part_t(-323,  ParticleInfo(0, -1, 1, 2, -1)), //   0.89166, 0.0508, Ka0892min
-    Part_t(223,   ParticleInfo(0, 0, 0, 2, 0)),   //   0.78257, 0.00844, om0782zer
-    Part_t(213,   ParticleInfo(0, 0, 2, 2, 1)),   //   0.7693, 0.1502, rho770plu
-    Part_t(-213,  ParticleInfo(0, 0, 2, 2, -1)),  //   0.7693, 0.1502, rho770min
-    Part_t(113,   ParticleInfo(0, 0, 2, 2, 0)),   //   0.7693, 0.1502, rho770zer
-    Part_t(221,   ParticleInfo(0, 0, 0, 0, 0)),   //   0.5473, 1.29e-06, eta547zer
-    Part_t(311,   ParticleInfo(0, 1, 1, 0, 0)),   //   0.497672, 7.335e-16, Ka0492zer
-    Part_t(-311,  ParticleInfo(0, -1, 1, 0, 0)),  //   0.497672, 7.335e-16, Ka0492zrb
-    Part_t(321,   ParticleInfo(0, 1, 1, 0, 1)),   //   0.493677, 0, Ka0492plu
-    Part_t(-321,  ParticleInfo(0, -1, 1, 0, -1)), //   0.493677, 0, Ka0492min
-    Part_t(211,   ParticleInfo(0, 0, 2, 0, 1)),   //   0.13957, 0, pi0139plu
-    Part_t(-211,  ParticleInfo(0, 0, 2, 0, -1)),  //   0.13957, 0, pi0139min
-    Part_t(111,   ParticleInfo(0, 0, 2, 0, 0)),   //   0.134976, 0, pi0135zer
-    Part_t(22,    ParticleInfo(0, 0, 0, 2, 0)),   //   0.00, 0, gam000zer
-  };
-
-const std::map<const Int_t, ParticleInfo> gParticleTable(gTableInitializer,
-                                                        gTableInitializer + sizeof gTableInitializer / sizeof (Part_t));
-  
-
-//Part_t(443,  ParticleInfo(0, 0, 0, 2, 0)),// 3.09687, 0, jp3096zer
-//Part_t(1231, ParticleInfo(0, 0, 1, 0, 0)),// 1.8693, 0, Dc1800plu
-//Part_t(1232, ParticleInfo(0, 0, 1, 0, 0)),// 1.8693, 0, Dc1800min
-//Part_t(1233, ParticleInfo(0, 0, 1, 0, 0)), //1.8693, 0, Dc1800zer
-//Part_t(1234, ParticleInfo(0, 0, 1, 0, 0)), //1.8693, 0, Dc1800zrb
-//Part_t(4231, ParticleInfo(0, 0, 1, 0, 0)), //2.01, 0, Dc2010plu
-//Part_t(4232, ParticleInfo(0, 0, 1, 0, 0)), //2.0103, 0, Dc2010min
-//Part_t(4233, ParticleInfo(0, 0, 1, 0, 0)), //2.0103, 0, Dc2010zer
-//Part_t(4234, ParticleInfo(0, 0, 1, 0, 0)), //2.0103, 0, Dc2010zrb
-//Part_t(9401, ParticleInfo(1, 0, 1, 11, 1)),// 2.6, 0.65, Ns2600plu
-//Part_t(9400, ParticleInfo(1, 0, 1, 11, 0)), //2.6, 0.65, Ns2600zer
-//Part_t(-9401,ParticleInfo( -1, 0, 1, 11, -1)), //2.6, 0.65, Ns2600plb
-//Part_t(-9400,ParticleInfo( -1, 0, 1, 11, 0)),// 2.6, 0.65, Ns2600zrb
-//Part_t(9297, ParticleInfo(1, 0, 3, 11, 2)), //2.42, 0.4, Dl2420plp
-//Part_t(9298, ParticleInfo(1, 0, 3, 11, 1)), //2.42, 0.4, Dl2420plu
-//Part_t(9299, ParticleInfo(1, 0, 3, 11, 0)), //2.42, 0.4, Dl2420zer
-//Part_t(9300, ParticleInfo(1, 0, 3, 11, -1)), //2.42, 0.4, Dl2420min
-//Part_t(-9297,ParticleInfo( -1, 0, 3, 11, -2)), //2.42, 0.4, Dl2420ppb
-//Part_t(-9298,ParticleInfo( -1, 0, 3, 11, -1)), //2.42, 0.4, Dl2420plb
-//Part_t(-9299,ParticleInfo( -1, 0, 3, 11, 0)), //2.42, 0.4, Dl2420zrb
-//Part_t(-9300,ParticleInfo( -1, 0, 3, 11, 1)),// 2.42, 0.4, Dl2420mnb
-//Part_t(9001, ParticleInfo(1, -1, 0, 3, 0)), //2.35, 0.15, Lm2350zer
-//Part_t(-9001,ParticleInfo( -1, 1, 0, 3, 0)), //2.35, 0.15, Lm2350zrb
-//Part_t(40225,ParticleInfo( 0, 0, 0, 8, 0)), //2.339, 0.319, f42340zer
-//Part_t(30225,ParticleInfo( 0, 0, 0, 4, 0)), //2.297, 0.149, f22300zer
-//Part_t(9000, ParticleInfo(1, -3, 0, 3, -1)),// 2.252, 0.055, UM2250min
-//Part_t(-9000,ParticleInfo( -1, 3, 0, 3, 1)),// 2.252, 0.055, UM2250mnb
-//Part_t(5128, ParticleInfo(1, 0, 1, 9, 1)), //2.25, 0.4, Ns2250plu
-//Part_t(5218, ParticleInfo(1, 0, 1, 9, 0)), //2.25, 0.4, Ns2250zer
-//Part_t(-5128,ParticleInfo( -1, 0, 1, 9, -1)),// 2.25, 0.4, Ns2250plb
-//Part_t(-5218,ParticleInfo( -1, 0, 1, 9, 0)), //2.25, 0.4, Ns2250zrb
-//Part_t(4028, ParticleInfo(1, -1, 2, 3, 1)), //2.25, 0.1, Sg2250plu
-//Part_t(4128, ParticleInfo(1, -1, 2, 3, -1)), //2.25, 0.1, Sg2250min
-//Part_t(4228, ParticleInfo(1, -1, 2, 3, 0)), //2.25, 0.1, Sg2250zer
-//Part_t(-4028,ParticleInfo( -1, 1, 2, 3, -1)), //2.25, 0.1, Sg2250plb
-//Part_t(-4128,ParticleInfo( -1, 1, 2, 3, 1)), //2.25, 0.1, Sg2250mnb
-//Part_t(-4228,ParticleInfo( -1, 1, 2, 3, 0)), //2.25, 0.1, Sg2250zrb
-//Part_t(3128, ParticleInfo(1, 0, 1, 5, 1)),// 2.22, 0.4, Ns2220plu
-//Part_t(3218, ParticleInfo(1, 0, 1, 5, 0)),// 2.22, 0.4, Ns2220zer
-//Part_t(-3128,ParticleInfo( -1, 0, 1, 5, -1)),// 2.22, 0.4, Ns2220plb
-//Part_t(-3218,ParticleInfo( -1, 0, 1, 5, 0)),// 2.22, 0.4, Ns2220zrb
-//Part_t(1218, ParticleInfo(1, 0, 1, 7, 1)), //2.19, 0.45, Ns2190plu
-//Part_t(2128, ParticleInfo(1, 0, 1, 7, 0)), //2.19, 0.45, Ns2190zer
-//Part_t(-1218,ParticleInfo( -1, 0, 1, 7, -1)), //2.19, 0.45, Ns2190plb
-//Part_t(-2128,ParticleInfo( -1, 0, 1, 7, 0)), //2.19, 0.45, Ns2190zrb
-//Part_t(23126,ParticleInfo( 1, -1, 0, 3, 0)), //2.11, 0.2, Lm2110zer
-//Part_t(-23126,ParticleInfo( -1, 1, 0, 3, 0)), //2.11, 0.2, Lm2110zrb
-//Part_t(3128, ParticleInfo(1, -1, 0, 3, 0)), //2.1, 0.2, Lm2100zer
-//Part_t(-3128,ParticleInfo( -1, 1, 0, 3, 0)), //2.1, 0.2, Lm2100zrb
-//Part_t(329,  ParticleInfo( 0, 1, 1, 4, 1)), //2.045, 0.198, Ka2045plu
-//Part_t(-329, ParticleInfo(0, -1, 1, 4, -1)),// 2.045, 0.198, Ka2045min
-//Part_t(319,  ParticleInfo(0, 1, 1, 4, 0)),// 2.045, 0.198, Ka2045zer
-//Part_t(-319, ParticleInfo(0, -1, 1, 4, 0)),// 2.045, 0.198, Ka2045zrb
-//Part_t(229,  ParticleInfo(0, 0, 0, 8, 0)), //2.034, 0.222, f42050zer
-//Part_t(3118, ParticleInfo(1, -1, 2, 3, 1)),// 2.03, 0.18, Sg2030plu
-//Part_t(3218, ParticleInfo(1, -1, 2, 3, -1)),// 2.03, 0.18, Sg2030min
-//Part_t(3228, ParticleInfo(1, -1, 2, 3, 0)), //2.03, 0.18, Sg2030zer
-//Part_t(-3118,ParticleInfo( -1, 1, 2, 3, -1)), //2.03, 0.18, Sg2030plb
-//Part_t(-3218,ParticleInfo( -1, 1, 2, 3, 1)), //2.03, 0.18, Sg2030mnb
-//Part_t(-3228,ParticleInfo( -1, 1, 2, 3, 0)), //2.03, 0.18, Sg2030zrb
-//Part_t(8901, ParticleInfo(1, -2, 1, 5, -1)), //2.025, 0.02, Xi2030min
-//Part_t(8900, ParticleInfo(-1, 2, 1, 5, 1)), //2.025, 0.02, Xi2030mnb
-//Part_t(-8901,ParticleInfo( 1, -2, 1, 5, 0)), //2.025, 0.02, Xi2030zer
-//Part_t(-8900,ParticleInfo( -1, 2, 1, 5, 0)), //2.025, 0.02, Xi2030zrb
-//Part_t(219,  ParticleInfo(0, 0, 2, 8, 1)), //2.014, 0.361, a42040plu
-//Part_t(-219, ParticleInfo(0, 0, 2, 8, -1)), //2.014, 0.361, a42040min
-//Part_t(119,  ParticleInfo(0, 0, 2, 8, 0)), //2.014, 0.361, a42040zer
-//Part_t(20225,ParticleInfo( 0, 0, 0, 4, 0)), //2.011, 0.202, f22010zer
-//Part_t(1118, ParticleInfo(1, 0, 3, 7, 2)), //1.95, 0.3, Dl1950plp
-//Part_t(2118, ParticleInfo(1, 0, 3, 7, 1)), //1.95, 0.3, Dl1950plu
-//Part_t(2218, ParticleInfo(1, 0, 3, 7, 0)), //1.95, 0.3, Dl1950zer
-//Part_t(2228, ParticleInfo(1, 0, 3, 7, -1)),// 1.95, 0.3, Dl1950min
-//Part_t(-1118,ParticleInfo( -1, 0, 3, 7, -2)), //1.95, 0.3, Dl1950ppb
-//Part_t(-2118,ParticleInfo( -1, 0, 3, 7, -1)), //1.95, 0.3, Dl1950plb
-//Part_t(-2218,ParticleInfo( -1, 0, 3, 7, 0)), //1.95, 0.3, Dl1950zrb
-//Part_t(-2228,ParticleInfo( -1, 0, 3, 7, 1)), //1.95, 0.3, Dl1950mnb
-//Part_t(67001,ParticleInfo( 1, -2, 1, 3, -1)), //1.95, 0.06, Xi1950min
-//Part_t(-67001,ParticleInfo( -1, 2, 1, 3, 1)), //1.95, 0.06, Xi1950mnb
-//Part_t(67000,ParticleInfo(1, -2, 1, 3, 0)), //1.95, 0.06, Xi1950zer
-//Part_t(-67000,ParticleInfo( -1, 2, 1, 3, 0)), //1.95, 0.06, Xi1950zrb
-//Part_t(23114, ParticleInfo(1, -1, 2, 3, 1)), //1.94, 0.22, Sg1940plu
-//Part_t(23214, ParticleInfo(1, -1, 2, 3, -1)), //1.94, 0.22, Sg1940min
-//Part_t(23224, ParticleInfo(1, -1, 2, 3, 0)), //1.94, 0.22, Sg1940zer
-//Part_t(-23114,ParticleInfo( -1, 1, 2, 3, -1)), //1.94, 0.22, Sg1940plb
-//Part_t(-23214,ParticleInfo( -1, 1, 2, 3, 1)), //1.94, 0.22, Sg1940mnb
-//Part_t(-23224,ParticleInfo(-1, 1, 2, 3, 0)), //1.94, 0.22, Sg1940zrb
-//Part_t(11116, ParticleInfo(1, 0, 3, 5, 2)), //1.93, 0.35, Dl1930plp
-//Part_t(11216, ParticleInfo(1, 0, 3, 5, 1)), //1.93, 0.35, Dl1930plu
-//Part_t(12126, ParticleInfo(1, 0, 3, 5, 0)), //1.93, 0.35, Dl1930zer
-//Part_t(12226, ParticleInfo(1, 0, 3, 5, -1)), //1.93, 0.35, Dl1930min
-//Part_t(-11116,ParticleInfo( -1, 0, 3, 5, -2)),// 1.93, 0.35, Dl1930ppb
-//Part_t(-11216,ParticleInfo( -1, 0, 3, 5, -1)),// 1.93, 0.35, Dl1930plb
-//Part_t(-12126,ParticleInfo( -1, 0, 3, 5, 0)), //1.93, 0.35, Dl1930zrb
-//Part_t(-12226,ParticleInfo( -1, 0, 3, 5, 1)),// 1.93, 0.35, Dl1930mnb
-//Part_t(21114, ParticleInfo(1, 0, 3, 3, 2)), //1.92, 0.2, Dl1920plp
-//Part_t(22114, ParticleInfo(1, 0, 3, 3, 1)), //1.92, 0.2, Dl1920plu
-//Part_t(22214, ParticleInfo(1, 0, 3, 3, 0)), //1.92, 0.2, Dl1920zer
-//Part_t(22224, ParticleInfo(1, 0, 3, 3, -1)), //1.92, 0.2, Dl1920min
-//Part_t(-21114,ParticleInfo( -1, 0, 3, 3, -2)), //1.92, 0.2, Dl1920ppb
-//Part_t(-22114,ParticleInfo( -1, 0, 3, 3, -1)), //1.92, 0.2, Dl1920plb
-//Part_t(-22214,ParticleInfo( -1, 0, 3, 3, 0)), //1.92, 0.2, Dl1920zrb
-//Part_t(-22224,ParticleInfo( -1, 0, 3, 3, 1)), //1.92, 0.2, Dl1920mnb
-//Part_t(13116, ParticleInfo(1, -1, 2, 5, 1)), //1.915, 0.12, Sg1915plu
-//Part_t(13216, ParticleInfo(1, -1, 2, 5, -1)), //1.915, 0.12, Sg1915min
-//Part_t(13226, ParticleInfo(1, -1, 2, 5, 0)), //1.915, 0.12, Sg1915zer
-//Part_t(-13116,ParticleInfo( -1, 1, 2, 5, -1)), //1.915, 0.12, Sg1915plb
-//Part_t(-13216,ParticleInfo( -1, 1, 2, 5, 1)), //1.915, 0.12, Sg1915mnb
-//Part_t(-13226,ParticleInfo( -1, 1, 2, 5, 0)), //1.915, 0.12, Sg1915zrb
-//Part_t(21112, ParticleInfo(1, 0, 3, 1, 2)),// 1.91, 0.25, Dl1910plp
-//Part_t(21212, ParticleInfo(1, 0, 3, 1, 1)),// 1.91, 0.25, Dl1910plu
-//Part_t(22122, ParticleInfo(1, 0, 3, 1, 0)),// 1.91, 0.25, Dl1910zer
-//Part_t(22222, ParticleInfo(1, 0, 3, 1, -1)), //1.91, 0.25, Dl1910min
-//Part_t(-21112,ParticleInfo( -1, 0, 3, 1, -2)),// 1.91, 0.25, Dl1910ppb
-//Part_t(-21212,ParticleInfo( -1, 0, 3, 1, -1)), //1.91, 0.25, Dl1910plb
-//Part_t(-22122,ParticleInfo( -1, 0, 3, 1, 0)), //1.91, 0.25, Dl1910zrb
-//Part_t(-22222,ParticleInfo( -1, 0, 3, 1, 1)), //1.91, 0.25, Dl1910mnb
-//Part_t(1116,  ParticleInfo(1, 0, 3, 5, 2)), //1.905, 0.35, Dl1905plp
-//Part_t(1216,  ParticleInfo(1, 0, 3, 5, 1)), //1.905, 0.35, Dl1905plu
-//Part_t(2126,  ParticleInfo(1, 0, 3, 5, 0)), //1.905, 0.35, Dl1905zer
-//Part_t(2226,  ParticleInfo(1, 0, 3, 5, -1)), //1.905, 0.35, Dl1905min
-//Part_t(-1116, ParticleInfo(-1, 0, 3, 5, -2)),// 1.905, 0.35, Dl1905ppb
-//Part_t(-1216, ParticleInfo(-1, 0, 3, 5, -1)),// 1.905, 0.35, Dl1905plb
-//Part_t(-2126, ParticleInfo(-1, 0, 3, 5, 0)), //1.905, 0.35, Dl1905zrb
-//Part_t(-2226, ParticleInfo(-1, 0, 3, 5, 1)), //1.905, 0.35, Dl1905mnb
-//Part_t(23124, ParticleInfo(1, -1, 0, 3, 0)), //1.89, 0.1, Lm1890zer
-//Part_t(-23124,ParticleInfo( -1, 1, 0, 3, 0)),// 1.89, 0.1, Lm1890zrb
-//Part_t(-80000,ParticleInfo( 2, 0, 4, 0, 1)),// 1.87561, 0, de2000plb
-//Part_t(80000, ParticleInfo(2, 0, 4, 0, 1)), //1.87561, 0, de2000plu
-//Part_t(337,   ParticleInfo(0, 0, 0, 6, 0)), //1.854, 0.087, ph1850zer
-//Part_t(13126, ParticleInfo(1, -1, 0, 1, 0)), //1.83, 0.95, Lm1830zer
-//Part_t(-13126,ParticleInfo( -1, 1, 0, 1, 0)), //1.83, 0.95, Lm1830zrb
-//Part_t(13314, ParticleInfo(1, -2, 1, 3, -1)), //1.823, 0.024, Xi1820min
-//Part_t(13324, ParticleInfo(-1, 2, 1, 3, 1)), //1.823, 0.024, Xi1820mnb
-//Part_t(-13314,ParticleInfo( 1, -2, 1, 3, 0)), //1.823, 0.024, Xi1820zer
-//Part_t(-13324,ParticleInfo( -1, 2, 1, 3, 0)), //1.823, 0.024, Xi1820zrb
-//Part_t(3126,  ParticleInfo(1, -1, 0, 1, 0)), //1.82, 0.8, Lm1820zer
-//Part_t(-3126, ParticleInfo(-1, 1, 0, 1, 0)), //1.82, 0.8, Lm1820zrb
-//Part_t(20315, ParticleInfo(0, 1, 1, 4, 1)), //1.816, 0.276, Ka1820plu
-//Part_t(20325, ParticleInfo(0, -1, 1, 4, -1)), //1.816, 0.276, Ka1820min
-//Part_t(-20325,ParticleInfo( 0, 1, 1, 4, 0)), //1.816, 0.276, Ka1820zer
-//Part_t(-20315,ParticleInfo( 0, -1, 1, 4, 0)), //1.816, 0.276, Ka1820zrb
-//Part_t(53122, ParticleInfo(1, -1, 0, 1, 0)), //1.81, 0.15, Lm1810zer
-//Part_t(-53122,ParticleInfo( -1, 1, 0, 1, 0)),// 1.81, 0.15, Lm1810zrb
-//Part_t(200111,ParticleInfo( 0, 0, 2, 0, 1)), //1.801, 0.21, pi1800plu
-//Part_t(-200111,ParticleInfo( 0, 0, 2, 0, -1)),// 1.801, 0.21, pi1800min
-//Part_t(200211, ParticleInfo(0, 0, 2, 0, 0)), //1.801, 0.21, pi1800zer
-//Part_t(43122, ParticleInfo(1, -1, 0, 1, 0)), //1.8, 0.3, Lm1800zer
-//Part_t(-43122, ParticleInfo(-1, 1, 0, 1, 0)),// 1.8, 0.3, Lm1800zrb
-//Part_t(317,   ParticleInfo(0, 1, 1, 6, 0)), //1.776, 0.159, Ka1780zer
-//Part_t(327,   ParticleInfo(0, -1, 1, 6, 0)), //1.776, 0.159, Ka1780zrb
-//Part_t(-317,  ParticleInfo(0, 1, 1, 6, 1)), //1.776, 0.159, Ka1780plu
-//Part_t(-327,  ParticleInfo(0, -1, 1, 6, -1)),// 1.776, 0.159, Ka1780min
-//Part_t(3116,  ParticleInfo(1, -1, 2, 5, 1)), //1.775, 0.12, Sg1775plu
-//Part_t(3216,  ParticleInfo(1, -1, 2, 5, -1)),// 1.775, 0.12, Sg1775min
-//Part_t(3226,  ParticleInfo(1, -1, 2, 5, 0)), //1.775, 0.12, Sg1775zer
-//Part_t(-3116, ParticleInfo(-1, 1, 2, 5, -1)),// 1.775, 0.12, Sg1775plb
-//Part_t(-3216, ParticleInfo(-1, 1, 2, 5, 1)), //1.775, 0.12, Sg1775mnb
-//Part_t(-3226, ParticleInfo(-1, 1, 2, 5, 0)), //1.775, 0.12, Sg1775zrb
-//Part_t(8116,  ParticleInfo(1, -1, 2, 1, 1)), //1.75, 0.09, Sg1750plu
-//Part_t(8117,  ParticleInfo(1, -1, 2, 1, 0)), //1.75, 0.09, Sg1750zer
-//Part_t(8118,  ParticleInfo(1, -1, 2, 1, -1)), //1.75, 0.09, Sg1750min
-//Part_t(-8116, ParticleInfo(-1, 1, 2, 1, -1)), //1.75, 0.09, Sg1750plb
-//Part_t(-8117, ParticleInfo(-1, 1, 2, 1, 0)), //1.75, 0.09, Sg1750zrb
-//Part_t(-8118, ParticleInfo(-1, 1, 2, 1, 1)), //1.75, 0.09, Sg1750mnb
-//Part_t(10315, ParticleInfo(0, 1, 1, 4, 0)), //1.773, 0.186, Ka1770zer
-//Part_t(10325, ParticleInfo(0, -1, 1, 4, 0)),// 1.773, 0.186, Ka1770zrb
-//Part_t(-10315,ParticleInfo( 0, 1, 1, 4, 1)), //1.773, 0.186, Ka1770plu
-//Part_t(-10325,ParticleInfo( 0, -1, 1, 4, -1)),// 1.773, 0.186, Ka1770min
-//Part_t(31214, ParticleInfo(1, 0, 1, 3, 1)), //1.72, 0.15, Ns1720plu
-//Part_t(32124, ParticleInfo(1, 0, 1, 3, 0)), //1.72, 0.15, Ns1720zer
-//Part_t(-31214,ParticleInfo( -1, 0, 1, 3, -1)), //1.72, 0.15, Ns1720plb
-//Part_t(-32124,ParticleInfo( -1, 0, 1, 3, 0)), //1.72, 0.15, Ns1720zrb
-//Part_t(30313, ParticleInfo(0, 1, 1, 2, 0)), //1.717, 0.322, Ka1680zer
-//Part_t(30323, ParticleInfo(0, -1, 1, 2, 0)), //1.717, 0.322, Ka1680zrb
-//Part_t(-30313,ParticleInfo( 0, 1, 1, 2, 1)), //1.717, 0.322, Ka1680plu
-//Part_t(-30323,ParticleInfo( 0, -1, 1, 2, -1)),// 1.717, 0.322, Ka1680min
-//Part_t(42112, ParticleInfo(1, 0, 1, 1, 1)), //1.71, 0.1, Ns1710plu
-//Part_t(42212, ParticleInfo(1, 0, 1, 1, 0)), //1.71, 0.1, Ns1710zer
-//Part_t(-42112,ParticleInfo( -1, 0, 1, 1, -1)),// 1.71, 0.1, Ns1710plb
-//Part_t(-42212,ParticleInfo( -1, 0, 1, 1, 0)), //1.71, 0.1, Ns1710zrb
-//Part_t(21214, ParticleInfo(1, 0, 1, 3, 1)), //1.7, 0.1, Ns1700plu
-//Part_t(22124, ParticleInfo(1, 0, 1, 3, 0)),// 1.7, 0.1, Ns1700zer
-//Part_t(-21214,ParticleInfo( -1, 0, 1, 3, -1)),// 1.7, 0.1, Ns1700plb
-//Part_t(-22124,ParticleInfo( -1, 0, 1, 3, 0)),// 1.7, 0.1, Ns1700zrb
-//Part_t(30213, ParticleInfo(0, 0, 2, 2, 1)), //1.7, 0.24, rh1700plu
-//Part_t(-30213,ParticleInfo( 0, 0, 2, 2, -1)), //1.7, 0.24, rh1700min
-//Part_t(30113, ParticleInfo(0, 0, 2, 2, 0)), //1.7, 0.24, rh1700zer
-//Part_t(11114, ParticleInfo(1, 0, 3, 3, 2)), //1.7, 0.3, Dl1700plp
-//Part_t(12114, ParticleInfo(1, 0, 3, 3, 1)), //1.7, 0.3, Dl1700plu
-//Part_t(12214, ParticleInfo(1, 0, 3, 3, 0)), //1.7, 0.3, Dl1700zer
-//Part_t(12224, ParticleInfo(1, 0, 3, 3, -1)), //1.7, 0.3, Dl1700min
-//Part_t(-11114,ParticleInfo( -1, 0, 3, 3, -2)), //1.7, 0.3, Dl1700ppb
-//Part_t(-12114,ParticleInfo( -1, 0, 3, 3, -1)), //1.7, 0.3, Dl1700plb
-//Part_t(-12214,ParticleInfo( -1, 0, 3, 3, 0)), //1.7, 0.3, Dl1700zrb
-//Part_t(-12224,ParticleInfo( -1, 0, 3, 3, 1)), //1.7, 0.3, Dl1700mnb
-//Part_t(217,   ParticleInfo(0, 0, 2, 6, 1)), //1.691, 0.161, rh1690plu
-//Part_t(-217,  ParticleInfo(0, 0, 2, 6, -1)), //1.691, 0.161, rh1690min
-//Part_t(117,   ParticleInfo(0, 0, 2, 0, 0)), //1.691, 0.161, rh1690zer
-//Part_t(13124, ParticleInfo(1, -1, 0, 3, 0)), //1.69, 0.06, Lm1690zer
-//Part_t(-13124,ParticleInfo( -1, 1, 0, 3, 0)), //1.69, 0.06, Lm1690zrb
-//Part_t(-67719,ParticleInfo(1, -2, 1, 3, -1)), //1.69, 0.029, Xi1690min
-//Part_t(67719, ParticleInfo(-1, 2, 1, 3, 1)), //1.69, 0.029, Xi1690mnb
-//Part_t(67718, ParticleInfo(1, -2, 1, 3, 0)), //1.69, 0.029, Xi1690zer
-//Part_t(-67718,ParticleInfo(-1, 2, 1, 3, 0)), //1.69, 0.029, Xi1690zrb
-//Part_t(12116, ParticleInfo(1, 0, 1, 5, 1)), //1.68, 0.13, Ns1680plu
-//Part_t(12216, ParticleInfo(1, 0, 1, 5, 0)), //1.68, 0.13, Ns1680zer
-//Part_t(-12116,ParticleInfo( -1, 0, 1, 5, -1)),// 1.68, 0.13, Ns1680plb
-//Part_t(-12216,ParticleInfo( -1, 0, 1, 5, 0)), //1.68, 0.13, Ns1680zrb
-//Part_t(100333,ParticleInfo( 0, 0, 0, 2, 0)), //1.68, 0.15, ph1680zer
-//Part_t(2116,  ParticleInfo(1, 0, 1, 5, 1)), //1.675, 0.15, Ns1675plu
-//Part_t(2216,  ParticleInfo(1, 0, 1, 5, 0)), //1.675, 0.15, Ns1675zer
-//Part_t(-2116, ParticleInfo(-1, 0, 1, 5, -1)), //1.675, 0.15, Ns1675plb
-//Part_t(-2216, ParticleInfo(-1, 0, 1, 5, 0)), //1.675, 0.15, Ns1675zrb
-//Part_t(10215, ParticleInfo(0, 0, 2, 4, 1)), //1.67, 0.259, pi1670plu
-//Part_t(-10215,ParticleInfo( 0, 0, 2, 4, -1)), //1.67, 0.259, pi1670min
-//Part_t(10115, ParticleInfo(0, 0, 2, 4, 0)), //1.67, 0.259, pi1670zer
-//Part_t(33122, ParticleInfo(1, -1, 0, 1, 0)), //1.67, 0.035, Lm1670zer
-//Part_t(-33122,ParticleInfo( -1, 1, 0, 1, 0)), //1.67, 0.035, Lm1670zrb
-//Part_t(13114, ParticleInfo(1, -1, 2, 3, 1)), //1.67, 0.06, Sg1670plu
-//Part_t(13214, ParticleInfo(1, -1, 2, 3, -1)),// 1.67, 0.06, Sg1670min
-//Part_t(13224, ParticleInfo(1, -1, 2, 3, 0)), //1.67, 0.06, Sg1670zer
-//Part_t(-13114,ParticleInfo( -1, 1, 2, 3, -1)), //1.67, 0.06, Sg1670plb
-//Part_t(-13214,ParticleInfo( -1, 1, 2, 3, 1)), //1.67, 0.06, Sg1670mnb
-//Part_t(-13224,ParticleInfo( -1, 1, 2, 3, 0)), //1.67, 0.06, Sg1670zrb
-//Part_t(227,   ParticleInfo( 0, 0, 0, 6, 0)), //1.667, 0.168, om1670zer
-//Part_t(13112, ParticleInfo(1, -1, 2, 1, 1)), //1.66, 0.1, Sg1660plu
-//Part_t(13212, ParticleInfo(1, -1, 2, 1, -1)), //1.66, 0.1, Sg1660min
-//Part_t(13222, ParticleInfo(1, -1, 2, 1, 0)), //1.66, 0.1, Sg1660zer
-//Part_t(-13112,ParticleInfo( -1, 1, 2, 1, -1)),// 1.66, 0.1, Sg1660plb
-//Part_t(-13212,ParticleInfo( -1, 1, 2, 1, 1)),// 1.66, 0.1, Sg1660mnb
-//Part_t(-13222,ParticleInfo( -1, 1, 2, 1, 0)),// 1.66, 0.1, Sg1660zrb
-//Part_t(32112, ParticleInfo(1, 0, 1, 1, 1)), //1.65, 0.15, Ns1650plu
-//Part_t(32212, ParticleInfo(1, 0, 1, 1, 0)), //1.65, 0.15, Ns1650zer
-//Part_t(-32112,ParticleInfo( -1, 0, 1, 1, -1)),// 1.65, 0.15, Ns1650plb
-//Part_t(-32212,ParticleInfo( -1, 0, 1, 1, 0)),// 1.65, 0.15, Ns1650zrb
-//Part_t(30223, ParticleInfo(0, 0, 0, 2, 0)), //1.649, 0.22, om1650zer
-//Part_t(1112,  ParticleInfo(1, 0, 3, 1, 2)), //1.62, 0.15, Dl1620plp
-//Part_t(1212,  ParticleInfo(1, 0, 3, 1, 1)), //1.62, 0.15, Dl1620plu
-//Part_t(2122,  ParticleInfo(1, 0, 3, 1, 0)), //1.62, 0.15, Dl1620zer
-//Part_t(2222,  ParticleInfo(1, 0, 3, 1, -1)), //1.62, 0.15, Dl1620min
-//Part_t(-1112, ParticleInfo(-1, 0, 3, 1, -2)),// 1.62, 0.15, Dl1620ppb
-//Part_t(-1212, ParticleInfo(-1, 0, 3, 1, -1)),// 1.62, 0.15, Dl1620plb
-//Part_t(-2122, ParticleInfo(-1, 0, 3, 1, 0)), //1.62, 0.15, Dl1620zrb
-//Part_t(-2222, ParticleInfo(-1, 0, 3, 1, 1)), //1.62, 0.15, Dl1620mnb
-//Part_t(46653, ParticleInfo(1, -2, 1, 3, -1)), //1.62, 0.03, Xi1620min
-//Part_t(-46653,ParticleInfo( -1, 2, 1, 3, 1)), //1.62, 0.03, Xi1620mnb
-//Part_t(45553, ParticleInfo(1, -2, 1, 3, 0)), //1.62, 0.03, Xi1620zer
-//Part_t(-45553,ParticleInfo( -1, 2, 1, 3, 0)),// 1.62, 0.03, Xi1620zrb
-//Part_t(31114, ParticleInfo(1, 0, 3, 3, 2)), //1.6, 0.35, Dl1600plp
-//Part_t(32114, ParticleInfo(1, 0, 3, 3, 1)), //1.6, 0.35, Dl1600plu
-//Part_t(32214, ParticleInfo(1, 0, 3, 3, 0)), //1.6, 0.35, Dl1600zer
-//Part_t(32224, ParticleInfo(1, 0, 3, 3, -1)), //1.6, 0.35, Dl1600min
-//Part_t(-31114,ParticleInfo( -1, 0, 3, 3, -2)), //1.6, 0.35, Dl1600ppb
-//Part_t(-32114,ParticleInfo( -1, 0, 3, 3, -1)), //1.6, 0.35, Dl1600plb
-//Part_t(-32214,ParticleInfo( -1, 0, 3, 3, 0)), //1.6, 0.35, Dl1600zrb
-//Part_t(-32224,ParticleInfo( -1, 0, 3, 3, 1)), //1.6, 0.35, Dl1600mnb
-//Part_t(23122, ParticleInfo(1, -1, 0, 1, 0)), //1.6, 0.15, Lm1600zer
-//Part_t(-23122,ParticleInfo( -1, 1, 0, 1, 0)),// 1.6, 0.15, Lm1600zrb
-//Part_t(22212, ParticleInfo(1, 0, 1, 1, 1)), //1.535, 0.15, Ns1535plu
-//Part_t(22122, ParticleInfo(1, 0, 1, 1, 0)), //1.535, 0.15, Ns1535zer
-//Part_t(-22212,ParticleInfo( -1, 0, 1, 1, -1)), //1.535, 0.15, Ns1535plb
-//Part_t(-22122,ParticleInfo( -1, 0, 1, 1, 0)), //1.535, 0.15, Ns1535zrb
-//Part_t(2124,  ParticleInfo(1, 0, 1, 3, 1)), //1.52, 0.12, Ns1520plu
-//Part_t(1214,  ParticleInfo(1, 0, 1, 3, 0)), //1.52, 0.12, Ns1520zer
-//Part_t(-2124, ParticleInfo(-1, 0, 1, 3, -1)),// 1.52, 0.12, Ns1520plb
-//Part_t(-1214, ParticleInfo(-1, 0, 1, 3, 0)), //1.52, 0.12, Ns1520zrb
-//Part_t(3124,  ParticleInfo(1, -1, 0, 3, 0)), //1.5195, 0.0156, Lm1520zer
-//Part_t(-3124, ParticleInfo(-1, 1, 0, 3, 0)), //1.5195, 0.0156, Lm1520zrb
-//Part_t(9000223,ParticleInfo( 0, 0, 0, 0, 0)), //1.507, 0.112, f01500zer
-//Part_t(100213,ParticleInfo( 0, 0, 2, 2, 1)),// 1.465, 0.31, rh1450plu
-//Part_t(-100213,ParticleInfo( 0, 0, 2, 2, -1)), //1.465, 0.31, rh1450min
-//Part_t(100113, ParticleInfo(0, 0, 2, 2, 0)), //1.465, 0.31, rh1450zer
-//Part_t(12212, ParticleInfo(1, 0, 1, 1, 1)), //1.44, 0.35, Ns1440plu
-//Part_t(12112, ParticleInfo(1, 0, 1, 1, 0)), //1.44, 0.35, Ns1440zer
-//Part_t(-12212,ParticleInfo( -1, 0, 1, 1, -1)),// 1.44, 0.35, Ns1440plb
-//Part_t(-12112,ParticleInfo( -1, 0, 1, 1, 0)),// 1.44, 0.35, Ns1440zrb
-//Part_t(100331,ParticleInfo( 0, 0, 0, 0, 0)), //1.435, 0.065, et1440zer
-//Part_t(100223,ParticleInfo( 0, 0, 0, 2, 0)), //1.419, 0.174, om1420zer
-//Part_t(100323,ParticleInfo( 0, 1, 1, 2, 1)), //1.414, 0.232, Ka1410plu
-//Part_t(-100323,ParticleInfo( 0, -1, 1, 2, -1)), //1.414, 0.232, Ka1410min
-//Part_t(100313, ParticleInfo(0, 1, 1, 0, 0)), //1.412, 0.294, Ka1412zer
-//Part_t(-100313, ParticleInfo(0, -1, 1, 0, 0)), //1.412, 0.294, Ka1412zrb
-//Part_t(13122, ParticleInfo(1, -1, 0, 1, 0)), //1.406, 0.05, Lm1405zer
-//Part_t(-13122,ParticleInfo(-1, 1, 0, 1, 0)), //1.406, 0.05, Lm1405zrb
-//Part_t(100211, ParticleInfo(0, 0, 2, 0, 1)),// 1.3, 0.4, pi1300plu
-//Part_t(-100211, ParticleInfo(0, 0, 2, 0, -1)), //1.3, 0.4, pi1300min
-//Part_t(100111, ParticleInfo(0, 0, 2, 0, 0)), //1.3, 0.4, pi1300zer
-//Part_t(100221, ParticleInfo(0, 0, 0, 0, 0)), //1.297, 0.053, et1295zer
-//Part_t(9000211, ParticleInfo(0, 0, 2, 0, 1)), //0.9848, 0.075, a00980plu
-//Part_t(-9000211, ParticleInfo(0, 0, 2, 0, -1)),// 0.9848, 0.075, a00980min
-//Part_t(9000111, ParticleInfo(0, 0, 2, 0, 0)),// 0.9848, 0.075, a00980zer
-//Part_t(9010221, ParticleInfo(0, 0, 0, 0, 0)),// 0.98, 0.1, f00980zer
-//Part_t(9000221, ParticleInfo(0, 0, 0, 0, 0)), //0.8, 0.8, f00600zer
-
diff --git a/TUHKMgen/UHKM/ParticleTable.h b/TUHKMgen/UHKM/ParticleTable.h
deleted file mode 100644 (file)
index fafa3c2..0000000
+++ /dev/null
@@ -1,35 +0,0 @@
-#ifndef PARTICLETABLE_INCLUDED
-#define PARTICLETABLE_INCLUDED
-
-/*                                                                            
-                                                                            
-        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
-      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
-                           November. 2, 2005                                
-
-*/
-
-#include <map>
-
-#include <Rtypes.h>
-
-struct ParticleInfo {
-  Int_t fBaryonNumber;
-  Int_t fStrangeness;
-  Int_t fIsospin;
-  Int_t fSpin;
-  Int_t fCharge;
-
-  ParticleInfo(Int_t bN, Int_t s, Int_t s1, Int_t s2, Int_t c) {
-    fBaryonNumber = bN;
-    fStrangeness = s;
-    fIsospin = s1; //2S
-    fSpin = s2; //2I
-    fCharge = c; //fCharge = 2 * I3
-  }
-};
-
-extern const std::map<const Int_t, ParticleInfo> gParticleTable;
-typedef std::map<const Int_t, ParticleInfo>::const_iterator MapIt_t;
-
-#endif
index 8e325b9..86fb32f 100644 (file)
@@ -1,14 +1,14 @@
-#include <TError.h>
+//                                                                            
+//                                                                            
+//        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
+//      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
+//                           November. 2, 2005                                
+//
+//
+//      This class is taken from the GEANT4 tool kit  and changed!!!!!
 
+#include <TError.h>
 #include "RandArrayFunction.h"
-/*                                                                            
-                                                                            
-        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
-      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
-                           November. 2, 2005                                
-
-*/
-//This class is taken from the GEANT4 tool kit  and changed!!!!!
 
 
 RandArrayFunction::RandArrayFunction(const Double_t *aProbFunc, Int_t theProbSize, Int_t intType):
index 61cfe27..c766253 100644 (file)
@@ -1,9 +1,3 @@
-#ifndef RANDARRAYFUNCTION_INCLUDED
-#define RANDARRAYFUNCTION_INCLUDED
-
-#include <vector>
-
-#include <TRandom.h>
 /*                                                                            
                                                                             
         Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
 
 //========================================================================================
 
+#ifndef RANDARRAYFUNCTION_H
+#define RANDARRAYFUNCTION_H
+
+#include <vector>
+#include <TRandom.h>
+
 class RandArrayFunction {
  public:
   RandArrayFunction(const Double_t *aProbFunc, Int_t theProbSize, Int_t interpolationType = 0);
@@ -86,10 +86,10 @@ class RandArrayFunction {
   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;
+  std::vector<Double_t> fIntegralPdf;         //
+  Int_t                 fNBins;               //
+  Double_t              fOneOverNbins;        //
+  Int_t                 fInterpolationType;   //
 
 };
 
diff --git a/TUHKMgen/UHKM/RunHadronSource.cxx b/TUHKMgen/UHKM/RunHadronSource.cxx
deleted file mode 100644 (file)
index 4a5170a..0000000
+++ /dev/null
@@ -1,357 +0,0 @@
-/*******************************************************************************
- *                                                                             *
- *    HYDJET++ , event generator under the ROOT FRAMEWORK for simulation of    *
- *    relativistic heavy ion AA collisions as the superposition of soft,       *
- *    hydro-type state and hard, multi-parton state.                           *
- *                                                                             *
- *     The main routine is written in the object-oriented C++ language         *        
- *     under the ROOT environment. The hard, multi-partonic part of            *  
- *     HYDJET++ event is identical to the hard part of Fortran-written         *
- *     HYDJET (PYTHIA6.4xx + PYQUEN1.5) and is included in the generator       *
- *     structure as the separate directory. The soft part of HYDJET++          * 
- *     event represents the "thermal" hadronic state obtained with the         *
- *     parameterization Bjorken-like of freeze-out hypersurface and            *
- *     includes longitudinal, radial and elliptic flow effects and             *
- *     decays of hadronic resonances. The corresponding fast                   * 
- *     Monte-Carlo simulation procedure (C++ code) FAST MC is adapted.         *
- * --------------------------------------------------------------              *
- *     Web-page:                                                               *
- *    http://cern.ch/lokhtin/hydjet++                                          *   
- *     --------------------------------------------------------------          *  
- *                                                                             *                                                                             *
- *                                                                             *
- * This program is a free software; you can use and redistribute it freely.    *  
- * Any publication of results obtained using this code must reference          * 
- *                                                                             *
- *                                                                             * 
- *                                                                             *
- *      Main reference for HYDJET++:                                           *
- *     I.P. Lokhtin, L.V. Malinina, S.V. Petrushanko, A.M. Snigirev,           *
- *     I. Arsene, K. Tywoniuk, submitted to Comp. Phys. Comm.                  *
- *                                                                             * 
- *     Reference for HYDJET and PYQUEN:                                        *
- *     I.P. Lokhtin, A.M. Snigirev, Eur. Phys. J. C 46 (2006) 211;             *
- *     http://cern.ch/lokhtin/hydro/hydjet.html                                * 
- *     http://cern.ch/lokhtin/pyquen.                                          *  
- *                                                                             *    
- *     Reference for PYTHIA6.4:                                                *
- *     T.Sjostrand, S. Mrenna and P. Skands, JHEP05 (2006) 026;                *
- *     http://home.thep.lu.se/~torbjorn/Pythia.html.                           * 
- *                                                                             * 
- *     References for FAST MC:                                                 *  
- *     N.S. Amelin, R. Lednicky, T.A. Pocheptsov, I.P. Lokhtin,                * 
- *     L.V. Malinina, A.M. Snigirev, Iu.A. Karpenko and Yu.M. Sinyukov,        * 
- *     Phys. Rev. C 74 (2006) 064901;                                          *
- *     N.S. Amelin, I. Arsene, L. Bravina, Iu.A. Karpenko, R. Lednicky,        *  
- *     I.P. Lokhtin, L.V. Malinina, A.M. Snigirev and Yu.M. Sinyukov,          *  
- *     Phys. Rev. C 77 (2008) 014903;                                          *
- *     http://uhkm.jinr.ru.                                                    *   
- *                                                                             *
- *     Reference for nuclear shadowing model:                                  *
- *     K. Tywoniuk, I.C. Arsene, L. Bravina, A. Kaidalov and                   *
- *     E. Zabrodin, Phys. Lett. B 657 (2007) 170.                              *
- *                                                                             * 
- *       version 2.0:                                                          *
- *                                                                             *
- *     Igor Lokhtin, SINP MSU, Moscow, RU                                      *
- *     e-mail: Igor.Lokhtin@cern.ch                                            *
- *                                                                             *
- *     Ludmila Malinina, SINP MSU, Moscow, RU                                  *   
- *     e-mail: malinina@lav01.sinp.msu.ru                                      * 
- *                                                                             *
- *******************************************************************************/ 
-
-#include <iostream> 
-#include <fstream>
-#include <vector>
-#include <time.h>
-
-#include <TNtuple.h>
-#include <TError.h>
-#include <TTree.h>
-#include <TFile.h>
-
-#include "InitialState.h"
-#include "InitialStateHydjet.h"
-
-#include <TRandom.h>
-#include "Particle.h"
-
-
-#include "HYJET_COMMONS.h"
-extern HYIPARCommon HYIPAR;
-extern HYFPARCommon HYFPAR;
-extern HYJPARCommon HYJPAR;
-extern HYPARTCommon HYPART;
-extern SERVICECommon SERVICE;
-
-
-//Main program:
-//reads input parameters from file "RunInputHydjet" ;
-//calculates particle densities and average initial multiplicities and writes them
-//in output file "multiplicities.txt";
-//creates trees (tree with direct hadrons and hadrons after resonance decays)
-//with space-time and momentum-energy information of produced hadrons;
-//writes trees in file "RunOutput.root".
-
-
-int main()
-
-{
-
-  clock_t start;
-  start = clock();
-//new
-  time_t  now;
-  struct tm  *ts;
-  char       buf[80];
-         
- // Get the current time
-   time(&now);
-              
- // Format and print the time, "ddd yyyy-mm-dd hh:mm:ss zzz"
-    ts = localtime(&now);
-    strftime(buf, sizeof(buf), "%a %Y-%m-%d %H:%M:%S %Z", ts);
-    printf("%s\n", buf);
-                                    
-  TFile *outputFile=new TFile("RunOutput.root", "RECREATE"); 
-
-  //SET MAXIMAl VALUE OF PARTICLE MULTIPLICITY!!!
-  const Int_t kMax = 500000; 
-  Int_t npart;
-  //define event number
-  Int_t nev;
-
-//define event characteristics: 
-//total event multiplicity, number of produced hadrons in hard part/soft part
-  Int_t Ntot, Npyt, Nhyd;
-
-// number of jets, number of binary collisions, number of participants :
-  Int_t Njet, Nbcol, Npart;
-  
- //impact parameter 
-  Float_t Bgen, Sigin, Sigjet;
-  //define hadron characteristic vectors
-  std::vector<Int_t> pdg(kMax); //pdg encodings
-  std::vector<Int_t> Mpdg(kMax);//pdg encodings for mother hadrons
-  std::vector<Int_t> type(kMax);//type of particle: 0-from hydro or decays, 1111 -from jets
-  std::vector<Float_t> Px(kMax);//x-hadron momentum component,[GeV/c]
-  std::vector<Float_t> Py(kMax);//y-hadron momentum component,[GeV/c]
-  std::vector<Float_t> Pz(kMax);//z-hadron momentum component,[GeV/c]
-  std::vector<Float_t> E(kMax); //hadron total energy,[GeV]  
-  std::vector<Float_t> X(kMax);//x-hadron coordinate component,[fm]
-  std::vector<Float_t> Y(kMax);//y-hadron coordinate component,[fm]
-  std::vector<Float_t> Z(kMax);//z-hadron coordinate component,[fm]
-  std::vector<Float_t> T(kMax);//hadron time,[fm/c] 
-   
-   
-   
-  TTree *ti=new TTree("ti","Initial");
-
-  ti->Branch("nev",&nev,"nev/I");
-  ti->Branch("Bgen",&Bgen,"Bgen/F");
-  ti->Branch("Sigin",&Sigin,"Sigin/F");
-  ti->Branch("Sigjet",&Sigjet,"Sigjet/F");
-  ti->Branch("Ntot",&Ntot,"Ntot/I");
-  ti->Branch("Nhyd",&Nhyd,"Nhyd/I");
-  ti->Branch("Npyt",&Npyt,"Npyt/I");
-  ti->Branch("Njet",&Njet,"Njet/I");  
-  ti->Branch("Nbcol",&Nbcol,"Nbcol/I");
-  ti->Branch("Npart",&Npart,"Npart/I");
-  ti->Branch("Px",&Px[0],"Px[Ntot]/F");
-  ti->Branch("Py",&Py[0],"Py[Ntot]/F");
-  ti->Branch("Pz",&Pz[0],"Pz[Ntot]/F");
-  ti->Branch("E",&E[0],"E[Ntot]/F");  
-  ti->Branch("X",&X[0],"X[Ntot]/F");
-  ti->Branch("Y",&Y[0],"Y[Ntot]/F");
-  ti->Branch("Z",&Z[0],"Z[Ntot]/F");
-  ti->Branch("T",&T[0],"T[Ntot]/F");
-  ti->Branch("pdg",&pdg[0],"pdg[Ntot]/I");
-  ti->Branch("Mpdg",&Mpdg[0],"Mpdg[Ntot]/I");
-
-  TTree *td=new TTree("td","After decays");
-  td->Branch("nev",&nev,"nev/I");
-  td->Branch("Bgen",&Bgen,"Bgen/F");
-  td->Branch("Sigin",&Sigin,"Sigin/F");
-  td->Branch("Sigjet",&Sigjet,"Sigjet/F");
-  td->Branch("Ntot",&Ntot,"Ntot/I");
-  td->Branch("Nhyd",&Nhyd,"Nhyd/I");
-  td->Branch("Npyt",&Npyt,"Npyt/I");
-  td->Branch("Njet",&Njet,"Njet/I");  
-  td->Branch("Nbcol",&Nbcol,"Nbcol/I");
-  td->Branch("Npart",&Npart,"Npart/I");
-  td->Branch("Px",&Px[0],"Px[Ntot]/F");
-  td->Branch("Py",&Py[0],"Py[Ntot]/F");
-  td->Branch("Pz",&Pz[0],"Pz[Ntot]/F");
-  td->Branch("E",&E[0],"E[Ntot]/F");  
-  td->Branch("X",&X[0],"X[Ntot]/F");
-  td->Branch("Y",&Y[0],"Y[Ntot]/F");
-  td->Branch("Z",&Z[0],"Z[Ntot]/F");
-  td->Branch("T",&T[0],"T[Ntot]/F");
-  td->Branch("pdg",&pdg[0],"pdg[Ntot]/I");
-  td->Branch("Mpdg",&Mpdg[0],"Mpdg[Ntot]/I");
-  td->Branch("type",&type[0],"type[Ntot]/I");
-  
-  
-  InitialState *FASTMC;
-    FASTMC = new InitialStateHydjet();
-   
-  if(!FASTMC->ReadParams()) {
-    Error("RunHadronSource::main", "No initial model parameters found!!\n");
-    return 0;
-  }
-  if(!FASTMC->MultIni()) {
-    Error("RunHadronSource::main", "Initial multiplicities are zero!!\n");
-    return 0;
-  }
-
-  ParticleAllocator allocator;
-  List_t source;
-  List_t secondaries;
-  std::cout << "Generating " << FASTMC->GetNev() << " events" << std::endl;
-  std::cout << "Starting the event loop" << std::endl;
-    
-  // Set Random Number seed 
-  Int_t sseed =0;               //Set 0 to use the current time 
-  gRandom->SetSeed(sseed); 
-  std::cout<<"Seed for random number generation= "<<gRandom->GetSeed()<<std::endl;  
-  
-  // Loop over events  
-  for(Int_t ev = 0; ev < FASTMC->GetNev(); ++ev) {
-    nev = ev;
-    // Initialize the source
-    FASTMC->Initialize(source, allocator);
-
-      Npart = HYFPAR.npart;      
-      Bgen = HYFPAR.bgen;
-      Njet = HYJPAR.njet;
-      Nbcol = HYFPAR.nbcol;
-      if(ev==0) { 
-            Sigin=HYJPAR.sigin;
-            Sigjet=HYJPAR.sigjet;
-         }
-     std::cout<<"in RunHadronSource: ev"<<ev<<" Njet "<<Njet<<" Nbcol "<<Nbcol<<" Npart "<<Npart<<std::endl;
-
-    if(source.empty()) {
-      Error("RunHadronSource::main", "Source is not initialized!!");
-      return 0;
-    }
-    
-    // Run the decays
-    if(FASTMC->GetTime() >= 0.)
-      FASTMC->Evolve(source, secondaries, allocator, FASTMC->GetWeakDecayLimit());
-   
-    std::cout << "event #" << ev << "\r" << std::flush;
-    Ntot = 0;
-    Npyt = 0;
-    Nhyd = 0;
-    Ntot = 0;
-
-    LPIT_t it;
-    LPIT_t e;
-
-    // Fill the source tree
-
-    Ntot = 0; Nhyd=0; Npyt=0;      
-    for(it = source.begin(), e = source.end(); it != e; ++it) {
-      TVector3 pos(it->Pos().Vect());
-      TVector3 mom(it->Mom().Vect());
-      Float_t m1 = it->TableMass();
-      pdg[Ntot] = it->Encoding();
-      Mpdg[Ntot] = -1;
-      Px[Ntot] = mom[0];
-      Py[Ntot] = mom[1];
-      Pz[Ntot] = mom[2];
-      E[Ntot] = TMath::Sqrt(mom.Mag2() + m1*m1);
-      X[Ntot] = pos[0];
-      Y[Ntot] = pos[1];
-      Z[Ntot] = pos[2];
-      T[Ntot] = it->T();
-      type[Ntot] = it->GetType();
-      if(type[Ntot]==0)Nhyd++;
-      if(type[Ntot]==1)Npyt++;            
-      Ntot++;
-      if(Ntot > kMax)
-        Error("in main:", "Ntot is too large %d", Ntot);
-    }
-    ti->Fill();
-    
-    std::cout<<"ti Ntot= " <<Ntot<<" Npyt= "<<Npyt<<" Nhyd=  "<<Nhyd<<std::endl;
-    
-    // Fill the decayed tree
-    Ntot = 0; Nhyd=0; Npyt=0;      
-    for(it = secondaries.begin(), e = secondaries.end(); it != e; ++it) {
-      TVector3 pos(it->Pos().Vect());
-      TVector3 mom(it->Mom().Vect());
-      Float_t m1 = it->TableMass();
-      pdg[Ntot] = it->Encoding();
-      Mpdg[Ntot] = it->GetLastMotherPdg();
-      Px[Ntot] = mom[0];
-      Py[Ntot] = mom[1];
-      Pz[Ntot] = mom[2];
-      E[Ntot] =  TMath::Sqrt(mom.Mag2() + m1*m1);
-      X[Ntot] = pos[0];
-      Y[Ntot] = pos[1];
-      Z[Ntot] = pos[2];
-      T[Ntot] = it->T();
-      type[Ntot] = it->GetType();
-      if(type[Ntot]==0)Nhyd++;
-      if(type[Ntot]==1)Npyt++;            
-      Ntot++;
-      if(Ntot > kMax)
-        Error("in main:", "Ntot is too large %d", Ntot);
-    }
-    td->Fill();      
-    
-    std::cout<<"td Ntot= " <<Ntot<<" Npyt= "<<Npyt<<" Nhyd=  "<<Nhyd<<std::endl;
-
-    allocator.FreeList(source);
-    allocator.FreeList(secondaries);
-  }
-
-
-
-  
-  // Close the output file by getting it from the tree object to avoid crashes when
-  // the output file is automatically switched by root.
-  TFile *saveFile = ti->GetCurrentFile();
-  saveFile->cd();
-  ti->Write();
-  td->Write();
-  saveFile->Close();
-  //  ti->GetCurrentFile()->Close();
-  
-  clock_t stop;
-  stop = clock();
-  std::cout << "*********************************************" << std::endl;
-  std::cout << "Execution time: " << (stop - start)/CLOCKS_PER_SEC << " seconds" << std::endl;
-  std::cout << "*********************************************" << std::endl;
-
-
-//new
-  time_t  now1;
-  struct tm  *ts1;
-  char       buf1[80];
-         
- // Get the current time
-   time(&now1);
-              
- // Format and print the time, "ddd yyyy-mm-dd hh:mm:ss zzz"
-    ts1 = localtime(&now1);
-    strftime(buf1, sizeof(buf1), "%a %Y-%m-%d %H:%M:%S %Z", ts1);
-    printf("%s\n", buf1);
-     
-                                    
-  
-
-
-  //return 0;
-}
diff --git a/TUHKMgen/UHKM/RunHadronSourceHISTO.cxx b/TUHKMgen/UHKM/RunHadronSourceHISTO.cxx
deleted file mode 100644 (file)
index 67de35a..0000000
+++ /dev/null
@@ -1,275 +0,0 @@
-/*******************************************************************************
- *                                                                             *
- *    HYDJET++ , event generator under the ROOT FRAMEWORK for simulation of    *
- *    relativistic heavy ion AA collisions as the superposition of soft,       *
- *    hydro-type state and hard, multi-parton state.                           *
- *                                                                             *
- *     The main routine is written in the object-oriented C++ language         *        
- *     under the ROOT environment. The hard, multi-partonic part of            *  
- *     HYDJET++ event is identical to the hard part of Fortran-written         *
- *     HYDJET (PYTHIA6.4xx + PYQUEN1.5) and is included in the generator       *
- *     structure as the separate directory. The soft part of HYDJET++          * 
- *     event represents the "thermal" hadronic state obtained with the         *
- *     parameterization Bjorken-like of freeze-out hypersurface and            *
- *     includes longitudinal, radial and elliptic flow effects and             *
- *     decays of hadronic resonances. The corresponding fast                   * 
- *     Monte-Carlo simulation procedure (C++ code) FAST MC is adapted.         *
- * --------------------------------------------------------------              *
- *     Web-page:                                                               *
- *    http://cern.ch/lokhtin/hydjet++                                          *   
- *     --------------------------------------------------------------          *  
- *                                                                             *                                                                             *
- *                                                                             *
- * This program is a free software; you can use and redistribute it freely.    *  
- * Any publication of results obtained using this code must reference          * 
- *                                                                             *
- *                                                                             * 
- *                                                                             *
- *      Main reference for HYDJET++:                                           *
- *     I.P. Lokhtin, L.V. Malinina, S.V. Petrushanko, A.M. Snigirev,           *
- *     I. Arsene, K. Tywoniuk, submitted to Comp. Phys. Comm.                  *
- *                                                                             * 
- *     Reference for HYDJET and PYQUEN:                                        *
- *     I.P. Lokhtin, A.M. Snigirev, Eur. Phys. J. C 46 (2006) 211;             *
- *     http://cern.ch/lokhtin/hydro/hydjet.html                                * 
- *     http://cern.ch/lokhtin/pyquen.                                          *  
- *                                                                             *    
- *     Reference for PYTHIA6.4:                                                *
- *     T.Sjostrand, S. Mrenna and P. Skands, JHEP05 (2006) 026;                *
- *     http://home.thep.lu.se/~torbjorn/Pythia.html.                           * 
- *                                                                             * 
- *     References for FAST MC:                                                 *  
- *     N.S. Amelin, R. Lednicky, T.A. Pocheptsov, I.P. Lokhtin,                * 
- *     L.V. Malinina, A.M. Snigirev, Iu.A. Karpenko and Yu.M. Sinyukov,        * 
- *     Phys. Rev. C 74 (2006) 064901;                                          *
- *     N.S. Amelin, I. Arsene, L. Bravina, Iu.A. Karpenko, R. Lednicky,        *  
- *     I.P. Lokhtin, L.V. Malinina, A.M. Snigirev and Yu.M. Sinyukov,          *  
- *     Phys. Rev. C 77 (2008) 014903;                                          *
- *     http://uhkm.jinr.ru.                                                    *   
- *                                                                             *
- *     Reference for nuclear shadowing model:                                  *
- *     K. Tywoniuk, I.C. Arsene, L. Bravina, A. Kaidalov and                   *
- *     E. Zabrodin, Phys. Lett. B 657 (2007) 170.                              *
- *                                                                             * 
- *       version 2.0:                                                          *
- *                                                                             *
- *     Igor Lokhtin, SINP MSU, Moscow, RU                                      *
- *     e-mail: Igor.Lokhtin@cern.ch                                            *
- *                                                                             *
- *     Ludmila Malinina, SINP MSU, Moscow, RU                                  *   
- *     e-mail: malinina@lav01.sinp.msu.ru                                      * 
- *                                                                             *
- *******************************************************************************/ 
-#include <iostream> 
-#include <fstream>
-#include <vector>
-#include <time.h>
-
-#include <TNtuple.h>
-#include <TError.h>
-#include <TTree.h>
-#include <TH1D.h>
-#include <TFile.h>
-
-#include "InitialState.h"
-#include "InitialStateHydjet.h"
-
-
-#include <TRandom.h>
-
-#include "Particle.h"
-//#include "HYJET_COMMONS.h"
-//extern SERVICECommon SERVICE;
-
-
-//Main program:
-//reads input parameters from file "RunInputBjorken" or "RunInputHubble";
-//calculates particle densities and average initial multiplicities and writes them
-//in output file "multiplicities.txt";
-//creates trees (tree with direct hadrons and hadrons after resonance decays)
-//with space-time and momentum-energy information of produced hadrons;
-//writes trees in file "RunOutput.root".
-
-Int_t main() {
-
-  clock_t start;
-  start = clock();
-
-//new
-  time_t  now;
-  struct tm  *ts;
-  char       buf[80];
-         
- // Get the current time
-   time(&now);
-              
- // Format and print the time, "ddd yyyy-mm-dd hh:mm:ss zzz"
-    ts = localtime(&now);
-    strftime(buf, sizeof(buf), "%a %Y-%m-%d %H:%M:%S %Z", ts);
-    printf("%s\n", buf);
-  
-  TFile *outputFile=new TFile("RunOutput.root", "RECREATE"); 
-
-  //SET MAXIMAl VALUE OF PARTICLE MULTIPLICITY!!!
-  const Int_t kMax = 500000; 
-  //define hadron number
-  Int_t ntot;
-  //define event number
-  Int_t nev;
-  //define hadron characteristic vectors
-  std::vector<Int_t> pdg(kMax); //pdg encodings
-  std::vector<Int_t> Mpdg(kMax);//pdg encodings for mother hadrons
-  std::vector<Int_t> type(kMax);//type: 0-from hydro or decay, 1111 from jets
-  std::vector<Float_t> Px(kMax);//x-hadron momentum component,[GeV/c]
-  std::vector<Float_t> Py(kMax);//y-hadron momentum component,[GeV/c]
-  std::vector<Float_t> Pz(kMax);//z-hadron momentum component,[GeV/c]
-  std::vector<Float_t> E(kMax); //hadron total energy,[GeV]  
-  std::vector<Float_t> X(kMax);//x-hadron coordinate component,[fm]
-  std::vector<Float_t> Y(kMax);//y-hadron coordinate component,[fm]
-  std::vector<Float_t> Z(kMax);//z-hadron coordinate component,[fm]
-  std::vector<Float_t> T(kMax);//hadron time,[fm/c] 
-
-   TH1D *hpt1 = new TH1D("hpt1", "hpt1", 100, 0., 20.);
-   TH1D *hpt1j = new TH1D("hpt1j", "hpt1j", 100, 0., 20.);
-   TH1D *hpt1h = new TH1D("hpt1h", "hpt1h", 100, 0., 20.);
-
-   TH1D *hv2 = new TH1D("hv2", "hv2", 100, 0.0, 10.);
-   TH1D *hv0 = new TH1D("hv0", "hv0", 100, 0.0, 10.);
-
-   TH1D *hy = new TH1D("hy", "hy", 51, -5.1, 5.1);
-   TH1D *hyjets = new TH1D("hyjets", "hyjets", 51, -5.1, 5.1);
-   TH1D *hyhydro = new TH1D("hyhydro", "hyhydro", 51, -5.1, 5.1);
-
-
-   double pdg1, Mpdg1, Px1, Py1, E1, Z1, Pz1, pt, phi, v2, eta;
-   int type1;
-
-  InitialState *FASTMC;
-
-    FASTMC = new InitialStateHydjet();
-   
-  if(!FASTMC->ReadParams()) {
-    Error("RunHadronSource::main", "No initial model parameters found!!\n");
-    return 0;
-  }
-
-
-  if(!FASTMC->MultIni()) {
-    Error("RunHadronSource::main", "Initial multiplicities are zero!!\n");
-    return 0;
-  }
-
-  ParticleAllocator allocator;
-  List_t source;
-  List_t secondaries;
-  std::cout << "Generating " << FASTMC->GetNev() << " events" << std::endl;
-  std::cout << "Starting the event loop" << std::endl;
-    
-  
-  // Loop over events  
-  for(Int_t ev = 0; ev < FASTMC->GetNev(); ++ev) {
-    nev = ev;
-    // Initialize the source
-    FASTMC->Initialize(source, allocator);
-    if(source.empty()) {
-      Error("RunHadronSource::main", "Source is not initialized!!");
-      //return 0;
-      continue;  
-    }
-    
-    // Run the decays //fDecay
-    if(FASTMC->GetTime() >= 0.) 
-      FASTMC->Evolve(source, secondaries, allocator, FASTMC->GetWeakDecayLimit());
-   
-    std::cout << "event #" << ev << "\r" << std::flush;
-//    npart = 0;
-    LPIT_t it;
-    LPIT_t e;
-    
-    // Fill the decayed tree
-//    npart = 0;      
-    
-    for(it = secondaries.begin(), e = secondaries.end(); it != e; ++it) {
-      TVector3 pos(it->Pos().Vect());
-      TVector3 mom(it->Mom().Vect());
-      Float_t m1 = it->TableMass();
-      pdg1 = it->Encoding();
-      Mpdg1 = it->GetLastMotherPdg();
-      Px1 = mom[0];
-      Py1 = mom[1];
-      Pz1 = mom[2];
-      E1 =  TMath::Sqrt(mom.Mag2() + m1*m1);
-      type1 = it->GetType();
-      if(pdg1==211 && abs(0.5*log((E1+Pz1)/(E1-Pz1)))<1.) {
-      hpt1->Fill(sqrt(Px1*Px1+Py1*Py1),1./sqrt(Px1*Px1+Py1*Py1));
-         }
-      
-      if(pdg1==211 && abs(0.5*log((E1+Pz1)/(E1-Pz1)))<1. && type1==0) hpt1h->Fill(sqrt(Px1*Px1+Py1*Py1),1./sqrt(Px1*Px1+Py1*Py1));
-      if(pdg1==211 && abs(0.5*log((E1+Pz1)/(E1-Pz1)))<1. && type1==1)hpt1j->Fill(sqrt(Px1*Px1+Py1*Py1),1./sqrt(Px1*Px1+Py1*Py1));
-
-      if(((abs(pdg1)==211)||(abs(pdg1)==321)||(abs(pdg1)==2212)) 
-       && (abs(0.5*log((E1+Pz1)/(E1-Pz1)))<1.0)){
-       pt = TMath::Sqrt(Px1*Px1+Py1*Py1);      
-       phi = TMath::ATan2(Py1,Px1);
-       v2 = TMath::Cos(2*phi);       
-       hv2->Fill(pt,v2);
-       hv0->Fill(pt,1.);
-       }
-       
-       if((abs(pdg1)==211)||(abs(pdg1)==321)||(abs(pdg1)==2212)){    
-       eta=0.5*TMath::Log((sqrt(Px1*Px1+Py1*Py1+Pz1*Pz1)+Pz1)/(sqrt(Px1*Px1+Py1*Py1+Pz1*Pz1)-Pz1));
-       if(type1==1)hyjets->Fill(eta);
-       if(type1==0)hyhydro->Fill(eta);
-       hy->Fill(eta);
-         }
-
-     // npar++;
-     // if(npart > kMax)
-    //    Error("in main:", "npart is too large %d", npart);
-
-
-    }
-     
-    allocator.FreeList(source);
-    allocator.FreeList(secondaries);
-  }
-  
-  hpt1->Write();
-  hpt1h->Write();
-  hpt1j->Write();
-  hv2->Write();
-  hv0->Write();
-  hyhydro->Write();
-  hyjets->Write();
-  hy->Write();
-  
-  clock_t stop;
-  stop = clock();
-  std::cout << "*********************************************" << std::endl;
-  std::cout << "Execution time: " << (stop - start)/CLOCKS_PER_SEC << " seconds" << std::endl;
-  std::cout << "*********************************************" << std::endl;
-
-
-//new
-  time_t  now1;
-  struct tm  *ts1;
-  char       buf1[80];
-         
- // Get the current time
-   time(&now1);
-              
- // Format and print the time, "ddd yyyy-mm-dd hh:mm:ss zzz"
-    ts1 = localtime(&now1);
-    strftime(buf1, sizeof(buf1), "%a %Y-%m-%d %H:%M:%S %Z", ts1);
-    printf("%s\n", buf1);
-    
-    
-
-  return 0;
-}
index 620997a..a15c173 100644 (file)
@@ -1,16 +1,35 @@
-#ifndef NAStrangeDensity_h
+//
+//        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
+//      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru
+//                           November. 2, 2005
+//
+//
+//This class is used to obtain grand canonical description  of strange density
+//by means of the temperature and chemical potentials (input). As for output
+
+#include <TMath.h>
 #include "StrangeDensity.h"
-#endif
+#include "DatabasePDG.h"
+#include "ParticlePDG.h"
+#include "UKUtility.h"
 
-NAStrangeDensity::NAStrangeDensity():
-  fTemperature(0.*GeV),
-  fBaryonPotential(0.*GeV),
-  fStrangePotential(0.*GeV),
+//__________________________________________________________
+StrangeDensity::StrangeDensity():
+  fTemperature(0.*kGeV),
+  fBaryonPotential(0.*kGeV),
+  fStrangePotential(0.*kGeV),
   fNMax(5)
 {
+  //
+  // constructor
+  //
 }
-// compute hadron system strangeness density
-Double_t NAStrangeDensity::StrangenessDensity(DatabasePDG* database) {
+
+//__________________________________________________________
+Double_t StrangeDensity::StrangenessDensity(const DatabasePDG* database) {
+  //
+  // compute hadron system strangeness density
+  //
   Double_t meanStrangenessDensity = 0.;
   for(Int_t particleIndex = 0; particleIndex < database->GetNParticles(); particleIndex++) {
     ParticlePDG *particle = database->GetPDGParticleByIndex(particleIndex);
@@ -20,8 +39,11 @@ Double_t NAStrangeDensity::StrangenessDensity(DatabasePDG* database) {
   return meanStrangenessDensity;
 }
 
-// compute hadron number density
-Double_t NAStrangeDensity::ParticleNumberDensity(ParticlePDG* pDef) {
+//__________________________________________________________
+Double_t StrangeDensity::ParticleNumberDensity(ParticlePDG* pDef) {
+  //
+  // compute hadron number density
+  //
   Double_t particleMass = pDef->GetMass();
   Int_t particleStrangeness = Int_t(pDef->GetStrangeness());
   Double_t particleBaryon = pDef->GetBaryonNumber();
@@ -37,7 +59,7 @@ Double_t NAStrangeDensity::ParticleNumberDensity(ParticlePDG* pDef) {
   Double_t prefactor;
   Double_t postfactor;
   prefactor = (particleDegFactor*particleMass*particleMass*
-              fTemperature/hbarc/hbarc/hbarc)/(2.*N_PI*N_PI);  
+              fTemperature/kHbarc/kHbarc/kHbarc)/(2.*TMath::Pi()*TMath::Pi());  
   postfactor = 0.;
  
   for(Int_t n = 1; n <= fNMax; n++) {
index 6b5bf68..2785ff9 100644 (file)
@@ -1,38 +1,25 @@
-/*
-
-        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
-      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru
-                           November. 2, 2005
-
-*/
-
+//
+//        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
+//      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru
+//                           November. 2, 2005
+//
+//
 //This class is used to obtain grand canonical description  of strange density
 //by means of the temperature and chemical potentials (input). As for output
 //we get  strange density.
 
-#ifndef NAStrangeDensity_h
-#define NAStrangeDensity_h 1
+#ifndef STRANGEDENSITY_H
+#define STRANGEDENSITY_H
 
-#ifndef NAMathUtil_h
-#include "MathUtil.h"
-#endif
-#ifndef HANKELFUNCTION_INCLUDED
 #include "HankelFunction.h"
-#endif
-#ifndef PARTICLE_INCLUDED
-#include "Particle.h"
-#endif
-#ifndef DATABASEPDG_H
-#include "DatabasePDG.h"
-#endif
-#ifndef PARTICLE_PDG
-#include "ParticlePDG.h"
-#endif
 
-class NAStrangeDensity {
+class DatabasePDG;
+class ParticlePDG;
+
+class StrangeDensity {
  public:
-  NAStrangeDensity();
-  ~NAStrangeDensity(){};
+  StrangeDensity();
+  ~StrangeDensity(){};
 
   //for input
   void SetTemperature(Double_t value) {fTemperature = value;}
@@ -43,13 +30,13 @@ class NAStrangeDensity {
     if(fNMax < 1) fNMax = 1;
   }
   // compute hadron system strangeness density
-  Double_t StrangenessDensity(DatabasePDG* database);
+  Double_t StrangenessDensity(const DatabasePDG* database);
 
  private:
   //input
-  Double_t fTemperature;
-  Double_t fBaryonPotential;   
-  Double_t fStrangePotential;
+  Double_t fTemperature;             // temperature
+  Double_t fBaryonPotential;        // baryon potential
+  Double_t fStrangePotential;        // strange potential
   Int_t fNMax;   //number of terms for summation, if nMax = 1 then
                 //Maxwell-Boltzmann distribution will be recovered     
 
index 0e47954..fd639f9 100644 (file)
@@ -1,16 +1,19 @@
-/*                                                                            
-                                                                            
-        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
-      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
-                           November. 2, 2006                                
+//                                                                          
+//                                                                            
+//        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
+//      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
+//                           November. 2, 2006                                
+//
+//
 
-*/
-
-#ifndef NAStrangePotential_h
+#include <TMath.h>
 #include "StrangePotential.h"
-#endif
 
-Double_t NAStrangePotential::CalculateStrangePotential() {
+//_____________________________________________________________________
+Double_t StrangePotential::CalculateStrangePotential() {
+  //
+  // compute strange potential
+  //
   Double_t minFunction = this->operator()(fMinStrangePotential);
   Double_t maxFunction = this->operator()(fMaxStrangePotential); 
   
@@ -22,7 +25,7 @@ Double_t NAStrangePotential::CalculateStrangePotential() {
    
   iter = 0;  
   while(minFunction*maxFunction > 0.0 && iter++ < fNIteration) {
-    fMaxStrangePotential += 1.5*Abs(fMaxStrangePotential-fMinStrangePotential);
+    fMaxStrangePotential += 1.5*TMath::Abs(fMaxStrangePotential-fMinStrangePotential);
     maxFunction = this->operator()(fMaxStrangePotential);
   }
        
@@ -31,8 +34,8 @@ Double_t NAStrangePotential::CalculateStrangePotential() {
     return 0.;
   }
 
-  NAEquationSolver<NAStrangePotential> * theSolver = 
-    new NAEquationSolver<NAStrangePotential>(fNSolverIteration, fTolerance);
+  EquationSolver<StrangePotential> * theSolver = 
+    new EquationSolver<StrangePotential>(fNSolverIteration, fTolerance);
 
   theSolver->SetIntervalLimits(fMinStrangePotential, fMaxStrangePotential);
   
@@ -44,9 +47,12 @@ Double_t NAStrangePotential::CalculateStrangePotential() {
   return strangePotential;
 }
 
-//calculate hadron system strange density
-Double_t NAStrangePotential::CalculateStrangeDensity(const Double_t strangePotential)
+//_____________________________________________________________________
+Double_t StrangePotential::CalculateStrangeDensity(const Double_t strangePotential)
 {
+  //
+  //calculate hadron system strange density
+  //
   fGc.SetStrangePotential(strangePotential);
   fGc.SetTemperature(fTemperature);
   fGc.SetBaryonPotential(fBaryonPotential);
index ad644e2..ba65a71 100644 (file)
@@ -1,35 +1,29 @@
-/*
-
-        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
-      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru
-                           November. 2, 2005
-
-*/
-
+//
+//
+//        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
+//      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru
+//                           November. 2, 2005
+//
+//
 //This class is used to calculate strange potential from
 //the known initial strange density = 0 at given temperature and baryon potential.
 
-#ifndef NAStrangePotential_h
-#define NAStrangePotential_h 1
+#ifndef STRANGEPOTENTIAL_H
+#define STRANGEPOTENTIAL_H
 
-#ifndef NAStrangeDensity_h
 #include "StrangeDensity.h"
-#endif
-#ifndef NAEquationSolver_h
 #include "EquationSolver.h"
-#endif
-#ifndef DATABASEPDG_H
 #include "DatabasePDG.h"
-#endif
+#include "UKUtility.h"
                                          
-class NAStrangePotential {
+class StrangePotential {
  public:
-  NAStrangePotential(const Double_t initialStrangeDensity=0, DatabasePDG* database=0x0) :
+  StrangePotential(const Double_t initialStrangeDensity=0, DatabasePDG* database=0x0) :
     fTemperature(0),
     fBaryonPotential(0),
     fStrangeDensity(initialStrangeDensity),
-    fMinStrangePotential(0.0001*GeV),
-    fMaxStrangePotential(0.9*GeV),
+    fMinStrangePotential(0.0001*kGeV),
+    fMaxStrangePotential(0.9*kGeV),
     fNIteration(100),
     fNSolverIteration(100),
     fTolerance(1.e-8),
@@ -37,7 +31,7 @@ class NAStrangePotential {
     fGc()
     {};
 
-  ~NAStrangePotential() {};
+  ~StrangePotential() {};
    
   Double_t operator()(const Double_t strangePotential) { 
     return (fStrangeDensity - this->CalculateStrangeDensity(strangePotential))/fStrangeDensity; 
@@ -50,24 +44,22 @@ class NAStrangePotential {
   Double_t CalculateStrangePotential();
 
  private:
-  NAStrangePotential(const NAStrangePotential&);
-  NAStrangePotential& operator=(const NAStrangePotential&);
+  StrangePotential();
+  StrangePotential(const StrangePotential&);
+  StrangePotential& operator=(const StrangePotential&);
 
-  Double_t fTemperature;
-  Double_t fBaryonPotential;
-  Double_t fStrangeDensity;
+  Double_t fTemperature;         // temperature
+  Double_t fBaryonPotential;     // baryo-chemical potential
+  Double_t fStrangeDensity;      // strangeness density
   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;
+  DatabasePDG* fDatabase;        // PDG database
+  StrangeDensity fGc;            // strangeness density object
   //compute hadron  system strange density through strange potential
   Double_t CalculateStrangeDensity(const Double_t strangePotential);
-  //default constructor is not accesible
-  NAStrangePotential();
-
 };
 
 #endif
diff --git a/TUHKMgen/UHKM/StrangePotential1.h b/TUHKMgen/UHKM/StrangePotential1.h
deleted file mode 100644 (file)
index 134ae18..0000000
+++ /dev/null
@@ -1,58 +0,0 @@
-#ifndef NAStrangePotential_h
-#define NAStrangePotential_h
-#include "StrangeDensity.h"
-#include "EquationSolver.h"
-/*                                                                            
-                                                                            
-        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
-      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
-                           November. 2, 2005                                
-
-*/
-
-//This class is used to calculate strange potential from 
-//the known initial strange density = 0 at given temperature and baryon potential.
-
-class NAStrangePotential {
- public:
-  NAStrangePotential(const Double_t initialStrangeDensity) :
-    fStrangeDensity(initialStrangeDensity),
-    fNIteration(100),
-    fTolerance(1.e-8),
-    fNSolverIteration(100),
-    fMinStrangePotential(0.0001*GeV),
-    fMaxStrangePotential(0.9*GeV)
-    {};
-
-  ~NAStrangePotential() {};
-  
-  Double_t operator()(const Double_t strangePotential) { 
-    return (fStrangeDensity - this->CalculateStrangeDensity(strangePotential))/fStrangeDensity; 
-  }    
-
- private:
-  //  default constructor is not accesible
-  NAStrangePotential(){};
-
- public:
-  void SetTemperature(Double_t value) {fTemperature = value;}
-  void SetBaryonPotential(Double_t value) {fBaryonPotential = value;}
-  void SetMinStrangePotential(Double_t value) {fMinStrangePotential = value;}
-  void SetMaxStrangePotential(Double_t value) {fMaxStrangePotential = value;}
-  Double_t CalculateStrangePotential();
-
- private:
-  //compute hadron  system strange density through strange potential
-  Double_t CalculateStrangeDensity(const Double_t strangePotential);
-  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 
-  NAStrangeDensity fGc;
-};
-
-#endif
index 3b2c3f4..6874cf8 100644 (file)
@@ -1,29 +1,22 @@
-/*                                                                           
-                                                                            
-        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
-      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru
-                           November. 2, 2005                                
-
-*/
+//                                                                           
+//                                                                            
+//        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
+//      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru
+//                           November. 2, 2005                                
+//
+//
 
 #include "TLorentzVector.h"
 #include "TVector3.h"
 #include "TRandom.h"
 
-#ifndef PARTICLE_INCLUDED
-#include "Particle.h"
-#endif
-#ifndef UKUTILITY_INCLUDED
 #include "UKUtility.h" 
-#endif
-
-const Double_t GeV = 1.;
-const Double_t fermi = 1.;
-const Double_t hbarc = 0.197 * GeV * fermi; 
-const Double_t w = 1.0 / 0.1973;
-const Double_t hbarc_squared = hbarc * hbarc;
 
+//_____________________________________________________________________
 void IsotropicR3(Double_t r, Double_t *x, Double_t *y, Double_t *z) {
+  //
+  // return a random isotropic orientation
+  //
   Double_t pZ  = 1. - 2.*(gRandom->Rndm());
   Double_t st  = TMath::Sqrt((1.-pZ)*(1.+pZ)) * r;
   Double_t phi = 2. * TMath::Pi() * (gRandom->Rndm());
@@ -33,7 +26,11 @@ void IsotropicR3(Double_t r, Double_t *x, Double_t *y, Double_t *z) {
   *z = pZ * r;
 }
 
+//_____________________________________________________________________
 void IsotropicR3(Double_t r, TVector3 &pos) {
+  //
+  // return a random isotropic orientation
+  //
   Double_t pZ  = 1. - 2.* (gRandom->Rndm());  
   Double_t st  = TMath::Sqrt((1.-pZ)*(1.+pZ)) * r;
   Double_t phi = 2. * TMath::Pi() * (gRandom->Rndm());
@@ -43,8 +40,12 @@ void IsotropicR3(Double_t r, TVector3 &pos) {
   pos.SetZ(pZ * r);
 }
 
+//_____________________________________________________________________
 void MomAntiMom(TLorentzVector &mom, Double_t mass, TLorentzVector &antiMom, 
                Double_t antiMass, Double_t initialMass) {
+  //
+  // perform a 2 - body decay and orientate randomly the product particles momentum vectors
+  //
   Double_t r = initialMass * initialMass - mass * mass - antiMass * antiMass;
   if (r * r - 4 * mass * mass * antiMass * antiMass < 0.) throw "MomAntiMom";
       
@@ -54,5 +55,3 @@ void MomAntiMom(TLorentzVector &mom, Double_t mass, TLorentzVector &antiMom,
   mom.SetVectM(mom3, mass);
   antiMom.SetVectM(- mom3, antiMass);
 }
-
-
index 9d05ab6..be90801 100644 (file)
@@ -1,31 +1,24 @@
-#ifndef UKUTILITY_INCLUDED
-#define UKUTILITY_INCLUDED
-/*                                                                            
-                                                                            
-        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
-      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
-                           November. 2, 2005                                
-
-*/
+//                                                                            
+//                                                                            
+//        Nikolai Amelin, Ludmila Malinina, Timur Pocheptsov (C) JINR/Dubna
+//      amelin@sunhe.jinr.ru, malinina@sunhe.jinr.ru, pocheptsov@sunhe.jinr.ru 
+//                           November. 2, 2005                                
+//
+//
 
+#ifndef UKUTILITY_H
+#define UKUTILITY_H
 class TLorentzVector;
 class TVector3;
-class TH1F;
-
-class Particle;
 
 void IsotropicR3(Double_t r, Double_t *pX, Double_t *pY, Double_t *pZ);
 void IsotropicR3(Double_t r, TVector3 &pos);
 void MomAntiMom(TLorentzVector &mom, Double_t mass, TLorentzVector &antiMom,
                Double_t antiMass, Double_t initialMass);
 
-extern const Double_t GeV;
-extern const Double_t MeV;
-extern const Double_t fermi;
-extern const Double_t mbarn;
-extern const Double_t hbarc; 
-extern const Double_t w;
-extern const Double_t hbarc_squared; 
+const Double_t kGeV = 1.;
+const Double_t kFermi = 1.;
+const Double_t kHbarc = 0.197 * kGeV * kFermi; 
 
 #endif