more secure string operations
[u/mrichter/AliRoot.git] / TPC / AliTPCcalibDButil.cxx
index 41ec6f0..37f7c9f 100644 (file)
@@ -40,6 +40,7 @@
 #include <AliCDBEntry.h>
 #include <AliCDBManager.h>
 #include <AliCDBId.h>
+#include <AliSplineFit.h>
 #include "AliTPCcalibDB.h"
 #include "AliTPCCalPad.h"
 #include "AliTPCCalROC.h"
@@ -478,6 +479,90 @@ void AliTPCcalibDButil::ProcessNoiseData(TVectorD &vNoiseMean, TVectorD &vNoiseM
 }
 
 //_____________________________________________________________________________________
+void AliTPCcalibDButil::ProcessQAData(TVectorD &vQaOcc, TVectorD &vQaQtot, 
+                                     TVectorD &vQaQmax)
+{
+  //
+  // process QA data
+  //
+  // vQaOcc/Qtot/Qmax contains the Mean occupancy/Qtot/Qmax for each sector
+  //
+
+
+  const UInt_t infoSize = 72;
+  //reset counters to error number
+  vQaOcc.ResizeTo(infoSize);
+  vQaOcc.Zero();
+  vQaQtot.ResizeTo(infoSize);
+  vQaQtot.Zero();
+  vQaQmax.ResizeTo(infoSize);
+  vQaQmax.Zero();
+  //counter
+  //retrieve pulser and ALTRO data
+  
+  if (!fDataQA) {
+    
+    AliInfo("No QA data");
+    return;
+  }
+  if (fDataQA->GetEventCounter()<=0) {
+
+    AliInfo("No QA data");
+    return; // no data processed
+  }
+  //
+  fDataQA->Analyse();
+
+  TVectorD normOcc(infoSize);
+  TVectorD normQ(infoSize);
+
+  for (UInt_t isec=0;isec<AliTPCCalPad::kNsec;++isec){
+
+    printf("Sector %d\n", isec);
+
+    AliTPCCalROC* occupancyROC = fDataQA->GetNoThreshold()->GetCalROC(isec); 
+    AliTPCCalROC* nclusterROC = fDataQA->GetNLocalMaxima()->GetCalROC(isec); 
+    AliTPCCalROC* qROC = fDataQA->GetMeanCharge()->GetCalROC(isec); 
+    AliTPCCalROC* qmaxROC = fDataQA->GetMaxCharge()->GetCalROC(isec); 
+    if (!occupancyROC) continue;
+    if (!nclusterROC) continue;
+    if (!qROC) continue;
+    if (!qmaxROC) continue;
+    
+    const UInt_t nchannels=occupancyROC->GetNchannels();
+
+    printf("Nchannels %d\n", nchannels);
+
+    for (UInt_t ichannel=0;ichannel<nchannels;++ichannel){
+
+      vQaOcc[isec] += occupancyROC->GetValue(ichannel);
+      ++normOcc[isec];
+
+      Float_t nClusters = nclusterROC->GetValue(ichannel);
+      normQ[isec] += nClusters;
+      vQaQtot[isec]+=nClusters*qROC->GetValue(ichannel);
+      vQaQmax[isec]+=nClusters*qmaxROC->GetValue(ichannel);
+    }
+  }
+
+  //calculate mean values
+  for (UInt_t isec=0;isec<AliTPCCalPad::kNsec;++isec){
+    
+    if (normOcc[isec]>0) vQaOcc[isec] /= normOcc[isec];
+    else vQaOcc[isec] = 0;
+
+    if (normQ[isec]>0) {
+      vQaQtot[isec] /= normQ[isec];
+      vQaQmax[isec] /= normQ[isec];
+    }else {
+
+      vQaQtot[isec] = 0;
+      vQaQmax[isec] = 0;
+    }
+  }
+}
+
+//_____________________________________________________________________________________
 void AliTPCcalibDButil::ProcessPulser(TVectorD &vMeanTime)
 {
   //
@@ -937,7 +1022,7 @@ AliTPCCalPad* AliTPCcalibDButil::CreatePadTime0(Int_t model, Double_t &gyA, Doub
   return padTime0;
 }
 //_____________________________________________________________________________________
-Float_t AliTPCcalibDButil::GetMeanAltro(const AliTPCCalROC *roc, const Int_t row, const Int_t pad, AliTPCCalROC *rocOut)
+Float_t AliTPCcalibDButil::GetMeanAltro(const AliTPCCalROC *roc, const Int_t row, const Int_t pad, AliTPCCalROC *const rocOut)
 {
   //
   // GetMeanAlto information
@@ -1140,11 +1225,11 @@ void AliTPCcalibDButil::UpdateRefDataFromOCDB()
     entry=GetRefEntry(cdbPath.Data());
     if (entry){
       entry->SetOwner(kTRUE);
-      fDataQA=dynamic_cast<AliTPCdataQA*>(entry->GetObject());
-      if (!fDataQA){
+      fRefDataQA=dynamic_cast<AliTPCdataQA*>(entry->GetObject());
+      if (!fRefDataQA){
         AliError(Form("Could not get object from entry '%s'\nPlease check!!!",entry->GetId().GetPath().Data()));
       } else {
-        fRefDataQA=(AliTPCdataQA*)fDataQA->Clone();
+        fRefDataQA=(AliTPCdataQA*)fRefDataQA->Clone();
       }
       delete entry;
     }
@@ -1262,24 +1347,24 @@ AliCDBEntry* AliTPCcalibDButil::GetRefEntry(const char* cdbPath)
   return entry;
 }
 //_____________________________________________________________________________________
-const Int_t AliTPCcalibDButil::GetCurrentReferenceRun(const char* type){
+Int_t AliTPCcalibDButil::GetCurrentReferenceRun(const char* type) const {
   //
   // Get reference run number for the specified OCDB path
   //
   if (!fCurrentRefMap) return -2;
   TObjString *str=dynamic_cast<TObjString*>(fCurrentRefMap->GetValue(type));
   if (!str) return -2;
-  return (const Int_t)str->GetString().Atoi();
+  return (Int_t)str->GetString().Atoi();
 }
 //_____________________________________________________________________________________
-const Int_t AliTPCcalibDButil::GetReferenceRun(const char* type) const{
+Int_t AliTPCcalibDButil::GetReferenceRun(const char* type) const{
   //
   // Get reference run number for the specified OCDB path
   //
   if (!fRefMap) return -1;
   TObjString *str=dynamic_cast<TObjString*>(fRefMap->GetValue(type));
   if (!str) return -1;
-  return (const Int_t)str->GetString().Atoi();
+  return (Int_t)str->GetString().Atoi();
 }
 //_____________________________________________________________________________________
 AliTPCCalPad *AliTPCcalibDButil::CreateCEOutlyerMap( Int_t & noutliersCE, AliTPCCalPad * const ceOut, Float_t minSignal, Float_t cutTrmsMin,  Float_t cutTrmsMax, Float_t cutMaxDistT){
@@ -1607,17 +1692,27 @@ Int_t AliTPCcalibDButil::GetNearest(TGraph *graph, Double_t xref, Double_t &dx,
   //
   // find the closest point to xref  in x  direction
   // return dx and value 
+  dx = 0;
+  y = 0;
+
+  if(!graph) return 0;
+  if(graph->GetN() < 1) return 0;
+
   Int_t index=0;
   index = TMath::BinarySearch(graph->GetN(), graph->GetX(),xref);
   if (index<0) index=0;
-  if (index>=graph->GetN()-1) index=graph->GetN()-2;
-  if (xref-graph->GetX()[index]>graph->GetX()[index]-xref) index++;
-  dx = xref-graph->GetX()[index];
+  if(graph->GetN()==1) {
+    dx = xref-graph->GetX()[index];
+  }
+  else {
+    if (index>=graph->GetN()-1) index=graph->GetN()-2;
+    if (xref-graph->GetX()[index]>graph->GetX()[index]-xref) index++;
+    dx = xref-graph->GetX()[index];
+  }
   y  = graph->GetY()[index];
   return index;
 }
 
-
 Double_t  AliTPCcalibDButil::GetTriggerOffsetTPC(Int_t run, Int_t timeStamp, Double_t deltaT, Double_t deltaTLaser, Int_t valType){
   //
   // Get the correction of the trigger offset
@@ -1636,7 +1731,7 @@ Double_t  AliTPCcalibDButil::GetTriggerOffsetTPC(Int_t run, Int_t timeStamp, Dou
   //
   //
   const Float_t kLaserCut=0.0005;
-  const Int_t   kMaxPeriod=3600*24*30*3; // 3 month max
+  const Int_t   kMaxPeriod=3600*24*30*12; // one year max
   const Int_t   kMinPoints=20;
   //
   TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
@@ -1679,9 +1774,13 @@ Double_t  AliTPCcalibDButil::GetTriggerOffsetTPC(Int_t run, Int_t timeStamp, Dou
     nused++;
   }
   if (nused<kMinPoints &&deltaT<kMaxPeriod) return  AliTPCcalibDButil::GetTriggerOffsetTPC(run, timeStamp, deltaT*2,deltaTLaser);
+  if (nused<kMinPoints) {
+    printf("AliFatal: No time offset calibration available\n");
+    return 0;
+  }
   Double_t median = TMath::Median(nused,tdelta);
   Double_t mean  = TMath::Mean(nused,tdelta);
-  delete tdelta;
+  delete [] tdelta;
   return (valType==0) ? median:mean;
 }
 
@@ -1717,7 +1816,7 @@ Double_t  AliTPCcalibDButil::GetVDriftTPC(Double_t &dist, Int_t run, Int_t timeS
   AliTPCcalibDButil::GetNearest(cosmicAll,timeStamp,dist,grY);
 
   Double_t t0= AliTPCcalibDButil::GetTriggerOffsetTPC(run,timeStamp, deltaT, deltaTLaser,valType);
-  Double_t vcosmic=  AliTPCcalibDButil::EvalGraphConst(cosmicAll, timeStamp);
+  Double_t vcosmic =  AliTPCcalibDButil::EvalGraphConst(cosmicAll, timeStamp);
   if (timeStamp>cosmicAll->GetX()[cosmicAll->GetN()-1])  vcosmic=cosmicAll->GetY()[cosmicAll->GetN()-1];
   if (timeStamp<cosmicAll->GetX()[0])  vcosmic=cosmicAll->GetY()[0];
   return  vcosmic-t0;
@@ -1812,7 +1911,7 @@ Bool_t AliTPCcalibDButil::CreateGUIRefTree(const char* filename)
 
 Double_t  AliTPCcalibDButil::GetVDriftTPCLaserTracks(Double_t &dist, Int_t run, Int_t timeStamp, Double_t deltaT, Int_t side){
   //
-  // Get the correction of the drift velocity using the laser tracks calbration
+  // Get the correction of the drift velocity using the offline laser tracks calbration
   //
   // run       - run number
   // timeStamp - tim stamp in seconds
@@ -1820,6 +1919,56 @@ Double_t  AliTPCcalibDButil::GetVDriftTPCLaserTracks(Double_t &dist, Int_t run,
   // side      - 0 - A side,  1 - C side, 2 - mean from both sides
   // Note in case no data form both A and C side - the value from active side used
   TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
+
+  return GetVDriftTPCLaserTracksCommon(dist, timeStamp, deltaT, side, array);
+}
+
+Double_t  AliTPCcalibDButil::GetVDriftTPCLaserTracksOnline(Double_t &dist, Int_t /*run*/, Int_t timeStamp, Double_t deltaT, Int_t side){
+  //
+  // Get the correction of the drift velocity using the online laser tracks calbration
+  //
+  // run       - run number
+  // timeStamp - tim stamp in seconds
+  // deltaT    - integration period to calculate time0 offset
+  // side      - 0 - A side,  1 - C side, 2 - mean from both sides
+  // Note in case no data form both A and C side - the value from active side used
+  TObjArray *array =AliTPCcalibDB::Instance()->GetCEfitsDrift();
+
+  Double_t dv = GetVDriftTPCLaserTracksCommon(dist, timeStamp, deltaT, side, array);
+  AliTPCParam *param  =AliTPCcalibDB::Instance()->GetParameters();
+  if (!param) return 0;
+
+  //the drift velocity is hard wired in the AliTPCCalibCE class, since online there is no access to OCDB
+  dv*=param->GetDriftV()/2.61301900000000000e+06;
+  if (dv>1e-20) dv=1/dv-1;
+  else return 0;
+  // T/P correction
+  TObjArray*  cearray =AliTPCcalibDB::Instance()->GetCEData();
+  
+  AliTPCSensorTempArray *temp = (AliTPCSensorTempArray*)cearray->FindObject("TempMap");
+  AliDCSSensor *press         = (AliDCSSensor*)cearray->FindObject("CavernAtmosPressure");
+  
+  Double_t corrPTA=0;
+  Double_t corrPTC=0;
+  
+  if (temp&&press) {
+    AliTPCCalibVdrift corr(temp,press,0);
+    corrPTA=corr.GetPTRelative(timeStamp,0);
+    corrPTC=corr.GetPTRelative(timeStamp,1);
+  }
+  
+  if (side==0) dv -=  corrPTA;
+  if (side==1) dv -=  corrPTC;
+  if (side==2) dv -=  (corrPTA+corrPTC)/2;
+  
+  return dv;
+}
+
+Double_t  AliTPCcalibDButil::GetVDriftTPCLaserTracksCommon(Double_t &dist, Int_t timeStamp, Double_t deltaT,
+  Int_t side, TObjArray * const array){
+  //
+  // common drift velocity retrieval for online and offline method
+  //
   TGraphErrors *grlaserA=0;
   TGraphErrors *grlaserC=0;
   Double_t vlaserA=0, vlaserC=0;
@@ -1827,12 +1976,12 @@ Double_t  AliTPCcalibDButil::GetVDriftTPCLaserTracks(Double_t &dist, Int_t run,
   grlaserA=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DRIFT_LASER_ALL_A");
   grlaserC=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DRIFT_LASER_ALL_C");
   Double_t deltaY;
-  if (grlaserA) {
+  if (grlaserA && grlaserA->GetN()>0) {
     AliTPCcalibDButil::GetNearest(grlaserA,timeStamp,dist,deltaY);
     if (TMath::Abs(dist)>deltaT)  vlaserA= deltaY;
     else  vlaserA = AliTPCcalibDButil::EvalGraphConst(grlaserA,timeStamp);
   }
-  if (grlaserC) {
+  if (grlaserC && grlaserC->GetN()>0) {
     AliTPCcalibDButil::GetNearest(grlaserC,timeStamp,dist,deltaY);
     if (TMath::Abs(dist)>deltaT)  vlaserC= deltaY;
     else  vlaserC = AliTPCcalibDButil::EvalGraphConst(grlaserC,timeStamp);
@@ -1868,6 +2017,7 @@ Double_t  AliTPCcalibDButil::GetVDriftTPCCE(Double_t &dist,Int_t run, Int_t time
   Double_t gry=0;
   Double_t corrA=0, corrC=0;
   Double_t timeA=0, timeC=0;
+  const Double_t kEpsilon = 0.00001;
   TGraph *graphA = (TGraph*)arrT->At(72);
   TGraph *graphC = (TGraph*)arrT->At(73);
   if (!graphA && !graphC) return 0.;
@@ -1876,6 +2026,7 @@ Double_t  AliTPCcalibDButil::GetVDriftTPCCE(Double_t &dist,Int_t run, Int_t time
     timeA   = AliTPCcalibDButil::EvalGraphConst(graphA,timeStamp);
     Int_t mtime   =TMath::Nint((graphA->GetX()[0]+graphA->GetX()[graphA->GetN()-1])*0.5);
     ltime0A       = GetLaserTime0(run,mtime,TMath::Nint(deltaT),0);
+    if(ltime0A < kEpsilon) return 0;
     if (driftCalib) corrPTA =  driftCalib->GetPTRelative(timeStamp,0);
     corrA = (param->GetZLength(36)/(timeA*param->GetTSample()*(1.-ltime0A)-param->GetL1Delay()-0*param->GetZSigma()/param->GetDriftV()))/param->GetDriftV()-1;
     corrA-=corrPTA;
@@ -1885,7 +2036,8 @@ Double_t  AliTPCcalibDButil::GetVDriftTPCCE(Double_t &dist,Int_t run, Int_t time
     timeC=AliTPCcalibDButil::EvalGraphConst(graphC,timeStamp);
     Int_t mtime=TMath::Nint((graphC->GetX()[0]+graphC->GetX()[graphC->GetN()-1])*0.5);
     ltime0C       = GetLaserTime0(run,mtime,TMath::Nint(deltaT),0);
-    if (driftCalib) corrPTC =  driftCalib->GetPTRelative(timeStamp,0);
+    if(ltime0C < kEpsilon) return 0;   
+if (driftCalib) corrPTC =  driftCalib->GetPTRelative(timeStamp,0);
     corrC = (param->GetZLength(54)/(timeC*param->GetTSample()*(1.-ltime0C)-param->GetL1Delay()-0*param->GetZSigma()/param->GetDriftV()))/param->GetDriftV()-1;
     corrC-=corrPTC;
   }
@@ -1907,6 +2059,7 @@ Double_t  AliTPCcalibDButil::GetVDriftTPCITS(Double_t &dist, Int_t run, Int_t ti
   TGraphErrors *graph=0;
   dist=0;
   if (!array) return 0;
+  //array->ls();
   graph = (TGraphErrors*)array->FindObject("ALIGN_ITSB_TPC_DRIFTVD");
   if (!graph) return 0;
   Double_t deltaY;
@@ -2027,11 +2180,12 @@ TGraph* AliTPCcalibDButil::FilterGraphMedian(TGraph * graph, Float_t sigmaCut,Do
   Int_t npoints0 = graph->GetN();
   Int_t npoints=0;
   Float_t  rmsY=0;
-  Double_t *outx=new Double_t[npoints0];
-  Double_t *outy=new Double_t[npoints0];
   //
   //
   if (npoints0<kMinPoints) return 0;
+
+  Double_t *outx=new Double_t[npoints0];
+  Double_t *outy=new Double_t[npoints0];
   for (Int_t iter=0; iter<3; iter++){
     npoints=0;
     for (Int_t ipoint=0; ipoint<npoints0; ipoint++){
@@ -2047,6 +2201,8 @@ TGraph* AliTPCcalibDButil::FilterGraphMedian(TGraph * graph, Float_t sigmaCut,Do
   }
   TGraph *graphOut=0;
   if (npoints>1) graphOut= new TGraph(npoints,outx,outy); 
+  delete [] outx;
+  delete [] outy;
   return graphOut;
 }
 
@@ -2060,11 +2216,12 @@ TGraph* AliTPCcalibDButil::FilterGraphMedianAbs(TGraph * graph, Float_t cut,Doub
   Int_t npoints0 = graph->GetN();
   Int_t npoints=0;
   Float_t  rmsY=0;
-  Double_t *outx=new Double_t[npoints0];
-  Double_t *outy=new Double_t[npoints0];
   //
   //
   if (npoints0<kMinPoints) return 0;
+
+  Double_t *outx=new Double_t[npoints0];
+  Double_t *outy=new Double_t[npoints0];
   for (Int_t iter=0; iter<3; iter++){
     npoints=0;
     for (Int_t ipoint=0; ipoint<npoints0; ipoint++){
@@ -2080,6 +2237,8 @@ TGraph* AliTPCcalibDButil::FilterGraphMedianAbs(TGraph * graph, Float_t cut,Doub
   }
   TGraph *graphOut=0;
   if (npoints>1) graphOut= new TGraph(npoints,outx,outy); 
+  delete [] outx;
+  delete [] outy;
   return graphOut;
 }
 
@@ -2094,14 +2253,16 @@ TGraphErrors* AliTPCcalibDButil::FilterGraphMedianErr(TGraphErrors * const graph
   Int_t npoints0 = graph->GetN();
   Int_t npoints=0;
   Float_t  medianErr=0, rmsErr=0;
+  //
+  //
+  if (npoints0<kMinPoints) return 0;
+
   Double_t *outx=new Double_t[npoints0];
   Double_t *outy=new Double_t[npoints0];
   Double_t *erry=new Double_t[npoints0];
   Double_t *nerry=new Double_t[npoints0];
   Double_t *errx=new Double_t[npoints0];
-  //
-  //
-  if (npoints0<kMinPoints) return 0;
+
   for (Int_t iter=0; iter<3; iter++){
     npoints=0;
     for (Int_t ipoint=0; ipoint<npoints0; ipoint++){
@@ -2122,8 +2283,9 @@ TGraphErrors* AliTPCcalibDButil::FilterGraphMedianErr(TGraphErrors * const graph
   if (npoints>1) graphOut= new TGraphErrors(npoints,outx,outy,errx,erry); 
   delete []outx;
   delete []outy;
-  delete []errx;
   delete []erry;
+  delete []nerry;
+  delete []errx;
   return graphOut;
 }
 
@@ -2142,6 +2304,9 @@ void AliTPCcalibDButil::Sort(TGraph *graph){
   for (Int_t i=0;i<npoints;i++) graph->GetX()[i]=outx[i];
   for (Int_t i=0;i<npoints;i++) graph->GetY()[i]=outy[i];
  
+  delete [] indexes;
+  delete [] outx;
+  delete [] outy;
 }
 void AliTPCcalibDButil::SmoothGraph(TGraph *graph, Double_t delta){
   //
@@ -2195,12 +2360,39 @@ Double_t AliTPCcalibDButil::EvalGraphConst(TGraph * const graph, Double_t xref){
     printf("AliTPCcalibDButil::EvalGraphConst: 0 pointer\n");
     return 0;
   }
+
   if (graph->GetN()<1){
-    printf("AliTPCcalibDButil::EvalGraphConst: Empty graph");
+    printf("AliTPCcalibDButil::EvalGraphConst: Empty graph \n");
     return 0;
   }
+
   if (xref<graph->GetX()[0]) return graph->GetY()[0];
   if (xref>graph->GetX()[graph->GetN()-1]) return graph->GetY()[graph->GetN()-1]; 
+
+  //  printf("graph->Eval(graph->GetX()[0]) %f, graph->Eval(xref) %f \n",graph->Eval(graph->GetX()[0]), graph->Eval(xref));
+
+  if(graph->GetN()==1)
+    return graph->Eval(graph->GetX()[0]);
+
+
+  return graph->Eval(xref);
+}
+
+Double_t AliTPCcalibDButil::EvalGraphConst(AliSplineFit *graph, Double_t xref){
+  //
+  // Use constant interpolation outside of range also for spline fits
+  //
+  if (!graph) {
+    printf("AliTPCcalibDButil::EvalGraphConst: 0 pointer\n");
+    return 0;
+  }
+  if (graph->GetKnots()<1){
+    printf("AliTPCcalibDButil::EvalGraphConst: Empty graph");
+    return 0;
+  }
+  if (xref<graph->GetX()[0]) return graph->GetY0()[0];
+  if (xref>graph->GetX()[graph->GetKnots()-1]) return graph->GetY0()[graph->GetKnots()-1]; 
   return graph->Eval( xref);
 }
 
@@ -2243,6 +2435,8 @@ Float_t AliTPCcalibDButil::FilterSensor(AliDCSSensor * sensor, Double_t ymin, Do
   if (naccept<1) {
     delete fit;
     sensor->SetFit(0);
+    delete [] yin0;
+    delete [] yin1;
     return 0.;
   }
 
@@ -2335,12 +2529,13 @@ void AliTPCcalibDButil::FilterCE(Double_t deltaT, Double_t cutAbs, Double_t cutS
   //
   //
   AliTPCSensorTempArray *tempMapCE = (AliTPCSensorTempArray *)cearray->FindObject("TempMap");
-  AliDCSSensor * cavernPressureCE  = (AliDCSSensor *) cearray->FindObject("CavernPressure");
+  AliDCSSensor * cavernPressureCE  = (AliDCSSensor *) cearray->FindObject("CavernAtmosPressure");
   if ( tempMapCE && cavernPressureCE){
     //
-    Bool_t isOK = FilterTemperature(tempMapCE)>0.1;
-    FilterSensor(cavernPressureCE,960,1050,10, 5.);
-    if (cavernPressureCE->GetFit()==0) isOK=kFALSE;
+    //     Bool_t isOK = FilterTemperature(tempMapCE)>0.1;
+    //     FilterSensor(cavernPressureCE,960,1050,10, 5.);
+    //     if (cavernPressureCE->GetFit()==0) isOK=kFALSE;
+    Bool_t isOK=kTRUE;
     if (isOK)  {      
       // recalculate P/T correction map for time of the CE
       AliTPCCalibVdrift * driftCalib = new AliTPCCalibVdrift(tempMapCE,cavernPressureCE ,0);
@@ -2355,7 +2550,8 @@ void AliTPCcalibDButil::FilterCE(Double_t deltaT, Double_t cutAbs, Double_t cutS
 
   for (Int_t i=0; i<72;i++){
     TGraph *graph= (TGraph*)arrT->At(i);
-    if (!graph) continue;
+    if (!graph) continue; 
+    graph->Sort();
     if (graph->GetN()<kMinPoints){
       arrT->AddAt(0,i);
       delete graph;  // delete empty graph
@@ -2403,7 +2599,8 @@ void AliTPCcalibDButil::FilterCE(Double_t deltaT, Double_t cutAbs, Double_t cutS
     Double_t median = (isec%36<18) ? medianA: medianC;
     Double_t rms    = (isec%36<18) ? rmsA:    rmsC;
     Int_t naccept=0;
-    for (Int_t ipoint=kMinPoints-1; ipoint<graph->GetN();ipoint++){
+    //    for (Int_t ipoint=kMinPoints-1; ipoint<graph->GetN();ipoint++){ //not neccessary to remove first points
+    for (Int_t ipoint=0; ipoint<graph->GetN();ipoint++){
       if (TMath::Abs(graph->GetY()[ipoint]-median)>cutAbs) continue;
       if (TMath::Abs(graph->GetY()[ipoint]-median)>cutSigma*rms) continue;
       vecX[naccept]= graph->GetX()[ipoint];
@@ -2518,16 +2715,25 @@ void AliTPCcalibDButil::FilterTracks(Int_t run, Double_t cutSigma, TTreeSRedirec
   Double_t medianY=0;
   if (!arrT) return;
   for (Int_t i=0; i<arrT->GetEntries();i++){
-    TGraphErrors *graph= (TGraphErrors*)arrT->At(i);
+    TGraphErrors *graph= dynamic_cast<TGraphErrors*>(arrT->At(i));
     if (!graph) continue;
     if (graph->GetN()<kMinPoints){
       delete graph;
       arrT->AddAt(0,i);
       continue;
     }
-    TGraphErrors *graph2= FilterGraphMedianErr(graph,cutSigma,medianY);
-    if (!graph2) {
-      delete graph; arrT->AddAt(0,i); continue;
+    TGraphErrors *graph2 = NULL;
+    if(graph->GetN()<10) {
+      graph2 = new TGraphErrors(graph->GetN(),graph->GetX(),graph->GetY(),graph->GetEX(),graph->GetEY()); 
+      if (!graph2) {
+        delete graph; arrT->AddAt(0,i); continue;
+      }
+    } 
+    else {
+      graph2= FilterGraphMedianErr(graph,cutSigma,medianY);
+      if (!graph2) {
+        delete graph; arrT->AddAt(0,i); continue;
+      }
     }
     if (graph2->GetN()<1) {
       delete graph; arrT->AddAt(0,i); continue;
@@ -2806,7 +3012,8 @@ TMatrixD* AliTPCcalibDButil::MakeStatRelKalman(TObjArray * const array, Float_t
       (*valArray[ipar])[naccept]=state[ipar];
     naccept++;
   }
-  if (naccept<2) return 0;
+  //if (naccept<2) return 0;
+  if (naccept<1) return 0;
   TMatrixD *pstat=new TMatrixD(9,3);
   TMatrixD &stat=*pstat;
   for (Int_t ipar=0; ipar<9; ipar++){
@@ -2833,7 +3040,7 @@ TObjArray *AliTPCcalibDButil::SmoothRelKalman(TObjArray * const array, const TMa
   const Double_t kerrsTime[9]={
     0.00001,  0.00001, 0.00001,
     0.001,    0.001,   0.001,
-    0.0001,  0.001,   0.0001};
+    0.002,  0.01,   0.001};
   //
   //
   Int_t entries = array->GetEntriesFast();
@@ -2887,16 +3094,32 @@ TObjArray *AliTPCcalibDButil::SmoothRelKalman(TObjArray * const arrayP, TObjArra
   if (arrayP->GetEntries()<=0) return 0;
   if (!arrayM) return 0;
   if (arrayM->GetEntries()<=0) return 0;
+
   Int_t entries = arrayP->GetEntriesFast();
   TObjArray *array = new TObjArray(arrayP->GetEntriesFast()); 
+
   for (Int_t i=0; i<entries; i++){
      AliRelAlignerKalman * kalmanP = (AliRelAlignerKalman *) arrayP->UncheckedAt(i);
      AliRelAlignerKalman * kalmanM = (AliRelAlignerKalman *) arrayM->UncheckedAt(i);
      if (!kalmanP) continue;
      if (!kalmanM) continue;
-     AliRelAlignerKalman *kalman = new AliRelAlignerKalman(*kalmanP);
-     kalman->Merge(kalmanM);
+  
+     AliRelAlignerKalman *kalman = NULL;
+     if(kalmanP->GetRunNumber() != 0 && kalmanM->GetRunNumber() != 0) {
+       kalman = new AliRelAlignerKalman(*kalmanP);
+       kalman->Merge(kalmanM);
+     }
+     else if (kalmanP->GetRunNumber() == 0) {
+       kalman = new AliRelAlignerKalman(*kalmanM);
+     }
+     else if (kalmanM->GetRunNumber() == 0) {
+       kalman = new AliRelAlignerKalman(*kalmanP);
+     }
+     else 
+       continue;
+
      array->AddAt(kalman,i);
   }
+
   return array;
 }