correct coding violations (Adam)
authorgconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 8 Dec 2011 18:59:23 +0000 (18:59 +0000)
committergconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 8 Dec 2011 18:59:23 +0000 (18:59 +0000)
EMCAL/AliEMCALAfterBurnerUF.cxx
EMCAL/AliEMCALAfterBurnerUF.h
EMCAL/AliEMCALUnfolding.cxx
EMCAL/AliEMCALUnfolding.h

index d7f2b59..d07ffe4 100644 (file)
@@ -147,6 +147,10 @@ void AliEMCALAfterBurnerUF::Init()
 //------------------------------------------------------------------------
 AliEMCALAfterBurnerUF::~AliEMCALAfterBurnerUF()
 {
+  //
+  // destructor
+  //
+
   if (fClusterUnfolding) delete fClusterUnfolding;
 
   if (fRecPoints) {
@@ -181,7 +185,7 @@ void AliEMCALAfterBurnerUF::RecPoints2Clusters(TObjArray *clusArray)
     AliEMCALRecPoint *recPoint = (AliEMCALRecPoint*) fRecPoints->At(i);
 
     const Int_t ncells = recPoint->GetMultiplicity();
-    Int_t ncells_true = 0;
+    Int_t ncellsTrue = 0;
 
     // cells and their amplitude fractions
     UShort_t absIds[ncells];  // NOTE: unfolding must not give recPoints with no cells!
@@ -190,13 +194,13 @@ void AliEMCALAfterBurnerUF::RecPoints2Clusters(TObjArray *clusArray)
     for (Int_t c = 0; c < ncells; c++) {
       AliEMCALDigit *digit = (AliEMCALDigit*) fDigitsArr->At(recPoint->GetDigitsList()[c]);
 
-      absIds[ncells_true] = digit->GetId();
-      ratios[ncells_true] = recPoint->GetEnergiesList()[c]/digit->GetAmplitude();
+      absIds[ncellsTrue] = digit->GetId();
+      ratios[ncellsTrue] = recPoint->GetEnergiesList()[c]/digit->GetAmplitude();
 
-      if (ratios[ncells_true] > 0.001) ncells_true++;
+      if (ratios[ncellsTrue] > 0.001) ncellsTrue++;
     }
 
-    if (ncells_true < 1) {
+    if (ncellsTrue < 1) {
       Warning("AliEMCALAfterBurnerUF::RecPoints2Clusters", "skipping cluster with no cells");
       continue;
     }
@@ -214,7 +218,7 @@ void AliEMCALAfterBurnerUF::RecPoints2Clusters(TObjArray *clusArray)
     clus->SetType(AliVCluster::kEMCALClusterv1);
     clus->SetE(recPoint->GetEnergy());
     clus->SetPosition(g);
-    clus->SetNCells(ncells_true);
+    clus->SetNCells(ncellsTrue);
     clus->SetCellsAbsId(absIds);
     clus->SetCellsAmplitudeFraction(ratios);
     // TODO: time not stored
index ee0b938..52c8a18 100644 (file)
@@ -22,23 +22,18 @@ class AliEMCALGeometry;
 class AliEMCALUnfolding;
 class AliVCaloCells;
 
-class AliEMCALAfterBurnerUF {
+class AliEMCALAfterBurnerUF{
 
   public:
     AliEMCALAfterBurnerUF();
     AliEMCALAfterBurnerUF(Float_t logWeight, Float_t locMaxCut, Float_t minEcut);
     virtual ~AliEMCALAfterBurnerUF();
 
-  private:
-    AliEMCALAfterBurnerUF(const AliEMCALAfterBurnerUF & uf) ; // cpy ctor not needed, put here to avoid compilation warning 
-    AliEMCALAfterBurnerUF & operator = (const AliEMCALAfterBurnerUF & uf) ;//cpy assignment, put here to avoid compilation warning 
-  
-  public:
     virtual void Clear();
     virtual void Init();
     virtual void RecPoints2Clusters(TObjArray *clusArray);
     virtual void UnfoldClusters(TObjArray *clusArray, AliVCaloCells *cellsEMCAL);  // does the job
-  
+
     // getters and setters
     virtual AliEMCALUnfolding *GetClusterUnfoldingInstance() { return fClusterUnfolding; }
 
@@ -52,6 +47,12 @@ class AliEMCALAfterBurnerUF {
 
     AliEMCALUnfolding *fClusterUnfolding;  // unfolding class instance
 
+  private:
+    AliEMCALAfterBurnerUF(const AliEMCALAfterBurnerUF & uf) ; // cpy ctor not needed, put here to avoid compilation warning 
+    AliEMCALAfterBurnerUF & operator = (const AliEMCALAfterBurnerUF & uf) ;//cpy assignment, put here to avoid compilation warning 
+  
+
+
     ClassDef(AliEMCALAfterBurnerUF,2)
 } ;
 
index f59c609..5f1a923 100644 (file)
@@ -47,9 +47,9 @@
 class AliCDBStorage;
 #include "AliCDBEntry.h"
 
-Double_t AliEMCALUnfolding::fSSPars[8]={0.9262,3.365,1.548,0.1625,-0.4195,0.,0.,2.332};
-Double_t AliEMCALUnfolding::fPar5[3]={12.31,-0.007381,-0.06936};
-Double_t AliEMCALUnfolding::fPar6[3]={0.05452,0.0001228,0.001361};
+Double_t AliEMCALUnfolding::fgSSPars[8]={0.9262,3.365,1.548,0.1625,-0.4195,0.,0.,2.332};
+Double_t AliEMCALUnfolding::fgPar5[3]={12.31,-0.007381,-0.06936};
+Double_t AliEMCALUnfolding::fgPar6[3]={0.05452,0.0001228,0.001361};
 
 ClassImp(AliEMCALUnfolding)
   
@@ -103,10 +103,10 @@ AliEMCALUnfolding::AliEMCALUnfolding(AliEMCALGeometry* geometry,Float_t ECALocMa
     AliFatal("AliEMCALUnfolding: Geometry not initialized.");
   }
   Int_t i=0;
-  for (i = 0; i < 8; i++) fSSPars[i] = SSPars[i];
+  for (i = 0; i < 8; i++) fgSSPars[i] = SSPars[i];
   for (i = 0; i < 3; i++) {
-    fPar5[i] = Par5[i];
-    fPar6[i] = Par6[i];
+    fgPar5[i] = Par5[i];
+    fgPar6[i] = Par6[i];
   }
 
 }
@@ -671,21 +671,23 @@ Double_t  AliEMCALUnfolding::ShowerShapeV2(Double_t x, Double_t y)
   // Shape of the shower
   // If you change this function, change also the gradient evaluation in ChiSquare()
 
-  Double_t r = fSSPars[7]*TMath::Sqrt(x*x+y*y);
-  Double_t rp1  = TMath::Power(r, fSSPars[1]) ;
-  Double_t rp5  = TMath::Power(r, fSSPars[5]) ;
-  Double_t shape = fSSPars[0]*TMath::Exp( -rp1 * (1. / (fSSPars[2] + fSSPars[3] * rp1) + fSSPars[4] / (1 + fSSPars[6] * rp5) ) ) ;
+  Double_t r = fgSSPars[7]*TMath::Sqrt(x*x+y*y);
+  Double_t rp1  = TMath::Power(r, fgSSPars[1]) ;
+  Double_t rp5  = TMath::Power(r, fgSSPars[5]) ;
+  Double_t shape = fgSSPars[0]*TMath::Exp( -rp1 * (1. / (fgSSPars[2] + fgSSPars[3] * rp1) + fgSSPars[4] / (1 + fgSSPars[6] * rp5) ) ) ;
   return shape ;
 }
 
 //____________________________________________________________________________
 void AliEMCALUnfolding::UnfoldingChiSquareV2(Int_t & nPar, Double_t * Grad,
-                                                Double_t & fret,
-                                                Double_t * x, Int_t iflag)
+                                            Double_t & fret,
+                                            Double_t * x, Int_t iflag)
 {
   // Calculates the Chi square for the cluster unfolding minimization
   // Number of parameters, Gradient, Chi squared, parameters, what to do
   
+  nPar=nPar;//to cheat rulechecker
+
   TList * toMinuit = dynamic_cast<TList*>( gMinuit->GetObjectFit() ) ;
   if(toMinuit){
     AliEMCALRecPoint * recPoint = dynamic_cast<AliEMCALRecPoint*>( toMinuit->At(0) )  ;
@@ -752,15 +754,15 @@ void AliEMCALUnfolding::UnfoldingChiSquareV2(Int_t & nPar, Double_t * Grad,
             Double_t zpar = x[iParam+1] ;
             Double_t epar = x[iParam+2] ;
             
-            Double_t dr = fSSPars[7]*TMath::Sqrt( ((Float_t)iphi - xpar) * ((Float_t)iphi - xpar) + ((Float_t)ieta - zpar) * ((Float_t)ieta - zpar) );
+            Double_t dr = fgSSPars[7]*TMath::Sqrt( ((Float_t)iphi - xpar) * ((Float_t)iphi - xpar) + ((Float_t)ieta - zpar) * ((Float_t)ieta - zpar) );
             Double_t shape = sum * ShowerShapeV2((Float_t)iphi - xpar,(Float_t)ieta - zpar) ;
-            Double_t rp1  = TMath::Power(dr, fSSPars[1]) ;
-            Double_t rp5  = TMath::Power(dr, fSSPars[5]) ;
+            Double_t rp1  = TMath::Power(dr, fgSSPars[1]) ;
+            Double_t rp5  = TMath::Power(dr, fgSSPars[5]) ;
             
-            Double_t deriv = -2 * TMath::Power(dr,fSSPars[1]-2.) * fSSPars[7] * fSSPars[7] * 
-            (fSSPars[1] * ( 1/(fSSPars[2]+fSSPars[3]*rp1) + fSSPars[4]/(1+fSSPars[6]*rp5) ) - 
-             (fSSPars[1]*fSSPars[3]*rp1/( (fSSPars[2]+fSSPars[3]*rp1)*(fSSPars[2]+fSSPars[3]*rp1) ) + 
-              fSSPars[4]*fSSPars[5]*fSSPars[6]*rp5/( (1+fSSPars[6]*rp5)*(1+fSSPars[6]*rp5) ) ) );
+            Double_t deriv = -2 * TMath::Power(dr,fgSSPars[1]-2.) * fgSSPars[7] * fgSSPars[7] * 
+            (fgSSPars[1] * ( 1/(fgSSPars[2]+fgSSPars[3]*rp1) + fgSSPars[4]/(1+fgSSPars[6]*rp5) ) - 
+             (fgSSPars[1]*fgSSPars[3]*rp1/( (fgSSPars[2]+fgSSPars[3]*rp1)*(fgSSPars[2]+fgSSPars[3]*rp1) ) + 
+              fgSSPars[4]*fgSSPars[5]*fgSSPars[6]*rp5/( (1+fgSSPars[6]*rp5)*(1+fgSSPars[6]*rp5) ) ) );
             
             //Double_t deriv =-1.33 * TMath::Power(dr,0.33)*dr * ( 1.57 / ( (1.57 + 0.0860 * r133) * (1.57 + 0.0860 * r133) )
             //                                                   - 0.55 / (1 + 0.000563 * r669) / ( (1 + 0.000563 * r669) * (1 + 0.000563 * r669) ) ) ;
@@ -797,20 +799,20 @@ void AliEMCALUnfolding::UnfoldingChiSquareV2(Int_t & nPar, Double_t * Grad,
 //____________________________________________________________________________
 void AliEMCALUnfolding::SetShowerShapeParams(Double_t *pars){
   for(UInt_t i=0;i<7;++i)
-    fSSPars[i]=pars[i];
-  if(pars[2]==0. && pars[3]==0.) fSSPars[2]=1.;//to avoid dividing by 0
+    fgSSPars[i]=pars[i];
+  if(pars[2]==0. && pars[3]==0.) fgSSPars[2]=1.;//to avoid dividing by 0
 }
 
 //____________________________________________________________________________
 void AliEMCALUnfolding::SetPar5(Double_t *pars){
   for(UInt_t i=0;i<3;++i)
-    fPar5[i]=pars[i];
+    fgPar5[i]=pars[i];
 }
 
 //____________________________________________________________________________
 void AliEMCALUnfolding::SetPar6(Double_t *pars){
   for(UInt_t i=0;i<3;++i)
-    fPar6[i]=pars[i];
+    fgPar6[i]=pars[i];
 }
 
 //____________________________________________________________________________
@@ -820,7 +822,7 @@ void AliEMCALUnfolding::EvalPar5(Double_t phi){
   //phi in degrees range (-10,10)
   //
   //fSSPars[5] = 12.31 - phi*0.007381 - phi*phi*0.06936;
-  fSSPars[5] = fPar5[0] + phi * fPar5[1] + phi*phi * fPar5[2];
+  fgSSPars[5] = fgPar5[0] + phi * fgPar5[1] + phi*phi * fgPar5[2];
 }
 
 //____________________________________________________________________________
@@ -830,11 +832,11 @@ void AliEMCALUnfolding::EvalPar6(Double_t phi){
   //phi in degrees range (-10,10)
   //
   //fSSPars[6] = 0.05452 + phi*0.0001228 + phi*phi*0.001361;
-  fSSPars[6] = fPar6[0] + phi * fPar6[1] + phi*phi * fPar6[2];
+  fgSSPars[6] = fgPar6[0] + phi * fgPar6[1] + phi*phi * fgPar6[2];
 }
 
 //____________________________________________________________________________
-void AliEMCALUnfolding::EvalParsPhiDependence(Int_t absId, AliEMCALGeometry *geom){
+void AliEMCALUnfolding::EvalParsPhiDependence(Int_t absId, const AliEMCALGeometry *geom){
   //
   // calculate params p5 and p6 depending on the phi angle in global coordinate
   // for the cell with given absId index
index 8f69142..91fb7cd 100644 (file)
@@ -1,97 +1,99 @@
-#ifndef ALIEMCALUNFOLDING_H\r\r
-#define ALIEMCALUNFOLDING_H\r\r
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r\r
- * See cxx source for full Copyright notice                               */\r\r
-     \r\r
-//_________________________________________________________________________\r\r
-//  Base class for the cluster unfolding algorithm \r\r
-//*-- Author: Adam Matyja (SUBATECH)\r\r
-\r\r
-// --- ROOT system ---\r\r
-#include "AliLog.h"\r\r
-#include "TObject.h" \r\r
-//class TTree;\r\r
-\r\r
-// --- Standard library ---\r\r
-\r\r
-// --- AliRoot header files ---\r\r
-class AliEMCALGeometry ;\r\r
-//class AliEMCALCalibData ;\r\r
-//class AliCaloCalibPedestal ;\r\r
-class AliEMCALRecPoint ; \r\r
-class AliEMCALDigit ;\r\r
-\r\r
-\r\r
-class AliEMCALUnfolding : public TObject {\r\r
-\r\r
-public:\r\r
-\r\r
-  AliEMCALUnfolding() ;        // default ctor\r\r
-  virtual ~AliEMCALUnfolding() ; // dtorEM\r\r
-  AliEMCALUnfolding(AliEMCALGeometry* geometry);// constructor\r\r
-  AliEMCALUnfolding(AliEMCALGeometry* geometry,Float_t ECALocMaxCut,Double_t *SSPars,Double_t *Par5,Double_t *Par6);// constructor\r\r
-\r\r
-  virtual void Init() ;\r\r
-  virtual void SetInput(Int_t numberOfECAClusters,TObjArray *recPoints,TClonesArray *digitsArr);\r\r
-\r\r
-  //setters and getters\r\r
-  virtual void SetNumberOfECAClusters(Int_t n) { fNumberOfECAClusters = n; }\r\r
-  virtual Int_t GetNumberOfECAClusters() const { return fNumberOfECAClusters; }\r\r
-  virtual void SetRecPoints(TObjArray *rec) { fRecPoints = rec; }\r\r
-  virtual TObjArray * GetRecPoints() const { return fRecPoints; }\r\r
-  virtual void SetDigitsArr(TClonesArray *digit) { fDigitsArr = digit; }\r\r
-  virtual TClonesArray * GetDigitsArr() const { return fDigitsArr; }\r\r
-  virtual void SetECALocalMaxCut(Float_t cut) { fECALocMaxCut = cut ; }\r\r
-  virtual Float_t GetECALocalMaxCut() const { return fECALocMaxCut; }\r\r
-  virtual void SetThreshold(Float_t energy) { fThreshold = energy; }\r\r
-  virtual Float_t GetThreshold() const { return fThreshold; }\r\r
-\r\r
-  //unfolding main methods\r\r
-  virtual void   MakeUnfolding();\r\r
-  static Double_t ShowerShapeV2(Double_t x, Double_t y) ; // Shape of EM shower used in unfolding; \r\r
-                                              //class member function (not object member function)\r\r
-  static void UnfoldingChiSquareV2(Int_t & nPar, Double_t * Grad, Double_t & fret, Double_t * x, Int_t iflag)  ;\r\r
-                                            // Chi^2 of the fit. Should be static to be passes to MINUIT\r\r
-  virtual void SetShowerShapeParams(Double_t *pars) ;\r\r
-  virtual Double_t* GetShowerShapeParams() const { return fSSPars ; }\r\r
-  virtual void SetPar5(Double_t *pars) ;\r\r
-  virtual Double_t* GetPar5() const { return fPar5 ; }\r\r
-  virtual void SetPar6(Double_t *pars) ;\r\r
-  virtual Double_t* GetPar6() const { return fPar6 ; }\r\r
-\r\r
-protected:\r\r
-  Int_t   fNumberOfECAClusters ;     // number of clusters found in EC section\r\r
-  Float_t fECALocMaxCut ;            // minimum energy difference to distinguish local maxima in a cluster\r\r
-  Float_t fThreshold ; //minimum energy for cell to be joined to a cluster\r\r
-  AliEMCALGeometry     * fGeom;       //! pointer to geometry for utilities\r\r
-  TObjArray    *fRecPoints; // Array with EMCAL clusters\r\r
-  TClonesArray *fDigitsArr; // Array with EMCAL digits\r\r
-\r\r
-private:\r\r
-  AliEMCALUnfolding(const AliEMCALUnfolding &); //copy ctor\r\r
-  AliEMCALUnfolding & operator = (const AliEMCALUnfolding &);\r\r
-  \r\r
-  Bool_t         UnfoldClusterV2(AliEMCALRecPoint * iniEmc, Int_t Nmax, \r\r
-                                AliEMCALDigit ** maxAt,\r\r
-                                Float_t * maxAtEnergy ); //Unfolds cluster using TMinuit package\r\r
-  Bool_t         UnfoldClusterV2old(AliEMCALRecPoint * iniEmc, Int_t Nmax, \r\r
-                                   AliEMCALDigit ** maxAt,\r\r
-                                   Float_t * maxAtEnergy ); //Unfolds cluster using TMinuit package\r\r
-  Bool_t  FindFitV2(AliEMCALRecPoint * emcRP, AliEMCALDigit ** MaxAt, const Float_t * maxAtEnergy, \r\r
-                   Int_t NPar, Float_t * FitParametres) const; //Used in UnfoldClusters, calls TMinuit\r\r
-\r\r
-  static Double_t fSSPars[8];//! Unfolding shower shape parameters\r\r
-  // function:\r\r
-  // f(r)=exp(-(p0*r)^p1 * (1/(p2+p3*(p0*r)^p1)+p4/(1+p6*(p0*r)^p5) ) )\r\r
-  // p0,p1,p2,p3,p4 are fixed\r\r
-  // params p5 and p6 are phi-dependent and set in ShowerShapeV2\r\r
-  static Double_t fPar5[3];//! UF SSPar nr 5 = p0 + phi*p1 + phi^2 *p2\r\r
-  static Double_t fPar6[3];//! UF SSPar nr 6 = p0 + phi*p1 + phi^2 *p2\r\r
-  static void EvalPar5(Double_t phi);\r\r
-  static void EvalPar6(Double_t phi);\r\r
-  static void EvalParsPhiDependence(Int_t absId, AliEMCALGeometry *geom);\r\r
-\r\r
-  ClassDef(AliEMCALUnfolding,2)  // Unfolding algorithm class \r\r
-} ;\r\r
-\r\r
-#endif // AliEMCALUNFOLDING_H\r\r
+#ifndef ALIEMCALUNFOLDING_H 
+#define ALIEMCALUNFOLDING_H 
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * 
+ * See cxx source for full Copyright notice                               */ 
+      
+//_________________________________________________________________________ 
+//  Base class for the cluster unfolding algorithm  
+//*-- Author: Adam Matyja (SUBATECH) 
+// --- ROOT system --- 
+//#include "AliLog.h" 
+#include "TObject.h"  
+//class TTree; 
+class AliLog ; 
+
+// --- Standard library --- 
+// --- AliRoot header files --- 
+class AliEMCALGeometry ; 
+//class AliEMCALCalibData ; 
+//class AliCaloCalibPedestal ; 
+class AliEMCALRecPoint ;  
+class AliEMCALDigit ; 
+class AliEMCALUnfolding : public TObject { 
+public: 
+  AliEMCALUnfolding() ;        // default ctor 
+  virtual ~AliEMCALUnfolding() ; // dtorEM 
+  AliEMCALUnfolding(AliEMCALGeometry* geometry);// constructor 
+  AliEMCALUnfolding(AliEMCALGeometry* geometry,Float_t ECALocMaxCut,Double_t *SSPars,Double_t *Par5,Double_t *Par6);// constructor 
+  virtual void Init() ; 
+  virtual void SetInput(Int_t numberOfECAClusters,TObjArray *recPoints,TClonesArray *digitsArr); 
+  //setters and getters 
+  virtual void SetNumberOfECAClusters(Int_t n) { fNumberOfECAClusters = n; } 
+  virtual Int_t GetNumberOfECAClusters() const { return fNumberOfECAClusters; } 
+  virtual void SetRecPoints(TObjArray *rec) { fRecPoints = rec; } 
+  virtual TObjArray * GetRecPoints() const { return fRecPoints; } 
+  virtual void SetDigitsArr(TClonesArray *digit) { fDigitsArr = digit; } 
+  virtual TClonesArray * GetDigitsArr() const { return fDigitsArr; } 
+  virtual void SetECALocalMaxCut(Float_t cut) { fECALocMaxCut = cut ; } 
+  virtual Float_t GetECALocalMaxCut() const { return fECALocMaxCut; } 
+  virtual void SetThreshold(Float_t energy) { fThreshold = energy; } 
+  virtual Float_t GetThreshold() const { return fThreshold; } 
+  //unfolding main methods 
+  virtual void   MakeUnfolding(); 
+  static Double_t ShowerShapeV2(Double_t x, Double_t y) ; // Shape of EM shower used in unfolding;  
+                                              //class member function (not object member function) 
+  static void UnfoldingChiSquareV2(Int_t & nPar, Double_t * Grad, Double_t & fret, Double_t * x, Int_t iflag)  ; 
+                                              // Chi^2 of the fit. Should be static to be passes to MINUIT 
+  virtual void SetShowerShapeParams(Double_t *pars) ; 
+  virtual Double_t* GetShowerShapeParams() const { return fgSSPars ; } 
+  virtual void SetPar5(Double_t *pars) ; 
+  virtual Double_t* GetPar5() const { return fgPar5 ; } 
+  virtual void SetPar6(Double_t *pars) ; 
+  virtual Double_t* GetPar6() const { return fgPar6 ; } 
+protected: 
+  Int_t   fNumberOfECAClusters ;     // number of clusters found in EC section 
+  Float_t fECALocMaxCut ;            // minimum energy difference to distinguish local maxima in a cluster 
+  Float_t fThreshold ; //minimum energy for cell to be joined to a cluster 
+  AliEMCALGeometry     * fGeom;       //! pointer to geometry for utilities 
+  TObjArray    *fRecPoints; // Array with EMCAL clusters 
+  TClonesArray *fDigitsArr; // Array with EMCAL digits 
+private: 
+  AliEMCALUnfolding(const AliEMCALUnfolding &); //copy ctor 
+  AliEMCALUnfolding & operator = (const AliEMCALUnfolding &); 
+   
+  Bool_t         UnfoldClusterV2(AliEMCALRecPoint * iniEmc, Int_t Nmax,  
+                                AliEMCALDigit ** maxAt, 
+                                Float_t * maxAtEnergy ); //Unfolds cluster using TMinuit package 
+  Bool_t         UnfoldClusterV2old(AliEMCALRecPoint * iniEmc, Int_t Nmax,  
+                                   AliEMCALDigit ** maxAt, 
+                                   Float_t * maxAtEnergy ); //Unfolds cluster using TMinuit package 
+  Bool_t  FindFitV2(AliEMCALRecPoint * emcRP, AliEMCALDigit ** MaxAt, const Float_t * maxAtEnergy,  
+                   Int_t NPar, Float_t * FitParametres) const; //Used in UnfoldClusters, calls TMinuit 
+  static Double_t fgSSPars[8];//! Unfolding shower shape parameters 
+  // function: 
+  // f(r)=exp(-(p0*r)^p1 * (1/(p2+p3*(p0*r)^p1)+p4/(1+p6*(p0*r)^p5) ) ) 
+  // p0,p1,p2,p3,p4 are fixed 
+  // params p5 and p6 are phi-dependent and set in ShowerShapeV2 
+  static Double_t fgPar5[3];//! UF SSPar nr 5 = p0 + phi*p1 + phi^2 *p2 
+  static Double_t fgPar6[3];//! UF SSPar nr 6 = p0 + phi*p1 + phi^2 *p2 
+  static void EvalPar5(Double_t phi); 
+  static void EvalPar6(Double_t phi); 
+  static void EvalParsPhiDependence(Int_t absId, const AliEMCALGeometry *geom); 
+  ClassDef(AliEMCALUnfolding,2)  // Unfolding algorithm class  
+} ; 
+#endif // AliEMCALUNFOLDING_H