Several nonlinearity corrections implemented
authorprsnko <prsnko@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 5 Oct 2010 09:46:25 +0000 (09:46 +0000)
committerprsnko <prsnko@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 5 Oct 2010 09:46:25 +0000 (09:46 +0000)
13 files changed:
PHOS/AliPHOSAodCluster.cxx
PHOS/AliPHOSAodCluster.h
PHOS/AliPHOSEsdCluster.cxx
PHOS/AliPHOSEsdCluster.h
PHOS/AliPHOSPID.cxx
PHOS/AliPHOSPID.h
PHOS/AliPHOSPIDv1.cxx
PHOS/AliPHOSPIDv1.h
PHOS/AliPHOSRecoParam.cxx
PHOS/AliPHOSRecoParam.h
PHOS/AliPHOSReconstructor.cxx
PHOS/AliPHOSReconstructor.h
PHOS/macros/pi0Calib/AliAnalysisTaskPi0CalibSelection.cxx

index 1625b7b..241a0b6 100755 (executable)
@@ -30,6 +30,7 @@
 #include "AliLog.h" 
 #include "AliPHOSGeometry.h" 
 #include "AliPHOSPIDv1.h" 
+#include "AliPHOSReconstructor.h" 
 #include "AliPHOSAodCluster.h" 
 #include "AliPHOSCalibData.h"
 #include "AliAODCaloCells.h"
@@ -109,9 +110,9 @@ void AliPHOSAodCluster::EvalEnergy(){
    
 }
 //____________________________________________________________________________
-void AliPHOSAodCluster::EnergyCorrection(AliPHOSPIDv1 * pid){
+void AliPHOSAodCluster::EnergyCorrection(){
   //apply nonlinearity correction same as in AliPHOSPIDv1.
-  SetE(pid->GetCalibratedEnergy(E())) ;
+  SetE(AliPHOSReconstructor::CorrectNonlinearity(E())) ;
 }
 //____________________________________________________________________________
 void AliPHOSAodCluster::EvalPID(AliPHOSPIDv1 * /*pid*/){           
index dfe3cb6..29f46f6 100755 (executable)
@@ -31,7 +31,7 @@ public:
 
   void  EvalAll(Float_t logWeight, TVector3 &vtx) ; //re-calculate all cluster parameters
   void  Recalibrate(AliPHOSCalibData * calibData,AliAODCaloCells *phsCells) ; //Apply recalibration to this cluster
-  void  EnergyCorrection(AliPHOSPIDv1 * pid) ;  //Apply non-linearity correction
+  void  EnergyCorrection() ;  //Apply non-linearity correction
   void  EvalPID(AliPHOSPIDv1 * pid) ;           //re-evaluate identification parameters
 
 protected:
index c443afd..02af1d6 100644 (file)
@@ -30,6 +30,7 @@
 #include "AliLog.h" 
 #include "AliPHOSGeometry.h" 
 #include "AliPHOSPIDv1.h" 
+#include "AliPHOSReconstructor.h"
 #include "AliPHOSEsdCluster.h" 
 #include "AliPHOSCalibData.h"
 #include "AliESDCaloCells.h"
@@ -76,8 +77,12 @@ void AliPHOSEsdCluster::Recalibrate(AliPHOSCalibData * calibData,AliESDCaloCells
     Int_t   column = relId[3];
     Int_t   row    = relId[2];
     Double_t energy = phsCells->GetCellAmplitude(fCellsAbsId[i]) ;
+Double_t fr = fCellsAmpFraction[i] ;
     fCellsAmpFraction[i]*=energy*calibData->GetADCchannelEmc(module,column,row);
+    printf("      mod=%d, col=%d, row=%d \n",module,column,row);
+    printf("  cell=%d, Amp=%f, E(i)=%f, Fr=%f, ci=%f \n",i,energy,fCellsAmpFraction[i],fr,calibData->GetADCchannelEmc(module,column,row)) ;
   }
+printf("----\n") ;
   fRecalibrated=kTRUE; 
 }
 //____________________________________________________________________________
@@ -100,12 +105,19 @@ void AliPHOSEsdCluster::EvalEnergy(){
     fEnergy+=fCellsAmpFraction[iDigit] ;
   }
   //Correct for nonlinearity later
+  if(fEnergy==0.){
+    printf("fEnergy=0 \n") ;
+    printf("n Digits = %d \n",fNCells) ;
+    for(Int_t iDigit=0; iDigit<fNCells; iDigit++) {
+      printf("E(%d)=%f \n",iDigit,fCellsAmpFraction[iDigit]);
+    }
+  }
    
 }
 //____________________________________________________________________________
-void AliPHOSEsdCluster::EnergyCorrection(AliPHOSPIDv1 * pid){
-  //apply nonlinearity correction same as in AliPHOSPIDv1.
-  fEnergy = pid->GetCalibratedEnergy(fEnergy) ;
+void AliPHOSEsdCluster::EnergyCorrection(){
+  //apply nonlinearity correction 
+  fEnergy = AliPHOSReconstructor::CorrectNonlinearity(fEnergy) ;
 }
 //____________________________________________________________________________
 void AliPHOSEsdCluster::EvalPID(AliPHOSPIDv1 * /*pid*/){           
index 604a02c..68f5bd7 100644 (file)
@@ -31,7 +31,7 @@ public:
 
   void  EvalAll(Float_t logWeight, TVector3 &vtx) ; //re-calculate all cluster parameters
   void  Recalibrate(AliPHOSCalibData * calibData,AliESDCaloCells *phsCells) ; //Apply recalibration to this cluster
-  void  EnergyCorrection(AliPHOSPIDv1 * pid) ;  //Apply non-linearity correction
+  void  EnergyCorrection() ;  //Apply non-linearity correction
   void  EvalPID(AliPHOSPIDv1 * pid) ;           //re-evaluate identification parameters
 
 protected:
index 8f40371..c6eaaaf 100644 (file)
@@ -48,8 +48,7 @@ AliPHOSPID::AliPHOSPID():
   fEMCRecPoints(NULL),
   fCPVRecPoints(NULL),
   fTrackSegments(NULL),
-  fRecParticles(NULL),
-  fEnergyCorrectionOn(kTRUE)
+  fRecParticles(NULL)
 {
   // ctor
 }
@@ -63,8 +62,7 @@ AliPHOSPID::AliPHOSPID(AliPHOSGeometry *geom):
   fEMCRecPoints(NULL),
   fCPVRecPoints(NULL),
   fTrackSegments(NULL),
-  fRecParticles(NULL),
-  fEnergyCorrectionOn(kTRUE)
+  fRecParticles(NULL)
 {
   // ctor
   fEMCRecPoints = new TObjArray(100) ;
@@ -82,8 +80,7 @@ AliPHOSPID::AliPHOSPID(const AliPHOSPID & pid) :
   fEMCRecPoints(pid.fEMCRecPoints),
   fCPVRecPoints(pid.fCPVRecPoints),
   fTrackSegments(pid.fTrackSegments),
-  fRecParticles(pid.fRecParticles),
-  fEnergyCorrectionOn(pid.fEnergyCorrectionOn)
+  fRecParticles(pid.fRecParticles)
 {
   // Copy constructor
 }
index aceca48..7588907 100644 (file)
@@ -69,9 +69,6 @@ class AliPHOSPID : public TObject {
 
   void SetESD(AliESDEvent *esd) { fESD = esd; }
 
-  void SetEnergyCorrectionOn(Bool_t on=kTRUE) {fEnergyCorrectionOn = on;}
-  Bool_t GetEnergyCorrectionOn() const  {return fEnergyCorrectionOn;}
-
   virtual const char * Version() const = 0;
 
 protected:
@@ -85,11 +82,9 @@ protected:
   TClonesArray *fTrackSegments;     //!Array with found track segments
   TClonesArray *fRecParticles;      //!Array with reconstructed particles (PID)
   
-  Bool_t   fEnergyCorrectionOn;     // Do energy correction in GetCalibratedEnergy()
-  
 private: 
 
-  ClassDef(AliPHOSPID,7)  // Particle Identifier algorithm (base class)
+  ClassDef(AliPHOSPID,8)  // Particle Identifier algorithm (base class)
 
 } ;
 
index d89245a..86b1598 100644 (file)
@@ -591,24 +591,6 @@ Float_t  AliPHOSPIDv1::GetParameterCalibration(Int_t i) const
 }
 
 //____________________________________________________________________________
-Float_t  AliPHOSPIDv1::GetCalibratedEnergy(Float_t e) const
-{
-//      It calibrates Energy depending on the recpoint energy.
-//      The energy of the reconstructed cluster is corrected with 
-//      the formula A + B* E  + C* E^2, whose parameters where obtained 
-//      through the study of the reconstructed energy distribution of 
-//      monoenergetic photons.
-  
-  if(!fEnergyCorrectionOn) return e;
-  
-  Float_t p[]={0.,0.,0.};
-  for (Int_t i=0; i<3; i++) p[i] = GetParameterCalibration(i);
-  Float_t enerec = p[0] +  p[1]*e + p[2]*e*e;
-  return enerec ;
-
-}
-
-//____________________________________________________________________________
 Float_t  AliPHOSPIDv1::GetParameterCpv2Emc(Int_t i, TString axis) const 
 {
   // Get the i-th parameter "CPV-EMC distance" for the specified axis
@@ -739,36 +721,6 @@ Float_t  AliPHOSPIDv1::GetParameterToCalculateEllipse(TString particle, TString
   
   return par;
 }
-
-
-//DP____________________________________________________________________________
-//Float_t  AliPHOSPIDv1::GetDistance(AliPHOSEmcRecPoint * emc,AliPHOSCpvRecPoint * cpv, Option_t *  axis)const
-//{
-//  // Calculates the distance between the EMC RecPoint and the PPSD RecPoint
-//  
-//  AliPHOSGeometry * geom =  AliPHOSGeometry::GetInstance();
-//  TVector3 vecEmc ;
-//  TVector3 vecCpv ;
-//  if(cpv){
-//    emc->GetLocalPosition(vecEmc) ;
-//    cpv->GetLocalPosition(vecCpv) ; 
-//    
-//    if(emc->GetPHOSMod() == cpv->GetPHOSMod()){      
-//      // Correct to difference in CPV and EMC position due to different distance to center.
-//      // we assume, that particle moves from center
-//      Float_t dCPV = geom->GetIPtoOuterCoverDistance();
-//      Float_t dEMC = geom->GetIPtoCrystalSurface() ;
-//      dEMC         = dEMC / dCPV ;
-//      vecCpv = dEMC * vecCpv  - vecEmc ; 
-//      if (axis == "X") return vecCpv.X();
-//      if (axis == "Y") return vecCpv.Y();
-//      if (axis == "Z") return vecCpv.Z();
-//      if (axis == "R") return vecCpv.Mag();
-//    }
-//    return 100000000 ;
-//  }
-//  return 100000000 ;
-//}
 //____________________________________________________________________________
 Int_t  AliPHOSPIDv1::GetCPVBit(AliPHOSTrackSegment * ts, Int_t effPur, Float_t e) const
 {
@@ -1368,7 +1320,7 @@ void  AliPHOSPIDv1::MakeRecParticles()
 
     Float_t e = emc->GetEnergy() ;   
     
-    Float_t  lambda[2] ;
+    Float_t  lambda[2]={0.,0.} ;
     emc->GetElipsAxis(lambda) ;
  
     if((lambda[0]>0.01) && (lambda[1]>0.01)){
@@ -1442,10 +1394,9 @@ void  AliPHOSPIDv1::MakeRecParticles()
       rp->SetPIDBit(14) ; 
 
     //Set momentum, energy and other parameters 
-    Float_t  encal = GetCalibratedEnergy(e);
     TVector3 dir   = GetMomentumDirection(emc,cpv) ; 
-    dir.SetMag(encal) ;
-    rp->SetMomentum(dir.X(),dir.Y(),dir.Z(),encal) ;
+    dir.SetMag(e) ;
+    rp->SetMomentum(dir.X(),dir.Y(),dir.Z(),e) ;
     rp->SetCalcMass(0);
     rp->Name(); //If photon sets the particle pdg name to gamma
     rp->SetProductionVertex(fVtx.X(),fVtx.Y(),fVtx.Z(),0);
index 7c3ee83..b0e86ba 100644 (file)
@@ -79,7 +79,6 @@ public:
   Float_t GetParameterPi0Boundary    (Int_t i)               const;
 
   // Get energy-dependent PID parameters
-  Float_t GetCalibratedEnergy    (Float_t e)                 const;
   Float_t GetCpv2EmcDistanceCut  (TString axis, Float_t e)   const ;
   Float_t GetEllipseParameter    (TString particle, TString param, Float_t e) const;
 
index aff24fe..31c9639 100644 (file)
@@ -32,6 +32,7 @@ TObjArray* AliPHOSRecoParam::fgkMaps =0; //ALTRO mappings
 //-----------------------------------------------------------------------------
 AliPHOSRecoParam::AliPHOSRecoParam() :
   AliDetectorRecoParam(),
+  fNonLinearityParams(3),
   fEMCClusteringThreshold(0.2),
   fEMCLocMaxCut(0.03),
   fEMCRawDigitThreshold(2),
@@ -40,13 +41,14 @@ AliPHOSRecoParam::AliPHOSRecoParam() :
   fEMCSampleQualityCut(1.),
   fTimeGateAmpThresh(10.),
   fTimeGateLow(1.e-6),
-  fTimeGateHigh(1.e-6),    
+  fTimeGateHigh(1.e-6),
   fEMCEcoreRadius(3.),
   fEMCEcore2ESD(kFALSE),
   fEMCSubtractPedestals(kTRUE),
   fEMCUnfold(kTRUE),
   fEMCEnergyCorrectionOn(kTRUE),
   fEMCFitterVersion(""),
+  fNonlinearityCorrVersion(""),
   fGlobalAltroOffset(0),
   fGlobalAltroThreshold(0),
   fCPVClusteringThreshold(0.0),
@@ -56,11 +58,13 @@ AliPHOSRecoParam::AliPHOSRecoParam() :
   fCPVUnfold(kTRUE)
 {
   //Default constructor.
+  SetNonlinearityCorrectionVersion("Gustavo2005") ;
 }
 
 //-----------------------------------------------------------------------------
 AliPHOSRecoParam::AliPHOSRecoParam(const AliPHOSRecoParam& ):
   AliDetectorRecoParam(),
+  fNonLinearityParams(3),
   fEMCClusteringThreshold(0.2),
   fEMCLocMaxCut(0.03),
   fEMCRawDigitThreshold(2),
@@ -69,13 +73,14 @@ AliPHOSRecoParam::AliPHOSRecoParam(const AliPHOSRecoParam& ):
   fEMCSampleQualityCut(1.),
   fTimeGateAmpThresh(10.),
   fTimeGateLow(1.e-6),
-  fTimeGateHigh(1.e-6),    
+  fTimeGateHigh(1.e-6),
   fEMCEcoreRadius(3.),
   fEMCEcore2ESD(kFALSE),
   fEMCSubtractPedestals(kTRUE),
   fEMCUnfold(kTRUE),
   fEMCEnergyCorrectionOn(kTRUE),
   fEMCFitterVersion(""),
+  fNonlinearityCorrVersion(""),
   fGlobalAltroOffset(0),
   fGlobalAltroThreshold(0),
   fCPVClusteringThreshold(0.0),
@@ -93,6 +98,7 @@ AliPHOSRecoParam& AliPHOSRecoParam::operator = (const AliPHOSRecoParam& recoPara
   //Assignment operator.
 
   if(this != &recoParam) {
+    fNonLinearityParams     = recoParam.fNonLinearityParams;
     fEMCClusteringThreshold = recoParam.fEMCClusteringThreshold;
     fEMCLocMaxCut           = recoParam.fEMCLocMaxCut;
     fEMCRawDigitThreshold   = recoParam.fEMCRawDigitThreshold;
@@ -108,6 +114,7 @@ AliPHOSRecoParam& AliPHOSRecoParam::operator = (const AliPHOSRecoParam& recoPara
     fEMCUnfold              = recoParam.fEMCUnfold;
     fEMCEnergyCorrectionOn  = recoParam.fEMCEnergyCorrectionOn;
     fEMCFitterVersion       = recoParam.fEMCFitterVersion;
+    fNonlinearityCorrVersion= recoParam.fNonlinearityCorrVersion;
     fGlobalAltroOffset      = recoParam.fGlobalAltroOffset;
     fGlobalAltroThreshold   = recoParam.fGlobalAltroThreshold;
     fCPVClusteringThreshold = recoParam.fCPVClusteringThreshold;
@@ -115,6 +122,7 @@ AliPHOSRecoParam& AliPHOSRecoParam::operator = (const AliPHOSRecoParam& recoPara
     fCPVMinE                = recoParam.fCPVMinE;
     fCPVW0                  = recoParam.fCPVW0;
     fCPVUnfold              = recoParam.fCPVUnfold;
+    fNonLinearityParams     = recoParam.fNonLinearityParams ;
   }
 
   return *this;
@@ -185,3 +193,29 @@ const TObjArray* AliPHOSRecoParam::GetMappings()
   return fgkMaps;
   
 }
+//-----------------------------------------------------------------------------
+void AliPHOSRecoParam::SetNonlinearityCorrectionVersion(const char * ver){
+  //Set non-linearity correction version and adjust parameters
+
+  if(strcmp(ver,"NoCorrection")==0){
+    fNonLinearityParams.Set(1) ;
+    fNonLinearityParams.AddAt(0.,0) ;
+    fNonlinearityCorrVersion=ver ;
+    return ;
+  }
+  if(strcmp(ver,"Henrik2010")==0){
+    Float_t pars[7]={1.051,2.54e-003,-1.737e-002,5.69e-002,3.3e-001,1.42e-001,1.50e-002} ;
+    fNonLinearityParams.Set(7,pars) ;
+    fNonlinearityCorrVersion=ver ;
+    return ;
+  }
+  if(strcmp(ver,"Gustavo2005")==0){
+    Float_t pars[3]={0.0241, 1.0504, 0.000249} ;
+    fNonLinearityParams.Set(3,pars) ;
+    fNonlinearityCorrVersion=ver ;
+    return ;
+  }
+  AliError(Form("Non known correction version: %s, still using default \n",ver)) ;
+
+
+}
index 7cd9607..594da4c 100644 (file)
@@ -8,6 +8,7 @@
 // Base class for the PHOS reconstruction parameters.
 // Do not use in the reconstruction; use derivative classes instead.
 
+#include "TArrayF.h"
 #include "AliDetectorRecoParam.h"
 
 class AliPHOSRecoParam : public AliDetectorRecoParam {
@@ -26,6 +27,7 @@ public:
   Float_t GetEMCLogWeight()           const { return fEMCW0;                   }
   Float_t GetEMCSampleQualityCut()    const { return fEMCSampleQualityCut;     }
   Float_t GetEMCEcoreRadius()         const { return fEMCEcoreRadius;          }
+  const Float_t * GetNonlinearityParams()   const { return fNonLinearityParams.GetArray() ;}
   Bool_t  EMCEcore2ESD()              const { return fEMCEcore2ESD;            }
   Bool_t  EMCSubtractPedestals()      const { return fEMCSubtractPedestals;    }
   Bool_t  EMCToUnfold()               const { return fEMCUnfold;               }
@@ -36,7 +38,8 @@ public:
   Float_t GetTimeGateAmpThresh()      const { return fTimeGateAmpThresh ;      }
   Float_t GetTimeGateLow()            const { return fTimeGateLow ;            }
   Float_t GetTimeGateHigh()           const { return fTimeGateHigh ;           }
+
+  const char* GetNonlinearityCorrectionVersion()const{return fNonlinearityCorrVersion.Data();}
 
   Float_t GetCPVClusteringThreshold() const { return fCPVClusteringThreshold;  }
   Float_t GetCPVLocalMaxCut()         const { return fCPVLocMaxCut;            }
@@ -56,12 +59,14 @@ public:
   void SetEMCFitterVersion(const char* version="v1") { fEMCFitterVersion     =version ; }
   void SetEMCUnfolding(Bool_t toUnfold=kFALSE)       { fEMCUnfold             =toUnfold;}
   void SetEMCEnergyCorrectionOn(Bool_t on=kTRUE)     { fEMCEnergyCorrectionOn =on;      }
+  //Make sure to set first version and then parameters, otherwise parameters will be overwritten by default ones.
+  void SetNonlinearityParams(Int_t n, Float_t * params){fNonLinearityParams.Set(n,params);}
   void SetGlobalAltroOffset(Int_t offset=5)          { fGlobalAltroOffset     =offset ; }
   void SetGlobalAltroThreshold(Int_t ZSth=5)         { fGlobalAltroThreshold  =ZSth;    }
   void SetTimeGateAmpThresh(Float_t thrs=10)         { fTimeGateAmpThresh     = thrs ;  }
   void SetTimeGateLow(Float_t gate=1.e-7)            { fTimeGateLow = gate ;            }
   void SetTimeGateHigh(Float_t gate=1.e-8)           { fTimeGateHigh = gate;            }
+  void SetNonlinearityCorrectionVersion(const char * ver="Gustavo2005");
 
   void SetCPVClusteringThreshold(Float_t cluth)      { fCPVClusteringThreshold=cluth;   }
   void SetCPVLocalMaxCut(Float_t cut)                { fCPVLocMaxCut          =cut;     }
@@ -76,6 +81,7 @@ public:
 
 protected:
 
+  TArrayF fNonLinearityParams;     // EMC: Array of non-linearity correction parameters
   Float_t fEMCClusteringThreshold; // EMC: Min.digit energy to start a new cluster, in GeV
   Float_t fEMCLocMaxCut;           // EMC: Min.energy difference between two local maxima, in GeV
   Float_t fEMCRawDigitThreshold;   // EMC: Min.amplitude of a digit produced from raw data in ADC
@@ -91,6 +97,7 @@ protected:
   Bool_t  fEMCUnfold;              // EMC: true if overlapped clusters should be unfolded
   Bool_t  fEMCEnergyCorrectionOn;  // EMC: if true do non-linear correction of cluster energy
   TString fEMCFitterVersion ;      // EMC: AliPHOSRawFitter version
+  TString fNonlinearityCorrVersion ;// EMC: choose which version of nenlinearity correction
   Int_t   fGlobalAltroOffset ;     // Offset used in ALTRO chips in SZ runs
   Int_t   fGlobalAltroThreshold ;  // Threshold used in ALTRO chips in SZ runs
 
index ca7eae6..96495a1 100644 (file)
@@ -130,8 +130,6 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree,
   else 
     fTSM->Clusters2TrackSegments("") ;
   
-  fPID->SetEnergyCorrectionOn(GetRecoParam()->GetEMCEnergyCorrectionOn());
-  
   fPID->SetInput(clustersTree, fTSM->GetTrackSegments()) ; 
   fPID->SetESD(esd) ; 
   if ( Debug() ) 
@@ -288,11 +286,14 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree,
     Int_t  primMult  = 0;
     Int_t *primList =  emcRP->GetPrimaries(primMult);
 
-    Float_t energy;
+    Float_t energy=0.;
     if (GetRecoParam()->EMCEcore2ESD())
       energy = emcRP->GetCoreEnergy();
     else
       energy = rp->Energy();
+    //Apply nonlinearity correction
+    if(GetRecoParam()->GetEMCEnergyCorrectionOn())
+      energy=CorrectNonlinearity(energy) ;
 
     // fills the ESDCaloCluster
     ec->SetType(AliVCluster::kPHOSNeutral);
@@ -503,5 +504,24 @@ void AliPHOSReconstructor::FillMisalMatrixes(AliESDEvent* esd)const{
   }
 
 }
+//==================================================================================
+Float_t AliPHOSReconstructor::CorrectNonlinearity(Float_t en){
 
+  if(strcmp(GetRecoParam()->GetNonlinearityCorrectionVersion(),"NoCorrection")==0){
+    return en ;
+  }
+  if(strcmp(GetRecoParam()->GetNonlinearityCorrectionVersion(),"Gustavo2005")==0){
+    const Float_t *par=GetRecoParam()->GetNonlinearityParams() ;
+    return par[0]+par[1]*en + par[2]*en*en ;
+  }
+  if(strcmp(GetRecoParam()->GetNonlinearityCorrectionVersion(),"Henrik2010")==0){
+     const Float_t *par=GetRecoParam()->GetNonlinearityParams() ;
+     return en*(par[0]+par[1]*TMath::Exp(-en*par[2]))*(1.+par[3]*TMath::Exp(-en*par[4]))*(1.+par[6]/(en*en+par[5])) ;
+  }
+  //For backward compatibility
+  if(strcmp(GetRecoParam()->GetNonlinearityCorrectionVersion(),"")==0){
+    return 0.0241+1.0504*en+0.000249*en*en ;
+  }
+  return en ;
+}
 
index 4d3f3e5..62e6c6d 100644 (file)
@@ -90,6 +90,7 @@ public:
   
   static const AliPHOSRecoParam* GetRecoParam() {
     return dynamic_cast<const AliPHOSRecoParam*>(AliReconstructor::GetRecoParam(4)); }
+  static Float_t CorrectNonlinearity(Float_t oldEnergy) ;
 
 private:
   AliPHOSReconstructor(const AliPHOSReconstructor & rec); // Not implemented
index f932d5f..685d064 100644 (file)
@@ -154,7 +154,7 @@ void AliAnalysisTaskPi0CalibSelection::UserExec(Option_t* /* option */)
     AliPHOSEsdCluster clu1(*c1);
     clu1.Recalibrate(fCalibData, phsCells);
     clu1.EvalAll(logWeight,vtx);
-    clu1.EnergyCorrection(&pid) ;
+    clu1.EnergyCorrection() ;
 
     clu1.GetMomentum(p1,v);
 
@@ -177,7 +177,7 @@ void AliAnalysisTaskPi0CalibSelection::UserExec(Option_t* /* option */)
       AliPHOSEsdCluster clu2(*c2);
       clu2.Recalibrate(fCalibData, phsCells);
       clu2.EvalAll(logWeight,vtx);
-      clu2.EnergyCorrection(&pid) ;
+      clu2.EnergyCorrection() ;
         
       clu2.GetMomentum(p2,v);
       Float_t E2_ii = clu2.E();