]> git.uio.no Git - u/mrichter/AliRoot.git/blobdiff - TRD/AliTRDCalibraFit.cxx
Put 0.1 as minimal value of the gas gain (Raphaelle)
[u/mrichter/AliRoot.git] / TRD / AliTRDCalibraFit.cxx
index 377b9fbd7759aede96a6de508f3ced43bbd774ae..eb9c4de9a50f68270230f692aa3cf4bd182f0d17 100644 (file)
 #include <TAxis.h>
 #include <TMath.h>
 #include <TDirectory.h>
-#include <TROOT.h>
 #include <TTreeStream.h>
 #include <TLinearFitter.h>
 #include <TVectorD.h>
-#include <TArrayF.h>
+#include <TROOT.h>
+#include <TString.h>
 
 #include "AliLog.h"
 #include "AliMathBase.h"
@@ -362,7 +362,8 @@ Bool_t AliTRDCalibraFit::AnalyseCH(const TH2I *ch)
   //
 
   // Set the calibration mode
-  const char *name = ch->GetTitle();
+  //const char *name = ch->GetTitle();
+  TString name = ch->GetTitle();
   if(!SetModeCalibration(name,0)) return kFALSE;
 
   // Number of Ybins (detectors or groups of pads)
@@ -460,7 +461,8 @@ Bool_t AliTRDCalibraFit::AnalyseCH(AliTRDCalibraVector *calvect)
   //
 
   // Set the calibraMode
-  const char *name = calvect->GetNameCH();
+  //const char *name = calvect->GetNameCH();
+  TString name = calvect->GetNameCH();
   if(!SetModeCalibration(name,0)) return kFALSE;  
 
   // Number of Xbins (detectors or groups of pads)
@@ -553,7 +555,8 @@ Bool_t AliTRDCalibraFit::AnalysePH(const TProfile2D *ph)
   //
 
   // Set the calibration mode
-  const char *name = ph->GetTitle();
+  //const char *name = ph->GetTitle();
+  TString name = ph->GetTitle();
   if(!SetModeCalibration(name,1)) return kFALSE;
   
   //printf("Mode calibration set\n");
@@ -654,7 +657,8 @@ Bool_t AliTRDCalibraFit::AnalysePH(AliTRDCalibraVector *calvect)
   //
 
   // Set the calibration mode
-  const char *name = calvect->GetNamePH();
+  //const char *name = calvect->GetNamePH();
+  TString name = calvect->GetNamePH();
   if(!SetModeCalibration(name,1)) return kFALSE;
 
   // Number of Xbins (detectors or groups of pads)
@@ -733,7 +737,8 @@ Bool_t AliTRDCalibraFit::AnalysePRF(const TProfile2D *prf)
   //
 
   // Set the calibration mode
-  const char *name = prf->GetTitle();
+  //const char *name = prf->GetTitle();
+  TString name = prf->GetTitle();
   if(!SetModeCalibration(name,2)) return kFALSE;
 
   // Number of Ybins (detectors or groups of pads)
@@ -820,7 +825,8 @@ Bool_t AliTRDCalibraFit::AnalysePRFMarianFit(const TProfile2D *prf)
   //
 
   // Set the calibration mode
-  const char *name = prf->GetTitle();
+  //const char *name = prf->GetTitle();
+  TString name = prf->GetTitle();
   if(!SetModeCalibration(name,2)) return kFALSE;
 
   // Number of Ybins (detectors or groups of pads)
@@ -915,7 +921,8 @@ Bool_t AliTRDCalibraFit::AnalysePRF(AliTRDCalibraVector *calvect)
   //
 
   // Set the calibra mode
-  const char *name = calvect->GetNamePRF();
+  //const char *name = calvect->GetNamePRF();
+  TString name = calvect->GetNamePRF();
   if(!SetModeCalibration(name,2)) return kFALSE;
   //printf("test0 %s\n",name);
 
@@ -991,7 +998,8 @@ Bool_t AliTRDCalibraFit::AnalysePRFMarianFit(AliTRDCalibraVector *calvect)
   //
 
   // Set the calibra mode
-  const char *name = calvect->GetNamePRF();
+  //const char *name = calvect->GetNamePRF();
+  TString name = calvect->GetNamePRF();
   if(!SetModeCalibration(name,2)) return kFALSE;
   //printf("test0 %s\n",name);
   Int_t    nbg     = GetNumberOfGroupsPRF((const char *)name);
@@ -1144,7 +1152,7 @@ Bool_t AliTRDCalibraFit::AnalyseLinearFitters(AliTRDCalibraVdriftLinearFit *cali
     fCurrentCoef2[0] = (param[0]+fCurrentCoef[1]*fCurrentCoef2[1])/fCurrentCoef[0];
     fCurrentCoefE    = error[1];
     fCurrentCoefE2   = error[0];
-    if((fCurrentCoef2[0] != 0.0) && (param[0] != 0.0)){
+    if((TMath::Abs(fCurrentCoef2[0]) > 0.0000001) && (TMath::Abs(param[0]) > 0.0000001)){
       fCurrentCoefE2 = (fCurrentCoefE2/param[0]+fCurrentCoefE/fCurrentCoef[0])*fCurrentCoef2[0];
     }    
 
@@ -1167,7 +1175,7 @@ Bool_t AliTRDCalibraFit::AnalyseLinearFitters(AliTRDCalibraVdriftLinearFit *cali
 }
 //____________Functions for seeing if the pad is really okey___________________
 //_____________________________________________________________________________
-Int_t AliTRDCalibraFit::GetNumberOfGroupsPRF(const char* nametitle)
+Int_t AliTRDCalibraFit::GetNumberOfGroupsPRF(TString nametitle)
 {
   //
   // Get numberofgroupsprf
@@ -1183,25 +1191,25 @@ Int_t AliTRDCalibraFit::GetNumberOfGroupsPRF(const char* nametitle)
   const Char_t *pattern6 = "Ngp6";
 
   // Nrphi mode
-  if (strstr(nametitle,pattern0)) {
+  if (strstr(nametitle.Data(),pattern0)) {
     return 0;
   }
-  if (strstr(nametitle,pattern1)) {
+  if (strstr(nametitle.Data(),pattern1)) {
     return 1;
   }
-  if (strstr(nametitle,pattern2)) {
+  if (strstr(nametitle.Data(),pattern2)) {
     return 2;
   }
-  if (strstr(nametitle,pattern3)) {
+  if (strstr(nametitle.Data(),pattern3)) {
     return 3;
   }
-  if (strstr(nametitle,pattern4)) {
+  if (strstr(nametitle.Data(),pattern4)) {
     return 4;
   }
-  if (strstr(nametitle,pattern5)) {
+  if (strstr(nametitle.Data(),pattern5)) {
     return 5;
   }
-  if (strstr(nametitle,pattern6)){
+  if (strstr(nametitle.Data(),pattern6)){
     return 6;
   }
   else return -1;
@@ -1209,7 +1217,7 @@ Int_t AliTRDCalibraFit::GetNumberOfGroupsPRF(const char* nametitle)
 
 }
 //_____________________________________________________________________________
-Bool_t AliTRDCalibraFit::SetModeCalibration(const char *name, Int_t i)
+Bool_t AliTRDCalibraFit::SetModeCalibration(TString name, Int_t i)
 {
   //
   // Set fNz[i] and fNrphi[i] of the AliTRDCalibraFit::Instance()
@@ -1223,7 +1231,7 @@ Bool_t AliTRDCalibraFit::SetModeCalibration(const char *name, Int_t i)
 
 }
 //_____________________________________________________________________________
-Bool_t AliTRDCalibraFit::SetNrphiFromTObject(const char *name, Int_t i)
+Bool_t AliTRDCalibraFit::SetNrphiFromTObject(TString name, Int_t i)
 {
   //
   // Set fNrphi[i] of the AliTRDCalibraFit::Instance()
@@ -1246,7 +1254,7 @@ Bool_t AliTRDCalibraFit::SetNrphiFromTObject(const char *name, Int_t i)
   const Char_t *patternz100 = "Nz100";
 
   // Nrphi mode
-  if ((strstr(name,patternrphi100)) && (strstr(name,patternz100))) {
+  if ((strstr(name.Data(),patternrphi100)) && (strstr(name.Data(),patternz100))) {
     fCalibraMode->SetAllTogether(i);
     fNbDet = 540;
     if (fDebugLevel > 1) {
@@ -1254,7 +1262,7 @@ Bool_t AliTRDCalibraFit::SetNrphiFromTObject(const char *name, Int_t i)
     }
     return kTRUE;
   }
-  if ((strstr(name,patternrphi10)) && (strstr(name,patternz10))) {
+  if ((strstr(name.Data(),patternrphi10)) && (strstr(name.Data(),patternz10))) {
     fCalibraMode->SetPerSuperModule(i);
     fNbDet = 30;
     if (fDebugLevel > 1) {
@@ -1263,49 +1271,49 @@ Bool_t AliTRDCalibraFit::SetNrphiFromTObject(const char *name, Int_t i)
     return kTRUE;
   }
   
-  if (strstr(name,patternrphi0)) {
+  if (strstr(name.Data(),patternrphi0)) {
     fCalibraMode->SetNrphi(i ,0);
     if (fDebugLevel > 1) {
       AliInfo(Form("fNbDet %d and 0",fNbDet));
     }
     return kTRUE;
   }
-  if (strstr(name,patternrphi1)) {
+  if (strstr(name.Data(),patternrphi1)) {
     fCalibraMode->SetNrphi(i, 1);
     if (fDebugLevel > 1) {
       AliInfo(Form("fNbDet %d and 1",fNbDet));
     }
     return kTRUE;
   }
-  if (strstr(name,patternrphi2)) {
+  if (strstr(name.Data(),patternrphi2)) {
     fCalibraMode->SetNrphi(i, 2);
     if (fDebugLevel > 1) {
       AliInfo(Form("fNbDet %d and 2",fNbDet));
     }    
     return kTRUE;
   }
-  if (strstr(name,patternrphi3)) {
+  if (strstr(name.Data(),patternrphi3)) {
     fCalibraMode->SetNrphi(i, 3);
     if (fDebugLevel > 1) {
       AliInfo(Form("fNbDet %d and 3",fNbDet));
     }   
     return kTRUE;
   }
-  if (strstr(name,patternrphi4)) {
+  if (strstr(name.Data(),patternrphi4)) {
     fCalibraMode->SetNrphi(i, 4);
     if (fDebugLevel > 1) {
       AliInfo(Form("fNbDet %d and 4",fNbDet));
     }   
     return kTRUE;
   }
-  if (strstr(name,patternrphi5)) {
+  if (strstr(name.Data(),patternrphi5)) {
     fCalibraMode->SetNrphi(i, 5);
     if (fDebugLevel > 1) {
       AliInfo(Form("fNbDet %d and 5",fNbDet));
     }
     return kTRUE;
   }
-  if (strstr(name,patternrphi6)) {
+  if (strstr(name.Data(),patternrphi6)) {
     fCalibraMode->SetNrphi(i, 6);
     if (fDebugLevel > 1) {
       AliInfo(Form("fNbDet %d and 6",fNbDet));
@@ -1321,7 +1329,7 @@ Bool_t AliTRDCalibraFit::SetNrphiFromTObject(const char *name, Int_t i)
   
 }
 //_____________________________________________________________________________
-Bool_t AliTRDCalibraFit::SetNzFromTObject(const char *name, Int_t i)
+Bool_t AliTRDCalibraFit::SetNzFromTObject(TString name, Int_t i)
 {
   //
   // Set fNz[i] of the AliTRDCalibraFit::Instance()
@@ -1340,7 +1348,7 @@ Bool_t AliTRDCalibraFit::SetNzFromTObject(const char *name, Int_t i)
   const Char_t *patternz10 = "Nz10";
   const Char_t *patternz100 = "Nz100";
 
-  if ((strstr(name,patternrphi100)) && (strstr(name,patternz100))) {
+  if ((strstr(name.Data(),patternrphi100)) && (strstr(name.Data(),patternz100))) {
     fCalibraMode->SetAllTogether(i);
     fNbDet = 540;
     if (fDebugLevel > 1) {
@@ -1348,7 +1356,7 @@ Bool_t AliTRDCalibraFit::SetNzFromTObject(const char *name, Int_t i)
     }
     return kTRUE;
   }
-  if ((strstr(name,patternrphi10)) && (strstr(name,patternz10))) {
+  if ((strstr(name.Data(),patternrphi10)) && (strstr(name.Data(),patternz10))) {
     fCalibraMode->SetPerSuperModule(i);
     fNbDet = 30;
     if (fDebugLevel > 1) {
@@ -1356,35 +1364,35 @@ Bool_t AliTRDCalibraFit::SetNzFromTObject(const char *name, Int_t i)
     }
     return kTRUE;
   }
-  if (strstr(name,patternz0)) {
+  if (strstr(name.Data(),patternz0)) {
     fCalibraMode->SetNz(i, 0);
     if (fDebugLevel > 1) {
       AliInfo(Form("fNbDet %d and 0",fNbDet));
     }
     return kTRUE;
   }
-  if (strstr(name,patternz1)) {
+  if (strstr(name.Data(),patternz1)) {
     fCalibraMode->SetNz(i ,1);
     if (fDebugLevel > 1) {
       AliInfo(Form("fNbDet %d and 1",fNbDet));
     }
     return kTRUE;
   }
-  if (strstr(name,patternz2)) {
+  if (strstr(name.Data(),patternz2)) {
     fCalibraMode->SetNz(i ,2);
     if (fDebugLevel > 1) {    
       AliInfo(Form("fNbDet %d and 2",fNbDet));
     }
     return kTRUE;
   }
-  if (strstr(name,patternz3)) {
+  if (strstr(name.Data(),patternz3)) {
     fCalibraMode->SetNz(i ,3);
     if (fDebugLevel > 1) {
       AliInfo(Form("fNbDet %d and 3",fNbDet));
     }
     return kTRUE;  
   }
-  if (strstr(name,patternz4)) {
+  if (strstr(name.Data(),patternz4)) {
     fCalibraMode->SetNz(i ,4);
     if (fDebugLevel > 1) {    
       AliInfo(Form("fNbDet %d and 4",fNbDet));
@@ -1936,6 +1944,7 @@ AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectGain(const TObjArray *vectorFit,
       } // Row
       if(count > 0) mean = mean/count;
     }
+    if(mean < 0.1) mean = 0.1;
     object->SetValue(detector,mean);
   }
  
@@ -2060,7 +2069,7 @@ TObject *AliTRDCalibraFit::CreatePadObjectGain(const TObjArray *vectorFit, Doubl
       detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
       AliTRDCalROC *calROC = object->GetCalROC(detector);
       Float_t mean         = detobject->GetValue(detector);
-      if(mean == 0) continue;
+      if(TMath::Abs(mean) <= 0.0000000001) continue;
       Int_t rowMax    = calROC->GetNrows();
       Int_t colMax    = calROC->GetNcols();
       for (Int_t row = 0; row < rowMax; row++) {
@@ -4166,11 +4175,11 @@ void AliTRDCalibraFit::FitPente(TH1* projPH)
   Float_t l3P2am = pentea->GetFunction("pol2")->GetParameter(2);
   Float_t l3P1amE = pentea->GetFunction("pol2")->GetParError(1);
   Float_t l3P2amE = pentea->GetFunction("pol2")->GetParError(2);
-  if (l3P2am != 0) {
+  if (TMath::Abs(l3P2am) > 0.00000001) {
     fPhd[0] = -(l3P1am / (2 * l3P2am));
   }
   if(!fTakeTheMaxPH){
-    if((l3P1am != 0.0) && (l3P2am != 0.0)){
+    if((TMath::Abs(l3P1am) > 0.0000000001) && (TMath::Abs(l3P2am) > 0.00000000001)){
       fCurrentCoefE2 = (l3P1amE/l3P1am + l3P2amE/l3P2am)*fPhd[0];
     }
   }
@@ -4197,10 +4206,10 @@ void AliTRDCalibraFit::FitPente(TH1* projPH)
   Float_t l3P2amf = projPH->GetFunction("pol2")->GetParameter(2);
   Float_t l3P1amfE = projPH->GetFunction("pol2")->GetParError(1);
   Float_t l3P2amfE = projPH->GetFunction("pol2")->GetParError(2);
-  if (l3P2amf != 0) {
+  if (TMath::Abs(l3P2amf) > 0.00000000001) {
     fPhd[1] = -(l3P1amf / (2 * l3P2amf));
   }
-  if((l3P1amf != 0.0) && (l3P2amf != 0.0)){
+  if((TMath::Abs(l3P1amf) > 0.0000000001) && (TMath::Abs(l3P2amf) > 0.000000001)){
     fCurrentCoefE = (l3P1amfE/l3P1amf + l3P2amfE/l3P2amf)*fPhd[1];
   }
   if(fTakeTheMaxPH){
@@ -4231,10 +4240,10 @@ void AliTRDCalibraFit::FitPente(TH1* projPH)
   Float_t l3P2dr = pente->GetFunction("pol2")->GetParameter(2);
   Float_t l3P1drE = pente->GetFunction("pol2")->GetParError(1);
   Float_t l3P2drE = pente->GetFunction("pol2")->GetParError(2);
-  if (l3P2dr != 0) {
+  if (TMath::Abs(l3P2dr) > 0.00000001) {
     fPhd[2] = -(l3P1dr / (2 * l3P2dr));
   }
-  if((l3P1dr != 0.0) && (l3P2dr != 0.0)){
+  if((TMath::Abs(l3P1dr) > 0.0000000001) && (TMath::Abs(l3P2dr) > 0.00000000001)){
     fCurrentCoefE += (l3P1drE/l3P1dr + l3P2drE/l3P2dr)*fPhd[2]; 
   }
   Float_t fPhdt0  = 0.0;
@@ -4306,8 +4315,10 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
   const Float_t kDrWidth = AliTRDgeometry::DrThick();
   Int_t binmax      = 0;
   Int_t binmin      = 0;
-  Double_t    *x    = new Double_t[5];
-  Double_t    *y    = new Double_t[5];
+  //Double_t    *x    = new Double_t[5];
+  //Double_t    *y    = new Double_t[5];
+  Double_t x[5];
+  Double_t y[5];
   x[0]              = 0.0;
   x[1]              = 0.0;
   x[2]              = 0.0;
@@ -4330,7 +4341,11 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
   TF1 * polynome = 0x0;
   TF1 * polynomea = 0x0;
   TF1 * polynomeb = 0x0;
-  Double_t *c = 0x0;
+  Double_t c0 = 0.0;
+  Double_t c1 = 0.0;
+  Double_t c2 = 0.0;
+  Double_t c3 = 0.0;
+  Double_t c4 = 0.0;
   
   // Some variables
   TAxis   *xpph    = projPH->GetXaxis();
@@ -4370,7 +4385,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
       y[0] = pentea->GetBinContent(binmax-2);
       y[1] = pentea->GetBinContent(binmax-1);
       y[2] = pentea->GetBinContent(binmax);
-      c = CalculPolynomeLagrange2(x,y);
+      CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
       AliInfo("At the limit for beginning!");
       break;  
     case 2:
@@ -4384,7 +4399,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
       y[1] = pentea->GetBinContent(binmax-1);
       y[2] = pentea->GetBinContent(binmax);
       y[3] = pentea->GetBinContent(binmax+1);
-      c = CalculPolynomeLagrange3(x,y);
+      CalculPolynomeLagrange3(x,y,c0,c1,c2,c3,c4);
       break;
     default:
       switch(binmax){
@@ -4400,7 +4415,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
        y[0] = pentea->GetBinContent(binmax);
        y[1] = pentea->GetBinContent(binmax+1);
        y[2] = pentea->GetBinContent(binmax+2);
-       c = CalculPolynomeLagrange2(x,y);
+       CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
        break;
       case 2:
        minnn = pentea->GetBinCenter(binmax-1);
@@ -4413,7 +4428,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
        y[1] = pentea->GetBinContent(binmax);
        y[2] = pentea->GetBinContent(binmax+1);
        y[3] = pentea->GetBinContent(binmax+2);
-               c = CalculPolynomeLagrange3(x,y);
+               CalculPolynomeLagrange3(x,y,c0,c1,c2,c3,c4);
        break;
       default:
        minnn = pentea->GetBinCenter(binmax-2);
@@ -4428,7 +4443,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
        y[2] = pentea->GetBinContent(binmax);
        y[3] = pentea->GetBinContent(binmax+1);
        y[4] = pentea->GetBinContent(binmax+2);
-       c = CalculPolynomeLagrange4(x,y);
+       CalculPolynomeLagrange4(x,y,c0,c1,c2,c3,c4);
        break;
       }
       break;
@@ -4437,7 +4452,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
   
   if(put) {
     polynomeb = new TF1("polb","[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x",minnn,maxxx);
-    polynomeb->SetParameters(c[0],c[1],c[2],c[3],c[4]);
+    polynomeb->SetParameters(c0,c1,c2,c3,c4);
       
     Double_t step = (maxxx-minnn)/10000;
     Double_t l = minnn;
@@ -4493,7 +4508,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
       y[0] = projPH->GetBinContent(binmax-2);
       y[1] = projPH->GetBinContent(binmax-1);
       y[2] = projPH->GetBinContent(binmax);
-      c = CalculPolynomeLagrange2(x,y);
+      CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
       //AliInfo("At the limit for the drift!");
       break;
     case 1:
@@ -4507,7 +4522,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
       y[1] = projPH->GetBinContent(binmax-1);
       y[2] = projPH->GetBinContent(binmax);
       y[3] = projPH->GetBinContent(binmax+1);
-      c = CalculPolynomeLagrange3(x,y);
+      CalculPolynomeLagrange3(x,y,c0,c1,c2,c3,c4);
       break;
     default:
       switch(binmax)
@@ -4524,7 +4539,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
          y[0] = projPH->GetBinContent(binmax);
          y[1] = projPH->GetBinContent(binmax+1);
          y[2] = projPH->GetBinContent(binmax+2);
-         c = CalculPolynomeLagrange2(x,y);
+         CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
          break;
        case 2:
          minn = projPH->GetBinCenter(binmax-1);
@@ -4537,7 +4552,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
          y[1] = projPH->GetBinContent(binmax);
          y[2] = projPH->GetBinContent(binmax+1);
          y[3] = projPH->GetBinContent(binmax+2);
-         c = CalculPolynomeLagrange3(x,y);
+         CalculPolynomeLagrange3(x,y,c0,c1,c2,c3,c4);
          break;
        default:
          minn = projPH->GetBinCenter(binmax-2);
@@ -4552,7 +4567,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
          y[2] = projPH->GetBinContent(binmax);
          y[3] = projPH->GetBinContent(binmax+1);
          y[4] = projPH->GetBinContent(binmax+2);
-         c = CalculPolynomeLagrange4(x,y);
+         CalculPolynomeLagrange4(x,y,c0,c1,c2,c3,c4);
          break;
        }
       break;
@@ -4560,7 +4575,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
   
   if(put) {
     polynomea = new TF1("pola","[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x",minn,maxx);
-    polynomea->SetParameters(c[0],c[1],c[2],c[3],c[4]);
+    polynomea->SetParameters(c0,c1,c2,c3,c4);
        
     Double_t step = (maxx-minn)/1000;
     Double_t l = minn;
@@ -4601,7 +4616,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
     AliInfo("Too many fluctuations at the end!");
     put = kFALSE;
   }
-  if(pente->GetBinContent(binmin+1)==0){
+  if(TMath::Abs(pente->GetBinContent(binmin+1)) <= 0.0000000000001){
     AliInfo("No entries for the next bin!");
     pente->SetBinContent(binmin,0);
     if(pente->GetEntries() > 0) binmin = (Int_t) pente->GetMinimumBin();
@@ -4641,7 +4656,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
     y[3] = pente->GetBinContent(binmin+1);
     y[4] = pente->GetBinContent(binmin+2);
     //Calcul the polynome de Lagrange
-    c = CalculPolynomeLagrange4(x,y);
+    CalculPolynomeLagrange4(x,y,c0,c1,c2,c3,c4);
     //richtung +/-
     if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1)) &&
        (pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) {
@@ -4683,7 +4698,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
     y[2] = pente->GetBinContent(binmin);
     y[3] = pente->GetBinContent(binmin+1);
     //Calcul the polynome de Lagrange
-    c = CalculPolynomeLagrange3(x,y);
+    CalculPolynomeLagrange3(x,y,c0,c1,c2,c3,c4);
     //richtung +: nothing
     //richtung -
     if((pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) {
@@ -4705,7 +4720,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
     y[2] = pente->GetBinContent(binmin+1);
     y[3] = pente->GetBinContent(binmin+2);
     //Calcul the polynome de Lagrange
-    c = CalculPolynomeLagrange3(x,y);
+    CalculPolynomeLagrange3(x,y,c0,c1,c2,c3,c4);
     //richtung +
     if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1))) {
       //AliInfo("polynome 3+ case 2");      
@@ -4723,7 +4738,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
     y[1] = pente->GetBinContent(binmin+1);
     y[2] = pente->GetBinContent(binmin+2);
     //Calcul the polynome de Lagrange
-    c = CalculPolynomeLagrange2(x,y);
+    CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
     //richtung +
     if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1))) {
       //AliInfo("polynome 2+ false");
@@ -4742,7 +4757,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
     y[1] = pente->GetBinContent(binmin);
     y[2] = pente->GetBinContent(binmin+1);
     //Calcul the polynome de Lagrange
-    c = CalculPolynomeLagrange2(x,y);
+    CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
     //richtung +: nothing
     //richtung -: nothing
   }
@@ -4758,7 +4773,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
     y[1] = pente->GetBinContent(binmin-1);
     y[2] = pente->GetBinContent(binmin);
     //Calcul the polynome de Lagrange
-    c = CalculPolynomeLagrange2(x,y);
+    CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
     //AliInfo("At the limit for the drift!");
     //fluctuation too big!
     //richtung +: nothing
@@ -4786,7 +4801,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
   
   if(put) {
     polynome = new TF1("pol","[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x",min,max);
-    polynome->SetParameters(c[0],c[1],c[2],c[3],c[4]);
+    polynome->SetParameters(c0,c1,c2,c3,c4);
     //AliInfo(Form("GetMinimum of the function %f",polynome->GetMinimumX()));
     Double_t step = (max-min)/1000;
     Double_t l = min;
@@ -4876,14 +4891,13 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
     pente->Draw();
   }
   else {
-    if(pentea) delete pentea;
-    if(pente) delete pente;
+    delete pentea;
+    delete pente;
     if(polynome) delete polynome;
     if(polynomea) delete polynomea;
     if(polynomeb) delete polynomeb;
-    if(x) delete [] x;
-    if(y) delete [] y;
-    if(c) delete [] c;
+    //if(x) delete [] x;
+    //if(y) delete [] y;
     if(line) delete line;
 
   }
@@ -4997,7 +5011,7 @@ Bool_t AliTRDCalibraFit::FitPRFGausMI(Double_t *arraye, Double_t *arraym, Double
 
   Double_t ret = FitGausMI(arraye, arraym, arrayme, nBins, xMin, xMax,&param); 
 
-  if(ret == -4){
+  if(TMath::Abs(ret+4) <= 0.000000001){
     fCurrentCoef[0] = -fCurrentCoef[1];
     return kFALSE;
   }
@@ -5060,7 +5074,7 @@ Double_t AliTRDCalibraFit::FitGausMI(Double_t *arraye, Double_t *arraym, Double_
          if((valueI - arrayme[ibin]) > 0.0) errorn = TMath::Log((valueI - arrayme[ibin])/valueI);
          error = TMath::Max(TMath::Abs(errorm),TMath::Abs(errorn));
        }
-       if(error == 0.0) continue;
+       if(TMath::Abs(error) < 0.000000001) continue;
        val      = TMath::Log(Float_t(valueI));
        fitter.AddPoint(&xcenter,val,error);
        npoints++;
@@ -5107,7 +5121,7 @@ Double_t AliTRDCalibraFit::FitGausMI(Double_t *arraye, Double_t *arraym, Double_
     
         
     if (!param)  param  = new TVectorD(3);
-    if(par[2] == 0.0) return -4.0;
+    if(TMath::Abs(par[2]) <= 0.000000001) return -4.0;
     Double_t  x      = TMath::Sqrt(TMath::Abs(-2*par[2])); 
     Double_t deltax = (fitter.GetParError(2))/x;
     Double_t errorparam2 = TMath::Abs(deltax)/(x*x);
@@ -5307,7 +5321,7 @@ void AliTRDCalibraFit::FitTnpRange(Double_t *arraye, Double_t *arraym, Double_t
     Double_t ermin0       = 0.0;
     //Double_t prfe0      = 0.0;
     Double_t prf0         = 0.0;
-    if((pars0[2] > 0.0) && (pars0[1] != 0.0)) {
+    if((pars0[2] > 0.000000000001) && (TMath::Abs(pars0[1]) >= 0.000000000001)) {
       min0 = -pars0[1]/(2*pars0[2]);
       ermin0 = TMath::Abs(min0*(errorsx0/pars0[2]+linearfitter.GetParError(1)*pointError0/pars0[1]));
       prf0 = pars0[0]+pars0[1]*min0+pars0[2]*min0*min0;
@@ -5625,68 +5639,59 @@ void AliTRDCalibraFit::FitBisCH(TH1* projch, Double_t mean)
   }
 } 
 //_____________________________________________________________________________
-Double_t *AliTRDCalibraFit::CalculPolynomeLagrange2(const Double_t *x, const Double_t *y) const
+void AliTRDCalibraFit::CalculPolynomeLagrange2(const Double_t *x, const Double_t *y, Double_t &c0, Double_t &c1, Double_t &c2, Double_t &c3, Double_t &c4) const
 {
   //
   // Calcul the coefficients of the polynome passant par ces trois points de degre 2
   //
-  Double_t *c = new Double_t[5];
   Double_t x0 = y[0]/((x[0]-x[1])*(x[0]-x[2]));
   Double_t x1 = y[1]/((x[1]-x[0])*(x[1]-x[2]));
   Double_t x2 = y[2]/((x[2]-x[0])*(x[2]-x[1]));
 
-  c[4] = 0.0;
-  c[3] = 0.0;
-  c[2] = x0+x1+x2;
-  c[1] = -(x0*(x[1]+x[2])+x1*(x[0]+x[2])+x2*(x[0]+x[1]));
-  c[0] = x0*x[1]*x[2]+x1*x[0]*x[2]+x2*x[0]*x[1];
-
-  return c;
-  
+  c4 = 0.0;
+  c3 = 0.0;
+  c2 = x0+x1+x2;
+  c1 = -(x0*(x[1]+x[2])+x1*(x[0]+x[2])+x2*(x[0]+x[1]));
+  c0 = x0*x[1]*x[2]+x1*x[0]*x[2]+x2*x[0]*x[1];
 
 }
 
 //_____________________________________________________________________________
-Double_t *AliTRDCalibraFit::CalculPolynomeLagrange3(const Double_t *x, const Double_t *y) const
+void AliTRDCalibraFit::CalculPolynomeLagrange3(const Double_t *x, const Double_t *y, Double_t &c0, Double_t &c1, Double_t &c2, Double_t &c3, Double_t &c4) const
 {
   //
   // Calcul the coefficients of the polynome passant par ces quatre points de degre 3
   //
-  Double_t *c = new Double_t[5];
   Double_t x0 = y[0]/((x[0]-x[1])*(x[0]-x[2])*(x[0]-x[3]));
   Double_t x1 = y[1]/((x[1]-x[0])*(x[1]-x[2])*(x[1]-x[3]));
   Double_t x2 = y[2]/((x[2]-x[0])*(x[2]-x[1])*(x[2]-x[3]));
   Double_t x3 = y[3]/((x[3]-x[0])*(x[3]-x[1])*(x[3]-x[2]));
 
-  c[4] = 0.0;
-  c[3] = x0+x1+x2+x3;
-  c[2] = -(x0*(x[1]+x[2]+x[3])
+  c4 = 0.0;
+  c3 = x0+x1+x2+x3;
+  c2 = -(x0*(x[1]+x[2]+x[3])
           +x1*(x[0]+x[2]+x[3])
           +x2*(x[0]+x[1]+x[3])
           +x3*(x[0]+x[1]+x[2]));
-  c[1] = (x0*(x[1]*x[2]+x[1]*x[3]+x[2]*x[3])
+  c1 = (x0*(x[1]*x[2]+x[1]*x[3]+x[2]*x[3])
          +x1*(x[0]*x[2]+x[0]*x[3]+x[2]*x[3])
          +x2*(x[0]*x[1]+x[0]*x[3]+x[1]*x[3])
          +x3*(x[0]*x[1]+x[0]*x[2]+x[1]*x[2]));
   
-  c[0] = -(x0*x[1]*x[2]*x[3]
+  c0 = -(x0*x[1]*x[2]*x[3]
          +x1*x[0]*x[2]*x[3]
          +x2*x[0]*x[1]*x[3]
          +x3*x[0]*x[1]*x[2]);  
 
 
-  return c;
-  
-
 }
 
 //_____________________________________________________________________________
-Double_t *AliTRDCalibraFit::CalculPolynomeLagrange4(const Double_t *x, const Double_t *y) const
+void AliTRDCalibraFit::CalculPolynomeLagrange4(const Double_t *x, const Double_t *y, Double_t &c0, Double_t &c1, Double_t &c2, Double_t &c3, Double_t &c4) const
 {
   //
   // Calcul the coefficients of the polynome passant par ces cinqs points de degre 4
   //
-  Double_t *c = new Double_t[5];
   Double_t x0 = y[0]/((x[0]-x[1])*(x[0]-x[2])*(x[0]-x[3])*(x[0]-x[4]));
   Double_t x1 = y[1]/((x[1]-x[0])*(x[1]-x[2])*(x[1]-x[3])*(x[1]-x[4]));
   Double_t x2 = y[2]/((x[2]-x[0])*(x[2]-x[1])*(x[2]-x[3])*(x[2]-x[4]));
@@ -5694,33 +5699,30 @@ Double_t *AliTRDCalibraFit::CalculPolynomeLagrange4(const Double_t *x, const Dou
   Double_t x4 = y[4]/((x[4]-x[0])*(x[4]-x[1])*(x[4]-x[2])*(x[4]-x[3]));
  
 
-  c[4] = x0+x1+x2+x3+x4;
-  c[3] = -(x0*(x[1]+x[2]+x[3]+x[4])
+  c4 = x0+x1+x2+x3+x4;
+  c3 = -(x0*(x[1]+x[2]+x[3]+x[4])
           +x1*(x[0]+x[2]+x[3]+x[4])
           +x2*(x[0]+x[1]+x[3]+x[4])
           +x3*(x[0]+x[1]+x[2]+x[4])
           +x4*(x[0]+x[1]+x[2]+x[3]));
-  c[2] = (x0*(x[1]*x[2]+x[1]*x[3]+x[1]*x[4]+x[2]*x[3]+x[2]*x[4]+x[3]*x[4])
+  c2 = (x0*(x[1]*x[2]+x[1]*x[3]+x[1]*x[4]+x[2]*x[3]+x[2]*x[4]+x[3]*x[4])
          +x1*(x[0]*x[2]+x[0]*x[3]+x[0]*x[4]+x[2]*x[3]+x[2]*x[4]+x[3]*x[4])
          +x2*(x[0]*x[1]+x[0]*x[3]+x[0]*x[4]+x[1]*x[3]+x[1]*x[4]+x[3]*x[4])
          +x3*(x[0]*x[1]+x[0]*x[2]+x[0]*x[4]+x[1]*x[2]+x[1]*x[4]+x[2]*x[4])
          +x4*(x[0]*x[1]+x[0]*x[2]+x[0]*x[3]+x[1]*x[2]+x[1]*x[3]+x[2]*x[3]));
 
-  c[1] = -(x0*(x[1]*x[2]*x[3]+x[1]*x[2]*x[4]+x[1]*x[3]*x[4]+x[2]*x[3]*x[4])
+  c1 = -(x0*(x[1]*x[2]*x[3]+x[1]*x[2]*x[4]+x[1]*x[3]*x[4]+x[2]*x[3]*x[4])
          +x1*(x[0]*x[2]*x[3]+x[0]*x[2]*x[4]+x[0]*x[3]*x[4]+x[2]*x[3]*x[4])
          +x2*(x[0]*x[1]*x[3]+x[0]*x[1]*x[4]+x[0]*x[3]*x[4]+x[1]*x[3]*x[4])
          +x3*(x[0]*x[1]*x[2]+x[0]*x[1]*x[4]+x[0]*x[2]*x[4]+x[1]*x[2]*x[4])
          +x4*(x[0]*x[1]*x[2]+x[0]*x[1]*x[3]+x[0]*x[2]*x[3]+x[1]*x[2]*x[3]));
 
-  c[0] = (x0*x[1]*x[2]*x[3]*x[4]
+  c0 = (x0*x[1]*x[2]*x[3]*x[4]
          +x1*x[0]*x[2]*x[3]*x[4]
          +x2*x[0]*x[1]*x[3]*x[4]
          +x3*x[0]*x[1]*x[2]*x[4]
          +x4*x[0]*x[1]*x[2]*x[3]);
 
-  return c;
-  
-
 }
 //_____________________________________________________________________________
 void AliTRDCalibraFit::NormierungCharge()
@@ -5971,9 +5973,9 @@ Double_t AliTRDCalibraFit::AsymmGauss(const Double_t *x, const Double_t *par)
   Double_t  sigma2  = par2save*par2save;
   Double_t  sqrt2   = TMath::Sqrt(2.0);
   Double_t  exp1    = par3save * TMath::Exp(-par3save * (dx - 0.5 * par3save * sigma2))
-                               * (1.0 - TMath::Erf((par3save * sigma2 - dx) / (sqrt2 * par2save)));
+                               * (1.0 - AliMathBase::ErfFast((par3save * sigma2 - dx) / (sqrt2 * par2save)));
   Double_t  exp2    = par5save * TMath::Exp(-par5save * (dx - 0.5 * par5save * sigma2))
-                               * (1.0 - TMath::Erf((par5save * sigma2 - dx) / (sqrt2 * par2save)));
+                               * (1.0 - AliMathBase::ErfFast((par5save * sigma2 - dx) / (sqrt2 * par2save)));
 
   //return par[0]*(exp1+par[4]*exp2);
   return par[0] * (exp1 + 1.00124 * exp2);
@@ -6204,3 +6206,6 @@ Double_t AliTRDCalibraFit::GausConstant(const Double_t *x, const Double_t *par)
   return gauss;
 
 }
+
+
+