EffC++ warnings corrected.
authormorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 15 Aug 2006 12:25:37 +0000 (12:25 +0000)
committermorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 15 Aug 2006 12:25:37 +0000 (12:25 +0000)
43 files changed:
EVGEN/AliDecayerPolarized.cxx
EVGEN/AliDecayerPolarized.h
EVGEN/AliDimuCombinator.cxx
EVGEN/AliGeVSimParticle.cxx
EVGEN/AliGeVSimParticle.h
EVGEN/AliGenAfterBurnerFlow.cxx
EVGEN/AliGenBeamGas.cxx
EVGEN/AliGenBox.cxx
EVGEN/AliGenCocktail.cxx
EVGEN/AliGenCocktailAfterBurner.cxx
EVGEN/AliGenCocktailEntry.cxx
EVGEN/AliGenCocktailEventHeader.cxx
EVGEN/AliGenDoubleScan.cxx
EVGEN/AliGenExtFile.cxx
EVGEN/AliGenFLUKAsource.cxx
EVGEN/AliGenFixed.cxx
EVGEN/AliGenGeVSim.cxx
EVGEN/AliGenGeVSim.h
EVGEN/AliGenGeVSimEventHeader.cxx
EVGEN/AliGenHBTosl.cxx
EVGEN/AliGenHBTosl.h
EVGEN/AliGenHIJINGpara.cxx
EVGEN/AliGenHIJINGparaBa.cxx
EVGEN/AliGenHalo.cxx
EVGEN/AliGenHaloProtvino.cxx
EVGEN/AliGenMC.cxx
EVGEN/AliGenMC.h
EVGEN/AliGenMUONCocktail.cxx
EVGEN/AliGenMUONCocktail.h
EVGEN/AliGenMUONCocktailpp.cxx
EVGEN/AliGenParam.cxx
EVGEN/AliGenReaderCwn.cxx
EVGEN/AliGenReaderCwn.h
EVGEN/AliGenReaderEMD.cxx
EVGEN/AliGenReaderEMD.h
EVGEN/AliGenReaderEcalHijing.cxx
EVGEN/AliGenReaderEcalHijing.h
EVGEN/AliGenReaderEcalJets.cxx
EVGEN/AliGenReaderEcalJets.h
EVGEN/AliGenScan.cxx
EVGEN/AliGenSlowNucleons.cxx
EVGEN/AliGenThetaSlice.cxx
EVGEN/AliSlowNucleonModelExp.cxx

index cfe2acb..b1f2065 100644 (file)
 #include "AliDecayerPolarized.h"
 #include "AliLog.h"
 
-ClassImp(AliDecayerPolarized)
+ClassImp(AliDecayerPolarized);
+
+
 
 //____________________________________________________________
-AliDecayerPolarized::AliDecayerPolarized()
+AliDecayerPolarized::AliDecayerPolarized():
+    fAlpha(0),
+    fSystRef(kHelicity),
+    fDecProd(kMuon),
+    fPol(new TF1("dsigdcostheta","1.+[0]*x*x",-1.,1.)),
+    fMother(0),
+    fDaughter1(0),
+    fDaughter2(0)
 {
 // Default constructor
-    fAlpha=0;
-    fSystRef=kHelicity;
-    fDecProd=kMuon;
-    fMother=0;
-    fDaughter1=0;
-    fDaughter2=0;
-    fPol = new TF1("dsigdcostheta","1.+[0]*x*x",-1.,1.);
     fPol->SetParameter(0,fAlpha);
 }
 
 //____________________________________________________________
-AliDecayerPolarized::AliDecayerPolarized(Double_t alpha, Polar_t systref, FinState_t decprod)
+AliDecayerPolarized::AliDecayerPolarized(Double_t alpha, Polar_t systref, FinState_t decprod):
+    fAlpha(alpha),
+    fSystRef(systref),
+    fDecProd(decprod),
+    fPol(new TF1("dsigdcostheta","1.+[0]*x*x",-1.,1.)),
+    fMother(0),
+    fDaughter1(0),
+    fDaughter2(0)
 {
 // Another constructor
-    fAlpha=alpha;
-    fSystRef=systref;
-    fDecProd=decprod;
-    fMother=0;
-    fDaughter1=0;
-    fDaughter2=0;
-    fPol = new TF1("dsigdcostheta","1.+[0]*x*x",-1.,1.);
     fPol->SetParameter(0,fAlpha);
     if(fDecProd!=kMuon && fDecProd!=kElectron)
-    AliFatal("Only polarized decay into muons or electrons is implemented!");
+       AliFatal("Only polarized decay into muons or electrons is implemented!");
+}
+
+AliDecayerPolarized::AliDecayerPolarized(const AliDecayerPolarized &decayer):
+    AliDecayer(decayer),
+    fAlpha(0),
+    fSystRef(kHelicity),
+    fDecProd(kMuon),
+    fPol(new TF1("dsigdcostheta","1.+[0]*x*x",-1.,1.)),
+    fMother(0),
+    fDaughter1(0),
+    fDaughter2(0)   
+{
+    // Copy Constructor
+    decayer.Copy(*this);
 }
 
 //____________________________________________________________
index ac1f7ae..c547122 100644 (file)
@@ -19,8 +19,7 @@ class AliDecayerPolarized : public AliDecayer
     typedef enum { kElectron = 1, kMuon = 2} FinState_t;
   AliDecayerPolarized();
   AliDecayerPolarized(Double_t alpha, Polar_t systref, FinState_t decprod);
-  AliDecayerPolarized(const AliDecayerPolarized &decayer):AliDecayer(decayer)
-      {decayer.Copy(*this);}
+  AliDecayerPolarized(const AliDecayerPolarized &decayer);
   virtual ~AliDecayerPolarized();
   void SetPolDec(Double_t alpha=0) {fAlpha=alpha;}
   void SetPolRefSys(Polar_t systref=kColSop) {fSystRef=systref;}
index 44001c8..0933aed 100644 (file)
@@ -1,4 +1,4 @@
-/**************************************************************************
+ /**************************************************************************
  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  *                                                                        *
  * Author: The ALICE Off-line Project.                                    *
 
 //
 ClassImp(AliDimuCombinator)
-    AliDimuCombinator::AliDimuCombinator() 
+
+AliDimuCombinator::AliDimuCombinator():
+    fNParticle((Int_t) (gAlice->TreeK())->GetEntries()),
+    fImuon1(0),
+    fImuon2(0),
+    fImin1(0),
+    fImin2(0),
+    fImax1(fNParticle),
+    fImax2(fNParticle),
+    fRate1(1.),
+    fRate2(1.),
+    fMuon1(0),
+    fMuon2(0),
+    fPtMin(0.),
+    fEtaMin(-10.),
+    fEtaMax(10.)
 {
 // Constructor
     fNParticle = (Int_t) (gAlice->TreeK())->GetEntries();
-    fImuon1 = 0;
-    fImuon2 = 0;
-    fMuon1  = 0;
-    fMuon2  = 0;
-    fImin1  = 0;
-    fImin2  = 0;
-    fImax1  = fNParticle;
-    fImax2  = fNParticle;
-    fPtMin  = 0;
-    fEtaMin = -10;
-    fEtaMax = -10;
-    fRate1  = 1.;
-    fRate2  = 1.;
 }
 
 AliDimuCombinator::AliDimuCombinator(const AliDimuCombinator & combinator)
-    :TObject(combinator)
+    :TObject(combinator),
+     fNParticle(0),
+     fImuon1(0),
+     fImuon2(0),
+     fImin1(0),
+     fImin2(0),
+     fImax1(0),
+     fImax2(0),
+     fRate1(0),
+     fRate2(0),
+     fMuon1(0),
+     fMuon2(0),
+     fPtMin(0.),
+     fEtaMin(0.),
+     fEtaMax(0.)
 {
 // Dummy copy constructor
     combinator.Copy(*this);
index 70dd432..4360d02 100644 (file)
 
 ClassImp(AliGeVSimParticle)
 
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
+AliGeVSimParticle::AliGeVSimParticle():
+    fPDG(0),
+    fModel(0),
+    fN(0),
+    fMultTotal(kTRUE),
+    fIsSetMult(kFALSE),
+    fT(0.),
+    fSigmaY(0.),
+    fExpansion(0.),
+    fIsDirectedSimple(kTRUE),
+    fIsEllipticSimple(kTRUE),
+    fIsEllipticOld(kFALSE)
+{
+    // Default constructor
+}
 
 AliGeVSimParticle::AliGeVSimParticle(Int_t pdg, Int_t model, Float_t multiplicity,
-                                    Float_t T, Float_t dY, Float_t exp) {
+                                    Float_t T, Float_t dY, Float_t exp):
+    fPDG(pdg),
+    fModel(model),
+    fN(multiplicity),
+    fMultTotal(kTRUE),
+    fIsSetMult(kFALSE),
+    fT(T),
+    fSigmaY(dY),
+    fExpansion(exp),
+    fIsDirectedSimple(kTRUE),
+    fIsEllipticSimple(kTRUE),
+    fIsEllipticOld(kFALSE)
+{
   //
   //  pdg          - Particle type code in PDG standard (see: http://pdg.lbl.gov)
   //  model        - momentum distribution model (1 - 7)
@@ -59,51 +87,33 @@ AliGeVSimParticle::AliGeVSimParticle(Int_t pdg, Int_t model, Float_t multiplicit
   //  T            - Inverse slope parameter ("temperature")
   //  dY           - Raridity Width (only for model 1)
   //  exp          - expansion velocity (only for model 4) 
-  
-  fPDG = pdg;
-  fT = T;
-  fSigmaY = dY;
-  fExpansion = exp;
-
-  fN = multiplicity;
-  fMultTotal = kTRUE;
-  fIsSetMult = kFALSE;
-
-  SetModel(model);
-
   fV1[0] = fV1[1] = fV1[2] = fV1[3] = 0.;
   fV2[0] = fV2[1] = fV2[2] = 0.;
-
-  fIsEllipticSimple = fIsDirectedSimple = kTRUE;
-  fIsEllipticOld = kFALSE;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-AliGeVSimParticle::AliGeVSimParticle(Int_t pdg, Int_t model, Float_t multiplicity) {
+AliGeVSimParticle::AliGeVSimParticle(Int_t pdg, Int_t model, Float_t multiplicity):
+    fPDG(pdg),
+    fModel(model),
+    fN(multiplicity),
+    fMultTotal(kTRUE),
+    fIsSetMult(kFALSE),
+    fT(0.),
+    fSigmaY(0.),
+    fExpansion(0.),
+    fIsDirectedSimple(kTRUE),
+    fIsEllipticSimple(kTRUE),
+    fIsEllipticOld(kFALSE)
+ {
   //
   // pdg - Particle type code in PDG standard (see: http://pdg.lbl.gov)
   //  
   // Note that multiplicity can be interpreted by GeVSim 
   // either as Total multiplicity in the acceptance or dN/dY
   // 
-  fPDG = pdg;
-  fN = multiplicity; 
-  fMultTotal = kTRUE;
-  fIsSetMult = kFALSE;
-  
-  SetModel(model);
-
-  fT = 0.;
-  fSigmaY = 0.;
-  fExpansion = 0.;
-  
   fV1[0] = fV1[1] = fV1[2] = fV1[3] = 0.;
   fV2[0] = fV2[1] = fV2[2] = 0.; 
-
-  fIsEllipticSimple = fIsDirectedSimple = kTRUE;
-  fIsEllipticOld = kFALSE;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
index 945b849..2355a63 100644 (file)
@@ -41,13 +41,13 @@ class AliGeVSimParticle : public TObject {
  public:
   
   ////////////////////////////////////////////////////////////////////////////
-  
-  AliGeVSimParticle() {}
-  AliGeVSimParticle(Int_t pdg, Int_t model, Float_t multiplicity); 
-  AliGeVSimParticle(Int_t pdg, Int_t model, Float_t multiplicity, 
+
+    AliGeVSimParticle();
+    AliGeVSimParticle(Int_t pdg, Int_t model, Float_t multiplicity); 
+    AliGeVSimParticle(Int_t pdg, Int_t model, Float_t multiplicity, 
                    Float_t T, Float_t dY = 1., Float_t exp=0.);
   
-  ~AliGeVSimParticle() {}
+    ~AliGeVSimParticle() {}
   
   ////////////////////////////////////////////////////////////////////////////
   
index 902360e..01ecf0c 100644 (file)
@@ -50,18 +50,21 @@ ClassImp(AliGenAfterBurnerFlow)
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-AliGenAfterBurnerFlow::AliGenAfterBurnerFlow() {
-  //
-  // Deafult Construction
-  //
-
-  fReactionPlane = 0;
-  fCounter = 0;
+    AliGenAfterBurnerFlow::AliGenAfterBurnerFlow(): 
+       fReactionPlane(0),
+       fCounter(0)
+{
+    //
+    // Default Construction
+    //
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-AliGenAfterBurnerFlow::AliGenAfterBurnerFlow(Float_t reactionPlane) {
+AliGenAfterBurnerFlow::AliGenAfterBurnerFlow(Float_t reactionPlane):
+       fReactionPlane(reactionPlane),
+       fCounter(0) 
+{
   //
   // Standard Construction
   // 
index a5eea6c..1c14dba 100644 (file)
 ClassImp(AliGenBeamGas)
 
 AliGenBeamGas::AliGenBeamGas()
-    :AliGenExtFile()
+    :AliGenExtFile(), 
+     fInteractions(1)
 {
 //  Constructor
 //
-    fInteractions = 1;
     fOsigma[0] =    0.;
     fOsigma[1] =    0.;
     fOsigma[2] = 2000.;
 }
 
 AliGenBeamGas::AliGenBeamGas(const AliGenBeamGas & beamgas):
-    AliGenExtFile(beamgas)
+    AliGenExtFile(beamgas),
+    fInteractions(1)
 {
 // Copy constructor
     beamgas.Copy(*this);
index 56c8e73..46c3b97 100644 (file)
@@ -34,25 +34,24 @@ ClassImp(AliGenBox)
 
 //_____________________________________________________________________________
 AliGenBox::AliGenBox()
-    :AliGenerator()
+    :AliGenerator(), 
+     fIpart(0)
 {
   //
   // Default constructor
   //
-  fIpart=0;
 }
 
 //_____________________________________________________________________________
 AliGenBox::AliGenBox(Int_t npart)
-  :AliGenerator(npart)
+    :AliGenerator(npart),
+     fIpart(kProton)
 {
   //
   // Standard constructor
   //
   fName  = "Box";
   fTitle = "Box particle generator";
-  // Generate Proton by default
-  fIpart=kProton;
 }
 
 //_____________________________________________________________________________
index 96fa73a..1b57031 100644 (file)
 ClassImp(AliGenCocktail)
 
 AliGenCocktail::AliGenCocktail()
-                 :AliGenerator()
+    :AliGenerator(), 
+     fNGenerators(0),
+     fRandom(kFALSE),
+     fUsePerEventRate(kFALSE),
+     fProb(0),
+     fEntries(0),
+     flnk1(0),
+     flnk2(0), 
+     fHeader(0)
 {
 // Constructor
     fName = "Cocktail";
     fTitle= "Particle Generator using cocktail of generators";
-    flnk1            = 0;
-    flnk2            = 0;
-    fNGenerators     = 0;
-    fEntries         = 0;
-    fHeader          = 0;
-    fRandom          = kFALSE;
-    fUsePerEventRate = kFALSE;
 }
 
 AliGenCocktail::AliGenCocktail(const AliGenCocktail & cocktail):
-    AliGenerator(cocktail)
+    AliGenerator(cocktail), 
+    fNGenerators(0),
+    fRandom(kFALSE),
+    fUsePerEventRate(kFALSE),
+    fProb(0),
+    fEntries(0),
+    flnk1(0),
+    flnk2(0), 
+    fHeader(0)
 {
 // Copy constructor
     cocktail.Copy(*this);
@@ -188,7 +197,6 @@ AddGenerator(AliGenerator *Generator, const char* Name, Float_t RateExp)
        // Loop over generators and generate events
        Int_t igen=0;
        while((entry = (AliGenCocktailEntry*)next())) {
-
            if (fUsePerEventRate && (gRandom->Rndm() > entry->Rate())) continue;
            
            igen++;
index 3f9db92..e8157b6 100644 (file)
@@ -48,29 +48,37 @@ ClassImp(AliGenCocktailAfterBurner)
 /*********************************************************************/ 
 /*********************************************************************/ 
 
-AliGenCocktailAfterBurner::AliGenCocktailAfterBurner()
+    AliGenCocktailAfterBurner::AliGenCocktailAfterBurner():
+       fNAfterBurners(0),
+       fAfterBurnerEntries(new TList()),
+       fGenerationDone(kFALSE),
+       fInternalStacks(0),
+       fCollisionGeometries(0),
+       fCurrentEvent(0),
+       fActiveStack(0),
+       fActiveEvent(-1),
+       fCurrentGenerator(0),
+       fNBgEvents(0)
 {
 // Constructor
     if (gDebug > 0) 
-       cout<<"AliGenCocktailAfterBurner::AliGenCocktailAfterBurner()"<<endl;
+       cout<<"AliGenCocktailAfterBurner::AliGenCocktailAfterBurner()"<<endl;
     SetName("AliGenCocktailAfterBurner");
     SetTitle("AliGenCocktailAfterBurner");
-    fInternalStacks = 0;
-    fCollisionGeometries = 0;
-    fActiveStack = 0;
-    fCurrentGenerator = 0;
-    fCurrentEvent =0;
-    fAfterBurnerEntries = new TList();
-    fNAfterBurners = 0;
-    fGenerationDone = kFALSE;
-    
-    fActiveEvent = -1;  
-    fNBgEvents = 0;
 }
 /*********************************************************************/ 
 AliGenCocktailAfterBurner::AliGenCocktailAfterBurner(const AliGenCocktailAfterBurner& cocktail):
-    AliGenCocktail(cocktail)
-
+    AliGenCocktail(cocktail), 
+    fNAfterBurners(0),
+    fAfterBurnerEntries(new TList()),
+    fGenerationDone(kFALSE),
+    fInternalStacks(0),
+    fCollisionGeometries(0),
+    fCurrentEvent(0),
+    fActiveStack(0),
+    fActiveEvent(-1),
+    fCurrentGenerator(0),
+    fNBgEvents(0)
 {
  //Copy constructor
     cocktail.Copy(*this);
index eee9335..1d3d103 100644 (file)
 #include "AliGenerator.h"
 
 
-ClassImp(AliGenCocktailEntry)
+ClassImp(AliGenCocktailEntry);
 
-
-
-AliGenCocktailEntry::AliGenCocktailEntry()
+AliGenCocktailEntry::AliGenCocktailEntry():
+    fGenerator(0),
+    fNGenerated(0),
+    fFirst(-1),
+    fLast(-1),
+    fRate(0),
+    fKineBias(1),
+    fBias(1)
 {
 // Default constructor
-    fGenerator =0;
-    fNGenerated=0;
-    fFirst=-1;
-    fLast=-1;
-    fRate=0;
-    fKineBias=1;
-    fBias=1;
+
 }
 
 AliGenCocktailEntry:: AliGenCocktailEntry
-(AliGenerator* Generator, const char * Name, Float_t RateExp):TNamed(Name, "Generator Cocktail Entry")
+(AliGenerator* Generator, const char * Name, Float_t RateExp):TNamed(Name, "Generator Cocktail Entry"),
+    fGenerator(Generator),
+    fNGenerated(0),
+    fFirst(-1),
+    fLast(-1),
+    fRate(RateExp),
+    fKineBias(1),
+    fBias(1)
 {
-// Constructor using generator type, name and rate per event
-    fGenerator=Generator;
-    fNGenerated=0;
-    fFirst=-1;
-    fLast=-1;
-    fRate=RateExp;
-//         
-    fKineBias=1;
-    fBias=1;
+    // Constructor
 }
 
 AliGenCocktailEntry::AliGenCocktailEntry(const AliGenCocktailEntry &entry):
-    TNamed(entry)
+    TNamed(entry),
+    fGenerator(0),
+    fNGenerated(0),
+    fFirst(-1),
+    fLast(-1),
+    fRate(0),
+    fKineBias(1),
+    fBias(1)
 {
 // Dummy copy constructor
     entry.Copy(*this);
index 7f75685..d775c17 100644 (file)
 #include "AliGenEventHeader.h"
 #include <TList.h>
 
-ClassImp(AliGenCocktailEventHeader)
+ClassImp(AliGenCocktailEventHeader);
 
 
-
-AliGenCocktailEventHeader::AliGenCocktailEventHeader()
+AliGenCocktailEventHeader::AliGenCocktailEventHeader():
+    fHeaders(0)
 {
 // Default Constructor
-    fHeaders = 0x0;
 }
 
-AliGenCocktailEventHeader::AliGenCocktailEventHeader(const char* name):AliGenEventHeader(name)
+AliGenCocktailEventHeader::AliGenCocktailEventHeader(const char* name):AliGenEventHeader(name),
+    fHeaders(0)
 {
 // Constructor
-    fHeaders = 0x0;
 }
 
 AliGenCocktailEventHeader::AliGenCocktailEventHeader(const AliGenCocktailEventHeader &header):
-AliGenEventHeader(header)
+    AliGenEventHeader(header),
+    fHeaders(0)
 {
 // Copy Constructor
     header.Copy(*this);
index 7f18a5b..778ad96 100644 (file)
  ClassImp(AliGenDoubleScan)
     
  AliGenDoubleScan::AliGenDoubleScan()
-        :AliGenScan(-1)
+     :AliGenScan(-1),
+      fDistance(0.)
 {
+    // Default constructor
 }
 
 AliGenDoubleScan::AliGenDoubleScan(Int_t npart)
-    :AliGenScan(npart)
+    :AliGenScan(npart),
+     fDistance(0.)
 {
 // Constructor
     fName = "Double Scan";
index 9d9f73e..6f8bcea 100644 (file)
 ClassImp(AliGenExtFile)
 
 AliGenExtFile::AliGenExtFile()
-  :AliGenMC()
+    :AliGenMC(),
+     fFileName(0),
+     fReader(0)
 {
 //  Constructor
 //
 //  Read all particles
     fNpart  =- 1;
-    fReader =  0;
 }
 
 AliGenExtFile::AliGenExtFile(Int_t npart)
-    :AliGenMC(npart)
+    :AliGenMC(npart),
+     fFileName(0),
+     fReader(0)
 {
 //  Constructor
     fName   = "ExtFile";
     fTitle  = "Primaries from ext. File";
-    fReader = 0;
 }
 
 AliGenExtFile::AliGenExtFile(const AliGenExtFile & ExtFile):
-    AliGenMC(ExtFile)
+    AliGenMC(ExtFile),
+     fFileName(0),
+     fReader(0)
 {
 // Copy constructor
     ExtFile.Copy(*this);
index 118ac53..d1565b9 100644 (file)
 ClassImp(AliGenFLUKAsource)
 
 AliGenFLUKAsource::AliGenFLUKAsource()
-        :AliGenerator(-1)
+    :AliGenerator(-1), 
+     fIkine(6),
+     fAgeMax(1.e-5), 
+     fAddWeight(1.),
+     fZshift(0.),
+     fFrac(0.),
+     fSourceId(-1),
+     fFileName(0),
+     fTreeChain(0),
+     fTreeFluka(0),
+     fIp(0.),
+     fIpp(0.),
+     fXi(0.),
+     fYi(0.),
+     fZi(0.),
+     fPx(0.),
+     fPy(0.),
+     fPz(0.),
+     fEkin(0.),
+     fZv(0.),
+     fRv(0.),
+     fItra(0.),
+     fIgas(0.),
+     fWgt(0.),
+     fEtag(0.),
+     fPtg(0.),
+     fAge(0.)
 {
     // Constructor
     fName="FLUKA";
     fTitle="FLUKA Boundary Source";
     // Read in all particle types by default
-    fIkine=6;
     // Set maximum admitted age of particles to 1.e-05 by default 
-    fAgeMax=1.e-05;
     // Do not add weight
-    fAddWeight=1.;
     // Shift the z-coordinate of the impact point by 4.5 cm only if it reads 
     // from  specific boundary source to the chamber (fZshift=4.5;),else there 
     // is no need to shift as it reads boundary source for the whole volume of 
     // the Muon Arm; the default value corresponds to boundary source for the
     // whole volume of the MUON Arm 
-    fZshift=0;
     // Set the default file 
-    fFileName="";
-
-    fTreeFluka=0;
     fTreeChain = new TChain("h1");
 //
 //  Read all particles
@@ -65,33 +84,67 @@ AliGenFLUKAsource::AliGenFLUKAsource()
 }
 
 AliGenFLUKAsource::AliGenFLUKAsource(Int_t npart)
-    :AliGenerator(npart)
+    :AliGenerator(npart), 
+     fIkine(6),
+     fAgeMax(1.e-5), 
+     fAddWeight(1.),
+     fZshift(0.),
+     fFrac(0.),
+     fSourceId(-1),
+     fFileName(""),
+     fTreeChain(new TChain("h1")),
+     fTreeFluka(0),
+     fIp(0.),
+     fIpp(0.),
+     fXi(0.),
+     fYi(0.),
+     fZi(0.),
+     fPx(0.),
+     fPy(0.),
+     fPz(0.),
+     fEkin(0.),
+     fZv(0.),
+     fRv(0.),
+     fItra(0.),
+     fIgas(0.),
+     fWgt(0.),
+     fEtag(0.),
+     fPtg(0.),
+     fAge(0.)
 {
     // Constructor
     fName  = "FLUKA";
     fTitle = "FLUKA Boundary Source";
-    // Read in all particle types by default
-    fIkine=6;
-    // Set maximum admitted age of particles to 1.e-05 by default 
-    fAgeMax=1.e-05;
-    // Do not add weight
-    fAddWeight=1.;
-    // Shift the z-coordinate of the impact point by 4.5 cm only if it reads 
-    // from  specific boundary source to the chamber (fZshift=4.5;),else there 
-    // is no need to shift as it reads boundary source for the whole volume of 
-    // the Muon Arm; the default value corresponds to boundary source for the
-    // whole volume of the MUON Arm 
-    fZshift=0;
-    // Set the default file 
-    fFileName="";
-
-    fTreeFluka=0;
-    fTreeChain = new TChain("h1"); 
-    fSourceId=-1;
 }
 
 AliGenFLUKAsource::AliGenFLUKAsource(const AliGenFLUKAsource & FLUKAsource):
-    AliGenerator(FLUKAsource)
+    AliGenerator(FLUKAsource), 
+    fIkine(6),
+    fAgeMax(1.e-5), 
+    fAddWeight(1.),
+    fZshift(0.),
+    fFrac(0.),
+    fSourceId(-1),
+    fFileName(0),
+    fTreeChain(0),
+    fTreeFluka(0),
+    fIp(0.),
+    fIpp(0.),
+    fXi(0.),
+    fYi(0.),
+    fZi(0.),
+    fPx(0.),
+    fPy(0.),
+    fPz(0.),
+    fEkin(0.),
+    fZv(0.),
+    fRv(0.),
+    fItra(0.),
+    fIgas(0.),
+    fWgt(0.),
+    fEtag(0.),
+    fPtg(0.),
+    fAge(0.)
 {
 // Copy constructor
     FLUKAsource.Copy(*this);
index 4fab8af..f359cbb 100644 (file)
@@ -30,27 +30,26 @@ ClassImp(AliGenFixed)
 
 //_____________________________________________________________________________
 AliGenFixed::AliGenFixed()
-  :AliGenerator()
+    :AliGenerator(), 
+     fIpart(0),
+     fExplicit(kFALSE)
 {
   //
   // Default constructor
   //
-  fIpart = 0;
-  fExplicit = kFALSE;
 }
 
 //_____________________________________________________________________________
 AliGenFixed::AliGenFixed(Int_t npart)
-  :AliGenerator(npart)
+    :AliGenerator(npart),
+     fIpart(kProton),
+     fExplicit(kFALSE)
 {
   //
   // Standard constructor
   //
   fName="Fixed";
   fTitle="Fixed Particle Generator";
-  // Generate Proton by default
-  fIpart=kProton;
-  fExplicit = kFALSE;
 }
 
 //_____________________________________________________________________________
@@ -67,8 +66,16 @@ void AliGenFixed::Generate()
   }
   Int_t i, nt;
   //
+  Float_t o[3];
+  o[0] = fOrigin[0];
+  o[1] = fOrigin[1];
+  o[2] = fOrigin[2];
+
+  printf("Origin %f %f %f \n", o[0], o[1], o[2]);
+  
+  
   for(i=0;i<fNpart;i++) 
-    PushTrack(fTrackIt,-1,fIpart,fP,fOrigin.GetArray(),polar,0,kPPrimary,nt);
+    PushTrack(fTrackIt,-1,fIpart,fP,o ,polar,0,kPPrimary,nt);
 }
   
 //_____________________________________________________________________________
index fb065e2..038d60e 100644 (file)
@@ -97,7 +97,8 @@ AliGenGeVSim::AliGenGeVSim() :
   fPhiFormula(0),
   fCurrentForm(0),
   fPtYHist(0),
-  fPartTypes(0) {
+  fPartTypes(0) 
+{
   //
   //  Default constructor
   // 
@@ -110,7 +111,18 @@ AliGenGeVSim::AliGenGeVSim() :
 
 //////////////////////////////////////////////////////////////////////////////////
 
-AliGenGeVSim::AliGenGeVSim(Float_t psi, Bool_t isMultTotal) : AliGenerator(-1) {
+AliGenGeVSim::AliGenGeVSim(Float_t psi, Bool_t isMultTotal) 
+    : AliGenerator(-1),
+      fModel(0),
+      fPsi(psi),
+      fIsMultTotal(isMultTotal),
+      fPtFormula(0),
+      fYFormula(0),
+      fPhiFormula(0),
+      fCurrentForm(0),
+      fPtYHist(0),
+      fPartTypes(0) 
+ {
   //
   //  Standard Constructor.
   //  
@@ -136,12 +148,28 @@ AliGenGeVSim::AliGenGeVSim(Float_t psi, Bool_t isMultTotal) : AliGenerator(-1) {
   fPsi = psi * TMath::Pi() / 180. ;
   fIsMultTotal = isMultTotal;
 
-  // initialization 
+  // Initialization 
 
   fPartTypes = new TObjArray();
   InitFormula();
 }
 
+AliGenGeVSim::AliGenGeVSim(const AliGenGeVSim & ggs)
+    : AliGenerator(ggs),
+      fModel(0),
+      fPsi(0),
+      fIsMultTotal(0),
+      fPtFormula(0),
+      fYFormula(0),
+      fPhiFormula(0),
+      fCurrentForm(0),
+      fPtYHist(0),
+      fPartTypes(0) 
+{
+    Fatal("copy ctor","Not implemented\n");
+}
+
+
 //////////////////////////////////////////////////////////////////////////////////
 
 AliGenGeVSim::~AliGenGeVSim() {
index 288500e..b7a909f 100644 (file)
@@ -87,10 +87,9 @@ class AliGenGeVSim : public AliGenerator {
   
  private:
 
-  AliGenGeVSim(const AliGenGeVSim & ggs): AliGenerator(ggs)
-    {Fatal("copy ctor","Not implemented\n");}
+  AliGenGeVSim(const AliGenGeVSim & ggs);
   AliGenGeVSim & operator=(const AliGenGeVSim & /*ggs*/)
-    {Fatal("= operator","Not implemented\n"); return *this;}
+      {Fatal("= operator","Not implemented\n"); return *this;}
 
   Int_t   fModel;            // Selected model (1-7)
   Float_t fPsi;              // Reaction Plane angle (0-2pi)
index 4f1d501..27fec95 100644 (file)
@@ -37,26 +37,26 @@ ClassImp(AliGenGeVSimEventHeader)
 ////////////////////////////////////////////////////////////////////////////////
 
 AliGenGeVSimEventHeader::AliGenGeVSimEventHeader()
-  :AliGenEventHeader() {
+  :AliGenEventHeader(),
+   fEventPlane(0),
+   fEllipticFlow(0)
+{
   //
   // Default Constructor 
   //
-
-  fEventPlane = 0;
-  fEllipticFlow = 0;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 
 AliGenGeVSimEventHeader::AliGenGeVSimEventHeader(const char *name)
-  :AliGenEventHeader(name) {
+  :AliGenEventHeader(name),
+   fEventPlane(0),
+   fEllipticFlow(0)
+ {
   //
   // Standard constructor
   //
-  
-  fEventPlane = 0;
-  fEllipticFlow = 0;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
index 802e77b..cf06103 100644 (file)
@@ -100,9 +100,11 @@ AliGenHBTosl::AliGenHBTosl():
  fQRange(0.06),
  fQNBins(60),
  fGenerator(0x0),
+ fStackBuffer(0),
  fBufferSize(5),
  fNBinsToScale(Int_t(fQNBins*0.1)),
  fDebug(0),
+ fSignalShapeCreated(0),
  fMaxIterations(1000),
  fMaxChiSquereChange(0.01),
  fMaxChiSquerePerNDF(1.5), 
@@ -112,6 +114,7 @@ AliGenHBTosl::AliGenHBTosl():
  fSamplePhiMax(TMath::TwoPi()+0.01),
  fSignalRegion(0.0),
  fMinFill(1000),
+ fSwapped(0),
  fLogFile(0x0)
 {
 //default constructor
@@ -129,6 +132,7 @@ AliGenHBTosl::AliGenHBTosl(Int_t n, Int_t pid):
  fQRange(0.06),
  fQNBins(60),
  fGenerator(0x0),
+ fStackBuffer(0),
  fBufferSize(5),
  fNBinsToScale(Int_t(fQNBins*0.1)),
  fDebug(0),
@@ -142,10 +146,43 @@ AliGenHBTosl::AliGenHBTosl(Int_t n, Int_t pid):
  fSamplePhiMax(TMath::TwoPi()+0.01),
  fSignalRegion(0.0),
  fMinFill(1000),
+ fSwapped(0),
  fLogFile(0x0)
 {
 //default constructor
 }
+
+AliGenHBTosl::AliGenHBTosl(const AliGenHBTosl & hbt):
+ AliGenerator(-1),
+ fQCoarseBackground(0x0),
+ fQCoarseSignal(0x0),
+ fQSignal(0x0),
+ fQBackground(0x0),
+ fQSecondSignal(0x0),
+ fQSecondBackground(0x0),
+ fQRange(0.06),
+ fQNBins(60),
+ fGenerator(0x0),
+ fStackBuffer(0),
+ fBufferSize(5),
+ fNBinsToScale(Int_t(fQNBins*0.1)),
+ fDebug(0),
+ fSignalShapeCreated(kFALSE),
+ fMaxIterations(1000),
+ fMaxChiSquereChange(0.01),
+ fMaxChiSquerePerNDF(1.5),
+ fQRadius(8.0),
+ fPID(kPiPlus),
+ fSamplePhiMin(-0.01),
+ fSamplePhiMax(TMath::TwoPi()+0.01),
+ fSignalRegion(0.0),
+ fMinFill(1000),
+ fSwapped(0),
+ fLogFile(0x0)
+{
+// Copy constructor
+    hbt.Copy(*this);
+}
 /***********************************************************/
 
 AliGenHBTosl::~AliGenHBTosl()
@@ -1898,3 +1935,20 @@ void AliGenHBTosl::SwapGeneratingHistograms()
   fSwapped = kTRUE;
   
 }
+
+AliGenHBTosl& AliGenHBTosl::operator=(const  AliGenHBTosl& rhs)
+{
+// Assignment operator
+    rhs.Copy(*this);
+    return *this;
+}
+
+void AliGenHBTosl::Copy(TObject&) const
+{
+    //
+    // Copy 
+    //
+    Fatal("Copy","Not implemented!\n");
+}
+
+
index 2274046..cfa081c 100644 (file)
@@ -63,6 +63,7 @@ class AliGenHBTosl: public AliGenerator
  public:
    AliGenHBTosl();
    AliGenHBTosl(Int_t n,Int_t pid = 211);
+   AliGenHBTosl(const AliGenHBTosl& hbt);
    virtual ~AliGenHBTosl();
 
    void      Init();
@@ -103,6 +104,8 @@ class AliGenHBTosl: public AliGenerator
    void     TestCoarseSignal();
    
    Bool_t CheckParticle(TParticle* p, TParticle* aupair,AliStack* stack);
+   void Copy(TObject&) const;
+   AliGenHBTosl & operator=(const AliGenHBTosl & rhs);
  private:
   TH3D*    fQCoarseBackground;//Initial Background
   TH3D*    fQCoarseSignal;//signal calculated by multiplying coarse background and model function
index 65f33b3..22115af 100644 (file)
 ClassImp(AliGenHIJINGpara)
 
 
-AliGenHIJINGpara::AliGenHIJINGpara(const AliGenHIJINGpara & para):
-    AliGenerator(para)
-{
-// Copy constructor
-    para.Copy(*this);
-}
 
 //_____________________________________________________________________________
 static Double_t ptpi(Double_t *px, Double_t *)
@@ -164,42 +158,63 @@ static Double_t etakac( Double_t *py, Double_t *)
 
 //_____________________________________________________________________________
 AliGenHIJINGpara::AliGenHIJINGpara()
-  :AliGenerator()
+    :AliGenerator(),
+       fNt(-1),
+       fNpartProd(0),
+       fPi0Decays(kFALSE),
+       fPtWgtPi(0.),
+       fPtWgtKa(0.),
+       fPtpi(0),
+       fPtka(0),
+       fETApic(0),
+       fETAkac(0),
+       fDecayer(0)
 {
     //
     // Default constructor
     //
-    fPtpi    =  0;
-    fPtka    =  0;
-    fETApic  =  0;
-    fETAkac  =  0;
-    fDecayer =  0;
-    fNt      = -1;
-    fNpartProd = 0;
     SetCutVertexZ();
     SetPtRange();
-    SetPi0Decays();
 }
 
 //_____________________________________________________________________________
 AliGenHIJINGpara::AliGenHIJINGpara(Int_t npart)
-  :AliGenerator(npart)
+    :AliGenerator(npart),
+       fNt(-1),
+       fNpartProd(npart),
+       fPi0Decays(kFALSE),
+       fPtWgtPi(0.),
+       fPtWgtKa(0.),
+       fPtpi(0),
+       fPtka(0),
+       fETApic(0),
+       fETAkac(0),
+       fDecayer(0)
 {
   // 
   // Standard constructor
   //
     fName="HIJINGpara";
     fTitle="HIJING Parametrisation Particle Generator";
-    fPtpi    =  0;
-    fPtka    =  0;
-    fETApic  =  0;
-    fETAkac  =  0;
-    fDecayer =  0;
-    fNt      = -1;
-    fNpartProd = npart;
     SetCutVertexZ();
     SetPtRange();
-    SetPi0Decays();
+}
+
+AliGenHIJINGpara::AliGenHIJINGpara(const AliGenHIJINGpara & para):
+    AliGenerator(para),
+    fNt(-1),
+    fNpartProd(0),
+    fPi0Decays(kFALSE),
+    fPtWgtPi(0.),
+    fPtWgtKa(0.),
+    fPtpi(0),
+    fPtka(0),
+    fETApic(0),
+    fETAkac(0),
+    fDecayer(0)
+{
+// Copy constructor
+    para.Copy(*this);
 }
 
 //_____________________________________________________________________________
index 683ad4c..5d584a6 100644 (file)
@@ -153,31 +153,34 @@ static Double_t etakac( Double_t *py, Double_t *)
 }
 
 AliGenHIJINGparaBa::AliGenHIJINGparaBa()
-  :AliGenHIJINGpara()
+    :AliGenHIJINGpara(),
+     fPtba(0),
+     fETAba(0)
 {
     //
     // Default constructor
     //
     fName="HIGINGparaBa";
     fTitle="HIJING Parametrisation Particle Generator with Baryons";
-    fETAba = 0;
-    fPtba  = 0;
 }
 
 //_____________________________________________________________________________
 AliGenHIJINGparaBa::AliGenHIJINGparaBa(Int_t npart)
-  :AliGenHIJINGpara(npart)
+  :AliGenHIJINGpara(npart),
+     fPtba(0),
+     fETAba(0)
 {
   // 
   // Standard constructor
   //
     fName="HIGINGparaBa";
     fTitle="HIJING Parametrisation Particle Generator with Baryons";
-    fETAba = 0;
-    fPtba  = 0;
 }
 
-AliGenHIJINGparaBa::AliGenHIJINGparaBa(const AliGenHIJINGparaBa& para) : AliGenHIJINGpara(para)
+AliGenHIJINGparaBa::AliGenHIJINGparaBa(const AliGenHIJINGparaBa& para) : 
+    AliGenHIJINGpara(para),
+    fPtba(0),
+    fETAba(0)                                                                  
 {
 // Copy constructor
     para.Copy(*this);
index 7f91486..f69483c 100644 (file)
@@ -32,7 +32,9 @@
 ClassImp(AliGenHalo)
 
 AliGenHalo::AliGenHalo()
-    :AliGenerator(-1)
+    :AliGenerator(-1),
+     fp(0),
+     fFileName(0)
 {
 // Constructor
     fName="Halo";
@@ -40,11 +42,12 @@ AliGenHalo::AliGenHalo()
 //
 //  Read all particles
     fNpart=-1;
-    fp=0;
 }
 
 AliGenHalo::AliGenHalo(Int_t npart)
-    :AliGenerator(npart)
+    :AliGenerator(npart),
+     fp(0),
+     fFileName(0)
 {
 // Constructor
     fName="Halo";
@@ -52,11 +55,12 @@ AliGenHalo::AliGenHalo(Int_t npart)
 //
 //  Read all particles
     fNpart=-1;
-    fp=0;
 }
 
 AliGenHalo::AliGenHalo(const AliGenHalo & Halo)
-    :AliGenerator(Halo)
+    :AliGenerator(Halo),
+     fp(0),
+     fFileName(0)
 {
 // Copy constructor
     Halo.Copy(*this);
index 9270eeb..900ddda 100644 (file)
 ClassImp(AliGenHaloProtvino)
 
 AliGenHaloProtvino::AliGenHaloProtvino()
-    :AliGenerator(-1)
+    :AliGenerator(-1), 
+     fFile(0),
+     fFileName(0),
+     fSide(1),
+     fRunPeriod(kY3D90),
+     fTimePerEvent(1.e-4),
+     fNskip(0),
+     fZ1(0),
+     fZ2(0),
+     fG1(0),
+     fG2(0),
+     fGPASize(0)
 {
 // Constructor
     
@@ -44,32 +55,45 @@ AliGenHaloProtvino::AliGenHaloProtvino()
 //
 //  Read all particles
     fNpart = -1;
-    fFile  =  0;
-    fSide  =  1;
-//
-    SetRunPeriod();
-    SetTimePerEvent();
     SetAnalog(0);
 }
 
 AliGenHaloProtvino::AliGenHaloProtvino(Int_t npart)
-    :AliGenerator(npart)
+    :AliGenerator(npart),
+     fFile(0),
+     fFileName(0),
+     fSide(1),
+     fRunPeriod(kY3D90),
+     fTimePerEvent(1.e-4),
+     fNskip(0),
+     fZ1(0),
+     fZ2(0),
+     fG1(0),
+     fG2(0),
+     fGPASize(0)
 {
 // Constructor
     fName = "Halo";
     fTitle= "Halo from LHC Tunnel";
 //
     fNpart   = npart;
-    fFile    = 0;
-    fSide    = 1;
 //
-    SetRunPeriod();
-    SetTimePerEvent();
     SetAnalog(0);
 }
 
 AliGenHaloProtvino::AliGenHaloProtvino(const AliGenHaloProtvino & HaloProtvino):
-    AliGenerator(HaloProtvino)
+    AliGenerator(HaloProtvino),
+    fFile(0),
+    fFileName(0),
+    fSide(1),
+    fRunPeriod(kY3D90),
+    fTimePerEvent(1.e-4),
+    fNskip(0),
+    fZ1(0),
+    fZ2(0),
+    fG1(0),
+    fG2(0),
+    fGPASize(0)
 {
 // Copy constructor
     HaloProtvino.Copy(*this);
index a8e4e36..63872c8 100644 (file)
 ClassImp(AliGenMC)
 
 AliGenMC::AliGenMC()
-    :AliGenerator()
+    :AliGenerator(),
+     fParticles(0),
+     fParentSelect(8),
+     fChildSelect(8),
+     fCutOnChild(0),
+     fChildPtMin(0.),
+     fChildPtMax(1.e10),
+     fChildPMin(0.),
+     fChildPMax(1.e10),
+     fChildPhiMin(0.),
+     fChildPhiMax(2. * TMath::Pi()),
+     fChildThetaMin(0.),
+     fChildThetaMax(TMath::Pi()),
+     fChildYMin(-12.),
+     fChildYMax(12.),
+     fXingAngleX(0.),
+     fXingAngleY(0.),
+     fForceDecay(kAll),
+     fMaxLifeTime(1.e-15),
+     fAProjectile(1),
+     fZProjectile(1),
+     fATarget(1),
+     fZTarget(1),
+     fProjectile("P"),
+     fTarget("P"),    
+     fDyBoost(0.),
+     fGeometryAcceptance(0),
+     fPdgCodeParticleforAcceptanceCut(0),
+     fNumberOfAcceptedParticles(2)
 {
 // Default Constructor
-    SetCutOnChild();
-    SetChildMomentumRange();
-    SetChildPtRange();
-    SetChildPhiRange();
-    SetChildThetaRange(); 
-    SetChildYRange(); 
-    SetMaximumLifetime();
-    SetGeometryAcceptance();
-    SetPdgCodeParticleforAcceptanceCut();
-    SetNumberOfAcceptedParticles();
-    SetTarget();
-    SetProjectile();
-    fParentSelect.Set(8);
-    fChildSelect.Set(8);
-    fForceDecay = kAll;
 }
 
 AliGenMC::AliGenMC(Int_t npart)
-    :AliGenerator(npart)
+    :AliGenerator(npart),
+     fParticles(0),
+     fParentSelect(8),
+     fChildSelect(8),
+     fCutOnChild(0),
+     fChildPtMin(0.),
+     fChildPtMax(1.e10),
+     fChildPMin(0.),
+     fChildPMax(1.e10),
+     fChildPhiMin(0.),
+     fChildPhiMax(2. * TMath::Pi()),
+     fChildThetaMin(0.),
+     fChildThetaMax(TMath::Pi()),
+     fChildYMin(-12.),
+     fChildYMax(12.),
+     fXingAngleX(0.),
+     fXingAngleY(0.),
+     fForceDecay(kAll),
+     fMaxLifeTime(1.e-15),
+     fAProjectile(1),
+     fZProjectile(1),
+     fATarget(1),
+     fZTarget(1),
+     fProjectile("P"),
+     fTarget("P"),    
+     fDyBoost(0.),
+     fGeometryAcceptance(0),
+     fPdgCodeParticleforAcceptanceCut(0),
+     fNumberOfAcceptedParticles(2)
 {
 //  Constructor
-    SetCutOnChild();
-    SetChildMomentumRange();
-    SetChildPtRange();
-    SetChildPhiRange();
-    SetChildThetaRange();
-    SetChildYRange(); 
 // 
-    fParentSelect.Set(8);
-    fChildSelect.Set(8);
     for (Int_t i=0; i<8; i++) fParentSelect[i]=fChildSelect[i]=0;
-    SetMaximumLifetime();
-    SetGeometryAcceptance();
-    SetPdgCodeParticleforAcceptanceCut();
-    SetNumberOfAcceptedParticles();
-    SetTarget();
-    SetProjectile();
-    fForceDecay = kAll;
 }
 
 AliGenMC::AliGenMC(const AliGenMC & mc):
-    AliGenerator(mc)
+    AliGenerator(mc),
+    fParticles(0),
+    fParentSelect(8),
+    fChildSelect(8),
+    fCutOnChild(0),
+    fChildPtMin(0.),
+    fChildPtMax(1.e10),
+    fChildPMin(0.),
+    fChildPMax(1.e10),
+    fChildPhiMin(0.),
+    fChildPhiMax(2. * TMath::Pi()),
+    fChildThetaMin(0.),
+    fChildThetaMax(TMath::Pi()),
+    fChildYMin(-12.),
+    fChildYMax(12.),
+    fXingAngleX(0.),
+    fXingAngleY(0.),
+    fForceDecay(kAll),
+    fMaxLifeTime(1.e-15),
+    fAProjectile(1),
+    fZProjectile(1),
+    fATarget(1),
+    fZTarget(1),
+    fProjectile("P"),
+    fTarget("P"),    
+    fDyBoost(0.),
+    fGeometryAcceptance(0),
+    fPdgCodeParticleforAcceptanceCut(0),
+    fNumberOfAcceptedParticles(2)
 {
 // Copy constructor
     mc.Copy(*this);
index a014553..623c79c 100644 (file)
@@ -57,7 +57,8 @@ class AliGenMC : public AliGenerator
     virtual void   SetProjectile(TString proj="P", Int_t a = 1, Int_t z = 1)
        {fProjectile = proj; fAProjectile = a; fZProjectile = z;}    
     virtual void   SetTarget(TString tar="P", Int_t a = 1, Int_t z = 1)
-       {fTarget = tar; fATarget = a; fZTarget = z;}    
+       {fTarget = tar; fATarget = a; fZTarget = z;}
+    virtual void   SetCrossingAngle(Float_t phiX, Float_t phiY) {fXingAngleX = phiX; fXingAngleY = phiY;}
     virtual void Boost();
 
  protected:
@@ -84,6 +85,8 @@ class AliGenMC : public AliGenerator
     Float_t     fChildThetaMax; // Children maximum theta
     Float_t     fChildYMin;     // Children minimum y
     Float_t     fChildYMax;     // Children maximum y
+    Float_t     fXingAngleX;    // Crossing angle X
+    Float_t     fXingAngleY;    // Crossing angle Y    
     Decay_t     fForceDecay;    // Decay channel forced
     Float_t     fMaxLifeTime;   // Maximum lifetime for unstable particles
     Int_t       fAProjectile;   // Projectile A
index badde6d..5968c64 100644 (file)
@@ -47,50 +47,51 @@ ClassImp(AliGenMUONCocktail)
   
 //________________________________________________________________________
 AliGenMUONCocktail::AliGenMUONCocktail()
-  :AliGenCocktail()
+    :AliGenCocktail(),
+     fFastGlauber (0x0),
+     fTotalRate(0),  
+     fMuonMultiplicity(1),
+     fMuonPtCut(1.),
+     fMuonThetaMinCut(171.), 
+     fMuonThetaMaxCut(178.),
+     fNSucceded(0), 
+     fNGenerated(0), 
+     fLowImpactParameter(0.),
+     fHighImpactParameter(5.),
+     fAverageImpactParameter(0.),
+     fNumberOfCollisions(0.), 
+     fNumberOfParticipants(0.),
+     fHadronicMuons(kTRUE),
+     fInvMassCut (kFALSE),
+     fInvMassMinCut (0.),
+     fInvMassMaxCut (100.)
 {
 // Constructor
-  fFastGlauber =0x0;
-  fTotalRate =0;  
-  fNSucceded=0; 
-  fNGenerated=0; 
-  fMuonMultiplicity=1;
-  fMuonPtCut= 1.;
-  fMuonThetaMinCut=171.; 
-  fMuonThetaMaxCut=178.;
-  fLowImpactParameter = 0.;
-  fHighImpactParameter = 5.;
-  fAverageImpactParameter =0.;
-  fNumberOfCollisions   = 0.; 
-  fNumberOfParticipants = 0.;
-  fHadronicMuons = kTRUE;
-  fInvMassCut = kFALSE;
-  fInvMassMinCut = 0.;
-  fInvMassMaxCut = 100.;
 }
 //_________________________________________________________________________
 AliGenMUONCocktail::AliGenMUONCocktail(const AliGenMUONCocktail & cocktail):
-    AliGenCocktail(cocktail)
+    AliGenCocktail(cocktail),
+    fFastGlauber(0x0),
+    fTotalRate(0),  
+    fMuonMultiplicity(1),
+    fMuonPtCut(1.),
+    fMuonThetaMinCut(171.), 
+    fMuonThetaMaxCut(178.),
+    fNSucceded(0), 
+    fNGenerated(0), 
+    fLowImpactParameter(0.),
+    fHighImpactParameter(5.),
+    fAverageImpactParameter(0.),
+    fNumberOfCollisions(0.), 
+    fNumberOfParticipants(0.),
+    fHadronicMuons(kTRUE),
+    fInvMassCut (kFALSE),
+    fInvMassMinCut (0.),
+    fInvMassMaxCut (100.)
 {
 // Copy constructor
-  fFastGlauber =0x0;
-  fTotalRate =0; 
-  fNSucceded=0; 
-  fNGenerated=0; 
-  fMuonMultiplicity=1;
-  fMuonPtCut= 1.;
-  fMuonThetaMinCut=171.; 
-  fMuonThetaMaxCut=178.;  
-  fLowImpactParameter = 0.;
-  fHighImpactParameter = 5.;
-  fAverageImpactParameter =0.;
-  fNumberOfCollisions = 0.; 
-  fNumberOfParticipants = 0.;
-  fHadronicMuons = kTRUE;
-  fInvMassCut = kFALSE;
-  fInvMassMinCut = 0.;
-  fInvMassMaxCut = 100.;
 }
+
 //_________________________________________________________________________
 AliGenMUONCocktail::~AliGenMUONCocktail()
 {
@@ -475,7 +476,17 @@ void AliGenMUONCocktail::Generate()
 }
 
 
+AliGenMUONCocktail& AliGenMUONCocktail::operator=(const  AliGenMUONCocktail& rhs)
+{
+// Assignment operator
+    rhs.Copy(*this);
+    return *this;
+}
 
+void AliGenMUONCocktail::Copy(TObject &) const
+{
+    Fatal("Copy","Not implemented!\n");
+}
 
 
 
index b130192..05b203d 100644 (file)
@@ -56,9 +56,9 @@ class AliGenMUONCocktail : public AliGenCocktail
       { fInvMassMinCut=MassMin; 
         fInvMassMaxCut=MassMax;
         fInvMassCut = kTRUE; }
-
- protected:
+ private:
+    AliGenMUONCocktail& operator=(const AliGenMUONCocktail & rhs);
+    void Copy(TObject &cocktail) const;
     //
  private:
     AliFastGlauber *  fFastGlauber; //! Fast glauber calculations
index 4441a24..5d4fde5 100644 (file)
@@ -45,29 +45,29 @@ ClassImp(AliGenMUONCocktailpp)
   
 //________________________________________________________________________
 AliGenMUONCocktailpp::AliGenMUONCocktailpp()
-  :AliGenCocktail()
+    :AliGenCocktail(),
+     fTotalRate(0),
+     fMuonMultiplicity(0),
+     fMuonPtCut(0.),
+     fMuonThetaMinCut(0.), 
+     fMuonThetaMaxCut(0.),
+     fNSucceded(0), 
+     fNGenerated(0)
 {
 // Constructor
-  fTotalRate =0;
-  fNSucceded=0; 
-  fNGenerated=0;
-  fMuonMultiplicity=0;
-  fMuonPtCut= 0.;
-  fMuonThetaMinCut=0.; 
-  fMuonThetaMaxCut=0.;
 }
 //_________________________________________________________________________
 AliGenMUONCocktailpp::AliGenMUONCocktailpp(const AliGenMUONCocktailpp & cocktail):
-    AliGenCocktail(cocktail)
+    AliGenCocktail(cocktail),
+    fTotalRate(0),
+    fMuonMultiplicity(0),
+    fMuonPtCut(0.),
+    fMuonThetaMinCut(0.), 
+    fMuonThetaMaxCut(0.),
+    fNSucceded(0), 
+    fNGenerated(0)
 {
 // Copy constructor
-  fTotalRate =0;
-  fNSucceded=0; 
-  fNGenerated=0;
-  fMuonMultiplicity=0;
-  fMuonPtCut=0.;
-  fMuonThetaMinCut=0.; 
-  fMuonThetaMaxCut=0.;
 }
 //_________________________________________________________________________
 AliGenMUONCocktailpp::~AliGenMUONCocktailpp()
index dac627b..289e2d2 100644 (file)
@@ -49,53 +49,73 @@ ClassImp(AliGenParam)
   //End_Html
 
 //____________________________________________________________
-AliGenParam::AliGenParam()
+    AliGenParam::AliGenParam():
+       fPtParaFunc(0),
+       fYParaFunc(0),
+       fIpParaFunc(0),
+       fPtPara(0),
+       fYPara(0),
+       fParam(0),
+       fdNdy0(0.),
+       fYWgt(0.),
+       fPtWgt(0.),
+       fBias(0.),
+       fTrials(0),
+       fDeltaPt(0.01),
+       fDecayer(0)
 {
-// Deafault constructor
-    fPtPara = 0;
-    fYPara  = 0;
-    fParam  = 0;
-    fAnalog = kAnalog;
-    SetDeltaPt();
-    fDecayer = 0;
-
-
+// Default constructor
 }
 //____________________________________________________________
-AliGenParam::AliGenParam(Int_t npart, AliGenLib * Library,  Int_t param, char* tname):AliGenMC(npart)
+AliGenParam::AliGenParam(Int_t npart, AliGenLib * Library,  Int_t param, char* tname)
+    :AliGenMC(npart),
+     fPtParaFunc(Library->GetPt(param, tname)),
+     fYParaFunc (Library->GetY (param, tname)),
+     fIpParaFunc(Library->GetIp(param, tname)),
+     fPtPara(0),
+     fYPara(0),
+     fParam(param),
+     fdNdy0(0.),
+     fYWgt(0.),
+     fPtWgt(0.),
+     fBias(0.),
+     fTrials(0),
+     fDeltaPt(0.01),
+     fDecayer(0)
 {
 // Constructor using number of particles parameterisation id and library
     fName = "Param";
     fTitle= "Particle Generator using pT and y parameterisation";
-    
-    fPtParaFunc = Library->GetPt(param, tname);
-    fYParaFunc  = Library->GetY (param, tname);
-    fIpParaFunc = Library->GetIp(param, tname);
-    
-    fPtPara = 0;
-    fYPara  = 0;
-    fParam  = param;
     fAnalog = kAnalog;
     SetForceDecay();
-    SetDeltaPt(); 
 }
 //____________________________________________________________
-AliGenParam::AliGenParam(Int_t npart, Int_t param, const char* tname, const char* name):AliGenMC(npart)
+AliGenParam::AliGenParam(Int_t npart, Int_t param, const char* tname, const char* name):
+    AliGenMC(npart),
+    fPtParaFunc(0),
+    fYParaFunc (0),
+    fIpParaFunc(0),
+    fPtPara(0),
+    fYPara(0),
+    fParam(param),
+    fdNdy0(0.),
+    fYWgt(0.),
+    fPtWgt(0.),
+    fBias(0.),
+    fTrials(0),
+    fDeltaPt(0.01),
+    fDecayer(0)
 {
 // Constructor using parameterisation id and number of particles
 //
-  fName = name;
-  fTitle= "Particle Generator using pT and y parameterisation";
+    fName = name;
+    fTitle= "Particle Generator using pT and y parameterisation";
       
     AliGenLib* pLibrary = new AliGenMUONlib();
     fPtParaFunc = pLibrary->GetPt(param, tname);
     fYParaFunc  = pLibrary->GetY (param, tname);
     fIpParaFunc = pLibrary->GetIp(param, tname);
     
-    fPtPara = 0;
-    fYPara  = 0;
-    fParam  = param;
     fAnalog = kAnalog;
     fChildSelect.Set(5);
     for (Int_t i=0; i<5; i++) fChildSelect[i]=0;
@@ -105,7 +125,6 @@ AliGenParam::AliGenParam(Int_t npart, Int_t param, const char* tname, const char
     SetChildPtRange();
     SetChildPhiRange();
     SetChildThetaRange(); 
-    SetDeltaPt(); 
 }
 //____________________________________________________________
 
@@ -113,20 +132,27 @@ AliGenParam::AliGenParam(Int_t npart, Int_t param,
                          Double_t (*PtPara) (Double_t*, Double_t*),
                          Double_t (*YPara ) (Double_t* ,Double_t*),
                         Int_t    (*IpPara) (TRandom *))                 
-    :AliGenMC(npart)
+    :AliGenMC(npart),
+     
+     fPtParaFunc(PtPara),
+     fYParaFunc(YPara),
+     fIpParaFunc(IpPara),
+     fPtPara(0),
+     fYPara(0),
+     fParam(param),
+     fdNdy0(0.),
+     fYWgt(0.),
+     fPtWgt(0.),
+     fBias(0.),
+     fTrials(0),
+     fDeltaPt(0.01),
+     fDecayer(0)
 {
 // Constructor
 // Gines Martinez 1/10/99 
     fName = "Param";
     fTitle= "Particle Generator using pT and y parameterisation";
 
-    fPtParaFunc = PtPara; 
-    fYParaFunc  = YPara;  
-    fIpParaFunc = IpPara;
-//  
-    fPtPara = 0;
-    fYPara  = 0;
-    fParam  = param;
     fAnalog = kAnalog;
     fChildSelect.Set(5);
     for (Int_t i=0; i<5; i++) fChildSelect[i]=0;
@@ -136,12 +162,24 @@ AliGenParam::AliGenParam(Int_t npart, Int_t param,
     SetChildPtRange();
     SetChildPhiRange();
     SetChildThetaRange();  
-    SetDeltaPt();
 }
 
 
 AliGenParam::AliGenParam(const AliGenParam & Param)
-    :AliGenMC(Param)
+    :AliGenMC(Param),  
+     fPtParaFunc(0),
+     fYParaFunc(0),
+     fIpParaFunc(0),
+     fPtPara(0),
+     fYPara(0),
+     fParam(0),
+     fdNdy0(0.),
+     fYWgt(0.),
+     fPtWgt(0.),
+     fBias(0.),
+     fTrials(0),
+     fDeltaPt(0.01),
+     fDecayer(0)
 {
 // Copy constructor
     Param.Copy(*this);
index 6e0d333..82f68d9 100644 (file)
 
 #include "AliGenReaderCwn.h"
 
-ClassImp(AliGenReaderCwn)
-
-
-AliGenReaderCwn::AliGenReaderCwn() 
+ClassImp(AliGenReaderCwn);
+
+AliGenReaderCwn::AliGenReaderCwn():
+    fNcurrent(0),
+    fNparticle(0),
+    fNparticleMax(0),
+    fTreeNtuple(0),
+    fNihead(0),
+    fNrhead(0),
+    fIdpart(0),
+    fTheta(0.),
+    fPhi(0.),
+    fP(0.),
+    fE(0.)
 {
 // Default constructor
-    fNcurrent   = 0;
-    fTreeNtuple = 0;
 }
 
+AliGenReaderCwn::AliGenReaderCwn(const AliGenReaderCwn &reader):
+    AliGenReader(reader),
+    fNcurrent(0),
+    fNparticle(0),
+    fNparticleMax(0),
+    fTreeNtuple(0),
+    fNihead(0),
+    fNrhead(0),
+    fIdpart(0),
+    fTheta(0.),
+    fPhi(0.),
+    fP(0.),
+    fE(0.)
+{
+    // Copy constructor
+    reader.Copy(*this);
+}
+
+
 AliGenReaderCwn::~AliGenReaderCwn()
 {
     delete fTreeNtuple;
index 95d4a60..76939d8 100644 (file)
@@ -18,9 +18,7 @@ class AliGenReaderCwn : public AliGenReader
 {
  public:
     AliGenReaderCwn();
-    
-    AliGenReaderCwn(const AliGenReaderCwn &reader):AliGenReader(reader)
-       {reader.Copy(*this);}
+    AliGenReaderCwn(const AliGenReaderCwn &reader);
     virtual ~AliGenReaderCwn();
         // Initialise 
     virtual void Init();
index ff6f218..4dad99d 100644 (file)
 
 #include "AliGenReaderEMD.h"
 
-ClassImp(AliGenReaderEMD)
-
-
-  // -----------------------------------------------------------------------------------
-AliGenReaderEMD::AliGenReaderEMD() 
+ClassImp(AliGenReaderEMD);
+
+AliGenReaderEMD::AliGenReaderEMD():
+    fStartEvent(0),
+    fNcurrent(0),  
+    fNparticle(0), 
+    fTreeNtuple(0),
+    fIPSide(0),
+    fPcToTrack(0),
+    fNnLeft(0),
+    fEnLeft(0),
+    fNnRight(0),
+    fEnRight(0),
+    fNpLeft(0),
+    fEtapLeft(0),
+    fNpRight(0),
+    fEtapRight(0)
 {
 // Default constructor
-    fStartEvent  = 0;
-    fTreeNtuple  = 0;
-    fIPSide      = 0;
-    fPcToTrack = 0;
 }
 
+AliGenReaderEMD::AliGenReaderEMD(const AliGenReaderEMD &reader):
+    AliGenReader(reader),
+    fStartEvent(0),
+    fNcurrent(0),  
+    fNparticle(0), 
+    fTreeNtuple(0),
+    fIPSide(0),
+    fPcToTrack(0),
+    fNnLeft(0),
+    fEnLeft(0),
+    fNnRight(0),
+    fEnRight(0),
+    fNpLeft(0),
+    fEtapLeft(0),
+    fNpRight(0),
+    fEtapRight(0)
+{
+    // Copy Constructor
+    reader.Copy(*this);
+}
   // -----------------------------------------------------------------------------------
 AliGenReaderEMD::~AliGenReaderEMD()
 {
index 390d777..57e7baa 100644 (file)
@@ -16,8 +16,7 @@ class AliGenReaderEMD : public AliGenReader
  public:
     AliGenReaderEMD();
     
-    AliGenReaderEMD(const AliGenReaderEMD &reader):AliGenReader(reader)
-       {reader.Copy(*this);}
+    AliGenReaderEMD(const AliGenReaderEMD &reader);
     virtual ~AliGenReaderEMD();
     AliGenReaderEMD & operator=(const AliGenReaderEMD & rhs);
     // Initialise 
index 9c55549..c00cb9c 100644 (file)
 
 #include "AliGenReaderEcalHijing.h"
 
-ClassImp(AliGenReaderEcalHijing)
-
-
-AliGenReaderEcalHijing::AliGenReaderEcalHijing() 
+ClassImp(AliGenReaderEcalHijing);
+
+AliGenReaderEcalHijing::AliGenReaderEcalHijing():
+    fNcurrent(0),
+    fNparticle(0),
+    fTreeNtuple(0),
+    fNjatt(0),
+    fNahij(0),
+    fNphij(0)
 {
 // Default constructor
-    fNcurrent   = 0;
-    fTreeNtuple = 0;
+}
+
+AliGenReaderEcalHijing::AliGenReaderEcalHijing(const AliGenReaderEcalHijing &reader):
+    AliGenReader(reader),
+    fNcurrent(0),
+    fNparticle(0),
+    fTreeNtuple(0),
+    fNjatt(0),
+    fNahij(0),
+    fNphij(0)
+{
+    // Copy constructor
+    reader.Copy(*this);
 }
 
 void AliGenReaderEcalHijing::Init() 
index b858ae7..b9af2ed 100644 (file)
@@ -18,8 +18,7 @@ class AliGenReaderEcalHijing : public AliGenReader
  public:
     AliGenReaderEcalHijing();
     
-    AliGenReaderEcalHijing(const AliGenReaderEcalHijing &reader):AliGenReader(reader)
-       {reader.Copy(*this);}
+    AliGenReaderEcalHijing(const AliGenReaderEcalHijing &reader);
     virtual ~AliGenReaderEcalHijing(){;}
     // Initialise 
     virtual void Init();
index 90a5752..f982aaa 100644 (file)
 ClassImp(AliGenReaderEcalJets)
 
 
-AliGenReaderEcalJets::AliGenReaderEcalJets() 
+AliGenReaderEcalJets::AliGenReaderEcalJets():
+    fNcurrent(0),
+    fNparticle(0),
+    fNev(0),
+    fNpart(0),
+    fNjet(0),     
+    fNsjet(0),
+    fNpjet(0),
+    fTreeNtuple(0) 
 {
 // Default constructor
-    fNcurrent   = 0;
-    fTreeNtuple = 0;
+}
+
+ AliGenReaderEcalJets::AliGenReaderEcalJets(const AliGenReaderEcalJets &reader)
+     :AliGenReader(reader),
+      fNcurrent(0),
+      fNparticle(0),
+      fNev(0),
+      fNpart(0),
+      fNjet(0),     
+      fNsjet(0),
+      fNpjet(0),
+      fTreeNtuple(0) 
+{
+    // Copy Constructor
+    reader.Copy(*this);
 }
 
 void AliGenReaderEcalJets::Init() 
index 032793c..41cc85a 100644 (file)
@@ -16,9 +16,7 @@ class AliGenReaderEcalJets : public AliGenReader
 {
  public:
     AliGenReaderEcalJets();
-    
-    AliGenReaderEcalJets(const AliGenReaderEcalJets &reader):AliGenReader(reader)
-       {reader.Copy(*this);}
+    AliGenReaderEcalJets(const AliGenReaderEcalJets &reader);
     virtual ~AliGenReaderEcalJets(){;}
     // Initialise 
     virtual void Init();
index 7ea64c3..c55f4cc 100644 (file)
  ClassImp(AliGenScan)
     
  AliGenScan::AliGenScan()
-        :AliGenerator(-1)
+     :AliGenerator(-1), 
+      fXCmin(0),
+      fXCmax(0),
+      fNx(1),
+      fYCmin(0),
+      fYCmax(0),
+      fNy(1),
+      fZmin(0),
+      fZmax(0),
+      fNz(1),
+      fIpart(0)
 {
 // Constructor
-    fXCmin=0;
-    fXCmax=0;
-    fNx=1;
-    fYCmin=0;
-    fYCmax=0;
-    fNy=1;
-    fZmin=0;
-    fZmax=0;
-    fNz=1;
 //
 //  Read all particles
     fNpart=-1;
 }
 
 AliGenScan::AliGenScan(Int_t npart)
-    :AliGenerator(npart)
+    :AliGenerator(npart), 
+      fXCmin(0),
+      fXCmax(0),
+      fNx(1),
+      fYCmin(0),
+      fYCmax(0),
+      fNy(1),
+      fZmin(0),
+      fZmax(0),
+      fNz(1),
+      fIpart(0)
 {
 // Constructor
     fName  = "Scan";
     fTitle = "Generator for particles on a grid";
-
-
-    fXCmin=0;
-    fXCmax=0;
-    fNx=1;
-    fYCmin=0;
-    fYCmax=0;
-    fNy=1;
-    fZmin=0;
-    fZmax=0;
-    fNz=1;
 }
 
 //____________________________________________________________
index b408a22..6edf90b 100644 (file)
 #include "AliGenSlowNucleons.h"
 #include "AliSlowNucleonModel.h"
 
- ClassImp(AliGenSlowNucleons)
+ClassImp(AliGenSlowNucleons);
+
     
- AliGenSlowNucleons::AliGenSlowNucleons():AliGenerator(-1)
+AliGenSlowNucleons::AliGenSlowNucleons()
+    :AliGenerator(-1),
+     fCMS(0.),
+     fMomentum(0.),
+     fBeta(0.),
+     fPmax (0.),
+     fATarget (0.),
+     fZTarget (0.),
+     fCharge(0),
+     fProtonDirection(0.),
+     fTemperatureG(0.), 
+     fBetaSourceG(0.),
+     fTemperatureB(0.),
+     fBetaSourceB(0.),
+     fNgp(0),
+     fNgn(0),
+     fNbp(0),
+     fNbn(0),
+     fDebug(0),
+     fDebugHist1(0),
+     fDebugHist2(0),
+     fThetaDistribution(),
+     fCosThetaGrayHist(),
+     fCosTheta(),
+     fSlowNucleonModel(0)
 {
 // Default constructor
-    fSlowNucleonModel = 0;
     fCollisionGeometry = 0;
-    fDebugHist1 = 0;
-    fDebugHist2 = 0;
 }
 
 AliGenSlowNucleons::AliGenSlowNucleons(Int_t npart)
-    :AliGenerator(npart)
+    :AliGenerator(npart),
+     fCMS(14000.),
+     fMomentum(0.),
+     fBeta(0.),
+     fPmax (10.),
+     fATarget (208.),
+     fZTarget (82.),
+     fCharge(1),
+     fProtonDirection(0.),
+     fTemperatureG(0.04), 
+     fBetaSourceG(0.05),
+     fTemperatureB(0.004),
+     fBetaSourceB(0.),
+     fNgp(0),
+     fNgn(0),
+     fNbp(0),
+     fNbn(0),
+     fDebug(0),
+     fDebugHist1(0),
+     fDebugHist2(0),
+     fThetaDistribution(),
+     fCosThetaGrayHist(),
+     fCosTheta(),
+     fSlowNucleonModel(new AliSlowNucleonModel())
 {
 // Constructor
     fName  = "SlowNucleons";
     fTitle = "Generator for gray particles in pA collisions";
-    SetPmax();
-    SetTarget();
-    SetNominalCmsEnergy();
-    SetCharge();
-    SetTemperature();
-    SetBetaSource();
-    fSlowNucleonModel = new AliSlowNucleonModel();
     fCollisionGeometry = 0;
-    fDebug = 0;
 }
 
 //____________________________________________________________
 AliGenSlowNucleons::AliGenSlowNucleons(const AliGenSlowNucleons & sn):
-    AliGenerator(sn)
+    AliGenerator(sn),
+    fCMS(0.),
+    fMomentum(0.),
+    fBeta(0.),
+    fPmax (0.),
+    fATarget (0.),
+    fZTarget (0.),
+    fCharge(0),
+    fProtonDirection(0.),
+    fTemperatureG(0.), 
+    fBetaSourceG(0.),
+    fTemperatureB(0.),
+    fBetaSourceB(0.),
+    fNgp(0),
+    fNgn(0),
+    fNbp(0),
+    fNbn(0),
+    fDebug(0),
+    fDebugHist1(0),
+    fDebugHist2(0),
+    fThetaDistribution(),
+    fCosThetaGrayHist(),
+    fCosTheta(),
+    fSlowNucleonModel(0)
 {
 // Copy constructor
     sn.Copy(*this);
index 3d03432..a9077c3 100644 (file)
@@ -37,25 +37,24 @@ ClassImp(AliGenThetaSlice)
 
 //_____________________________________________________________________________
 AliGenThetaSlice::AliGenThetaSlice()
-    :AliGenerator()
+    :AliGenerator(),
+     fIpart(0)
 {
   //
   // Default constructor
   //
-  fIpart=0;
 }
 
 //_____________________________________________________________________________
 AliGenThetaSlice::AliGenThetaSlice(Int_t npart)
-  :AliGenerator(npart)
+    :AliGenerator(npart),
+     fIpart(kProton)
 {
   //
   // Standard constructor
   //
   fName  = "ThetaSlice";
   fTitle = "Particle generator - const. phi, slices in theta";
-  // Generate Proton by default
-  fIpart=kProton;
 }
 
 //_____________________________________________________________________________
index 1e5589b..afbeb47 100644 (file)
 #include "AliCollisionGeometry.h"
 #include <TRandom.h>
 
-ClassImp(AliSlowNucleonModelExp)
+ClassImp(AliSlowNucleonModelExp);
 
-AliSlowNucleonModelExp::AliSlowNucleonModelExp()
+
+AliSlowNucleonModelExp::AliSlowNucleonModelExp():
+    fP(82),
+    fN (208 - 82),
+    fAlphaGray(2.),
+    fAlphaBlack(4.)
 {
   //
   // Default constructor
   //
-    fP = 82;
-    fN = 208 - 82;
-    fAlphaGray  = 2.;
-    fAlphaBlack = 4.;
 }