Coding violations corrected
authorschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 5 Nov 2003 15:04:22 +0000 (15:04 +0000)
committerschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 5 Nov 2003 15:04:22 +0000 (15:04 +0000)
PHOS/AliPHOSEMCAGeometry.h
PHOS/AliPHOSEvalRecPoint.cxx
PHOS/AliPHOSEvalRecPoint.h
PHOS/AliPHOSLoader.cxx
PHOS/AliPHOSLoader.h

index 4864557..24a8024 100644 (file)
@@ -13,8 +13,6 @@
 // Modified: Yuri Kharlov (IHEP, Protvino)
 // 15 September 2000
 
-#include <assert.h> 
-
 // --- ROOT system ---
 #include "TObject.h"
 class TObjArray ;
@@ -28,13 +26,13 @@ public:
   AliPHOSEMCAGeometry();
   AliPHOSEMCAGeometry(const AliPHOSEMCAGeometry & cpv) : TObject(cpv) {
     // cpy ctor requested by Coding Convention but not yet needed
-    assert(0==1) ;
+    Fatal("Copy ctor","Not implemented yet");
   } 
   virtual ~AliPHOSEMCAGeometry(void) {}
 
   AliPHOSEMCAGeometry & operator = (const AliPHOSEMCAGeometry  & /*rvalue*/) {
     // assignement operator requested by coding convention but not needed
-    assert(0==1) ;
+    Fatal("Operator = ","Not implemented yet");
     return *this ; 
   }
 
@@ -96,95 +94,94 @@ public:
  
 private:
 
-  Float_t fStripHalfSize[3]   ;
-  Float_t fAirCellHalfSize[3] ;
-  Float_t fWrappedHalfSize[3] ;
-  Float_t fSupportPlateHalfSize[3] ;
-  Float_t fSupportPlateInHalfSize[3] ;
-  Float_t fCrystalHalfSize[3] ;
-  Float_t fAirGapLed ;
-  Float_t fStripWallWidthOut ; // Side to another strip  
-  Float_t fStripWallWidthIn ; 
-  Float_t fTyvecThickness ; 
-  Float_t fTSupport1HalfSize[3] ;
-  Float_t fTSupport2HalfSize[3] ;
-  Float_t fPreampHalfSize[3] ;
-  Float_t fPinDiodeHalfSize[3] ;              // Size of the PIN Diode 
-
-  Float_t fOuterThermoParams[4] ; 
-  Float_t fCoolerHalfSize[3] ; 
-  Float_t fAirGapHalfSize[3] ;
-  Float_t fInnerThermoHalfSize[3] ;
-  Float_t fAlCoverParams[4] ;
-  Float_t fFiberGlassHalfSize[3] ;
-
-
-  Float_t fInnerThermoWidthX ;
-  Float_t fInnerThermoWidthY ;
-  Float_t fInnerThermoWidthZ ;
-  Float_t fAirGapWidthX ;
-  Float_t fAirGapWidthY ;
-  Float_t fAirGapWidthZ ;
-  Float_t fCoolerWidthX ;
-  Float_t fCoolerWidthY ;
-  Float_t fCoolerWidthZ ;
-  Float_t fAlCoverThickness ;
-  Float_t fOuterThermoWidthXUp ;
-  Float_t fOuterThermoWidthXLow;
-  Float_t fOuterThermoWidthY ;
-  Float_t fOuterThermoWidthZ ;
-  Float_t fAlFrontCoverX  ;
-  Float_t fAlFrontCoverZ  ; 
-  Float_t fFiberGlassSup2X ;
-  Float_t fFiberGlassSup1X ; 
-  Float_t fFrameHeight ; 
-  Float_t fFrameThickness ; 
-  Float_t fAirSpaceFeeX ;
-  Float_t fAirSpaceFeeZ ;
-  Float_t fAirSpaceFeeY ;
-  Float_t fTCables2HalfSize[3] ; 
-  Float_t fTCables1HalfSize[3] ; 
-  Float_t fWarmUpperThickness ;
-  Float_t fWarmBottomThickness ;
-  Float_t fWarmAlCoverWidthX ;
-  Float_t fWarmAlCoverWidthY ;
-  Float_t fWarmAlCoverWidthZ ;
-  Float_t fWarmAlCoverHalfSize[3] ;
-  Float_t fWarmThermoHalfSize[3] ;
-  Float_t fFiberGlassSup1Y ;
-  Float_t fFiberGlassSup2Y ;
-  Float_t fTSupportDist ;
-  Float_t fTSupport1Thickness ;
-  Float_t fTSupport2Thickness ;
-  Float_t fTSupport1Width ;
-  Float_t fTSupport2Width ;
-  Float_t fFrameXHalfSize[3] ;
-  Float_t fFrameZHalfSize[3] ;
-  Float_t fFrameXPosition[3] ;
-  Float_t fFrameZPosition[3] ;
-  Float_t fFGupXHalfSize[3] ;
-  Float_t fFGupXPosition[3] ;
-  Float_t fFGupZHalfSize[3] ;
-  Float_t fFGupZPosition[3] ;
-  Float_t fFGlowXHalfSize[3] ;
-  Float_t fFGlowXPosition[3] ;
-  Float_t fFGlowZHalfSize[3] ;
-  Float_t fFGlowZPosition[3] ;
-  Float_t fFEEAirHalfSize[3] ;
-  Float_t fFEEAirPosition[3] ;
-  Float_t fEMCParams[4] ;
+  Float_t fStripHalfSize[3]   ;        // Strip unit size/2
+  Float_t fAirCellHalfSize[3] ;        // geometry parameter
+  Float_t fWrappedHalfSize[3] ;        // geometry parameter
+  Float_t fSupportPlateHalfSize[3] ;   // geometry parameter
+  Float_t fSupportPlateInHalfSize[3] ; // geometry parameter
+  Float_t fCrystalHalfSize[3] ;        // crystal size/2
+  Float_t fAirGapLed ;                 // geometry parameter
+  Float_t fStripWallWidthOut ;         // Side to another strip  
+  Float_t fStripWallWidthIn ;          // geometry parameter
+  Float_t fTyvecThickness ;            // geometry parameter
+  Float_t fTSupport1HalfSize[3] ;      // geometry parameter
+  Float_t fTSupport2HalfSize[3] ;      // geometry parameter
+  Float_t fPreampHalfSize[3] ;         // geometry parameter
+  Float_t fPinDiodeHalfSize[3] ;       // Size of the PIN Diode 
+
+  Float_t fOuterThermoParams[4] ;      // geometry parameter
+  Float_t fCoolerHalfSize[3] ;         // geometry parameter
+  Float_t fAirGapHalfSize[3] ;         // geometry parameter
+  Float_t fInnerThermoHalfSize[3] ;    // geometry parameter
+  Float_t fAlCoverParams[4] ;          // geometry parameter
+  Float_t fFiberGlassHalfSize[3] ;     // geometry parameter
+
+
+  Float_t fInnerThermoWidthX ;         // geometry parameter
+  Float_t fInnerThermoWidthY ;         // geometry parameter
+  Float_t fInnerThermoWidthZ ;         // geometry parameter
+  Float_t fAirGapWidthX ;              // geometry parameter
+  Float_t fAirGapWidthY ;              // geometry parameter
+  Float_t fAirGapWidthZ ;              // geometry parameter
+  Float_t fCoolerWidthX ;              // geometry parameter
+  Float_t fCoolerWidthY ;              // geometry parameter
+  Float_t fCoolerWidthZ ;              // geometry parameter
+  Float_t fAlCoverThickness ;          // geometry parameter
+  Float_t fOuterThermoWidthXUp ;       // geometry parameter
+  Float_t fOuterThermoWidthXLow;       // geometry parameter
+  Float_t fOuterThermoWidthY ;         // geometry parameter
+  Float_t fOuterThermoWidthZ ;         // geometry parameter
+  Float_t fAlFrontCoverX  ;            // geometry parameter
+  Float_t fAlFrontCoverZ  ;            // geometry parameter
+  Float_t fFiberGlassSup2X ;           // geometry parameter
+  Float_t fFiberGlassSup1X ;           // geometry parameter
+  Float_t fFrameHeight ;               // geometry parameter
+  Float_t fFrameThickness ;            // geometry parameter
+  Float_t fAirSpaceFeeX ;              // geometry parameter
+  Float_t fAirSpaceFeeZ ;              // geometry parameter
+  Float_t fAirSpaceFeeY ;              // geometry parameter
+  Float_t fTCables2HalfSize[3] ;       // geometry parameter
+  Float_t fTCables1HalfSize[3] ;       // geometry parameter
+  Float_t fWarmUpperThickness ;        // geometry parameter
+  Float_t fWarmBottomThickness ;       // geometry parameter
+  Float_t fWarmAlCoverWidthX ;         // geometry parameter
+  Float_t fWarmAlCoverWidthY ;         // geometry parameter
+  Float_t fWarmAlCoverWidthZ ;         // geometry parameter
+  Float_t fWarmAlCoverHalfSize[3] ;    // geometry parameter
+  Float_t fWarmThermoHalfSize[3] ;     // geometry parameter
+  Float_t fFiberGlassSup1Y ;           // geometry parameter
+  Float_t fFiberGlassSup2Y ;           // geometry parameter
+  Float_t fTSupportDist ;              // geometry parameter
+  Float_t fTSupport1Thickness ;        // geometry parameter
+  Float_t fTSupport2Thickness ;        // geometry parameter
+  Float_t fTSupport1Width ;            // geometry parameter
+  Float_t fTSupport2Width ;            // geometry parameter
+  Float_t fFrameXHalfSize[3] ;         // geometry parameter
+  Float_t fFrameZHalfSize[3] ;         // geometry parameter
+  Float_t fFrameXPosition[3] ;         // geometry parameter
+  Float_t fFrameZPosition[3] ;         // geometry parameter
+  Float_t fFGupXHalfSize[3] ;          // geometry parameter
+  Float_t fFGupXPosition[3] ;          // geometry parameter
+  Float_t fFGupZHalfSize[3] ;          // geometry parameter
+  Float_t fFGupZPosition[3] ;          // geometry parameter
+  Float_t fFGlowXHalfSize[3] ;         // geometry parameter
+  Float_t fFGlowXPosition[3] ;         // geometry parameter
+  Float_t fFGlowZHalfSize[3] ;         // geometry parameter
+  Float_t fFGlowZPosition[3] ;         // geometry parameter
+  Float_t fFEEAirHalfSize[3] ;         // geometry parameter
+  Float_t fFEEAirPosition[3] ;         // geometry parameter
+  Float_t fEMCParams[4] ;              // geometry parameter
   Float_t fIPtoOuterCoverDistance ;       // Distances from interaction point to outer cover 
   Float_t fIPtoCrystalSurface ;           // Distances from interaction point to Xtal surface
 
   Float_t fSupportPlateThickness ;        // Thickness of the Aluminium support plate for Strip   
 
-  Int_t  fNCellsInStrip ;
-  Int_t  fNStripX ;
-  Int_t  fNStripZ ;
-  Int_t  fNTSupports ;
-  Int_t  fNPhi ;                         // Number of crystal units in X (phi) direction
-  Int_t  fNZ ;                           // Number of crystal units in Z direction
-
+  Int_t  fNCellsInStrip ;              // Number of cells in a strip unit
+  Int_t  fNStripX ;                    // Number of strip units in X
+  Int_t  fNStripZ ;                    // Number of strip units in Z
+  Int_t  fNTSupports ;                 // geometry parameter
+  Int_t  fNPhi ;                       // Number of crystal units in X (phi) direction
+  Int_t  fNZ ;                         // Number of crystal units in Z direction
   ClassDef(AliPHOSEMCAGeometry,1)         // EMCA geometry class 
 
 } ;
index 5a2a840..8ed06d3 100644 (file)
@@ -1,3 +1,27 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+/* $Id:  */
+
+/* $Log:
+ */
+//*-- Author: Boris Polichtchouk, IHEP
+//////////////////////////////////////////////////////////////////////////////
+// Reconstructed point operations for the Clusterization class for IHEP reconstruction.
+// Performs clusterization (collects neighbouring active cells)
+// It differs from AliPHOSClusterizerv1 in neighbour definition only
+
 // ---- ROOT system ---
 #include "TDirectory.h"
 #include "TBranch.h"
@@ -22,16 +46,16 @@ ClassImp(AliPHOSEvalRecPoint)
 
   AliPHOSEvalRecPoint::AliPHOSEvalRecPoint(): fEventFolderName(AliConfig::fgkDefaultEventFolderName)
 {
+  // default ctor
   fParent=-333;
   fChi2Dof=-111;
   fIsCpv = kTRUE;
   fIsEmc = kFALSE;
 }
 
-AliPHOSEvalRecPoint::AliPHOSEvalRecPoint(Bool_t cpv, AliPHOSEvalRecPoint* parent) 
-  : fEventFolderName(AliConfig::fgkDefaultEventFolderName)
+AliPHOSEvalRecPoint::AliPHOSEvalRecPoint(Bool_t cpv, AliPHOSEvalRecPoint* parent) : AliPHOSCpvRecPoint()
 {
-
+  // ctor
   fParent=-333;
   fChi2Dof=-111;
 
@@ -61,7 +85,7 @@ AliPHOSEvalRecPoint::AliPHOSEvalRecPoint(Bool_t cpv, AliPHOSEvalRecPoint* parent
 
 AliPHOSEvalRecPoint::AliPHOSEvalRecPoint(Int_t i, Bool_t cpv) : fEventFolderName(AliConfig::fgkDefaultEventFolderName)
 {
-
+  // ctor
   fChi2Dof=-111;
   fParent=-333;
 
@@ -80,13 +104,13 @@ AliPHOSEvalRecPoint::AliPHOSEvalRecPoint(Int_t i, Bool_t cpv) : fEventFolderName
     fIsCpv = kFALSE;
   }
 
-  Int_t* Digits = rp->GetDigitsList();
-  Float_t* Energies = rp->GetEnergiesList();
+  Int_t* digits = rp->GetDigitsList();
+  Float_t* energies = rp->GetEnergiesList();
   Int_t nDigits = rp->GetMultiplicity();
   
   for(Int_t iDigit=0; iDigit<nDigits; iDigit++) {
-    AliPHOSDigit* digit = (AliPHOSDigit*)fLoader->Digits()->At( Digits[iDigit] );
-    Float_t eDigit = Energies[iDigit];
+    AliPHOSDigit* digit = (AliPHOSDigit*)fLoader->Digits()->At( digits[iDigit] );
+    Float_t eDigit = energies[iDigit];
     this->AddDigit(*digit,eDigit);
   }
 
@@ -101,6 +125,7 @@ AliPHOSEvalRecPoint::AliPHOSEvalRecPoint(Int_t i, Bool_t cpv) : fEventFolderName
 
 AliPHOSClusterizer* AliPHOSEvalRecPoint::GetClusterizer()
 {
+  // returns clusterizer task
   TFolder* aliceF = (TFolder*)gROOT->FindObjectAny("YSAlice");
   TFolder* wPoolF = (TFolder*)aliceF->FindObject("WhiteBoard/RecPoints/PHOS/SmP");
   AliPHOSClusterizer* clu = (AliPHOSClusterizer*)wPoolF->FindObject("PHOS:clu-v1");
@@ -114,12 +139,13 @@ AliPHOSClusterizer* AliPHOSEvalRecPoint::GetClusterizer()
 
 Bool_t AliPHOSEvalRecPoint::TooClose(AliPHOSRecPoint* pt) const 
 {
-  TVector3 her_pos;
-  TVector3 my_pos;
-  pt->GetLocalPosition(her_pos);
-  this->GetLocalPosition(my_pos);
-  Float_t dx = her_pos.X() - my_pos.X();
-  Float_t dz = her_pos.Z() - my_pos.Z();
+  // check if a rec.point pt is too close to this one
+  TVector3 herPos;
+  TVector3 myPos;
+  pt->GetLocalPosition(herPos);
+  this->GetLocalPosition(myPos);
+  Float_t dx = herPos.X() - myPos.X();
+  Float_t dz = herPos.Z() - myPos.Z();
   Float_t dr = TMath::Sqrt(dx*dx + dz*dz);
 
   if(dr<GetReconstructionManager()->MergeGammasMinDistanceCut())
@@ -131,17 +157,19 @@ Bool_t AliPHOSEvalRecPoint::TooClose(AliPHOSRecPoint* pt) const
 
 Bool_t AliPHOSEvalRecPoint::NeedToSplit() const 
 {
+  // rec.point needs to be split
   return kFALSE;
 }
 
 void AliPHOSEvalRecPoint::DeleteParent()
 {
+  // delete parent
   fParent=-333;
 }
 
 void AliPHOSEvalRecPoint::UpdateWorkingPool()
 {
-
+  // update pool of rec.points
   Int_t i; //loop variable
   
   for(i=0; i<this->InWorkingPool(); i++) {
@@ -150,7 +178,7 @@ void AliPHOSEvalRecPoint::UpdateWorkingPool()
      Int_t nChild = parent->HasChild(children);
      for(Int_t iChild=0; iChild<nChild; iChild++)
        {
-        ((AliPHOSEvalRecPoint*)children.At(iChild))->DeleteParent();
+        ((AliPHOSEvalRecPoint*)children.At(iChild))->DeleteParent();
        }
 
      if(nChild) {
@@ -177,6 +205,7 @@ void AliPHOSEvalRecPoint::UpdateWorkingPool()
 
 Int_t AliPHOSEvalRecPoint::HasChild(TObjArray& children)
 {
+  // returns the number of children
   for(Int_t iChild=0; iChild<InWorkingPool(); iChild++)
     {
       AliPHOSEvalRecPoint* child = (AliPHOSEvalRecPoint*)GetFromWorkingPool(iChild);
@@ -190,7 +219,7 @@ Int_t AliPHOSEvalRecPoint::HasChild(TObjArray& children)
 
 void AliPHOSEvalRecPoint::Init()
 {
-
+  // initialization
   AliPHOSClusterizer* clusterizer = GetClusterizer();
   if(!clusterizer) {
     Error("Init", "Cannot get clusterizer. Exit.") ;
@@ -198,16 +227,16 @@ void AliPHOSEvalRecPoint::Init()
   }
 
   TClonesArray* digits = AliPHOSLoader::GetPHOSLoader(fEventFolderName)->Digits();
-  Float_t LogWeight=0;  
+  Float_t logWeight=0;  
 
   if(this->IsEmc()) {
-    LogWeight = clusterizer->GetEmcLogWeight();
+    logWeight = clusterizer->GetEmcLogWeight();
   }
   else {
-    LogWeight = clusterizer->GetCpvLogWeight();
+    logWeight = clusterizer->GetCpvLogWeight();
   }
   
-  EvalLocalPosition(LogWeight,digits); // evaluate initial position
+  EvalLocalPosition(logWeight,digits); // evaluate initial position
 }
 
 
@@ -249,19 +278,19 @@ void AliPHOSEvalRecPoint::InitTwoGam(Float_t* gamma1, Float_t* gamma2)
   GetLocalPosition(lpos);
   Float_t xx = lpos.Z();
   Float_t yy = lpos.X();
-  Float_t E = GetEnergy();
+  Float_t e = GetEnergy();
 
-  Info("InitTwoGam", "(x,z,E)[old] = (%f, %f, %f)", yy, xx, E) ;
+  Info("InitTwoGam", "(x,z,e)[old] = (%f, %f, %f)", yy, xx, e) ;
 
-//    xx = XY(xx/E);
-//    yy = XY(yy/E);
+//    xx = XY(xx/e);
+//    yy = XY(yy/e);
 
 
   Float_t eDigit ;
   AliPHOSDigit * digit ;
   Int_t nDigits = GetMultiplicity();  
-  Int_t * Digits = GetDigitsList();
-  Float_t * Energies = GetEnergiesList();
+  Int_t * digits = GetDigitsList();
+  Float_t * energies = GetEnergiesList();
 
   Float_t ix ;
   Float_t iy ;
@@ -280,8 +309,8 @@ void AliPHOSEvalRecPoint::InitTwoGam(Float_t* gamma1, Float_t* gamma2)
 
   for(iDigit = 0 ; iDigit < nDigits ; iDigit ++)
     {
-      digit = (AliPHOSDigit*)fLoader->Digits()->At( Digits[iDigit] ); 
-      eDigit = Energies[iDigit];
+      digit = (AliPHOSDigit*)fLoader->Digits()->At( digits[iDigit] ); 
+      eDigit = energies[iDigit];
       fGeom->AbsToRelNumbering(digit->GetId(), relid) ;
       fGeom->RelPosInModule(relid, iy, ix);
     
@@ -303,8 +332,8 @@ void AliPHOSEvalRecPoint::InitTwoGam(Float_t* gamma1, Float_t* gamma2)
   Float_t eu3 = 0;
   for(iDigit = 0 ; iDigit < nDigits ; iDigit ++)
     {
-      digit = (AliPHOSDigit*)fLoader->Digits()->At( Digits[iDigit] ); 
-      eDigit = Energies[iDigit];
+      digit = (AliPHOSDigit*)fLoader->Digits()->At( digits[iDigit] ); 
+      eDigit = energies[iDigit];
       fGeom->AbsToRelNumbering(digit->GetId(), relid) ;
       fGeom->RelPosInModule(relid, iy, ix);
     
@@ -314,16 +343,16 @@ void AliPHOSEvalRecPoint::InitTwoGam(Float_t* gamma1, Float_t* gamma2)
       eu3 += eDigit*du*du*du;
     }
   
-  Float_t c = E*eu3*eu3/(euu*euu*euu)/2.;
+  Float_t c = e*eu3*eu3/(euu*euu*euu)/2.;
   Float_t sign = 1.;
   if(eu3<0) sign = -1.;
   Float_t r = 1.+ c + sign*TMath::Sqrt(2.*c + c*c);
   Float_t u = 0;
   if(TMath::Abs(r-1.)>0.1) u = eu3/euu*(r+1.)/(r-1.);
-  if(TMath::Abs(r-1.)<0.1) u = TMath::Sqrt(sqr/E/r)*(1.+r);
+  if(TMath::Abs(r-1.)<0.1) u = TMath::Sqrt(sqr/e/r)*(1.+r);
   
-  Float_t e2c = E/(1.+r);
-  Float_t e1c = E-e2c;
+  Float_t e2c = e/(1.+r);
+  Float_t e1c = e-e2c;
   Float_t u1 = -u/(1.+r);
   Float_t u2 = u+u1;
   
@@ -361,7 +390,7 @@ void AliPHOSEvalRecPoint::TwoGam(Float_t* gamma1, Float_t* gamma2)
   Float_t chmin = GetReconstructionManager()->TwoGamChisqMin();
   Float_t emin = GetReconstructionManager()->TwoGamEmin();
   Float_t stpmin = GetReconstructionManager()->TwoGamStepMin();
-  Int_t Niter = GetReconstructionManager()->TwoGamNumOfIterations(); // Number of iterations.
+  Int_t nIter = GetReconstructionManager()->TwoGamNumOfIterations(); // Number of iterations.
 
   Float_t chisq = 100.; //Initial chisquare.
 
@@ -391,13 +420,13 @@ void AliPHOSEvalRecPoint::TwoGam(Float_t* gamma1, Float_t* gamma2)
   Float_t y2c = gamma2[1];
   Float_t x2c = gamma2[2];
 
-  Float_t E = GetEnergy();
+  Float_t e = GetEnergy();
 
   Float_t eDigit ;
   AliPHOSDigit * digit ;
   Int_t nDigits = GetMultiplicity();  
-  Int_t * Digits = GetDigitsList();
-  Float_t * Energies = GetEnergiesList();
+  Int_t * digits = GetDigitsList();
+  Float_t * energies = GetEnergiesList();
 
   Float_t ix ;
   Float_t iy ;
@@ -406,7 +435,7 @@ void AliPHOSEvalRecPoint::TwoGam(Float_t* gamma1, Float_t* gamma2)
   AliPHOSLoader* fLoader = AliPHOSLoader::GetPHOSLoader(fEventFolderName);
   const AliPHOSGeometry* fGeom = fLoader->PHOSGeometry();
 
-  for(Int_t Iter=0; Iter<Niter; Iter++)
+  for(Int_t iter=0; iter<nIter; iter++)
     {
       Float_t chisqc = 0.;
       Float_t grx1c = 0.;
@@ -417,8 +446,8 @@ void AliPHOSEvalRecPoint::TwoGam(Float_t* gamma1, Float_t* gamma2)
 
       for(Int_t iDigit = 0 ; iDigit < nDigits ; iDigit ++)
        {
-         digit = (AliPHOSDigit*)fLoader->Digits()->At( Digits[iDigit] ); 
-         eDigit = Energies[iDigit];
+         digit = (AliPHOSDigit*)fLoader->Digits()->At( digits[iDigit] ); 
+         eDigit = energies[iDigit];
          fGeom->AbsToRelNumbering(digit->GetId(), relid) ;
          fGeom->RelPosInModule(relid, iy, ix);
          
@@ -437,25 +466,25 @@ void AliPHOSEvalRecPoint::TwoGam(Float_t* gamma1, Float_t* gamma2)
 //       AG(e2c,dx2,dy2,a2,gx2,gy2);
          GetReconstructionManager()->AG(e2c,dx2,dy2,a2,gx2,gy2);
       
-         Float_t A = a1+a2;
-//       Float_t D = Const*A*(1. - A/E);
+         Float_t a = a1+a2;
+//       Float_t D = Const*a*(1. - a/e);
 //       if(D<0) D=0;
 
 //  //           D = 9.; // ????
          
-//       Float_t da = A - eDigit;
+//       Float_t da = a - eDigit;
 //       chisqc += da*da/D;
 //       Float_t dd = da/D;
-//       dd = dd*(2.-dd*Const*(1.-2.*A/E));
+//       dd = dd*(2.-dd*Const*(1.-2.*a/e));
 
          Float_t dd;
-         chisqc += GetReconstructionManager()->TwoGamChi2(A,eDigit,E,dd);
+         chisqc += GetReconstructionManager()->TwoGamChi2(a,eDigit,e,dd);
          
          grx1c += gx1*dd;
          gry1c += gy1*dd;
          grx2c += gx2*dd;
          gry2c += gy2*dd;
-         grec += (a1/e1c - a2/e2c)*E*dd;
+         grec += (a1/e1c - a2/e2c)*e*dd;
 
        }
 
@@ -493,13 +522,13 @@ void AliPHOSEvalRecPoint::TwoGam(Float_t* gamma1, Float_t* gamma2)
       Float_t step = st*gr;
 
       Info("TwoGam", "Iteration %d dof %d chisq/dof %f chstop/dof %f step %d stpmin %d",
-          Iter, dof, ch/dof, chstop/dof, step, stpmin) ;
+          iter, dof, ch/dof, chstop/dof, step, stpmin) ;
 
       
       if(step<stpmin) 
        goto loop101;
 
-      Float_t de = st*gre*E;
+      Float_t de = st*gre*e;
       e1c = ee1 - de;
       e2c = ee2 + de;
       
@@ -531,19 +560,19 @@ void AliPHOSEvalRecPoint::TwoGam(Float_t* gamma1, Float_t* gamma2)
   gamma2[1] = yy2;
   gamma2[2] = xx2;
 
-  Float_t x1_new = yy1;
-  Float_t z1_new = xx1;
-  Float_t e1_new = ee1;
-  Float_t x2_new = yy2;
-  Float_t z2_new = xx2;
-  Float_t e2_new = ee2;
+  Float_t x1New = yy1;
+  Float_t z1New = xx1;
+  Float_t e1New = ee1;
+  Float_t x2New = yy2;
+  Float_t z2New = xx2;
+  Float_t e2New = ee2;
 
   TString message ; 
-  message  = "     (x,z,E)[1 fit] = (%f, %f, %f)\n" ;  
-  message  = "     (x,z,E)[2 fit] = (%f, %f, %f)\n" ;  
+  message  = "     (x,z,e)[1 fit] = (%f, %f, %f)\n" ;  
+  message  = "     (x,z,e)[2 fit] = (%f, %f, %f)\n" ;  
   Info("TwoGam", message.Data(), 
-       x1_new, z1_new, e1_new, 
-       x2_new, z2_new, e2_new) ;
+       x1New, z1New, e1New, 
+       x2New, z2New, e2New) ;
 
   fChi2Dof = chisq;
 
@@ -556,12 +585,12 @@ void AliPHOSEvalRecPoint::UnfoldTwoMergedPoints(Float_t* gamma1, Float_t* gamma2
   // Use TwoGam() to estimate the positions and energies of merged points.
  
   
-  Int_t Nmax = 2;
+  Int_t nMax = 2;
   Float_t* gamma;
 
-  Int_t* Digits = GetDigitsList();
+  Int_t* digits = GetDigitsList();
   Int_t nDigits = GetMultiplicity();
-  Float_t* Energies = GetEnergiesList();
+  Float_t* energies = GetEnergiesList();
   Float_t* eFit = new Float_t[nDigits];
 
   AliPHOSLoader* fLoader = AliPHOSLoader::GetPHOSLoader(fEventFolderName);
@@ -569,14 +598,14 @@ void AliPHOSEvalRecPoint::UnfoldTwoMergedPoints(Float_t* gamma1, Float_t* gamma2
 
   for(Int_t iDigit=0; iDigit<nDigits; iDigit++)
     {
-      AliPHOSDigit* digit = (AliPHOSDigit*)fLoader->Digits()->At( Digits[iDigit] ); 
+      AliPHOSDigit* digit = (AliPHOSDigit*)fLoader->Digits()->At( digits[iDigit] ); 
       Int_t relid[4] ;
       fGeom->AbsToRelNumbering(digit->GetId(), relid) ;
       Float_t x,z;     
       fGeom->RelPosInModule(relid, x, z);
 
       Float_t gain = 0.;
-      for(Int_t iMax=0; iMax<Nmax; iMax++)
+      for(Int_t iMax=0; iMax<nMax; iMax++)
        {
          if(iMax==0)
            gamma = gamma1;
@@ -589,16 +618,16 @@ void AliPHOSEvalRecPoint::UnfoldTwoMergedPoints(Float_t* gamma1, Float_t* gamma2
 
          Float_t dx = xMax - x;
          Float_t dz = zMax - z;
-         Float_t Amp,gx,gy;
-         GetReconstructionManager()->AG(eMax,dz,dx,Amp,gx,gy); 
-         gain += Amp;
+         Float_t amp,gx,gy;
+         GetReconstructionManager()->AG(eMax,dz,dx,amp,gx,gy); 
+         gain += amp;
        }
  
       eFit[iDigit] = gain;
     }
 
 
-  for( Int_t iMax=0; iMax<Nmax; iMax++)
+  for( Int_t iMax=0; iMax<nMax; iMax++)
     {      
       if(iMax==0)
        gamma = gamma1;
@@ -615,8 +644,8 @@ void AliPHOSEvalRecPoint::UnfoldTwoMergedPoints(Float_t* gamma1, Float_t* gamma2
 
       for( Int_t iDigit = 0 ; iDigit < nDigits ; iDigit ++)
        {
-         AliPHOSDigit* digit = (AliPHOSDigit*)fLoader->Digits()->At( Digits[iDigit] ); 
-         Float_t eDigit = Energies[iDigit];
+         AliPHOSDigit* digit = (AliPHOSDigit*)fLoader->Digits()->At( digits[iDigit] ); 
+         Float_t eDigit = energies[iDigit];
          Int_t relid[4] ;
          fGeom->AbsToRelNumbering(digit->GetId(), relid) ;
          Float_t ix,iz;
@@ -624,10 +653,10 @@ void AliPHOSEvalRecPoint::UnfoldTwoMergedPoints(Float_t* gamma1, Float_t* gamma2
          
          Float_t dx = xMax - ix;
          Float_t dz = zMax - iz;
-         Float_t single_shower_gain,gxMax,gyMax;
-         GetReconstructionManager()->AG(eMax,dz,dx,single_shower_gain,gxMax,gyMax);
-         Float_t total_gain = eFit[iDigit];
-         Float_t ratio = single_shower_gain/total_gain; 
+         Float_t singleShowerGain,gxMax,gyMax;
+         GetReconstructionManager()->AG(eMax,dz,dx,singleShowerGain,gxMax,gyMax);
+         Float_t totalGain = eFit[iDigit];
+         Float_t ratio = singleShowerGain/totalGain; 
          eDigit = eDigit*ratio;
          newRP->AddDigit(*digit,eDigit);
        }
@@ -652,10 +681,10 @@ void AliPHOSEvalRecPoint::EvaluatePosition()
   if(nDigits<2)
     return;
 
-  Int_t Niter = GetReconstructionManager()->OneGamNumOfIterations(); // number of iterations
-  Float_t St0 = GetReconstructionManager()->OneGamInitialStep(); // initial step
-//    const Float_t Stpmin = 0.005;
-  Float_t Stpmin = GetReconstructionManager()->OneGamStepMin();
+  Int_t nIter = GetReconstructionManager()->OneGamNumOfIterations(); // number of iterations
+  Float_t st0 = GetReconstructionManager()->OneGamInitialStep(); // initial step
+//    const Float_t stpMin = 0.005;
+  Float_t stpMin = GetReconstructionManager()->OneGamStepMin();
   Float_t chmin =  GetReconstructionManager()->OneGamChisqMin();
  
   TVector3 locpos;
@@ -665,11 +694,11 @@ void AliPHOSEvalRecPoint::EvaluatePosition()
   Float_t ix, iy;
 
   GetLocalPosition(locpos);
-  Float_t E = GetEnergy();
+  Float_t e = GetEnergy();
   Float_t xc = locpos.Z();
   Float_t yc = locpos.X();
   Float_t dx,dy,gx,gy,grxc,gryc;
-  Float_t st = St0;
+  Float_t st = st0;
   Float_t chisq = 1.e+20;
   Float_t gr = 1.;
   Float_t grx = 0.;
@@ -684,7 +713,7 @@ void AliPHOSEvalRecPoint::EvaluatePosition()
   AliPHOSLoader* fLoader = AliPHOSLoader::GetPHOSLoader(fEventFolderName);
   const AliPHOSGeometry* fGeom = fLoader->PHOSGeometry();
 
-  for(Int_t Iter=0; Iter<Niter; Iter++)
+  for(Int_t iter=0; iter<nIter; iter++)
     {
  
       chisqc = 0.;
@@ -693,10 +722,10 @@ void AliPHOSEvalRecPoint::EvaluatePosition()
       for(Int_t iDigit = 0 ; iDigit < nDigits ; iDigit ++)
        {
 
-         Float_t* Energies = GetEnergiesList();
-         Int_t* Digits = GetDigitsList();
-         digit = (AliPHOSDigit*)fLoader->Digits()->At( Digits[iDigit] );
-         eDigit = Energies[iDigit];
+         Float_t* energies = GetEnergiesList();
+         Int_t* digits = GetDigitsList();
+         digit = (AliPHOSDigit*)fLoader->Digits()->At( digits[iDigit] );
+         eDigit = energies[iDigit];
          fGeom->AbsToRelNumbering(digit->GetId(), relid) ;
          fGeom->RelPosInModule(relid, iy, ix);
       
@@ -706,11 +735,11 @@ void AliPHOSEvalRecPoint::EvaluatePosition()
          if(!dx) dx=dy;
          if(!dy) dy=dx;
                  
-         Float_t A;
-         GetReconstructionManager()->AG(E,dx,dy,A,gx,gy);
+         Float_t a;
+         GetReconstructionManager()->AG(e,dx,dy,a,gx,gy);
          Float_t dd;
          Info("EvaluatePosition", "  (ix iy  xc yc  dx dy)   %f %f %f %f %f %f", ix, iy, xc, yc, dx, dy) ;
-         Float_t chi2dg = GetReconstructionManager()->OneGamChi2(A,eDigit,E,dd);
+         Float_t chi2dg = GetReconstructionManager()->OneGamChi2(a,eDigit,e,dd);
 
          // Exclude digit with too large chisquare.
          if(chi2dg > 10) {  continue; }
@@ -743,11 +772,11 @@ void AliPHOSEvalRecPoint::EvaluatePosition()
     loop20: ;
       Float_t step = st*gr;
 
-      Info("EvaluatePosition", " Iteration %d dof %d chisq/dof %f chstop/dof %f step %d Stpmin %d",
-          Iter, dof, chisq/dof, chisq/dof, chstop/dof, step, Stpmin) ;
+      Info("EvaluatePosition", " Iteration %d dof %d chisq/dof %f chstop/dof %f step %d stpMin %d",
+          iter, dof, chisq/dof, chisq/dof, chstop/dof, step, stpMin) ;
        
 
-      if(step<Stpmin)
+      if(step<stpMin)
        goto loop101;
 
       if(step>1.)
@@ -765,7 +794,7 @@ void AliPHOSEvalRecPoint::EvaluatePosition()
 //      }
 
   Float_t gamma1[3];
-  gamma1[0] = E;
+  gamma1[0] = e;
   gamma1[1] = y1;
   gamma1[2] = x1;
 
@@ -773,7 +802,7 @@ void AliPHOSEvalRecPoint::EvaluatePosition()
   //SetLocalPosition(newpos);
   
   fLocPos=newpos;
-  fAmp=E;
+  fAmp=e;
 
 //    TVector3 pos;
 //    RP->GetLocalPosition(pos);
@@ -790,9 +819,9 @@ Bool_t AliPHOSEvalRecPoint::KillWeakPoint()
   // Remove this point from further procession
   // if it's energy is too small.
   
-  Float_t Thr0 = GetReconstructionManager()->KillGamMinEnergy();
+  Float_t thr0 = GetReconstructionManager()->KillGamMinEnergy();
   
-  if(GetEnergy()<Thr0) {
+  if(GetEnergy()<thr0) {
     Info("KillWeakPoint", "+++++++ Killing this rec point ++++++++++") ;
     RemoveFromWorkingPool(this);
     return kTRUE;
@@ -821,7 +850,7 @@ void AliPHOSEvalRecPoint::SplitMergedShowers()
 
 void AliPHOSEvalRecPoint::MergeClosePoint() 
 {
-
+  // merge rec.points if they are too close
   AliPHOSLoader* fLoader = AliPHOSLoader::GetPHOSLoader(fEventFolderName);
 //    AliPHOSDigitizer* digitizer = fLoader->Digitizer();
 //    Float_t fPedestal = digitizer->GetPedestal();  // YVK 30.09.2001
@@ -848,23 +877,23 @@ void AliPHOSEvalRecPoint::MergeClosePoint()
                  this->GetLocalPosition(lpos1);
                  rp->GetLocalPosition(lpos2);
 
-                 Int_t* Digits = rp->GetDigitsList();
+                 Int_t* digits = rp->GetDigitsList();
                  Float_t dE = rp->GetEnergy()/(rp->GetEnergy()+this->GetEnergy());
-                 Float_t new_x = lpos1.X()*dE + lpos2.X()*(1.-dE); 
-                 Float_t new_z = lpos1.Z()*dE + lpos2.Z()*(1.-dE);
-                 Float_t new_E = rp->GetEnergy()+this->GetEnergy();
-                 Float_t* Energies = ((AliPHOSEmcRecPoint*)rp)->GetEnergiesList();
+                 Float_t newX = lpos1.X()*dE + lpos2.X()*(1.-dE); 
+                 Float_t newZ = lpos1.Z()*dE + lpos2.Z()*(1.-dE);
+                 Float_t newE = rp->GetEnergy()+this->GetEnergy();
+                 Float_t* energies = ((AliPHOSEmcRecPoint*)rp)->GetEnergiesList();
 
                  for(Int_t iDigit=0; iDigit<rp->GetDigitsMultiplicity(); iDigit++)
                    {
-                     AliPHOSDigit* digit = (AliPHOSDigit*)fLoader->Digits()->At(Digits[iDigit]);
-                     Float_t eDigit = Energies[iDigit];
+                     AliPHOSDigit* digit = (AliPHOSDigit*)fLoader->Digits()->At(digits[iDigit]);
+                     Float_t eDigit = energies[iDigit];
                      this->AddDigit(*digit,eDigit);
                    }
 
-                 TVector3 newpos(new_x,0,new_z);
+                 TVector3 newpos(newX,0,newZ);
                  fLocPos = newpos;
-                 fAmp = new_E;
+                 fAmp = newE;
                  RemoveFromWorkingPool(rp);
                  delete rp;
                  
@@ -889,12 +918,11 @@ Int_t AliPHOSEvalRecPoint::UnfoldLocalMaxima()
 
   AliPHOSDigit * maxAt[1000];
   Float_t maxAtEnergy[1000];  
-  Float_t LocMaxCut, LogWeight;
+  Float_t locMaxCut, logWeight;
   Int_t relid[4] ; 
   Float_t xMax;
   Float_t zMax;
 
-//    AliPHOSClusterizer* clusterizer = fLoader->Clusterizer("PHOSclu-v1");  
   AliPHOSClusterizer* clusterizer = GetClusterizer();
   if(!clusterizer) {
     Error("UnfoldLocalMaxima", "Cannot get clusterizer. Exit.") ;
@@ -902,12 +930,12 @@ Int_t AliPHOSEvalRecPoint::UnfoldLocalMaxima()
   }
 
   if(this->IsEmc()) {
-    LocMaxCut = clusterizer->GetEmcLocalMaxCut();
-    LogWeight = clusterizer->GetEmcLogWeight();
+    locMaxCut = clusterizer->GetEmcLocalMaxCut();
+    logWeight = clusterizer->GetEmcLogWeight();
   }
   else {
-    LocMaxCut = clusterizer->GetCpvLocalMaxCut();
-    LogWeight = clusterizer->GetCpvLogWeight();
+    locMaxCut = clusterizer->GetCpvLocalMaxCut();
+    logWeight = clusterizer->GetCpvLogWeight();
   }
 
   AliPHOSLoader* fLoader = AliPHOSLoader::GetPHOSLoader(fEventFolderName);
@@ -915,12 +943,12 @@ Int_t AliPHOSEvalRecPoint::UnfoldLocalMaxima()
   TClonesArray* digits = fLoader->Digits();
 
   // if number of local maxima less then 2 - nothing to unfold
-  Int_t Nmax = GetNumberOfLocalMax(maxAt,maxAtEnergy,LocMaxCut,digits); 
-  if(Nmax<2) return Nmax;
+  Int_t nMax = GetNumberOfLocalMax(maxAt,maxAtEnergy,locMaxCut,digits); 
+  if(nMax<2) return nMax;
 
-  Int_t* Digits = GetDigitsList();
+  Int_t* digitsList = GetDigitsList();
   Int_t nDigits = GetMultiplicity();
-  Float_t* Energies = GetEnergiesList();
+  Float_t* energies = GetEnergiesList();
   Float_t* eFit = new Float_t[nDigits];
 
   Int_t iDigit; //loop variable
@@ -933,12 +961,12 @@ Int_t AliPHOSEvalRecPoint::UnfoldLocalMaxima()
   for(iDigit=0; iDigit<nDigits; iDigit++)
     {
       
-      AliPHOSDigit* digit = (AliPHOSDigit*)fLoader->Digits()->At( Digits[iDigit] );
+      AliPHOSDigit* digit = (AliPHOSDigit*)fLoader->Digits()->At( digitsList[iDigit] );
       fGeom->AbsToRelNumbering(digit->GetId(), relid) ;
       Float_t x,z;
       fGeom->RelPosInModule(relid, x, z);
 
-      for(Int_t iMax=0; iMax<Nmax; iMax++)
+      for(Int_t iMax=0; iMax<nMax; iMax++)
        {
          AliPHOSDigit* digitMax = maxAt[iMax];
          Float_t eMax = maxAtEnergy[iMax]; 
@@ -946,15 +974,15 @@ Int_t AliPHOSEvalRecPoint::UnfoldLocalMaxima()
          fGeom->RelPosInModule(relid, xMax, zMax);
          Float_t dx = xMax - x;
          Float_t dz = zMax - z;
-         Float_t Amp,gx,gy;
-         GetReconstructionManager()->AG(eMax,dz,dx,Amp,gx,gy); 
-//        Amp = Amp + 0.5;
-         eFit[iDigit] += Amp;
+         Float_t amp,gx,gy;
+         GetReconstructionManager()->AG(eMax,dz,dx,amp,gx,gy); 
+//        amp = amp + 0.5;
+         eFit[iDigit] += amp;
        }
     }
 
 
-  for(Int_t iMax=0; iMax<Nmax; iMax++) 
+  for(Int_t iMax=0; iMax<nMax; iMax++) 
     {
       AliPHOSDigit* digitMax = maxAt[iMax];
       fGeom->AbsToRelNumbering(digitMax->GetId(), relid) ;
@@ -967,8 +995,8 @@ Int_t AliPHOSEvalRecPoint::UnfoldLocalMaxima()
       //Neighbous ( matrix 3x3 around the local maximum)
       for(Int_t iDigit=0; iDigit<nDigits; iDigit++)
        {     
-         AliPHOSDigit* digit = (AliPHOSDigit*)fLoader->Digits()->At( Digits[iDigit] );
-         Float_t eDigit = Energies[iDigit];
+         AliPHOSDigit* digit = (AliPHOSDigit*)fLoader->Digits()->At( digitsList[iDigit] );
+         Float_t eDigit = energies[iDigit];
          fGeom->AbsToRelNumbering(digit->GetId(), relid) ;
          Float_t ix,iz;
          fGeom->RelPosInModule(relid, ix, iz);
@@ -977,17 +1005,17 @@ Int_t AliPHOSEvalRecPoint::UnfoldLocalMaxima()
            {
              Float_t dx = xMax - ix;
              Float_t dz = zMax - iz;
-             Float_t single_shower_gain,gxMax,gyMax;
-             GetReconstructionManager()->AG(eMax,dz,dx,single_shower_gain,gxMax,gyMax);
-             Float_t total_gain = eFit[iDigit];
-             Float_t ratio = single_shower_gain/total_gain; 
+             Float_t singleShowerGain,gxMax,gyMax;
+             GetReconstructionManager()->AG(eMax,dz,dx,singleShowerGain,gxMax,gyMax);
+             Float_t totalGain = eFit[iDigit];
+             Float_t ratio = singleShowerGain/totalGain; 
              Info("UnfoldLocalMaxima", " ratio -> %f", ratio) ;
              eDigit = eDigit*ratio;
              newRP->AddDigit(*digit,eDigit);
            }
        }
 
-      newRP->EvalLocalPosition(LogWeight,digits);
+      newRP->EvalLocalPosition(logWeight,digits);
       Info("UnfoldLocalMaxima", "======= Unfold: daughter rec point %d =================", iMax) ;
       newRP->Print("");
     }
@@ -996,12 +1024,13 @@ Int_t AliPHOSEvalRecPoint::UnfoldLocalMaxima()
 
   delete[] eFit;
 
-  return Nmax;
+  return nMax;
 
 }
 
 void AliPHOSEvalRecPoint::PrintPoint(Option_t* opt)
 {
+  // print rec.point to stdout
   AliPHOSCpvRecPoint::Print(opt);
 
   TVector3 lpos;
@@ -1016,7 +1045,7 @@ void AliPHOSEvalRecPoint::PrintPoint(Option_t* opt)
 
 AliPHOSRecManager* AliPHOSEvalRecPoint::GetReconstructionManager() const
 {
-
+  // returns reconstruction manager
   TFolder* aliceF = (TFolder*)gROOT->FindObjectAny("YSAlice");
   TFolder* wPoolF = (TFolder*)aliceF->FindObject("WhiteBoard/RecPoints/PHOS/SmP");
   AliPHOSRecManager* recMng = (AliPHOSRecManager*)wPoolF->FindObject("AliPHOSRecManager");
@@ -1031,6 +1060,7 @@ AliPHOSRecManager* AliPHOSEvalRecPoint::GetReconstructionManager() const
 
 AliPHOSRecPoint* AliPHOSEvalRecPoint::Parent()
 {
+  // returns a parent
   if(fParent<0) return NULL;
   else
     return (AliPHOSRecPoint*)GetFromWorkingPool(fParent);
@@ -1039,12 +1069,13 @@ AliPHOSRecPoint* AliPHOSEvalRecPoint::Parent()
 
 Float_t AliPHOSEvalRecPoint::Chi2Dof() const 
 {
+  // returns a chi^2 per degree of freedom
   return fChi2Dof;
 }
 
 const TObject* AliPHOSEvalRecPoint::GetWorkingPool()
 {
-
+  // returns a pool of rec.points
   TFolder* aliceF = (TFolder*)gROOT->FindObjectAny("YSAlice");
   TFolder* wPoolF = (TFolder*)aliceF->FindObject("WhiteBoard/RecPoints/PHOS/SmP");
   TObject* wPool = wPoolF->FindObject("SmartPoints");
@@ -1058,46 +1089,32 @@ const TObject* AliPHOSEvalRecPoint::GetWorkingPool()
 
 void AliPHOSEvalRecPoint::AddToWorkingPool(TObject* obj)
 {
+  // add a rec.point to a pool
   ((TObjArray*)GetWorkingPool())->Add(obj);
 }
 
 TObject* AliPHOSEvalRecPoint::GetFromWorkingPool(Int_t i)
 {
+  // return a rec.point from a pool at an index i
 //    return fWorkingPool->At(i);
   return ((TObjArray*)GetWorkingPool())->At(i);
 }
 
 Int_t AliPHOSEvalRecPoint::InWorkingPool()
 {
+  // return the number of rec.points in a pool
   return ((TObjArray*)GetWorkingPool())->GetEntries();
 }
 
 void AliPHOSEvalRecPoint::RemoveFromWorkingPool(TObject* obj)
 {
+  // remove a rec.point from a pool
   ((TObjArray*)GetWorkingPool())->Remove(obj);
   ((TObjArray*)GetWorkingPool())->Compress();
 }
 
 void AliPHOSEvalRecPoint::PrintWorkingPool()
 {
+  // print pool of rec.points to stdout
   ((TObjArray*)GetWorkingPool())->Print("");
 }
-
-void AliPHOSEvalRecPoint::SetEventFolderName(const char* evfname)
-{//Sets event folder name
-  fEventFolderName = evfname;
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
index 85790e0..894cd44 100644 (file)
@@ -6,7 +6,6 @@
 
 
 #include "AliPHOSCpvRecPoint.h"
-
 class AliPHOSClusterizer;
 class AliPHOSRecPoint;
 class AliPHOSRecManager;
@@ -56,9 +55,8 @@ public:
   Int_t InWorkingPool();
   void RemoveFromWorkingPool(TObject* obj);
   void PrintWorkingPool();
-  
-  enum RecPointType {emc,cpv};
-  void SetEventFolderName(const char* evfname);
+
+  enum RecPointType {kEmc,kCpv};
 
 private:
 
@@ -69,28 +67,14 @@ private:
 
 private:
 
-  Bool_t  fIsEmc;
-  Bool_t  fIsCpv;
-  Int_t   fParent;
-  Float_t fChi2Dof;
-  
-  TString fEventFolderName;
-  
+  Bool_t fIsEmc;    // true if EMC
+  Bool_t fIsCpv;    // true if CPV
+  Int_t fParent;    // parent
+  Float_t fChi2Dof; // chi^2 per degree of freedom
+  TString fEventFolderName; // Folder name
+
   ClassDef(AliPHOSEvalRecPoint,1)
 
 };
 
 #endif
-
-
-
-
-
-
-
-
-
-
-
-
-
index 6c11305..ad28678 100644 (file)
@@ -186,6 +186,7 @@ const AliPHOS * AliPHOSLoader::PHOS()
 //____________________________________________________________________________ 
 const AliPHOSGeometry * AliPHOSLoader::PHOSGeometry() 
 {
+  // Return PHOS geometry
   AliPHOSGeometry * rv = 0 ; 
   if (PHOS() )
     rv =  PHOS()->GetGeometry();
@@ -218,7 +219,8 @@ Int_t AliPHOSLoader::LoadHits(Option_t* opt)
 
 //____________________________________________________________________________ 
 Int_t AliPHOSLoader::LoadSDigits(Option_t* opt)
-{  //---------- SDigits -------------------------
+{
+  //---------- SDigits -------------------------
   Int_t res;
   //First call the AliLoader's method to send the TreeS to folder
   res = AliLoader::LoadSDigits(opt);
@@ -233,6 +235,7 @@ Int_t AliPHOSLoader::LoadSDigits(Option_t* opt)
 //____________________________________________________________________________ 
 Int_t AliPHOSLoader::LoadDigits(Option_t* opt)
 { 
+  //---------- Digits -------------------------
   Int_t res;
   //First call the AliLoader's method to send the TreeS to folder
   res = AliLoader::LoadDigits(opt);
@@ -245,7 +248,8 @@ Int_t AliPHOSLoader::LoadDigits(Option_t* opt)
 }
 //____________________________________________________________________________ 
 Int_t AliPHOSLoader::LoadRecPoints(Option_t* opt) 
-{ // -------------- RecPoints -------------------------------------------
+{
+  // -------------- RecPoints -------------------------------------------
   Int_t res;
   //First call the AliLoader's method to send the TreeR to folder
   res = AliLoader::LoadRecPoints(opt);
@@ -281,7 +285,8 @@ Int_t  AliPHOSLoader::LoadTracks(Option_t* opt)
 
 //____________________________________________________________________________ 
 Int_t AliPHOSLoader::LoadRecParticles(Option_t* opt) 
-{ // -------------- RecPoints -------------------------------------------
+{
+  // -------------- RecPoints -------------------------------------------
   Int_t res;
   //First call the AliLoader's method to send the TreeT to folder
   res = AliLoader::LoadRecParticles(opt);
@@ -297,6 +302,7 @@ Int_t AliPHOSLoader::LoadRecParticles(Option_t* opt)
 
 Int_t AliPHOSLoader::PostHits()
 {
+  // -------------- Hits -------------------------------------------
   Int_t reval = AliLoader::PostHits();
   if (reval)
    {
@@ -309,6 +315,7 @@ Int_t AliPHOSLoader::PostHits()
 
 Int_t AliPHOSLoader::PostSDigits()
 {
+  // -------------- SDigits -------------------------------------------
   Int_t reval = AliLoader::PostSDigits();
   if (reval)
    {
@@ -321,6 +328,7 @@ Int_t AliPHOSLoader::PostSDigits()
 
 Int_t AliPHOSLoader::PostDigits()
 {
+  // -------------- Digits -------------------------------------------
   Int_t reval = AliLoader::PostDigits();
   if (reval)
    {
@@ -333,6 +341,7 @@ Int_t AliPHOSLoader::PostDigits()
 
 Int_t AliPHOSLoader::PostRecPoints()
 {
+  // -------------- RecPoints -------------------------------------------
   Int_t reval = AliLoader::PostRecPoints();
   if (reval)
    {
@@ -346,6 +355,7 @@ Int_t AliPHOSLoader::PostRecPoints()
 
 Int_t AliPHOSLoader::PostRecParticles()
 {
+  // -------------- RecParticles -------------------------------------------
   Int_t reval = AliLoader::PostRecParticles();
   if (reval)
    {
@@ -358,6 +368,7 @@ Int_t AliPHOSLoader::PostRecParticles()
 
 Int_t AliPHOSLoader::PostTracks()
 {
+  // -------------- Tracks -------------------------------------------
   Int_t reval = AliLoader::PostTracks();
   if (reval)
    {
@@ -690,19 +701,20 @@ Int_t AliPHOSLoader::ReadRecParticles()
 
 AliPHOSGeometry* AliPHOSLoader::GetPHOSGeometry()
 {
-//returns PHOS geometry from gAlice 
-//static Method used by some classes where it is not convienient to pass eventfoldername
- if (gAlice == 0x0)
-  return 0x0;
- AliPHOS* phos=dynamic_cast<AliPHOS*>(gAlice->GetDetector("PHOS"));
- if (phos == 0x0)
-  return 0x0;
- return phos->GetGeometry();
+  //returns PHOS geometry from gAlice 
+  //static Method used by some classes where it is not convienient to pass eventfoldername
+  if (gAlice == 0x0)
+    return 0x0;
+  AliPHOS* phos=dynamic_cast<AliPHOS*>(gAlice->GetDetector("PHOS"));
+  if (phos == 0x0)
+    return 0x0;
+  return phos->GetGeometry();
 }
 /***************************************************************************************/
 
 AliPHOSLoader* AliPHOSLoader::GetPHOSLoader(const  char* eventfoldername)
 {
+  // Return PHOS loader
   AliRunLoader* rn  = AliRunLoader::GetRunLoader(eventfoldername);
   if (rn == 0x0)
    {
@@ -715,7 +727,8 @@ AliPHOSLoader* AliPHOSLoader::GetPHOSLoader(const  char* eventfoldername)
 /***************************************************************************************/
 
 Bool_t AliPHOSLoader::BranchExists(const TString& recName)
- {
+{
+  // Check if a branch named redName exists
   if (fBranchTitle.IsNull()) return kFALSE;
   TString dataname, zername ;
   TTree* tree;
@@ -779,7 +792,8 @@ Bool_t AliPHOSLoader::BranchExists(const TString& recName)
  }
 
 void AliPHOSLoader::SetBranchTitle(const TString& btitle)
- {
+{
+  // Set branch title
   if (btitle.CompareTo(fBranchTitle) == 0) return;
   fBranchTitle = btitle;
   ReloadAll();
@@ -788,6 +802,7 @@ void AliPHOSLoader::SetBranchTitle(const TString& btitle)
 
 void AliPHOSLoader::CleanHits()
 {
+  // Clean Hits array
   AliLoader::CleanHits();
   //Clear an array 
   TClonesArray* hits = Hits();
@@ -797,6 +812,7 @@ void AliPHOSLoader::CleanHits()
 
 void AliPHOSLoader::CleanSDigits()
 {
+  // Clean SDigits array
   AliLoader::CleanSDigits();
   TClonesArray* sdigits = SDigits();
   if (sdigits) sdigits->Clear();
@@ -806,6 +822,7 @@ void AliPHOSLoader::CleanSDigits()
 
 void AliPHOSLoader::CleanDigits()
 {
+  // Clean Digits array
   AliLoader::CleanDigits();
   TClonesArray* digits = Digits();
   if (digits) digits->Clear();
@@ -814,6 +831,7 @@ void AliPHOSLoader::CleanDigits()
 
 void AliPHOSLoader::CleanRecPoints()
 {
+  // Clean RecPoints array
   AliLoader::CleanRecPoints();
   TObjArray* recpoints = EmcRecPoints();
   if (recpoints) recpoints->Clear();
@@ -824,8 +842,7 @@ void AliPHOSLoader::CleanRecPoints()
 
 void AliPHOSLoader::CleanTracks()
 {
-//Cleans Tracks stuff
-  
+  //Cleans Tracks stuff
   AliLoader::CleanTracks();//tree
   
   //and clear the array
@@ -837,7 +854,7 @@ void AliPHOSLoader::CleanTracks()
 
 void AliPHOSLoader::CleanRecParticles()
  {
-
+   // Clean RecParticles array
    TClonesArray *recpar = RecParticles();
    if (recpar) recpar->Clear();
   
@@ -847,7 +864,7 @@ void AliPHOSLoader::CleanRecParticles()
 
 void AliPHOSLoader::ReadCalibrationDB(const char * database,const char * filename)
 {
-
+  // Read calibration data base from file
   if(fcdb && (strcmp(database,fcdb->GetTitle())==0))
     return ;
 
@@ -875,6 +892,7 @@ void AliPHOSLoader::ReadCalibrationDB(const char * database,const char * filenam
 //____________________________________________________________________________ 
 void AliPHOSLoader::MakeHitsArray()
 {
+  // Add Hits array to the data folder
   if (Hits()) return;
   TClonesArray* hits = new TClonesArray("AliPHOSHit",1000);
   hits->SetName(fgkHitsName);
@@ -884,6 +902,7 @@ void AliPHOSLoader::MakeHitsArray()
 //____________________________________________________________________________ 
 void AliPHOSLoader::MakeSDigitsArray()
 {
+  // Add SDigits array to the data folder
   if ( SDigits()) return;
   TClonesArray* sdigits = new TClonesArray("AliPHOSDigit",1);
   sdigits->SetName(fgkSDigitsName);
@@ -893,6 +912,7 @@ void AliPHOSLoader::MakeSDigitsArray()
 //____________________________________________________________________________ 
 void AliPHOSLoader::MakeDigitsArray()
 {
+  // Add Digits array to the data folder
   if ( Digits()) return;
   TClonesArray* digits = new TClonesArray("AliPHOSDigit",1);
   digits->SetName(fgkDigitsName);
@@ -903,6 +923,7 @@ void AliPHOSLoader::MakeDigitsArray()
 //____________________________________________________________________________ 
 void AliPHOSLoader::MakeRecPointsArray()
 {
+  // Add RecPoints array to the data folder
   if ( EmcRecPoints() == 0x0)
    {
     if (GetDebug()>9) Info("MakeRecPointsArray","Making array for EMC");
@@ -923,6 +944,7 @@ void AliPHOSLoader::MakeRecPointsArray()
 //____________________________________________________________________________ 
 void AliPHOSLoader::MakeTrackSegmentsArray()
 {
+  // Add TrackSegments array to the data folder
   if ( TrackSegments()) return;
   TClonesArray * ts = new TClonesArray("AliPHOSTrackSegment",100) ;
   ts->SetName(fgkTracksName);
@@ -933,6 +955,7 @@ void AliPHOSLoader::MakeTrackSegmentsArray()
 //____________________________________________________________________________ 
 void AliPHOSLoader::MakeRecParticlesArray()
 {
+  // Add RecParticles array to the data folder
   if ( RecParticles()) return;
   TClonesArray * rp = new TClonesArray("AliPHOSRecParticle",100) ;
   rp->SetName(fgkRecParticlesName);
index 9bb1157..5e74fd0 100644 (file)
@@ -185,6 +185,21 @@ class AliPHOSLoader : public AliLoader {
   AliPHOSCalibrationDB * CalibrationDB(){return  fcdb; }
   void ReadCalibrationDB(const char * name, const char * filename);
   
+ public:
+
+  static const TString fgkHitsName;//Name for TClonesArray with hits from one event
+  static const TString fgkSDigitsName;//Name for TClonesArray 
+  static const TString fgkDigitsName;//Name for TClonesArray 
+  static const TString fgkEmcRecPointsName;//Name for TClonesArray 
+  static const TString fgkCpvRecPointsName;//Name for TClonesArray 
+  static const TString fgkTracksName;//Name for TClonesArray 
+  static const TString fgkRecParticlesName;//Name for TClonesArray
+
+  static const TString fgkEmcRecPointsBranchName;//Name for branch
+  static const TString fgkCpvRecPointsBranchName;//Name for branch
+  static const TString fgkTrackSegmentsBranchName;//Name for branch
+  static const TString fgkRecParticlesBranchName;//Name for branch
+  
 protected:
   TString fBranchTitle;            //Title of the branch
   AliPHOSCalibrationDB * fcdb ;       //!
@@ -201,21 +216,6 @@ private:
   void  ReadTreeQA() ;
   Int_t  fDebug ;             // Debug level
  
- public:
-
-  static const TString fgkHitsName;//Name for TClonesArray with hits from one event
-  static const TString fgkSDigitsName;//Name for TClonesArray 
-  static const TString fgkDigitsName;//Name for TClonesArray 
-  static const TString fgkEmcRecPointsName;//Name for TClonesArray 
-  static const TString fgkCpvRecPointsName;//Name for TClonesArray 
-  static const TString fgkTracksName;//Name for TClonesArray 
-  static const TString fgkRecParticlesName;//Name for TClonesArray
-
-  static const TString fgkEmcRecPointsBranchName;//Name for branch
-  static const TString fgkCpvRecPointsBranchName;//Name for branch
-  static const TString fgkTrackSegmentsBranchName;//Name for branch
-  static const TString fgkRecParticlesBranchName;//Name for branch
-  
   ClassDef(AliPHOSLoader,3)  // Algorithm class that provides methods to retrieve objects from a list knowing the index 
 
 };