coding conventions corections
authorschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 5 Mar 2003 11:19:34 +0000 (11:19 +0000)
committerschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 5 Mar 2003 11:19:34 +0000 (11:19 +0000)
PHOS/AliPHOSRecCpvManager.cxx
PHOS/AliPHOSRecCpvManager.h
PHOS/AliPHOSRecEmcManager.cxx
PHOS/AliPHOSRecEmcManager.h
PHOS/AliPHOSRecManager.h

index 85e5ba7..17eb266 100644 (file)
@@ -14,7 +14,7 @@
  **************************************************************************/
 
 
-//_________________________________________________________________________
+ //_________________________________________________________________________
 // Class for the management by the CPV reconstruction.
 //                  
 //*-- Author   : Boris Polichtchouk (IHEP, Protvino) 6 Mar 2001
@@ -26,8 +26,6 @@
 // --- AliRoot header files ---
 
 #include "AliPHOSRecCpvManager.h"
-#include "AliPHOS.h"
-#include "AliRun.h"
 #include "AliPHOSGetter.h"
 
 ClassImp(AliPHOSRecCpvManager) 
@@ -36,6 +34,7 @@ ClassImp(AliPHOSRecCpvManager)
 
   AliPHOSRecCpvManager::AliPHOSRecCpvManager()
 {
+  // Put a comment here
 
   fOneGamChisqCut = 3.; // If Chi2/dof > fOneGamChisqCut, split point.
 
@@ -59,89 +58,93 @@ ClassImp(AliPHOSRecCpvManager)
   SetTitle("Cpv Reconstruction Manager");
 }
 
-AliPHOSRecCpvManager::~AliPHOSRecCpvManager(void) {}
+AliPHOSRecCpvManager::~AliPHOSRecCpvManager(void) 
+{
+  // Put a comment here
+}
 
-Float_t AliPHOSRecCpvManager::Dispersion(Float_t Etot, Float_t Ai, Float_t Ei)
+Float_t AliPHOSRecCpvManager::Dispersion(Float_t etot, Float_t ai, Float_t ei) const
 {
   //"Dispresion" of energy deposition in the cell.
-  // Etot is the total shower energy, Ai is the
+  // etot is the total shower energy, ai is the
   // calculated cell response,
-  // Ei is the measured cell response.
+  // ei is the measured cell response.
 
-  const Float_t Const = 1.5;
-  return Const*Ai*(1.-Ai/Etot);
+  const Float_t kConst = 1.5;
+  return kConst*ai*(1.-ai/etot);
 }
 
-Float_t AliPHOSRecCpvManager::OneGamChi2(Float_t Ai, Float_t Ei, Float_t Etot, Float_t& Gi)
+Float_t AliPHOSRecCpvManager::OneGamChi2(Float_t ai, Float_t ei, Float_t etot, Float_t& Gi)
 {
   //"Chi2" for one cell.
-  // Etot is the total "shower" energy, Ai is the
+  // etot is the total "shower" energy, ai is the
   // calculated cell response,
-  // Ei is the measured cell response.
+  // ei is the measured cell response.
 
-  const Float_t Const = 1.5;
+  const Float_t kConst = 1.5;
 
-  Float_t da = Ai - Ei;
-  Float_t D = Const*Ai*(1.-Ai/Etot);
+  Float_t da = ai - ei;
+  Float_t d = kConst*ai*(1.-ai/etot);
 
-  Float_t dd = da/D;
-  Gi = dd*(2.- dd*Const*(1.-2.*Ai/Etot));
+  Float_t dd = da/d;
+  Gi = dd*(2.- dd*kConst*(1.-2.*ai/etot));
 
-  Info("OneGamChi2", " OneGamChi2 (Ai,Ei,Etot,&Gi,chi2) %f %f %f %f %f", Ai, Ei, Etot, Gi, da*da/D );
+  Info("OneGamChi2", " OneGamChi2 (ai,ei,etot,&Gi,chi2) %f %f %f %f %f", ai, ei, etot, Gi, da*da/d );
 
-  return da*da/D;
+  return da*da/d;
 
 }
 
-Float_t AliPHOSRecCpvManager::TwoGamChi2(Float_t Ai, Float_t Ei, Float_t Etot, Float_t& Gi)
+Float_t AliPHOSRecCpvManager::TwoGamChi2(Float_t ai, Float_t ei, Float_t etot, Float_t& gi) const 
 {
+  // Put a comment here
 
-  const Float_t Const = 1.5;
+  const Float_t kConst = 1.5;
 
-  Float_t da = Ai - Ei;
-  Float_t D = Const*Ai*(1.-Ai/Etot);
+  Float_t da = ai - ei;
+  Float_t d = kConst*ai*(1.-ai/etot);
 
-  Float_t dd = da/D;
-  Gi = dd*(2.- dd*Const*(1.-2.*Ai/Etot));
+  Float_t dd = da/d;
+  gi = dd*(2.- dd*kConst*(1.-2.*ai/etot));
 
-  return da*da/D;
+  return da*da/d;
  
 }
 
-void AliPHOSRecCpvManager::AG(Float_t Ei, Float_t Xi, Float_t Yi, Float_t& Ai, Float_t& GXi, Float_t& GYi )
+void AliPHOSRecCpvManager::AG(Float_t ei, Float_t xi, Float_t yi, Float_t& ai, Float_t& gxi, Float_t& gyi )
 {
-  //Calculates amplitude (Ai) and gradients (GXi, GYi) of CPV pad response.
-  //Integrated response (total "shower energy") is E, 
-  //Xi and Yi are the distances along x and y from reference point 
+  //Calculates amplitude (ai) and gradients (gxi, gyi) of CPV pad response.
+  //Integrated response (total "shower energy") is e, 
+  //xi and yi are the distances along x and y from reference point 
   // to the pad center.
 
   AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ; 
   const AliPHOSGeometry* geom = gime->PHOSGeometry();
-  Float_t CelZ = geom->GetPadSizeZ();
-  Float_t CelY = geom->GetPadSizePhi();
+  Float_t celZ = geom->GetPadSizeZ();
+  Float_t celY = geom->GetPadSizePhi();
 
-//  //    Info("AG", "CelZ: %f CelY: %f", CelZ, CelY) ;
+//  //    Info("AG", "celZ: %f celY: %f", celZ, celY) ;
 
-  Float_t dx = CelZ/2.;
-  Float_t dy = CelY/2.;
+  Float_t dx = celZ/2.;
+  Float_t dy = celY/2.;
 
-//  //    Float_t x = Xi*CelZ;
-//  //    Float_t y = Yi*CelZ;
+//  //    Float_t x = xi*celZ;
+//  //    Float_t y = yi*celZ;
 
-  Float_t x = Xi*CelZ;
-  Float_t y = Yi*CelY;
+  Float_t x = xi*celZ;
+  Float_t y = yi*celY;
 
-  Float_t E = Ei;
+  Float_t e = ei;
 
-  Float_t A = Fcml(x+dx,y+dy) - Fcml(x+dx,y-dy) - Fcml(x-dx,y+dy) + Fcml(x-dx,y-dy);
-  Ai = A*E;
+  Float_t a = Fcml(x+dx,y+dy) - Fcml(x+dx,y-dy) - Fcml(x-dx,y+dy) + Fcml(x-dx,y-dy);
+  ai = a*e;
 
 
-  Float_t Gx = GradX(x+dx,y+dy) - GradX(x+dx,y-dy) - GradX(x-dx,y+dy) + GradX(x-dx,y-dy);
-  GXi = Gx*E*E;
+  Float_t gx = GradX(x+dx,y+dy) - GradX(x+dx,y-dy) - GradX(x-dx,y+dy) + GradX(x-dx,y-dy);
+  gxi = gx*e*e;
 
-  Float_t Gy = GradY(x+dx,y+dy) - GradY(x+dx,y-dy) - GradY(x-dx,y+dy) + GradY(x-dx,y-dy);
-  GYi = Gy*E*E;
+  Float_t gy = GradY(x+dx,y+dy) - GradY(x+dx,y-dy) - GradY(x-dx,y+dy) + GradY(x-dx,y-dy);
+  gyi = gy*e*e;
 
 }
 
@@ -149,56 +152,58 @@ Float_t AliPHOSRecCpvManager::Fcml(Float_t x, Float_t y)
 {
   //Cumulative function
 
-  const Float_t A = 1.0;
-  const Float_t b = 0.70;
+  const Float_t ka = 1.0;
+  const Float_t kb = 0.70;
 
-  Float_t Fff  = TMath::ATan(x*y/(  b*TMath::Sqrt(  (b*b) + x*x+y*y)))
-    - TMath::ATan(x*y/(3*b*TMath::Sqrt((3*b)*(3*b) + x*x+y*y)))
-    + TMath::ATan(x*y/(5*b*TMath::Sqrt((5*b)*(5*b) + x*x+y*y))) 
-    - TMath::ATan(x*y/(7*b*TMath::Sqrt((7*b)*(7*b) + x*x+y*y)))
-    + TMath::ATan(x*y/(9*b*TMath::Sqrt((9*b)*(9*b) + x*x+y*y))); 
+  Float_t fff  = TMath::ATan(x*y/(  kb*TMath::Sqrt(  (kb*kb) + x*x+y*y)))
+    - TMath::ATan(x*y/(3*kb*TMath::Sqrt((3*kb)*(3*kb) + x*x+y*y)))
+    + TMath::ATan(x*y/(5*kb*TMath::Sqrt((5*kb)*(5*kb) + x*x+y*y))) 
+    - TMath::ATan(x*y/(7*kb*TMath::Sqrt((7*kb)*(7*kb) + x*x+y*y)))
+    + TMath::ATan(x*y/(9*kb*TMath::Sqrt((9*kb)*(9*kb) + x*x+y*y))); 
   
-  Float_t Fcml = A*Fff/6.2831853071796;
-//    Info("Fcml", "Fcml: %f", Fcml) ;
-  return Fcml;
+  Float_t fcml = ka*fff/6.2831853071796;
+//    Info("Fcml", "fcml: %f", fcml) ;
+  return fcml;
 
 }
 
 
 Float_t AliPHOSRecCpvManager::GradX(Float_t x, Float_t y)
 {
+  // Put a comment here
 
-  const Float_t A = 1.0;
-  const Float_t b = 0.70;
+  const Float_t ka = 1.0;
+  const Float_t kb = 0.70;
 
-  Float_t skv      = b*b + x*x + y*y;
+  Float_t skv      = kb*kb + x*x + y*y;
 
-  Float_t Gradient = y*(1.-x*x/skv)*  b*TMath::Sqrt(skv)/( b*b*skv+x*x*y*y)
-    - y*(1.-x*x/skv)*3*b*TMath::Sqrt(skv)/((3*b)*(3*b)*skv+x*x*y*y)
-    + y*(1.-x*x/skv)*5*b*TMath::Sqrt(skv)/((5*b)*(5*b)*skv+x*x*y*y)
-    - y*(1.-x*x/skv)*7*b*TMath::Sqrt(skv)/((7*b)*(7*b)*skv+x*x*y*y)
-    + y*(1.-x*x/skv)*9*b*TMath::Sqrt(skv)/((9*b)*(9*b)*skv+x*x*y*y);
+  Float_t gradient = y*(1.-x*x/skv)*  kb*TMath::Sqrt(skv)/( kb*kb*skv+x*x*y*y)
+    - y*(1.-x*x/skv)*3*kb*TMath::Sqrt(skv)/((3*kb)*(3*kb)*skv+x*x*y*y)
+    + y*(1.-x*x/skv)*5*kb*TMath::Sqrt(skv)/((5*kb)*(5*kb)*skv+x*x*y*y)
+    - y*(1.-x*x/skv)*7*kb*TMath::Sqrt(skv)/((7*kb)*(7*kb)*skv+x*x*y*y)
+    + y*(1.-x*x/skv)*9*kb*TMath::Sqrt(skv)/((9*kb)*(9*kb)*skv+x*x*y*y);
       
-  Float_t Grad    = A*Gradient/6.2831853071796;
-  return Grad;
+  Float_t grad    = ka*gradient/6.2831853071796;
+  return grad;
 }
 
 
 Float_t AliPHOSRecCpvManager::GradY(Float_t x, Float_t y)
 {
+  // Put a comment here
   
-  const Float_t A = 1.0;
-  const Float_t b = 0.70;
+  const Float_t a = 1.0;
+  const Float_t kb = 0.70;
  
-  Float_t skv      = b*b + x*x + y*y;
-  Float_t Gradient = x*(1.-y*y/skv)*  b*TMath::Sqrt(skv)/( b*b*skv+x*x*y*y)
-    - x*(1.-y*y/skv)*3*b*TMath::Sqrt(skv)/((3*b)*(3*b)*skv+x*x*y*y)
-    + x*(1.-y*y/skv)*5*b*TMath::Sqrt(skv)/((5*b)*(5*b)*skv+x*x*y*y)
-    - x*(1.-y*y/skv)*7*b*TMath::Sqrt(skv)/((7*b)*(7*b)*skv+x*x*y*y)
-    + x*(1.-y*y/skv)*9*b*TMath::Sqrt(skv)/((9*b)*(9*b)*skv+x*x*y*y);
+  Float_t skv      = kb*kb + x*x + y*y;
+  Float_t gradient = x*(1.-y*y/skv)*  kb*TMath::Sqrt(skv)/( kb*kb*skv+x*x*y*y)
+    - x*(1.-y*y/skv)*3*kb*TMath::Sqrt(skv)/((3*kb)*(3*kb)*skv+x*x*y*y)
+    + x*(1.-y*y/skv)*5*kb*TMath::Sqrt(skv)/((5*kb)*(5*kb)*skv+x*x*y*y)
+    - x*(1.-y*y/skv)*7*kb*TMath::Sqrt(skv)/((7*kb)*(7*kb)*skv+x*x*y*y)
+    + x*(1.-y*y/skv)*9*kb*TMath::Sqrt(skv)/((9*kb)*(9*kb)*skv+x*x*y*y);
   
-  Float_t Grad    = A*Gradient/6.2831853071796;
-  return Grad;
+  Float_t grad    = a*gradient/6.2831853071796;
+  return grad;
 }
 
 
index 6d659ad..72ae47e 100644 (file)
@@ -9,7 +9,7 @@
 // 6 March 2001
 
 #include "AliPHOSRecManager.h"
-#include "AliPHOSGeometry.h"
+//class AliPHOSGeometry ; 
 
 class AliPHOSRecCpvManager : public AliPHOSRecManager {
 
@@ -19,55 +19,51 @@ class AliPHOSRecCpvManager : public AliPHOSRecManager {
   ~AliPHOSRecCpvManager(void);
 
 
-  void AG(Float_t E, Float_t dx, Float_t dy, Float_t& A, Float_t& grad_x, Float_t& grad_y );
-  Float_t Dispersion(Float_t Etot, Float_t Ai, Float_t Ei);
+  void AG(Float_t e, Float_t dx, Float_t dy, Float_t& a, Float_t& gradx, Float_t& grady );
+  Float_t Dispersion(Float_t etot, Float_t ai, Float_t ei) const;
 
-  Float_t OneGamChi2(Float_t Ai, Float_t Ei, Float_t Etot, Float_t& Gi);
-  Float_t TwoGamChi2(Float_t Ai, Float_t Ei, Float_t Etot, Float_t& Gi);
+  Float_t OneGamChi2(Float_t ai, Float_t ei, Float_t etot, Float_t& gi) ;
+  Float_t TwoGamChi2(Float_t ai, Float_t ei, Float_t etot, Float_t& gi) const ;
 
-  Float_t OneGamChisqCut() { return fOneGamChisqCut; }
-  Float_t OneGamInitialStep() { return fOneGamInitialStep; }
-  Float_t OneGamChisqMin() { return fOneGamChisqMin; }
-  Float_t OneGamStepMin() { return fOneGamStepMin; }
-  Int_t OneGamNumOfIterations() { return fOneGamNumOfIterations; }
+  Float_t OneGamChisqCut() const { return fOneGamChisqCut; } 
+  Float_t OneGamInitialStep() const { return fOneGamInitialStep; }
+  Float_t OneGamChisqMin() const { return fOneGamChisqMin; }
+  Float_t OneGamStepMin() const { return fOneGamStepMin; }
+  Int_t OneGamNumOfIterations() const { return fOneGamNumOfIterations; }
 
-  Float_t TwoGamInitialStep() { return fTwoGamInitialStep; }
-  Float_t TwoGamChisqMin() { return fTwoGamChisqMin; }
-  Float_t TwoGamEmin() { return fTwoGamEmin; }
-  Float_t TwoGamStepMin() { return fTwoGamStepMin; } 
-  Int_t TwoGamNumOfIterations() { return fTwoGamNumOfIterations; }
+  Float_t TwoGamInitialStep() const { return fTwoGamInitialStep; }
+  Float_t TwoGamChisqMin() const { return fTwoGamChisqMin; }
+  Float_t TwoGamEmin() const { return fTwoGamEmin; }
+  Float_t TwoGamStepMin() const { return fTwoGamStepMin; } 
+  Int_t TwoGamNumOfIterations() const { return fTwoGamNumOfIterations; }
 
-  Float_t KillGamMinEnergy() { return fThr0; } 
-  Float_t MergeGammasMinDistanceCut() { return fSqdCut; } 
+  Float_t KillGamMinEnergy() const { return fThr0; } 
+  Float_t MergeGammasMinDistanceCut() const { return fSqdCut; } 
 
   void SetTwoPointsMinDistance(Float_t dist) { fSqdCut=dist; }
   void SetPointMinEnergy(Float_t emin) { fThr0=emin; }
 
  private:
 
-  Float_t Fcml(Float_t x, Float_t y);
-  Float_t GradX(Float_t x, Float_t y);
-  Float_t GradY(Float_t x, Float_t y);
+  Float_t Fcml(Float_t x, Float_t y); // what is it ?
+  Float_t GradX(Float_t x, Float_t y); // what is it ?
+  Float_t GradY(Float_t x, Float_t y); // what is it ?
 
- private:
-
-  Float_t fOneGamChisqCut;
-
-  Float_t fOneGamInitialStep;
-  Float_t fOneGamChisqMin;
-  Float_t fOneGamStepMin;
-  Int_t fOneGamNumOfIterations;
+  Float_t fOneGamChisqCut; // what is it ?
 
-  Float_t fTwoGamInitialStep;
-  Float_t fTwoGamChisqMin;
-  Float_t fTwoGamEmin;
-  Float_t fTwoGamStepMin;
-  Int_t fTwoGamNumOfIterations;
+  Float_t fOneGamInitialStep; // what is it ?
+  Float_t fOneGamChisqMin; // what is it ?
+  Float_t fOneGamStepMin; // what is it ?
+  Int_t fOneGamNumOfIterations; // what is it ?
 
-  Float_t fThr0;
-  Float_t fSqdCut;
+  Float_t fTwoGamInitialStep; // what is it ?
+  Float_t fTwoGamChisqMin; // what is it ?
+  Float_t fTwoGamEmin; // what is it ?
+  Float_t fTwoGamStepMin; // what is it ?
+  Int_t fTwoGamNumOfIterations; // what is it ?
 
- public:
+  Float_t fThr0; // what is it ?
+  Float_t fSqdCut; // what is it ?
 
   ClassDef(AliPHOSRecCpvManager,1)        // CPV reconstruction management class 
 
index eba4bbe..4e084ba 100644 (file)
@@ -62,7 +62,7 @@ ClassImp(AliPHOSRecEmcManager)
 
 AliPHOSRecEmcManager::~AliPHOSRecEmcManager(void) {}
 
-Float_t AliPHOSRecEmcManager::Dispersion(Float_t Etot, Float_t Ai, Float_t Ei)
+Float_t AliPHOSRecEmcManager::Dispersion(Float_t Etot, Float_t Ai, Float_t Ei) const
 {
   //"Dispresion" of energy deposition in the cell.
   // Etot is the total shower energy, Ai is the
@@ -85,7 +85,7 @@ Float_t AliPHOSRecEmcManager::OneGamChi2(Float_t Ai, Float_t Ei, Float_t Etot, F
 
 }
 
-Float_t AliPHOSRecEmcManager::TwoGamChi2(Float_t Ai, Float_t Ei, Float_t Etot, Float_t& Gi)
+Float_t AliPHOSRecEmcManager::TwoGamChi2(Float_t Ai, Float_t Ei, Float_t Etot, Float_t& Gi) const
 {
 
   Float_t da = Ai - Ei;
index 96bd97e..dea2db0 100644 (file)
@@ -20,25 +20,25 @@ class AliPHOSRecEmcManager : public AliPHOSRecManager {
 
 
   void AG(Float_t E, Float_t dx, Float_t dy, Float_t& A, Float_t& grad_x, Float_t& grad_y );
-  Float_t Dispersion(Float_t Etot, Float_t Ai, Float_t Ei);
+  Float_t Dispersion(Float_t Etot, Float_t Ai, Float_t Ei) const;
 
   Float_t OneGamChi2(Float_t Ai, Float_t Ei, Float_t Etot, Float_t& Gi);
-  Float_t TwoGamChi2(Float_t Ai, Float_t Ei, Float_t Etot, Float_t& Gi);
-
-  Float_t OneGamChisqCut() { return fOneGamChisqCut; }
-  Float_t OneGamInitialStep() { return fOneGamInitialStep; }
-  Float_t OneGamChisqMin() { return fOneGamChisqMin; }
-  Float_t OneGamStepMin() { return fOneGamStepMin; }
-  Int_t OneGamNumOfIterations() { return fOneGamNumOfIterations; }
-
-  Float_t TwoGamInitialStep() { return fTwoGamInitialStep; }
-  Float_t TwoGamChisqMin() { return fTwoGamChisqMin; }
-  Float_t TwoGamEmin() { return fTwoGamEmin; }
-  Float_t TwoGamStepMin() { return fTwoGamStepMin; } 
-  Int_t TwoGamNumOfIterations() { return fTwoGamNumOfIterations; }
-
-  Float_t KillGamMinEnergy() { return fThr0; } 
-  Float_t MergeGammasMinDistanceCut() { return fSqdCut; } 
+  Float_t TwoGamChi2(Float_t Ai, Float_t Ei, Float_t Etot, Float_t& Gi)const;
+
+  Float_t OneGamChisqCut() const{ return fOneGamChisqCut; }
+  Float_t OneGamInitialStep() const{ return fOneGamInitialStep; }
+  Float_t OneGamChisqMin() const{ return fOneGamChisqMin; }
+  Float_t OneGamStepMin() const{ return fOneGamStepMin; }
+  Int_t OneGamNumOfIterations() const{ return fOneGamNumOfIterations; }
+
+  Float_t TwoGamInitialStep() const{ return fTwoGamInitialStep; }
+  Float_t TwoGamChisqMin() const{ return fTwoGamChisqMin; }
+  Float_t TwoGamEmin() const{ return fTwoGamEmin; }
+  Float_t TwoGamStepMin() const{ return fTwoGamStepMin; } 
+  Int_t TwoGamNumOfIterations() const{ return fTwoGamNumOfIterations; }
+
+  Float_t KillGamMinEnergy() const{ return fThr0; } 
+  Float_t MergeGammasMinDistanceCut() const{ return fSqdCut; } 
 
   void SetTwoPointsMinDistance(Float_t dist) { fSqdCut=dist; }
   void SetPointMinEnergy(Float_t emin) { fThr0=emin; }
index 6e76fd6..9a9029b 100644 (file)
@@ -21,25 +21,25 @@ class AliPHOSRecManager : public TNamed {
   virtual ~AliPHOSRecManager(void) {}
 
   virtual void AG(Float_t E, Float_t dx, Float_t dy, Float_t& A, Float_t& grad_x, Float_t& grad_y ) = 0;
-  virtual Float_t Dispersion(Float_t Etot, Float_t Ai, Float_t Ei) = 0;
+  virtual Float_t Dispersion(Float_t Etot, Float_t Ai, Float_t Ei) const = 0;
 
   virtual Float_t OneGamChi2(Float_t Ai, Float_t Ei, Float_t Etot, Float_t& Gi) = 0;
-  virtual Float_t TwoGamChi2(Float_t Ai, Float_t Ei, Float_t Etot, Float_t& Gi) = 0;
-
-  virtual Float_t OneGamChisqCut() = 0 ;
-  virtual Float_t OneGamInitialStep() = 0;
-  virtual Float_t OneGamChisqMin() = 0;
-  virtual Float_t OneGamStepMin() = 0;
-  virtual Int_t OneGamNumOfIterations() = 0;
-
-  virtual Float_t TwoGamInitialStep() = 0;
-  virtual Float_t TwoGamChisqMin() = 0;
-  virtual Float_t TwoGamEmin() = 0;
-  virtual Float_t TwoGamStepMin() = 0;
-  virtual Int_t TwoGamNumOfIterations() = 0;
-
-  virtual Float_t KillGamMinEnergy() = 0;
-  virtual Float_t MergeGammasMinDistanceCut() = 0;
+  virtual Float_t TwoGamChi2(Float_t Ai, Float_t Ei, Float_t Etot, Float_t& Gi) const = 0;
+
+  virtual Float_t OneGamChisqCut()const = 0 ;
+  virtual Float_t OneGamInitialStep() const = 0;
+  virtual Float_t OneGamChisqMin() const = 0;
+  virtual Float_t OneGamStepMin() const = 0;
+  virtual Int_t OneGamNumOfIterations() const = 0;
+
+  virtual Float_t TwoGamInitialStep() const = 0;
+  virtual Float_t TwoGamChisqMin() const = 0;
+  virtual Float_t TwoGamEmin() const = 0;
+  virtual Float_t TwoGamStepMin() const = 0;
+  virtual Int_t TwoGamNumOfIterations() const = 0;
+
+  virtual Float_t KillGamMinEnergy() const = 0;
+  virtual Float_t MergeGammasMinDistanceCut() const = 0;
 
   virtual void SetTwoPointsMinDistance(Float_t dist) = 0;
   virtual void SetPointMinEnergy(Float_t emin) = 0;