Corrections to comply with coding convention
authorschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 29 May 2000 13:42:55 +0000 (13:42 +0000)
committerschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 29 May 2000 13:42:55 +0000 (13:42 +0000)
38 files changed:
PHOS/AliPHOS.cxx
PHOS/AliPHOS.h
PHOS/AliPHOSAnalyze.cxx
PHOS/AliPHOSAnalyze.h
PHOS/AliPHOSClusterizer.h
PHOS/AliPHOSClusterizerv1.cxx
PHOS/AliPHOSClusterizerv1.h
PHOS/AliPHOSDigit.cxx
PHOS/AliPHOSDigit.h
PHOS/AliPHOSEmcRecPoint.cxx
PHOS/AliPHOSEmcRecPoint.h
PHOS/AliPHOSFastRecParticle.cxx
PHOS/AliPHOSFastRecParticle.h
PHOS/AliPHOSGeometry.cxx
PHOS/AliPHOSGeometry.h
PHOS/AliPHOSHit.h
PHOS/AliPHOSIndexToObject.cxx
PHOS/AliPHOSIndexToObject.h
PHOS/AliPHOSLink.h
PHOS/AliPHOSPID.h
PHOS/AliPHOSPIDv1.cxx
PHOS/AliPHOSPIDv1.h
PHOS/AliPHOSPpsdRecPoint.h
PHOS/AliPHOSRecParticle.h
PHOS/AliPHOSRecPoint.cxx
PHOS/AliPHOSRecPoint.h
PHOS/AliPHOSReconstructioner.cxx
PHOS/AliPHOSReconstructioner.h
PHOS/AliPHOSTrackSegment.cxx
PHOS/AliPHOSTrackSegment.h
PHOS/AliPHOSTrackSegmentMaker.h
PHOS/AliPHOSTrackSegmentMakerv1.cxx
PHOS/AliPHOSTrackSegmentMakerv1.h
PHOS/AliPHOSv0.cxx
PHOS/AliPHOSv0.h
PHOS/AliPHOSv0hits.cxx
PHOS/AliPHOSvFast.cxx
PHOS/AliPHOSvFast.h

index 38c1c3f..33e9918 100644 (file)
@@ -40,6 +40,7 @@ ClassImp(AliPHOS)
 //____________________________________________________________________________
 AliPHOS::~AliPHOS()
 {
+  // dtor
   delete fHits ;
   delete fDigits ;
 }
@@ -300,12 +301,12 @@ void AliPHOS::CreateMaterials()
 }
 
 //____________________________________________________________________________
-RecPointsList * AliPHOS::EmcRecPoints(Int_t evt) 
+AliPHOSRecPoint::RecPointsList * AliPHOS::EmcRecPoints(Int_t evt) 
 {
   // returns the pointer to the EMCA RecPoints list
   // if the list is empty, get it from TreeR on the disk file
 
-  RecPointsList * rv = 0 ; 
+  AliPHOSRecPoint::RecPointsList * rv = 0 ; 
   
   if ( fEmcRecPoints ) 
     rv = fEmcRecPoints ; 
@@ -325,12 +326,12 @@ RecPointsList * AliPHOS::EmcRecPoints(Int_t evt)
 }
 
 //____________________________________________________________________________
-RecParticlesList * AliPHOS::RecParticles(Int_t evt) 
+AliPHOSRecParticle::RecParticlesList * AliPHOS::RecParticles(Int_t evt) 
 {
   // returns the pointer to the RecParticles list
   // if the list is empty, get it from TreeR on the disk file
 
-  RecParticlesList * rv = 0 ; 
+  AliPHOSRecParticle::RecParticlesList * rv = 0 ; 
   
   if ( fRecParticles ) 
     rv = fRecParticles ; 
@@ -350,12 +351,12 @@ RecParticlesList * AliPHOS::RecParticles(Int_t evt)
 }
 
 //____________________________________________________________________________
-RecParticlesList * AliPHOS::TrackSegments(Int_t evt) 
+AliPHOSRecParticle::RecParticlesList * AliPHOS::TrackSegments(Int_t evt) 
 {
   // returns the pointer to the TrackSegments list
   // if the list is empty, get it from TreeR on the disk file
 
-  TrackSegmentsList * rv = 0 ; 
+  AliPHOSTrackSegment::TrackSegmentsList * rv = 0 ; 
   
   if ( fTrackSegments ) 
     rv = fTrackSegments ; 
index b4b9372..2b17d8f 100644 (file)
@@ -26,22 +26,26 @@ class AliPHOS : public AliDetector {
  public:
 
   AliPHOS(const char* name, const char* title): AliDetector(name,title) {} 
-  AliPHOS() : AliDetector() {} 
+  AliPHOS() : AliDetector() {
+    // default ctor
+  } 
   virtual ~AliPHOS() ; 
  
-  virtual void CreateMaterials() ;                     // defines the material of the detector
+  virtual void CreateMaterials() ;                                     // defines the material of the detector
   virtual AliPHOSGeometry * GetGeometry() = 0 ;  
-  RecPointsList* EmcRecPoints(Int_t evt=0) ;           // gets Array of cluster in the crystals 
-  RecParticlesList * RecParticles(Int_t evt = 0) ;     // gets Array of reconstructed particles
-  TrackSegmentsList * TrackSegments(Int_t evt=0) ;     // gets Array of track segments
-  virtual RecPointsList* PpsdRecPoints(Int_t evt=0)=0; // gets Array of clusters in the PPSD 
-  virtual TString Version() {return TString(" ") ; } 
+  AliPHOSRecPoint::RecPointsList* EmcRecPoints(Int_t evt=0) ;          // gets Array of cluster in the crystals 
+  AliPHOSRecParticle::RecParticlesList* RecParticles(Int_t evt = 0) ; // gets Array of reconstructed particles
+  AliPHOSTrackSegment::TrackSegmentsList* TrackSegments(Int_t evt=0) ;// gets Array of track segments
+  virtual AliPHOSRecPoint::RecPointsList* PpsdRecPoints(Int_t evt=0)=0;// gets Array of clusters in the PPSD 
+  virtual TString Version() {
+    // gives the version number (void for the base class)
+    return TString(" ") ; } 
 
  protected:
   
-  RecPointsList * fEmcRecPoints ;                 // The RecPoints (clusters) list in EMC 
-  TrackSegmentsList * fTrackSegments ;            // The TrackSegment list in PHOS
-  RecParticlesList * fRecParticles ;              // The reconstructed particles list in PHOS
+  AliPHOSRecPoint::RecPointsList * fEmcRecPoints ;         // The RecPoints (clusters) list in EMC 
+  AliPHOSTrackSegment::TrackSegmentsList * fTrackSegments ;// The TrackSegment list in PHOS
+  AliPHOSRecParticle::RecParticlesList * fRecParticles ;   // The reconstructed particles list in PHOS
 
 
   ClassDef(AliPHOS,2) // Photon Spectrometer Detector (base class)
index 98b0df4..24d3d4f 100644 (file)
@@ -82,6 +82,21 @@ AliPHOSAnalyze::AliPHOSAnalyze(Text_t * name)
 }
 
 //____________________________________________________________________________
+AliPHOSAnalyze::AliPHOSAnalyze(const AliPHOSAnalyze & ana)
+{
+  // copy ctor
+  ( (AliPHOSAnalyze &)ana ).Copy(*this) ;
+}
+
+//____________________________________________________________________________
+AliPHOSAnalyze::Copy(TObject & obj)
+{
+  // copy an analysis into an other one
+  TObject::Copy(obj) ;
+  // I do nothing more because the copy is silly but the Code checkers requires one
+}
+
+//____________________________________________________________________________
 AliPHOSAnalyze::~AliPHOSAnalyze()
 {
   // dtor
@@ -271,25 +286,25 @@ void AliPHOSAnalyze::AnalyzeOneEvent(Int_t evt)
                      //fhElectronPositionY->Fill(recpart. ) ; 
                      cout << "ELECTRON" << endl;
                      break;
-                   case kNEUTRAL_HA:
+                   case kNEUTRALHA:
                      fhNeutralHadronEnergy->Fill(recparticle->Energy() ) ; 
                      //fhNeutralHadronPositionX->Fill(recpart. ) ;
                      //fhNeutralHadronPositionY->Fill(recpart. ) ; 
                      cout << "NEUTRAl HADRON" << endl;
                      break ;
-                   case kNEUTRAL_EM:
+                   case kNEUTRALEM:
                      fhNeutralEMEnergy->Fill(recparticle->Energy() ) ; 
                      //fhNeutralEMPositionX->Fill(recpart. ) ;
                      //fhNeutralEMPositionY->Fill(recpart. ) ; 
                      //cout << "NEUTRAL EM" << endl;
                      break ;
-                   case kCHARGED_HA:
+                   case kCHARGEDHA:
                      fhChargedHadronEnergy->Fill(recparticle->Energy() ) ; 
                      //fhChargedHadronPositionX->Fill(recpart. ) ;
                      //fhChargedHadronPositionY->Fill(recpart. ) ; 
                      cout << "CHARGED HADRON" << endl;
                      break ;
-                   case kGAMMA_HA:
+                   case kGAMMAHA:
                      fhPhotonHadronEnergy->Fill(recparticle->Energy() ) ; 
                      //fhPhotonHadronPositionX->Fill(recpart. ) ;
                      //fhPhotonHadronPositionY->Fill(recpart. ) ; 
@@ -576,7 +591,7 @@ void AliPHOSAnalyze::DisplayRecParticles()
       Text_t canvasname[80] ; 
       sprintf(canvasname, "Reconstructed particles in PHOSmodule # %d", module) ;
       TCanvas * rparticlecanvas = new TCanvas("RparticleCanvas", canvasname, 650, 500) ; 
-      RecParticlesList * rpl = fPHOS->RecParticles() ; 
+      AliPHOSRecParticle::RecParticlesList * rpl = fPHOS->RecParticles() ; 
       Int_t nRecParticles = rpl->GetEntries() ; 
       Int_t nRecParticlesInModule = 0 ; 
       TIter nextRecPart(rpl) ; 
@@ -826,7 +841,7 @@ void AliPHOSAnalyze::DisplayTrackSegments()
       TCanvas * trackcanvas = new TCanvas("TrackSegmentCanvas", canvasname, 650, 500) ; 
       histotrack->Draw() ; 
 
-      TrackSegmentsList * trsegl = fPHOS->TrackSegments() ;
+      AliPHOSTrackSegment::TrackSegmentsList * trsegl = fPHOS->TrackSegments() ;
       AliPHOSTrackSegment * trseg ;
  
       Int_t nTrackSegments = trsegl->GetEntries() ;
index 2d4e9cd..048d91a 100644 (file)
@@ -30,11 +30,13 @@ public:
 
   AliPHOSAnalyze() ;              // ctor
   AliPHOSAnalyze(Text_t * name) ; // ctor
+  AliPHOSAnalyze(const AliPHOSAnalyze & ana) ; // cpy ctor                   
   virtual ~AliPHOSAnalyze() ;     // dtor
 
   void AnalyzeOneEvent(Int_t evt = -999) ;  // analyzes a single event ;
   void AnalyzeManyEvents(Int_t Nevtents = 100, Int_t Module=0) ;  // analyzes many events   ;
   void BookingHistograms() ;                // booking histograms for the ManyEvent analysis ;
+  void Copy(TObject & obj) ;                // copies an analysis into an other one   
   Bool_t Init(Int_t evt) ;                  // does various initialisations
   void DisplayKineEvent(Int_t evt = -999) ; // displays the Kine events in ALICE coordinate 
   void DisplayRecParticles() ;              // displays RecParticles in ALICE coordinate  
@@ -43,7 +45,7 @@ public:
   Bool_t OpenRootFile(Text_t * name) ;      // opens the root file
   void SavingHistograms() ;                 // Save histograms in a root file
  
-private:
+ private:
   
   AliPHOSClusterizer * fClu ;         // a clusterizer 
   Int_t fEvt ;                        // the evt number being processed 
index 8d07dd7..eedc652 100644 (file)
@@ -39,7 +39,7 @@ public:
   virtual Float_t GetPpsdClusteringThreshold() = 0 ; 
   virtual Float_t GetPpsdEnergyThreshold() = 0 ; 
 
-  virtual void MakeClusters(const DigitsList * dl, RecPointsList * emccl, RecPointsList * ppsdl) = 0 ; 
+  virtual void MakeClusters(const DigitsList * dl, AliPHOSRecPoint::RecPointsList * emccl, AliPHOSRecPoint::RecPointsList * ppsdl) = 0 ; 
   virtual void PrintParameters() = 0 ;  
   virtual void SetCalibrationParameters(Float_t A, Float_t B) = 0 ; 
   virtual void SetEmcClusteringThreshold(Float_t cluth) = 0 ; 
index ef3338a..9936bbd 100644 (file)
@@ -169,7 +169,9 @@ Bool_t AliPHOSClusterizerv1::IsInEmc(AliPHOSDigit * digit)
 }
 
 //____________________________________________________________________________
-void AliPHOSClusterizerv1::MakeClusters(const DigitsList * dl, RecPointsList * emcl, RecPointsList * ppsdl)
+void AliPHOSClusterizerv1::MakeClusters(const DigitsList * dl, 
+                                       AliPHOSRecPoint::RecPointsList * emcl, 
+                                       AliPHOSRecPoint::RecPointsList * ppsdl)
 {
   // Steering method to construct the clusters stored in a list of Reconstructed Points
   // A cluster is defined as a list of neighbour digits
index 55c9009..0e71c95 100644 (file)
@@ -42,7 +42,9 @@ public:
   virtual Float_t GetPpsdEnergyThreshold() { return  fPpsdEnergyThreshold;  }
 
   virtual Bool_t IsInEmc(AliPHOSDigit * digit) ;                      // Tells if id digit is in EMC
-  virtual void MakeClusters(const DigitsList * dl, RecPointsList * emcl, RecPointsList * ppsdl) ; // does the job 
+  virtual void MakeClusters(const DigitsList * dl, 
+                           AliPHOSRecPoint::RecPointsList * emcl, 
+                           AliPHOSRecPoint::RecPointsList * ppsdl) ; // does the job 
   virtual void PrintParameters() ;  
   virtual void SetCalibrationParameters(Float_t A,Float_t B){ fA = A ; fB = B;} 
   virtual void SetEmcClusteringThreshold(Float_t cluth) { fEmcClusteringThreshold = cluth ; }
index b19110a..7cf26b4 100644 (file)
@@ -85,7 +85,7 @@ Int_t AliPHOSDigit::Compare(TObject * obj)
   // Compares two digits with respect to its Id
   // to sort according increasing Id
 
-  Int_t rv ; 
+  Int_t rv ;
 
   AliPHOSDigit * digit = (AliPHOSDigit *)obj ; 
 
index 04f8426..92dda28 100644 (file)
 
 class AliPHOSDigit : public AliDigitNew {
   
-public:
+ public:
+  
   AliPHOSDigit() ;
   AliPHOSDigit(Int_t primary, Int_t id, Int_t DigEnergy, Int_t index = -1) ;
   AliPHOSDigit(const AliPHOSDigit & digit) ;
-  virtual ~AliPHOSDigit(){} 
+  virtual ~AliPHOSDigit(){
+    // dtor 
+  } 
 
   Bool_t operator==(AliPHOSDigit const &rValue) const;
   AliPHOSDigit& operator+(AliPHOSDigit const &rValue) ;
@@ -40,12 +42,18 @@ public:
   friend class ostream& operator << ( ostream& , const AliPHOSDigit&) ;
   
   Int_t   Compare(TObject * obj) ;  
-  Int_t   GetNprimary() const { return fNprimary ; }
+  Int_t   GetNprimary() const { 
+    // returns the number of primaries
+    return fNprimary ; }
   Int_t   GetPrimary(Int_t index) const ; 
-  Bool_t  IsSortable() const { return kTRUE ; }
-  void    SetAmp(Int_t Amp) { fAmp=Amp ; } 
+  Bool_t  IsSortable() const { 
+    // says that AliPHOSDigits are sortable (needed for Sort method
+    return kTRUE ; }
+  void    SetAmp(Int_t Amp) { 
+    // sets the amplitude data member 
+    fAmp=Amp ; } 
 
-private:
+ private:
 
   Int_t fPrimary1 ;          // first primary (because objects in a TClonesArray bust have constant length) 
   Int_t fPrimary2 ;          // second primary (because objects in a TClonesArray bust have constant lengt) 
index 18742f8..2b812ec 100644 (file)
@@ -61,6 +61,7 @@ AliPHOSEmcRecPoint::AliPHOSEmcRecPoint(Float_t W0, Float_t LocMaxCut)
 //____________________________________________________________________________
 AliPHOSEmcRecPoint::~AliPHOSEmcRecPoint()
 {
+  // dtor
   if ( fEnergyList )
     delete[] fEnergyList ; 
 }
@@ -195,9 +196,9 @@ void AliPHOSEmcRecPoint::ExecuteEvent(Int_t event, Int_t px, Int_t py)
     Int_t iDigit;
     Int_t relid[4] ;
     
-    const Int_t fMulDigit = AliPHOSEmcRecPoint::GetDigitsMultiplicity() ; 
-    Float_t * xi = new Float_t[fMulDigit] ; 
-    Float_t * zi = new Float_t[fMulDigit] ; 
+    const Int_t kMulDigit = AliPHOSEmcRecPoint::GetDigitsMultiplicity() ; 
+    Float_t * xi = new Float_t[kMulDigit] ; 
+    Float_t * zi = new Float_t[kMulDigit] ; 
     
     // create the histogram for the single cluster 
     // 1. gets histogram boundaries
@@ -206,7 +207,7 @@ void AliPHOSEmcRecPoint::ExecuteEvent(Int_t event, Int_t px, Int_t py)
     Float_t ximin = 999. ; 
     Float_t zimin = 999. ;
     
-    for(iDigit=0; iDigit<fMulDigit; iDigit++) {
+    for(iDigit=0; iDigit<kMulDigit; iDigit++) {
       digit = (AliPHOSDigit *) ( please->GimeDigit(fDigitsList[iDigit]) ) ;
       phosgeom->AbsToRelNumbering(digit->GetId(), relid) ;
       phosgeom->RelPosInModule(relid, xi[iDigit], zi[iDigit]);
@@ -238,7 +239,7 @@ void AliPHOSEmcRecPoint::ExecuteEvent(Int_t event, Int_t px, Int_t py)
     histo = new TH2F("cluster3D", title,  xdim, ximin, ximax, zdim, zimin, zimax)  ;
     
     Float_t x, z ; 
-    for(iDigit=0; iDigit<fMulDigit; iDigit++) {
+    for(iDigit=0; iDigit<kMulDigit; iDigit++) {
       digit = (AliPHOSDigit *) ( please->GimeDigit(fDigitsList[iDigit]) ) ;
       phosgeom->AbsToRelNumbering(digit->GetId(), relid) ;
       phosgeom->RelPosInModule(relid, x, z);
@@ -246,7 +247,7 @@ void AliPHOSEmcRecPoint::ExecuteEvent(Int_t event, Int_t px, Int_t py)
     }
     
     if (!digitgraph) {
-      digitgraph = new TGraph(fMulDigit,xi,zi);
+      digitgraph = new TGraph(kMulDigit,xi,zi);
       digitgraph-> SetMarkerStyle(5) ; 
       digitgraph-> SetMarkerSize(1.) ;
       digitgraph-> SetMarkerColor(1) ;
@@ -293,7 +294,7 @@ Float_t  AliPHOSEmcRecPoint::GetDispersion()
   AliPHOSGeometry * phosgeom =  (AliPHOSGeometry *) fGeom ;
   
   Int_t iDigit;
-  for(iDigit=0; iDigit<fMulDigit; iDigit++) {
+  for(iDigit=0; iDigit < fMulDigit; iDigit++) {
     digit = (AliPHOSDigit *) ( please->GimeDigit(fDigitsList[iDigit]) ) ;
     Int_t relid[4] ;
     Float_t xi ;
@@ -561,24 +562,25 @@ void AliPHOSEmcRecPoint::Print(Option_t * option)
  
 }
 //______________________________________________________________________________
-void AliPHOSEmcRecPoint::Streamer(TBuffer &R__b)
-{
-   // Stream an object of class AliPHOSEmcRecPoint.
-
-   if (R__b.IsReading()) {
-      Version_t R__v = R__b.ReadVersion(); if (R__v) { }
-      AliPHOSRecPoint::Streamer(R__b);
-      R__b >> fDelta;
-      fEnergyList = new Float_t[fMulDigit] ; 
-      R__b.ReadFastArray(fEnergyList, fMulDigit);
-      R__b >> fLocMaxCut;
-      R__b >> fW0;
-   } else {
-      R__b.WriteVersion(AliPHOSEmcRecPoint::IsA());
-      AliPHOSRecPoint::Streamer(R__b);
-      R__b << fDelta;
-      R__b.WriteFastArray(fEnergyList, fMulDigit);
-      R__b << fLocMaxCut;
-      R__b << fW0;
-   }
-}
+// void AliPHOSEmcRecPoint::Streamer(TBuffer &R__b)
+// {
+//    // Stream an object of class AliPHOSEmcRecPoint.
+
+//    if (R__b.IsReading()) {
+//       Version_t R__v = R__b.ReadVersion(); if (R__v) { }
+//       AliPHOSRecPoint::Streamer(R__b);
+//       R__b >> fDelta;
+//       fEnergyList = new Float_t[fMulDigit] ; 
+//       R__b.ReadFastArray(fEnergyList, fMulDigit);
+//       R__b >> fLocMaxCut;
+//       R__b >> fW0;
+//    } else {
+//       R__b.WriteVersion(AliPHOSEmcRecPoint::IsA());
+//       AliPHOSRecPoint::Streamer(R__b);
+//       R__b << fDelta;
+//       R__b.WriteFastArray(fEnergyList, fMulDigit);
+//       R__b << fLocMaxCut;
+//       R__b << fW0;
+//    }
+// }
index 6a727b1..caf0536 100644 (file)
@@ -27,30 +27,50 @@ class AliPHOSEmcRecPoint : public AliPHOSRecPoint  {
 
 public:
 
-  AliPHOSEmcRecPoint(){} ;                    
+  AliPHOSEmcRecPoint(){
+    // default ctor
+  } ;                    
   AliPHOSEmcRecPoint(Float_t W0, Float_t LocMaxCut) ;
   virtual ~AliPHOSEmcRecPoint() ;  
 
   virtual void  AddDigit(AliPHOSDigit & digit, Float_t Energy) ;  // add a digit to the digits list  
   Int_t       Compare(TObject * obj) ;                         // method for sorting  
   
-  Float_t     GetDelta (){ return fDelta ; }    
+  Float_t     GetDelta (){ 
+    // gets the fDelta data member 
+    return fDelta ; }    
   Float_t     GetDispersion() ;                               // computes the dispersion of the shower
   void        GetElipsAxis(Float_t * lambda) ;                // computes the axis of shower ellipsoide
-  Float_t *   GetEnergiesList(){return fEnergyList ;} 
+  Float_t *   GetEnergiesList(){
+    // gets the list of energies makink this recpoint
+    return fEnergyList ;} 
   virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py) ; 
-  Float_t     GetLocMaxCut () {return fLocMaxCut ; }
-  Float_t     GetLogWeightCut (){return fW0 ; }
+  Float_t     GetLocMaxCut () {
+    // gets the cut of the local maximum search 
+    return fLocMaxCut ; }
+  Float_t     GetLogWeightCut (){
+    // gets the logarythmic weight for the center of gravity calculation
+    return fW0 ; }
   Float_t     GetMaximalEnergy(void) ;                        // get the highest energy in the cluster
-  Int_t       GetMaximumMultiplicity() { return   fMaxDigit ; } 
-  Int_t       GetMultiplicity(void) const { return fMulDigit ; } 
+  Int_t       GetMaximumMultiplicity() { 
+    // gets the maximum number of digits allowed
+    return   fMaxDigit ; } 
+  Int_t       GetMultiplicity(void) const { 
+    // gets the number of digits making this recpoint
+    return fMulDigit ; } 
   Int_t       GetMultiplicityAtLevel(const Float_t level) ;   // computes multiplicity of digits with energy above relative level
   Int_t       GetNumberOfLocalMax(Int_t *  maxAt, Float_t * maxAtEnergy) ; // searches for the local maxima 
  
-  Float_t     GetTotalEnergy(void) const { return fAmp ; }    // in EMC RecPoint Amp = Energy
-  void        GetLocalPosition(TVector3 &Lpos) ;              // computes the position in the PHOS module 
-  Bool_t      IsEmc(void) {return kTRUE ; } 
-  Bool_t      IsSortable() const { return kTRUE ; } 
+  Float_t     GetTotalEnergy(void) const { 
+    // gets the total amplitude of this recpoint (in EMC RecPoint Amp = Energy)
+    return fAmp ; }    
+  void        GetLocalPosition(TVector3 &Lpos) ;  // computes the position in the PHOS module 
+  Bool_t      IsEmc(void) {
+    // true if the recpoint is in EMC
+    return kTRUE ; } 
+  Bool_t      IsSortable() const { 
+    // says that emcrecpoints are sortable objects 
+    return kTRUE ; } 
   void        Print(Option_t * opt = "void") ; 
 
 private:
@@ -58,7 +78,7 @@ private:
   Bool_t AreNeighbours(AliPHOSDigit * digit1, AliPHOSDigit * digit2 ) ;
 
   Float_t  fDelta ;          // parameter used to sort the clusters    
-  Float_t  *fEnergyList ;    // energy of digits
+  Float_t  *fEnergyList ;    //[fMulDigit] energy of digits
   Float_t  fLocMaxCut ;      // minimum energy difference to distinguish two maxima 
   Float_t  fW0 ;             // logarithmic weight factor for center of gravity calculation
   
index 365e7c3..4ece97b 100644 (file)
@@ -183,16 +183,16 @@ TString AliPHOSFastRecParticle::Name()
    case kELECTRON:
      name = "ELECTRON" ;
     break ; 
-   case kCHARGED_HA:
+   case kCHARGEDHA:
     name = "CHARGED_HA" ;
     break ; 
-  case kNEUTRAL_HA:
+  case kNEUTRALHA:
     name = "NEUTRAL_HA" ; 
     break ; 
-  case kNEUTRAL_EM:
+  case kNEUTRALEM:
     name = "NEUTRAL_EM" ; 
     break ; 
-  case kGAMMA_HA:
+  case kGAMMAHA:
     name = "PHOTON_HA" ; 
     break ; 
 
index 578bb30..fc4124f 100644 (file)
 
 // --- AliRoot header files ---
 
-typedef TClonesArray  FastRecParticlesList ; 
-
 const static Int_t kUNDEFINED =-1 ;
-const static Int_t kNEUTRAL_EM = 0 ;
-const static Int_t kNEUTRAL_HA = 1 ;
-const static Int_t kGAMMA      = 2 ; 
-const static Int_t kGAMMA_HA   = 3 ; 
-const static Int_t kABSURD_EM  = 4 ;
-const static Int_t kABSURD_HA  = 5 ;
-const static Int_t kELECTRON   = 6 ;
-const static Int_t kCHARGED_HA = 7 ;
+const static Int_t kNEUTRALEM = 0 ;
+const static Int_t kNEUTRALHA = 1 ;
+const static Int_t kGAMMA     = 2 ; 
+const static Int_t kGAMMAHA   = 3 ; 
+const static Int_t kABSURDEM  = 4 ;
+const static Int_t kABSURDHA  = 5 ;
+const static Int_t kELECTRON  = 6 ;
+const static Int_t kCHARGEDHA = 7 ;
 
 
 class AliPHOSFastRecParticle : public TParticle {
 
-public:
+ public:
   
-  AliPHOSFastRecParticle() {};          // ctor
+  AliPHOSFastRecParticle() {
+    // ctor 
+  };         
   AliPHOSFastRecParticle(const AliPHOSFastRecParticle & rp) ;  // ctor
   AliPHOSFastRecParticle(const TParticle & p) ;  // ctor
-  virtual ~AliPHOSFastRecParticle(){}  // dtor
-
+  virtual ~AliPHOSFastRecParticle(){
+    // dtor
+  }
   virtual Int_t DistancetoPrimitive(Int_t px, Int_t py) ; 
   virtual void Draw(Option_t *option) ;  
   virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py) ;
-  Int_t GetIndexInList() const { return fIndexInList ; } 
+  Int_t GetIndexInList() const { 
+    // returns the index of this in the list
+    return fIndexInList ; 
+  } 
   virtual Int_t * GetPrimaries(Int_t & number) ;
-  Int_t GetType() { return fType ; } 
+  Int_t GetType() { 
+    // returns the type of the particle
+    return fType ; 
+  } 
   TString Name() ; 
   virtual void Paint(Option_t * option="");
   void Print() ; 
-  void SetPrimary(Int_t index) { fPrimary = index ; }
-  void SetType(Int_t type) { fType = type ; } 
-  void SetIndexInList(Int_t val) { fIndexInList = val ; } 
-
-protected:
+  void SetPrimary(Int_t index) { 
+    // sets the primary particle index
+    fPrimary = index ; 
+  }
+  void SetType(Int_t type) { 
+    // sets the particle type 
+    fType = type ; 
+  } 
+  void SetIndexInList(Int_t val) { 
+    // sets the value of the index in the list 
+    fIndexInList = val ; 
+  } 
+
+ protected:
 
   Int_t fIndexInList ; // the index of this RecParticle in the list stored in TreeR (to be set by analysis)
   Int_t fPrimary ;     // (unique) primary particle index 
   Int_t fType ;        // particle type obtained by "virtual" reconstruction
 
+ private:
+
+  typedef TClonesArray  FastRecParticlesList ; 
+
   ClassDef(AliPHOSFastRecParticle,1)  // Reconstructed Particle produced by the fast simulation 
 
 };
index 51d1b8f..0c01cb8 100644 (file)
@@ -39,7 +39,7 @@
 
 ClassImp(AliPHOSGeometry)
 
-  AliPHOSGeometry * AliPHOSGeometry::fGeom = 0 ;
+  AliPHOSGeometry * AliPHOSGeometry::fgGeom = 0 ;
 
 //____________________________________________________________________________
 AliPHOSGeometry::~AliPHOSGeometry(void)
@@ -390,7 +390,7 @@ AliPHOSGeometry *  AliPHOSGeometry::GetInstance()
 { 
   // Returns the pointer of the unique instance
   
-  return (AliPHOSGeometry *) fGeom ; 
+  return (AliPHOSGeometry *) fgGeom ; 
 }
 
 //____________________________________________________________________________
@@ -399,17 +399,17 @@ AliPHOSGeometry *  AliPHOSGeometry::GetInstance(const Text_t* name, const Text_t
   // Returns the pointer of the unique instance
 
   AliPHOSGeometry * rv = 0  ; 
-  if ( fGeom == 0 ) {
-    fGeom = new AliPHOSGeometry(name, title) ; 
-    rv = (AliPHOSGeometry * ) fGeom ; 
+  if ( fgGeom == 0 ) {
+    fgGeom = new AliPHOSGeometry(name, title) ; 
+    rv = (AliPHOSGeometry * ) fgGeom ; 
   }
   else {
-    if ( strcmp(fGeom->GetName(), name) != 0 ) {
-      cout << "AliPHOSGeometry <E> : current geometry is " << fGeom->GetName() << endl
+    if ( strcmp(fgGeom->GetName(), name) != 0 ) {
+      cout << "AliPHOSGeometry <E> : current geometry is " << fgGeom->GetName() << endl
           << "                      you cannot call     " << name << endl ; 
     }
     else
-      rv = (AliPHOSGeometry *) fGeom ; 
+      rv = (AliPHOSGeometry *) fgGeom ; 
   } 
   return rv ; 
 }
index 6061be3..f379400 100644 (file)
@@ -31,7 +31,10 @@ class AliPHOSGeometry : public AliGeometry {
 
 public: 
 
-  AliPHOSGeometry() {} ;  // must be kept public for root persistency purposes, but should never be called by the outside world
+  AliPHOSGeometry() {
+    // default ctor 
+    // must be kept public for root persistency purposes, but should never be called by the outside world
+  } ;  
   virtual ~AliPHOSGeometry(void) ; 
   static AliPHOSGeometry * GetInstance(const Text_t* name, const Text_t* title) ; 
   static AliPHOSGeometry * GetInstance() ; 
@@ -187,7 +190,7 @@ private:
   Float_t fPPSDModuleSize[3] ;            // Size of an individual micromegas module
   Float_t fZDisplacement ;                // Z displacement of micromegas1 with respect to micromegas2  
 
-  static AliPHOSGeometry * fGeom ; // pointer to the unique instance of the singleton 
+  static AliPHOSGeometry * fgGeom ; // pointer to the unique instance of the singleton 
 
   ClassDef(AliPHOSGeometry,1)  // PHOS geometry class 
 
index b7ad271..c77d450 100644 (file)
@@ -24,15 +24,28 @@ class AliPHOSHit : public AliHit {
 
 public:
 
-  AliPHOSHit() {}
+  AliPHOSHit() {
+    // default ctor 
+  }
   AliPHOSHit(const AliPHOSHit & hit) ; 
   AliPHOSHit(Int_t primary, Int_t id, Float_t *hits) ;
   AliPHOSHit(Int_t shunt, Int_t primary, Int_t tracknumber, Int_t id, Float_t *hits) ;
-  virtual ~AliPHOSHit(void) {}  
+  virtual ~AliPHOSHit(void) {
+    // dtor 
+  }  
   
-  Float_t GetEnergy(void)   const { return fELOS ; }
-  Int_t   GetId(void)       const { return fId ; }
-  Int_t   GetPrimary(void)  const { return fPrimary ; }
+  Float_t GetEnergy(void)   const { 
+    // returns the energy loss for this hit 
+    return fELOS ; 
+  }
+  Int_t   GetId(void)       const { 
+    // return the identificator of this his
+    return fId ; 
+  }
+  Int_t   GetPrimary(void)  const { 
+    // returns the primary particle id at the origine of this hit 
+    return fPrimary ; 
+  }
 
   Bool_t operator == (AliPHOSHit const &rValue) const ;
   AliPHOSHit operator + (const AliPHOSHit& rValue) const ;
index 7ca69ea..1ee0dfd 100644 (file)
@@ -32,7 +32,7 @@
 
 ClassImp(AliPHOSIndexToObject)
   
-  AliPHOSIndexToObject * AliPHOSIndexToObject::fObjGetter = 0 ; 
+  AliPHOSIndexToObject * AliPHOSIndexToObject::fgObjGetter = 0 ; 
 
 //____________________________________________________________________________ 
 AliPHOSIndexToObject::AliPHOSIndexToObject(AliPHOS * det)
@@ -48,8 +48,8 @@ AliPHOSIndexToObject * AliPHOSIndexToObject::GetInstance()
   // Returns the pointer of the unique instance already defined
   
   AliPHOSIndexToObject * rv = 0 ;
-  if ( fObjGetter )
-    rv = fObjGetter ;
+  if ( fgObjGetter )
+    rv = fgObjGetter ;
   else
     cout << "AliPHOSIndexToObject::GetInstance ERROR: not yet initialized" << endl ;
   
@@ -62,12 +62,12 @@ AliPHOSIndexToObject * AliPHOSIndexToObject::GetInstance(AliPHOS * det)
   // Creates and returns the pointer of the unique instance
   // Must be called only when the environment has changed (a new event for exemple)
 
-  if ( fObjGetter )      // delete it if already exists
-    delete fObjGetter ; 
+  if ( fgObjGetter )      // delete it if already exists
+    delete fgObjGetter ; 
 
-  fObjGetter = new AliPHOSIndexToObject(det) ; 
+  fgObjGetter = new AliPHOSIndexToObject(det) ; 
   
-  return fObjGetter ; 
+  return fgObjGetter ; 
   
 }
 
@@ -113,7 +113,7 @@ AliPHOSRecParticle * AliPHOSIndexToObject::GimeRecParticle(Int_t index)
 
   AliPHOSRecParticle * rv = 0 ; 
 
-  RecParticlesList * rplist = fDetector->RecParticles() ; 
+  AliPHOSRecParticle::RecParticlesList * rplist = fDetector->RecParticles() ; 
 
   Int_t rpentries  = 0 ; 
 
@@ -147,8 +147,8 @@ AliRecPoint * AliPHOSIndexToObject::GimeRecPoint(Int_t index, TString type)
 
   AliPHOSRecPoint * rv = 0 ; 
   
-  RecPointsList * emclist = fDetector->EmcRecPoints() ; 
-  RecPointsList * ppsdlist = fDetector->PpsdRecPoints() ; 
+  AliPHOSRecPoint::RecPointsList * emclist = fDetector->EmcRecPoints() ; 
+  AliPHOSRecPoint::RecPointsList * ppsdlist = fDetector->PpsdRecPoints() ; 
 
   Int_t emcentries  = 0 ; 
   Int_t ppsdentries = 0 ; 
@@ -200,7 +200,7 @@ AliPHOSTrackSegment * AliPHOSIndexToObject::GimeTrackSegment(Int_t index)
 
   AliPHOSTrackSegment * rv = 0 ; 
 
-  TrackSegmentsList * tslist = fDetector->TrackSegments() ; 
+  AliPHOSTrackSegment::TrackSegmentsList * tslist = fDetector->TrackSegments() ; 
 
   Int_t tsentries  = 0 ; 
 
index 7e6c219..4740e71 100644 (file)
@@ -36,8 +36,13 @@ class AliPHOSIndexToObject : public TObject {
 
 public:
 
-  AliPHOSIndexToObject(){ assert(0==1) ; } // should be never called
-  virtual ~AliPHOSIndexToObject(){} ; // dtor
+  AliPHOSIndexToObject(){ 
+    // ctor: this is a singleton, the ctor should never be called but cint needs it as publiv
+    assert(0==1) ; 
+  } 
+  virtual ~AliPHOSIndexToObject(){
+    // dtor
+  }
 
   static AliPHOSIndexToObject * GetInstance(AliPHOS * det) ; 
   static AliPHOSIndexToObject * GetInstance() ; 
@@ -55,7 +60,7 @@ public:
   AliPHOS * fDetector ;                    // the detector 
   TTree * fReconstruct ;                   // the reconstruction tree  
 
-  static AliPHOSIndexToObject * fObjGetter ; // pointer to the unique instance of the singleton 
+  static AliPHOSIndexToObject * fgObjGetter ; // pointer to the unique instance of the singleton 
 
   ClassDef(AliPHOSIndexToObject,1)  // Algorithm class that provides methods to retrieve objects from a list knowing the index 
 
index 7d5c5e3..daa0cf8 100644 (file)
@@ -23,13 +23,26 @@ class AliPHOSLink : public  TObject{
 public:
   
   AliPHOSLink( Float_t r, Int_t EMC, Int_t PPSD) ;  // ctor            
-  virtual ~AliPHOSLink(){} // dtor
-  
+  virtual ~AliPHOSLink(){
+    // dtor
+  }
   Int_t   Compare(TObject * obj) ;
-  Int_t   GetEmc(void) { return fEmcN; }
-  Int_t   GetPpsd(void) { return fPpsdN ; }
-  Float_t GetR(void) { return fR ; } 
-  Bool_t  IsSortable() const{ return kTRUE ; }
+  Int_t   GetEmc(void) { 
+    // returns the index of EMC
+    return fEmcN; 
+  }
+  Int_t   GetPpsd(void) { 
+    // returns the index of PPSD
+    return fPpsdN ; 
+  }
+  Float_t GetR(void) { 
+    // returns the distance between EMC and PPSD
+    return fR ; 
+  } 
+  Bool_t  IsSortable() const{ 
+    // tells if this is a sortable object 
+    return kTRUE ; 
+  }
   
 private:
   
index e8efc91..ccd7095 100644 (file)
@@ -32,7 +32,8 @@ public:
   AliPHOSPID() ;          // ctor            
   virtual ~AliPHOSPID() ; // dtor
 
-  virtual void MakeParticles(TrackSegmentsList * trsl, RecParticlesList * rpl) {} ; 
+  virtual void MakeParticles(AliPHOSTrackSegment::TrackSegmentsList * trsl, 
+                            AliPHOSRecParticle::RecParticlesList * rpl) {} ; 
   virtual void SetShowerProfileCuts(Float_t, Float_t, Float_t, Float_t) {} ; 
   virtual void SetDispersionCutOff(Float_t ) {}    
 
index c9adfaa..a82e259 100644 (file)
@@ -38,7 +38,8 @@
 ClassImp( AliPHOSPIDv1) 
 
 //____________________________________________________________________________
-void  AliPHOSPIDv1::MakeParticles(TrackSegmentsList * trsl, RecParticlesList * rpl)
+void  AliPHOSPIDv1::MakeParticles(AliPHOSTrackSegment::TrackSegmentsList * trsl, 
+                                 AliPHOSRecParticle::RecParticlesList * rpl)
 {
   // Makes a RecParticle out of a TrackSegment
 
index d8be946..e1fc791 100644 (file)
@@ -27,7 +27,8 @@ public:
   AliPHOSPIDv1(): fCutOnDispersion(1.5){}                     
   virtual ~ AliPHOSPIDv1(){} ; // dtor
 
-  virtual void MakeParticles(TrackSegmentsList * trsl, RecParticlesList * rpl ) ; // does the job
+  virtual void MakeParticles(AliPHOSTrackSegment::TrackSegmentsList * trsl, 
+                            AliPHOSRecParticle::RecParticlesList * rpl ) ; // does the job
   void Print() ; 
   virtual void SetDispersionCutOff(Float_t Dcut) {fCutOnDispersion = Dcut ; }    
   virtual void SetShowerProfileCuts(Float_t l1m, Float_t l1M, Float_t l2m, Float_t l2M) ; 
index 9e8b916..540d5c6 100644 (file)
@@ -25,19 +25,39 @@ class AliPHOSPpsdRecPoint : public AliPHOSRecPoint {
 public:
 
   AliPHOSPpsdRecPoint() ;           // ctor   
-  virtual ~AliPHOSPpsdRecPoint(){}  // dtor
-
+  virtual ~AliPHOSPpsdRecPoint(){
+    // dtor
+  }
   virtual void AddDigit(AliPHOSDigit & digit, Float_t Energy) ;
   Int_t   Compare(TObject * obj) ;                    // method to sort clusters
 
-  Float_t GetDelta(void) {return fDelta ;}
-  Int_t   GetMultiplicity(void) const { return fMulDigit ; } 
-  Int_t   GetMaximumMultiplicity() { return   fMaxDigit ; } 
+  Float_t GetDelta(void) {
+    // returns the parameter used for sorting
+    return fDelta ;
+  }
+  Int_t   GetMultiplicity(void) const { 
+    // returns the multiplicity of digits at the origin of this recpoint
+    return fMulDigit ; 
+  } 
+  Int_t   GetMaximumMultiplicity() { 
+    // returns the maximum allowed digit multiplicity
+    return   fMaxDigit ; 
+  } 
   void    GetLocalPosition(TVector3 &LPos) ; // computes the position in the module of the cluster center 
-  Float_t GetTotalEnergy(void) const { return fAmp ; }    // in Ppsd EMC RecPoint Amp = Energy                             
+  Float_t GetTotalEnergy(void) const { 
+    // returns the amplitude for this recpoint 
+    // in Ppsd EMC RecPoint Amp = Energy   
+    return fAmp ; 
+  }                             
   Bool_t  GetUp() ;               // true if cluster is in upper ppsd 
-  Bool_t  IsEmc(void) {return kFALSE ; } 
-  Bool_t  IsSortable() const { return kTRUE ; }
+  Bool_t  IsEmc(void) {
+    // tells that this is not a EMC
+    return kFALSE ; 
+  } 
+  Bool_t  IsSortable() const { 
+    // tells that this is a sortable object
+    return kTRUE ; 
+  }
   virtual void  Paint(Option_t * option="");
   void    Print(Option_t * opt = "void") ; 
 
index 9bb9997..043db5f 100644 (file)
 #include "AliPHOSTrackSegment.h"
 #include "AliPHOSFastRecParticle.h"
 
-typedef TClonesArray RecParticlesList ; 
-
 class AliPHOSRecParticle : public AliPHOSFastRecParticle {
 
 public:
   
-  AliPHOSRecParticle() {};          // ctor
+  AliPHOSRecParticle() {
+    // ctor
+  }
   AliPHOSRecParticle(AliPHOSTrackSegment * ts) ;  // ctor
   AliPHOSRecParticle(const AliPHOSRecParticle & rp) ;  // ctor
-  virtual ~AliPHOSRecParticle(){} ; // dtor
-
+  virtual ~AliPHOSRecParticle(){
+    // dtor
+  }
   AliPHOSTrackSegment * GetPHOSTrackSegment() const ; 
   Int_t                 GetPHOSTrackSegmentIndex(){return fPHOSTrackSegment;}
   Int_t *               GetPrimaries(Int_t & number) ;
@@ -42,6 +43,9 @@ private:
 
   Int_t fPHOSTrackSegment ; // pointer to the associated track segment in PHOS  
 
+  typedef TClonesArray RecParticlesList ; 
+
+
   ClassDef(AliPHOSRecParticle,1)  // Reconstructed Particle
 };
 
index ff9337a..a7a715c 100644 (file)
@@ -100,11 +100,11 @@ void AliPHOSRecPoint::ExecuteEvent(Int_t event, Int_t px, Int_t py)
     Int_t iDigit;
     Int_t relid[4] ;
   
-    const Int_t fMulDigit=AliPHOSRecPoint::GetDigitsMultiplicity() ;
-    Float_t * xi = new Float_t [fMulDigit] ; 
-    Float_t * zi = new Float_t [fMulDigit] ;
+    const Int_t kMulDigit=AliPHOSRecPoint::GetDigitsMultiplicity() ;
+    Float_t * xi = new Float_t [kMulDigit] ; 
+    Float_t * zi = new Float_t [kMulDigit] ;
     
-    for(iDigit=0; iDigit<fMulDigit; iDigit++) {
+    for(iDigit = 0; iDigit < kMulDigit; iDigit++) {
       digit = (AliPHOSDigit *) fDigitsList[iDigit];
       phosgeom->AbsToRelNumbering(digit->GetId(), relid) ;
       phosgeom->RelPosInModule(relid, xi[iDigit], zi[iDigit]) ;
index 92fbba4..90275a6 100644 (file)
 #include "AliRecPoint.h"
 #include "AliPHOSDigit.h"
 
-typedef TObjArray       RecPointsList ; 
-
 class AliPHOSRecPoint : public AliRecPoint {
 
-public:
+ public:
 
   AliPHOSRecPoint() ;                   // ctor         
-  virtual ~AliPHOSRecPoint(){}          // dtor
+  virtual ~AliPHOSRecPoint(){
+    // dtor
+  }
   virtual  void   AddDigit(AliPHOSDigit & digit, Float_t Energy) = 0 ; 
-  virtual Int_t   Compare(TObject * obj) {  assert(0==1) ; return 1 ; }   
+  virtual Int_t   Compare(TObject * obj) { 
+    // check why this is done
+    assert(0==1) ; return 1 ; 
+  }   
   virtual Int_t   DistancetoPrimitive(Int_t px, Int_t py);
   virtual void    Draw(Option_t * option="") ;
   virtual void    ExecuteEvent(Int_t event, Int_t px, Int_t py) ;
   virtual Int_t   GetPHOSMod(void) ;
   virtual Int_t * GetPrimaries(Int_t & number) ;
-  virtual Bool_t  IsEmc(void){return kTRUE ;} 
-  virtual Bool_t  IsSortable() const { return kTRUE ; }  
+  virtual Bool_t  IsEmc(void){
+    // says that this is a EMC
+    return kTRUE ;
+  } 
+  virtual Bool_t  IsSortable() const { 
+    // tells that this is a sortable object
+    return kTRUE ; 
+  }  
   virtual void    Paint(Option_t * option="");
-  virtual void    Print(Option_t * opt = "void") {} 
+  virtual void    Print(Option_t * opt = "void") {
+    // Print prototype
+  } 
 
-protected:
+ protected:
   
   Int_t fPHOSMod ;      // PHOS Module number in which the RecPoint is found
 
+ private:
+  
+  typedef TObjArray RecPointsList ; 
+
   ClassDef(AliPHOSRecPoint,1) // RecPoint for PHOS (Base Class)
  
 };
index 89d12bc..7363f37 100644 (file)
@@ -64,8 +64,11 @@ AliPHOSReconstructioner::AliPHOSReconstructioner(AliPHOSClusterizer * Clusterize
 } 
 
 //____________________________________________________________________________
- void AliPHOSReconstructioner::Make(DigitsList * dl, RecPointsList * emccl, RecPointsList * ppsdl, 
-                                    TrackSegmentsList * trsl, RecParticlesList * rpl)
+ void AliPHOSReconstructioner::Make(DigitsList * dl, 
+                                   AliPHOSRecPoint::RecPointsList * emccl, 
+                                   AliPHOSRecPoint::RecPointsList * ppsdl, 
+                                   AliPHOSTrackSegment::TrackSegmentsList * trsl, 
+                                   AliPHOSRecParticle::RecParticlesList * rpl)
 {
   // Launches the Reconstruction process in the sequence: Make the reconstructed poins (clusterize)
   //                                                      Make the track segments 
@@ -285,28 +288,28 @@ AliPHOSReconstructioner::AliPHOSReconstructioner(AliPHOSClusterizer * Clusterize
       primaries = (rp->GetPHOSTrackSegment())->GetPrimariesEmc(nprimaries);
       switch(rp->GetType())
        {
-       case kNEUTRAL_EM:
+       case kNEUTRALEM:
          strcpy( particle, "NEUTRAL_EM");
          break;
-       case kNEUTRAL_HA:
+       case kNEUTRALHA:
          strcpy(particle, "NEUTRAL_HA");
          break;
        case kGAMMA:
          strcpy(particle, "GAMMA");
          break ;
-       case kGAMMA_HA: 
+       case kGAMMAHA: 
          strcpy(particle, "GAMMA_H");
          break ;
-       case kABSURD_EM:
+       case kABSURDEM:
          strcpy(particle, "ABSURD_EM") ;
          break ;
-       case kABSURD_HA:
+       case kABSURDHA:
          strcpy(particle, "ABSURD_HA") ;
          break ;       
        case kELECTRON:
          strcpy(particle, "ELECTRON") ;
          break ;
-       case kCHARGED_HA:
+       case kCHARGEDHA:
          strcpy(particle, "CHARGED_HA") ;
          break ; 
        }
index ccb37a1..95ea469 100644 (file)
@@ -36,8 +36,11 @@ public:
   AliPHOSClusterizer * GetClusterizer() { return fClusterizer ; }
   void Init(AliPHOSClusterizer * Clusterizer, AliPHOSTrackSegmentMaker * Tracker, 
                          AliPHOSPID * Identifier) ;  
-  void Make(TClonesArray * DL, RecPointsList * emccl, RecPointsList * ppsdl, 
-           TrackSegmentsList * trsl, RecParticlesList * rpl) ; // does the job
+  void Make(TClonesArray * DL, 
+           AliPHOSRecPoint::RecPointsList * emccl, 
+           AliPHOSRecPoint::RecPointsList * ppsdl, 
+           AliPHOSTrackSegment::TrackSegmentsList * trsl, 
+           AliPHOSRecParticle::RecParticlesList * rpl) ; // does the job
 
   void SetDebugReconstruction(Bool_t deb) { fDebugReconstruction = deb; }
 
index bcd8193..406d7ba 100644 (file)
@@ -41,8 +41,9 @@
 ClassImp(AliPHOSTrackSegment)
 
 //____________________________________________________________________________
-AliPHOSTrackSegment::AliPHOSTrackSegment( AliPHOSEmcRecPoint * emc , AliPHOSPpsdRecPoint * ppsdrp1,
-                  AliPHOSPpsdRecPoint * ppsdrp2  ) 
+AliPHOSTrackSegment::AliPHOSTrackSegment( AliPHOSEmcRecPoint * emc , 
+                                         AliPHOSPpsdRecPoint * ppsdrp1,
+                                         AliPHOSPpsdRecPoint * ppsdrp2  ) 
 {
   // ctor
 
@@ -209,6 +210,8 @@ Float_t AliPHOSTrackSegment::GetDistanceInPHOSPlane()
 //____________________________________________________________________________
 AliPHOSEmcRecPoint * AliPHOSTrackSegment::GetEmcRecPoint() const 
 {
+  // get the EMC recpoint at the origin of this track
   AliPHOSIndexToObject * please =  AliPHOSIndexToObject::GetInstance() ;
   AliPHOSEmcRecPoint * rv = 0 ;
   if (  fEmcRecPoint > -1 )
@@ -310,7 +313,8 @@ TVector3 AliPHOSTrackSegment::GetMomentumDirection()
 //____________________________________________________________________________
 Int_t AliPHOSTrackSegment:: GetPHOSMod(void) 
 {
-  
+  // Returns the phos module which contains this track
   AliPHOSEmcRecPoint  * emcrp   = GetEmcRecPoint() ; 
   
   return emcrp->GetPHOSMod();  
@@ -319,9 +323,11 @@ Int_t AliPHOSTrackSegment:: GetPHOSMod(void)
 //____________________________________________________________________________
 AliPHOSPpsdRecPoint * AliPHOSTrackSegment::GetPpsdLowRecPoint() const 
 {
+  // Returns the lower PPSD rec point at the origin of this track
+  
   AliPHOSIndexToObject * please =  AliPHOSIndexToObject::GetInstance() ;
   AliPHOSPpsdRecPoint * rv = 0 ;
-
+  
   if ( fPpsdLowRecPoint > -1 )
     rv = (AliPHOSPpsdRecPoint *)please->GimeRecPoint( fPpsdLowRecPoint, TString("ppsd") ) ;
   
@@ -331,6 +337,8 @@ AliPHOSPpsdRecPoint * AliPHOSTrackSegment::GetPpsdLowRecPoint() const
 //____________________________________________________________________________
 AliPHOSPpsdRecPoint * AliPHOSTrackSegment::GetPpsdUpRecPoint() const 
 {
+  // Returns the lower PPSD rec point at the origin of this track
+
   AliPHOSIndexToObject * please =  AliPHOSIndexToObject::GetInstance() ;
   AliPHOSPpsdRecPoint * rv = 0 ;
  
index f7e4001..1903ba2 100644 (file)
 #include "AliPHOSEmcRecPoint.h"
 #include "AliPHOSPpsdRecPoint.h"
 
-typedef TClonesArray TrackSegmentsList ; 
-
 class AliPHOSTrackSegment : public TObject  {
 
 public:
 
-  AliPHOSTrackSegment() {}       // ctor 
-  AliPHOSTrackSegment(AliPHOSEmcRecPoint * EmcRecPoint , AliPHOSPpsdRecPoint * PpsdUp, 
+  AliPHOSTrackSegment() {
+    // default ctor
+  } 
+  AliPHOSTrackSegment(AliPHOSEmcRecPoint * EmcRecPoint , 
+                     AliPHOSPpsdRecPoint * PpsdUp, 
                      AliPHOSPpsdRecPoint * PpsdLow  ) ; // ctor
   AliPHOSTrackSegment(const AliPHOSTrackSegment & ts) ;  // ctor                   
-  virtual ~AliPHOSTrackSegment() {} // dtor 
+  virtual ~AliPHOSTrackSegment() {
+    // dtor
+  } 
 
   void Copy(TObject & obj) ;  
   virtual Int_t  DistancetoPrimitive(Int_t px, Int_t py);
@@ -51,24 +54,40 @@ public:
   Int_t * GetPrimariesPpsdLow(Int_t & number) ;
   Int_t * GetPrimariesPpsdUp(Int_t & number) ;
   AliPHOSEmcRecPoint *   GetEmcRecPoint() const ;  
-  Int_t                  GetEmcRecPointIndex() {return fEmcRecPoint; }
-  Int_t   GetIndexInList() const { return fIndexInList ; } 
+  Int_t   GetIndexInList() const { 
+    // returns the index of this in the list  
+    return fIndexInList ; 
+  } 
+  Int_t                   GetEmcRecPointIndex() {
+    // return the index of the EMC recpoint at the origine of this 
+    return fEmcRecPoint ; 
+  }
   AliPHOSPpsdRecPoint *  GetPpsdLowRecPoint() const ;
-  Int_t                  GetPpsdLowRecPointIndex() {return fPpsdLowRecPoint ; }
+  Int_t                  GetPpsdLowRecPointIndex() {
+    // returns the PPSD low recpoint at the origin of this 
+    return fPpsdLowRecPoint ; 
+  }
   AliPHOSPpsdRecPoint *  GetPpsdUpRecPoint() const ; 
-  Int_t                  GetPpsdUpRecPointIndex() {return fPpsdUpRecPoint ; }
+  Int_t                  GetPpsdUpRecPointIndex() {
+    // returns the PPSD up recpoint at the origin of this 
+    return fPpsdUpRecPoint ; 
+  }
   virtual void  Paint(Option_t * option="");
   void    Print() ;
-  void    SetIndexInList(Int_t val) { fIndexInList = val ; } 
+  void    SetIndexInList(Int_t val) { 
+    // sets the index value  of this in the list 
+    fIndexInList = val ; 
+  } 
  
-  
-private:
+ private:
   
   Int_t fEmcRecPoint ;     // The EMC reconstructed point index in array stored in TreeR/PHOSEmcRP
   Int_t fIndexInList ;     // the index of this TrackSegment in the list stored in TreeR (to be set by analysis)
   Int_t fPpsdLowRecPoint ; // The PPSD reconstructed point from the lower layer index in array stored in TreeR/PHOSPpsdRP
   Int_t fPpsdUpRecPoint ;  // The PPSD reconstructed point from the upper layer index in array stored in TreeR/PHOSPpsdRP
 
+  typedef TClonesArray TrackSegmentsList ; 
+
   ClassDef(AliPHOSTrackSegment,1)  // Track segment in PHOS
 
 };
index 651daa6..7336f62 100644 (file)
@@ -31,8 +31,10 @@ public:
   
   virtual ~ AliPHOSTrackSegmentMaker(){}  // dtor
 
-  virtual void MakeTrackSegments(DigitsList * DL, RecPointsList * emcl, RecPointsList * ppsdl, TrackSegmentsList * trsl ) = 0 ; 
-                                         // does the job
+  virtual void MakeTrackSegments(DigitsList * DL, 
+                                AliPHOSRecPoint::RecPointsList * emcl, 
+                                AliPHOSRecPoint::RecPointsList * ppsdl,
+                                AliPHOSTrackSegment::TrackSegmentsList * trsl ) = 0 ; // does the job
   virtual void SetMaxEmcPpsdDistance(Float_t r) = 0 ; 
   virtual void SetUnfoldFlag() = 0 ;
   virtual void UnsetUnfoldFlag() = 0 ;
index d444199..d388bd5 100644 (file)
@@ -145,10 +145,15 @@ Bool_t  AliPHOSTrackSegmentMakerv1::FindFit(AliPHOSEmcRecPoint * emcRP, int * ma
 }
 
 //____________________________________________________________________________
-void  AliPHOSTrackSegmentMakerv1::FillOneModule(DigitsList * dl, RecPointsList * emcIn, TObjArray * emcOut, 
-                                       RecPointsList * ppsdIn, TObjArray * ppsdOutUp,
-                                       TObjArray * ppsdOutLow, Int_t & phosmod, Int_t & emcStopedAt, 
-                                       Int_t & ppsdStopedAt)
+void  AliPHOSTrackSegmentMakerv1::FillOneModule(DigitsList * dl, 
+                                               AliPHOSRecPoint::RecPointsList * emcIn, 
+                                               TObjArray * emcOut, 
+                                               AliPHOSRecPoint::RecPointsList * ppsdIn, 
+                                               TObjArray * ppsdOutUp,
+                                               TObjArray * ppsdOutLow, 
+                                               Int_t & phosmod, 
+                                               Int_t & emcStopedAt, 
+                                               Int_t & ppsdStopedAt)
 {
   // Unfold clusters and fill xxxOut arrays with clusters from one PHOS module
  
@@ -291,9 +296,12 @@ void  AliPHOSTrackSegmentMakerv1::MakeLinks(TObjArray * emcRecPoints, TObjArray
 }
     
 //____________________________________________________________________________
-void  AliPHOSTrackSegmentMakerv1::MakePairs(TObjArray * emcRecPoints, TObjArray * ppsdRecPointsUp, 
-                                   TObjArray * ppsdRecPointsLow, TClonesArray * linklowArray, 
-                                   TClonesArray * linkupArray, TrackSegmentsList * trsl) 
+void  AliPHOSTrackSegmentMakerv1::MakePairs(TObjArray * emcRecPoints, 
+                                           TObjArray * ppsdRecPointsUp, 
+                                           TObjArray * ppsdRecPointsLow, 
+                                           TClonesArray * linklowArray, 
+                                           TClonesArray * linkupArray, 
+                                           AliPHOSTrackSegment::TrackSegmentsList * trsl) 
 { 
 
   // Finds the smallest links and makes pairs of PPSD and EMC clusters with smallest distance 
@@ -366,8 +374,10 @@ void  AliPHOSTrackSegmentMakerv1::MakePairs(TObjArray * emcRecPoints, TObjArray
 }
 
 //____________________________________________________________________________
-void  AliPHOSTrackSegmentMakerv1::MakeTrackSegments(DigitsList * dl, RecPointsList * emcl, 
-                                       RecPointsList * ppsdl, TrackSegmentsList * trsl)
+void  AliPHOSTrackSegmentMakerv1::MakeTrackSegments(DigitsList * dl, 
+                                                   AliPHOSRecPoint::RecPointsList * emcl, 
+                                                   AliPHOSRecPoint::RecPointsList * ppsdl, 
+                                                   AliPHOSTrackSegment::TrackSegmentsList * trsl)
 {
   // Makes the track segments out of the list of EMC and PPSD Recpoints and stores them in a list
 
@@ -434,8 +444,13 @@ Double_t  AliPHOSTrackSegmentMakerv1::ShowerShape(Double_t r)
 }
 
 //____________________________________________________________________________
-void  AliPHOSTrackSegmentMakerv1::UnfoldClusters(DigitsList * dl, RecPointsList * emcIn,  AliPHOSEmcRecPoint * iniEmc, 
-                                        Int_t nMax, int * maxAt, Float_t * maxAtEnergy, TObjArray * emcList)
+void  AliPHOSTrackSegmentMakerv1::UnfoldClusters(DigitsList * dl, 
+                                                AliPHOSRecPoint::RecPointsList * emcIn, 
+                                                AliPHOSEmcRecPoint * iniEmc, 
+                                                Int_t nMax, 
+                                                int * maxAt, 
+                                                Float_t * maxAtEnergy, 
+                                                TObjArray * emcList)
 { 
   // Performs the unfolding of a cluster with nMax overlapping showers 
   // This is time consuming (use the (Un)SetUnfolFlag()  )
index dd45e5e..7e4244c 100644 (file)
@@ -34,22 +34,38 @@ public:
   
   Bool_t  FindFit(AliPHOSEmcRecPoint * emcRP, int * MaxAt, Float_t * maxAtEnergy, 
                  Int_t NPar, Float_t * FitParametres) ; //Used in UnfoldClusters, calls TMinuit
-  void    FillOneModule(DigitsList * Dl, RecPointsList * emcIn, TObjArray * emcOut, RecPointsList * ppsdIn, 
-                       TObjArray * ppsdOutUp, TObjArray * ppsdOutLow, Int_t &PHOSModule, Int_t & emcStopedAt, 
+  void    FillOneModule(DigitsList * Dl, AliPHOSRecPoint::RecPointsList * emcIn, 
+                       TObjArray * emcOut, 
+                       AliPHOSRecPoint::RecPointsList * ppsdIn, 
+                       TObjArray * ppsdOutUp, 
+                       TObjArray * ppsdOutLow, 
+                       Int_t &PHOSModule, 
+                       Int_t & emcStopedAt, 
                        Int_t & ppsdStopedAt) ; // Unfolds clusters and fills temporary arrais   
   Float_t GetDistanceInPHOSPlane(AliPHOSEmcRecPoint * EmcClu , AliPHOSPpsdRecPoint * Ppsd , Bool_t & TooFar ) ; // see R0
 
   void    MakeLinks(TObjArray * EmcRecPoints, TObjArray * PpsdRecPointsUp, TObjArray * PpsdRecPointsLow, 
                    TClonesArray * LinkLowArray, TClonesArray *LinkUpArray) ; //Evaluates distances(links) between EMC and PPSD
-  void    MakePairs(TObjArray * EmcRecPoints, TObjArray * PpsdRecPointsUp, TObjArray * PpsdRecPointsLow, 
-                   TClonesArray * LinkLowArray, TClonesArray * LinkUpArray, TrackSegmentsList * trsl) ; 
-                    //Finds pairs(triplets) with smallest link
-  void    MakeTrackSegments(DigitsList * DL, RecPointsList * emcl, RecPointsList * ppsdl, TrackSegmentsList * trsl ) ; // does the job
+  void    MakePairs(TObjArray * EmcRecPoints, 
+                   TObjArray * PpsdRecPointsUp, 
+                   TObjArray * PpsdRecPointsLow, 
+                   TClonesArray * LinkLowArray, 
+                   TClonesArray * LinkUpArray, 
+                   AliPHOSTrackSegment::TrackSegmentsList * trsl) ; //Finds pairs(triplets) with smallest link
+  void    MakeTrackSegments(DigitsList * DL, 
+                           AliPHOSRecPoint::RecPointsList * emcl, 
+                           AliPHOSRecPoint::RecPointsList * ppsdl, 
+                           AliPHOSTrackSegment::TrackSegmentsList * trsl ) ; // does the job
   virtual void SetMaxEmcPpsdDistance(Float_t r){ fR0 = r ;}
   virtual void    SetUnfoldFlag() { fUnfoldFlag = kTRUE ; } ; 
   static Double_t ShowerShape(Double_t r) ; // Shape of shower used in unfolding; class member function (not object member function)
-  void  UnfoldClusters(DigitsList * DL, RecPointsList * emcIn, AliPHOSEmcRecPoint * iniEmc, Int_t Nmax, 
-                        int * maxAt, Float_t * maxAtEnergy, TObjArray * emclist) ; //Unfolds overlaping clusters using TMinuit package
+  void  UnfoldClusters(DigitsList * DL, 
+                      AliPHOSRecPoint::RecPointsList * emcIn, 
+                      AliPHOSEmcRecPoint * iniEmc, 
+                      Int_t Nmax, 
+                      int * maxAt, 
+                      Float_t * maxAtEnergy, 
+                      TObjArray * emclist) ; //Unfolds overlaping clusters using TMinuit package
   virtual void UnsetUnfoldFlag() { fUnfoldFlag = kFALSE ; } 
 
 private:
index 068c8d1..d544906 100644 (file)
@@ -1270,12 +1270,12 @@ void AliPHOSv0::MakeBranch(Option_t* opt)
 }
 
 //____________________________________________________________________________
-RecPointsList * AliPHOSv0::PpsdRecPoints(Int_t evt) 
+AliPHOSRecPoint::RecPointsList * AliPHOSv0::PpsdRecPoints(Int_t evt) 
 {
   // returns the pointer to the PPSD RecPoints list
   // if the list is empty, get it from TreeR on the disk file
 
-  RecPointsList * rv = 0 ; 
+  AliPHOSRecPoint::RecPointsList * rv = 0 ; 
 
   if ( fPpsdRecPoints ) 
     rv = fPpsdRecPoints ; 
@@ -1322,8 +1322,8 @@ void AliPHOSv0::Reconstruction(AliPHOSReconstructioner * Reconstructioner)
     fEmcRecPoints = 0 ; 
   }
 
-  //  fEmcRecPoints= new RecPointsList("AliPHOSEmcRecPoint", 1000) ; if TClonesArray
-  fEmcRecPoints= new RecPointsList(100) ; 
+  //  fEmcRecPoints= new AliPHOSRecPoint::RecPointsList("AliPHOSEmcRecPoint", 1000) ; if TClonesArray
+  fEmcRecPoints= new AliPHOSRecPoint::RecPointsList(100) ; 
 
   if ( fEmcRecPoints && gAlice->TreeR() ) {
     sprintf(branchname,"%sEmcRP",GetName()) ;
@@ -1338,8 +1338,8 @@ void AliPHOSv0::Reconstruction(AliPHOSReconstructioner * Reconstructioner)
     fPpsdRecPoints = 0 ; 
   }
 
-  //  fPpsdRecPoints = new RecPointsList("AliPHOSPpsdRecPoint", 1000) ; if TClonesArray
-  fPpsdRecPoints = new RecPointsList(100) ;
+  //  fPpsdRecPoints = new AliPHOSRecPoint::RecPointsList("AliPHOSPpsdRecPoint", 1000) ; if TClonesArray
+  fPpsdRecPoints = new AliPHOSRecPoint::RecPointsList(100) ;
 
   if ( fPpsdRecPoints && gAlice->TreeR() ) {
     sprintf(branchname,"%sPpsdRP",GetName()) ;
@@ -1354,7 +1354,7 @@ void AliPHOSv0::Reconstruction(AliPHOSReconstructioner * Reconstructioner)
     fTrackSegments = 0 ; 
   }
 
-  fTrackSegments = new TrackSegmentsList("AliPHOSTrackSegment", 1000) ;
+  fTrackSegments = new AliPHOSTrackSegment::TrackSegmentsList("AliPHOSTrackSegment", 1000) ;
   if ( fTrackSegments && gAlice->TreeR() ) { 
     sprintf(branchname,"%sTS",GetName()) ;
     gAlice->TreeR()->Branch(branchname, &fTrackSegments, fBufferSize) ;
@@ -1365,7 +1365,7 @@ void AliPHOSv0::Reconstruction(AliPHOSReconstructioner * Reconstructioner)
     delete fRecParticles ; 
     fRecParticles = 0 ; 
   }
-  fRecParticles = new RecParticlesList("AliPHOSRecParticle", 1000) ;
+  fRecParticles = new AliPHOSRecParticle::RecParticlesList("AliPHOSRecParticle", 1000) ;
   if ( fRecParticles && gAlice->TreeR() ) { 
      sprintf(branchname,"%sRP",GetName()) ;
      gAlice->TreeR()->Branch(branchname, &fRecParticles, fBufferSize) ;
index c4834a5..a6ec0e5 100644 (file)
@@ -41,7 +41,7 @@ public:
   virtual void   Init(void) ;                                       // does nothing
   Int_t IsVersion(void) const { return 0 ; }
   void           MakeBranch(Option_t* opt) ;
-  virtual RecPointsList* PpsdRecPoints(Int_t evt=0) ;               // gets Array of clusters in the PPSD 
+  virtual AliPHOSRecPoint::RecPointsList* PpsdRecPoints(Int_t evt=0) ; // gets Array of clusters in the PPSD 
   void           Reconstruction(AliPHOSReconstructioner * Reconstructioner) ;
   void           ResetClusters(){} ;
   virtual void   ResetDigits() ; 
index 9031ac1..7d0a83f 100644 (file)
@@ -47,7 +47,7 @@ ClassImp(AliPHOSv0hits)
 //____________________________________________________________________________
 AliPHOSv0hits::AliPHOSv0hits()
 {
-  // ctor
+  // default ctor
   fNTmpHits = 0 ; 
   fTmpHits  = 0 ; 
 }
@@ -56,6 +56,7 @@ AliPHOSv0hits::AliPHOSv0hits()
 AliPHOSv0hits::AliPHOSv0hits(const char *name, const char *title):
   AliPHOSv0(name,title)
 {
+  // ctor
    fHits= new TClonesArray("AliPHOSHit",1000) ;
 }
 
index ea753fe..1c5f7ea 100644 (file)
@@ -71,7 +71,7 @@ AliPHOSvFast::AliPHOSvFast(const char *name, const char *title):
   SetBigBox(2, fGeom->GetOuterBoxSize(0) ); 
 
   fNRecParticles = 0 ; 
-  fFastRecParticles = new FastRecParticlesList("AliPHOSFastRecParticle", 100) ;
+  fFastRecParticles = new AliPHOSFastRecParticle::FastRecParticlesList("AliPHOSFastRecParticle", 100) ;
 
   fResPara1 = 0.030 ;    // GeV
   fResPara2 = 0.00003 ; 
@@ -352,26 +352,26 @@ Int_t AliPHOSvFast::MakeType(AliPHOSFastRecParticle & rp )
     else {
       ran = fRan.Rndm() ; 
       if( ran <= 0.9498 )
-       rv = kNEUTRAL_EM ; 
+       rv = kNEUTRALEM ; 
       else
-       rv = kNEUTRAL_HA ; 
+       rv = kNEUTRALHA ; 
     }     
     break ; 
 
   case 2112:  // it's a neutron
     ran = fRan.Rndm() ; 
     if ( ran <= 0.9998 )
-      rv = kNEUTRAL_HA ; 
+      rv = kNEUTRALHA ; 
     else 
-      rv = kNEUTRAL_EM ; 
+      rv = kNEUTRALEM ; 
     break ; 
 
   case -2112: // it's a anti-neutron
     ran = fRan.Rndm() ; 
     if ( ran <= 0.9984 )
-      rv = kNEUTRAL_HA ; 
+      rv = kNEUTRALHA ; 
     else 
-      rv = kNEUTRAL_EM ; 
+      rv = kNEUTRALEM ; 
     break ; 
     
   case 11:    // it's a electron
@@ -379,7 +379,7 @@ Int_t AliPHOSvFast::MakeType(AliPHOSFastRecParticle & rp )
     if ( ran <= 0.9996 )
       rv = kELECTRON ; 
     else 
-      rv = kCHARGED_HA ; 
+      rv = kCHARGEDHA ; 
     break; 
 
   case -11:   // it's a positon
@@ -387,13 +387,13 @@ Int_t AliPHOSvFast::MakeType(AliPHOSFastRecParticle & rp )
     if ( ran <= 0.9996 )
       rv = kELECTRON ; 
     else 
-      rv = kCHARGED_HA ; 
+      rv = kCHARGEDHA ; 
     break; 
 
   case -1:    // it's a charged
     ran = fRan.Rndm() ; 
     if ( ran <= 0.9996 )
-      rv = kCHARGED_HA ; 
+      rv = kCHARGEDHA ; 
     else 
       rv = kGAMMA ; 
 
index 90a2c79..56f1c69 100644 (file)
@@ -45,7 +45,8 @@ public:
                                                                      // makes the detected position
   void MakeRecParticle(const Int_t modid, const TVector3 pos, AliPHOSFastRecParticle & rp) ;  // makes a reconstructes particle from primary
   Int_t   MakeType(AliPHOSFastRecParticle & rp) ;                    // gets the detected type of particle
-  FastRecParticlesList * FastRecParticles() { return fFastRecParticles ; } // gets TClonesArray of reconstructed particles
+  // gets TClonesArray of reconstructed particles
+  AliPHOSFastRecParticle::FastRecParticlesList * FastRecParticles() { return fFastRecParticles ; } 
   virtual void ResetPoints() ; 
   void         ResetFastRecParticles() ; 
   void         SetBigBox(Int_t index, Float_t value) ;                             
@@ -58,7 +59,7 @@ private:
   Float_t fBigBoxX ;                         // main box containing all PHOS (EMC+PPSD)
   Float_t fBigBoxY ;                         // main box containing all PHOS (EMC+PPSD)
   Float_t fBigBoxZ ;                         // main box containing all PHOS (EMC+PPSD)
-  FastRecParticlesList * fFastRecParticles ; // list of particles modified by the response function 
+  AliPHOSFastRecParticle::FastRecParticlesList * fFastRecParticles ; // list of particles modified by the response function 
   AliPHOSGeometry * fGeom ;                  // geometry definition
   Int_t fNRecParticles ;                     // number of detected particles
   TRandom fRan ;                             // random number generator