Compatibility with the Root trunk
[u/mrichter/AliRoot.git] / TPC / AliTPCcalibTime.cxx
index 7a09e68..80af86e 100644 (file)
@@ -22,47 +22,6 @@ Comments to be written here:
 
   AliTPCcalibTime *calibTime = new AliTPCcalibTime("cosmicTime","cosmicTime",0, 1213.9e+06, 1213.96e+06, 0.04e+04, 0.04e+04);
 
-2. How to interpret results
-
-3. Simple example
-
-  a) determine the required time range:
-
-  AliXRDPROOFtoolkit tool;
-  TChain * chain = tool.MakeChain("pass2.txt","esdTree",0,6000);
-  chain->Draw("GetTimeStamp()")
-
-  b) analyse calibration object on Proof in calibration train 
-
-  AliTPCcalibTime *calibTime = new AliTPCcalibTime("cosmicTime","cosmicTime", StartTimeStamp, EndTimeStamp, IntegrationTimeVdrift);
-
-  c) plot results
-  .x ~/NimStyle.C
-  gSystem->Load("libANALYSIS");
-  gSystem->Load("libTPCcalib");
-
-  TFile f("CalibObjectsTrain1.root");
-  AliTPCcalibTime *calib = (AliTPCcalibTime *)f->Get("calibTime");
-  calib->GetHistoDrift("all")->Projection(2,0)->Draw()
-  calib->GetFitDrift("all")->Draw("lp")
-
-4. Analysis using debug streamers.    
-
-  gSystem->AddIncludePath("-I$ALICE_ROOT/TPC/macros");
-  gROOT->LoadMacro("$ALICE_ROOT/TPC/macros/AliXRDPROOFtoolkit.cxx+")
-  AliXRDPROOFtoolkit tool;
-  TChain * chainTime = tool.MakeChainRandom("time.txt","trackInfo",0,10000);
-
-  AliXRDPROOFtoolkit::FilterList("timetpctpc.txt","* tpctpc",1) 
-  AliXRDPROOFtoolkit::FilterList("timetoftpc.txt","* toftpc",1) 
-  AliXRDPROOFtoolkit::FilterList("timeitstpc.txt","* itstpc",1) 
-  AliXRDPROOFtoolkit::FilterList("timelaser.txt","* laserInfo",1)  
-  TChain * chainTPCTPC = tool.MakeChainRandom("timetpctpc.txt.Good","tpctpc",0,10000); 
-  TChain * chainTPCITS = tool.MakeChainRandom("timeitstpc.txt.Good","itstpc",0,10000); 
-  TChain * chainTPCTOF = tool.MakeChainRandom("timetoftpc.txt.Good","toftpc",0,10000); 
-  TChain * chainLaser = tool.MakeChainRandom("timelaser.txt.Good","laserInfo",0,10000);
-  chainTime->Lookup();
-  chainLaser->Lookup();
 */
 
 #include "Riostream.h"
@@ -97,18 +56,21 @@ Comments to be written here:
 #include "AliTrackPointArray.h"
 #include "AliTracker.h"
 #include "AliKFVertex.h"
+#include <AliLog.h>
+
 ClassImp(AliTPCcalibTime)
 
 
 AliTPCcalibTime::AliTPCcalibTime() 
-  :AliTPCcalibBase(), 
+  :AliTPCcalibBase(),  
+   fMemoryMode(1), // 0 -do not fill THnSparse with residuals  1- fill only important QA THn 2 - Fill all THnsparse for calibration
    fLaser(0),       // pointer to laser calibration
    fDz(0),          // current delta z
    fCutMaxD(3),        // maximal distance in rfi ditection
    fCutMaxDz(25),      // maximal distance in rfi ditection
    fCutTheta(0.03),    // maximal distan theta
    fCutMinDir(-0.99),  // direction vector products
-   fCutTracks(100),
+   fCutTracks(2500),
    fArrayLaserA(0),      //laser  fit parameters C
    fArrayLaserC(0),      //laser  fit parameters A
    fArrayDz(0),          //NEW! Tmap of V drifts for different triggers
@@ -152,17 +114,29 @@ AliTPCcalibTime::AliTPCcalibTime()
   for (Int_t i=0;i<12;i++) {
     fTPCVertex[i]=0;
   }
+  for (Int_t i=0;i<5;i++) {
+    fTPCVertexCorrelation[i]=0;
+  }
+  static Int_t counter=0;
+  if (1) {
+    TTimeStamp s;
+    Int_t time=s;
+    AliInfo(Form("Counter Constructor\t%d\t%d",counter,time));
+    counter++;
+  }
+
 }
 
-AliTPCcalibTime::AliTPCcalibTime(const Text_t *name, const Text_t *title, UInt_t StartTime, UInt_t EndTime, Int_t deltaIntegrationTimeVdrift)
+AliTPCcalibTime::AliTPCcalibTime(const Text_t *name, const Text_t *title, UInt_t StartTime, UInt_t EndTime, Int_t deltaIntegrationTimeVdrift, Int_t memoryMode)
   :AliTPCcalibBase(),
+   fMemoryMode(memoryMode), // 0 -do not fill THnSparse with residuals  1- fill only important QA THn 2 - Fill all THnsparse for calibration
    fLaser(0),            // pointer to laser calibration
    fDz(0),               // current delta z
    fCutMaxD(5*0.5356),   // maximal distance in rfi ditection
    fCutMaxDz(40),   // maximal distance in rfi ditection
    fCutTheta(5*0.004644),// maximal distan theta
    fCutMinDir(-0.99),    // direction vector products
-   fCutTracks(100),
+   fCutTracks(2500),
    fArrayLaserA(new TObjArray(1000)),      //laser  fit parameters C
    fArrayLaserC(new TObjArray(1000)),      //laser  fit parameters A
    fArrayDz(0),            //Tmap of V drifts for different triggers
@@ -278,6 +252,9 @@ AliTPCcalibTime::AliTPCcalibTime(const Text_t *name, const Text_t *title, UInt_t
   for (Int_t i=0;i<12;i++) {
     fTPCVertex[i]=0;
   }
+  for (Int_t i=0;i<5;i++) {
+    fTPCVertexCorrelation[i]=0;
+  }
   BookDistortionMaps();
   
 }
@@ -286,6 +263,13 @@ AliTPCcalibTime::~AliTPCcalibTime(){
   //
   // Virtual Destructor
   //
+  static Int_t counter=0;
+  if (1) {
+    TTimeStamp s;
+    Int_t time=s;
+    AliInfo(Form("Counter Destructor\t%s\t%d\t%d",GetName(),counter,time));
+    counter++;
+  }
   for(Int_t i=0;i<3;i++){
     if(fHistVdriftLaserA[i]){
       delete fHistVdriftLaserA[i];
@@ -302,7 +286,7 @@ AliTPCcalibTime::~AliTPCcalibTime(){
     delete fArrayDz;
     fArrayDz=NULL;
   }
-  for(Int_t i=0;i<5;i++){
+  for(Int_t i=0;i<10;i++){
     if(fCosmiMatchingHisto[i]){
       delete fCosmiMatchingHisto[i];
       fCosmiMatchingHisto[i]=NULL;
@@ -322,43 +306,60 @@ AliTPCcalibTime::~AliTPCcalibTime(){
     fResHistoTPCvertex[i]=0;
   }
 
-  if (fTPCVertex) {
-    for (Int_t i=0;i<12;i++)  delete fTPCVertex[i];
+  for (Int_t i=0;i<12;i++) if (fTPCVertex[i]) delete fTPCVertex[i];
+  for (Int_t i=0;i<5;i++)  if (fTPCVertexCorrelation[i]) delete fTPCVertexCorrelation[i];
+
+  if (fAlignITSTPC){
+    fAlignITSTPC->SetOwner(kTRUE);
+    fAlignTRDTPC->SetOwner(kTRUE);
+    fAlignTOFTPC->SetOwner(kTRUE);
+    
+    fAlignITSTPC->Delete();
+    fAlignTRDTPC->Delete();
+    fAlignTOFTPC->Delete();
+    delete fAlignITSTPC;
+    delete fAlignTRDTPC;
+    delete fAlignTOFTPC;
   }
-  
-  fAlignITSTPC->SetOwner(kTRUE);
-  fAlignTRDTPC->SetOwner(kTRUE);
-  fAlignTOFTPC->SetOwner(kTRUE);
 
-  fAlignITSTPC->Delete();
-  fAlignTRDTPC->Delete();
-  fAlignTOFTPC->Delete();
-  delete fAlignITSTPC;
-  delete fAlignTRDTPC;
-  delete fAlignTOFTPC;
-}
+  if (fArrayLaserA) {
+    fArrayLaserA->SetOwner(); 
+    fArrayLaserA->Delete();
+    delete fArrayLaserA;
+  }
 
-Bool_t AliTPCcalibTime::IsLaser(const AliESDEvent *const /*event*/){
-  //
-  // Indicator is laser event not yet implemented  - to be done using trigger info or event specie
-  //
-  return kTRUE; //More accurate creteria to be added
-}
-Bool_t AliTPCcalibTime::IsCosmics(const AliESDEvent *const /*event*/){
-  //
-  // Indicator is cosmic event not yet implemented - to be done using trigger info or event specie
-  //
+  if (fArrayLaserA) {
+    fArrayLaserC->SetOwner(); 
+    fArrayLaserC->Delete();
+    delete fArrayLaserC;
+  }
 
-  return kTRUE; //More accurate creteria to be added
 }
-Bool_t AliTPCcalibTime::IsBeam(const AliESDEvent *const /*event*/){
-  //
-  // Indicator is physic event not yet implemented - to be done using trigger info or event specie
-  //
 
-  return kTRUE; //More accurate creteria to be added
-}
+// Bool_t AliTPCcalibTime::IsLaser(const AliESDEvent *const /*event*/) const{
+//   //
+//   // Indicator is laser event not yet implemented  - to be done using trigger info or event specie
+//   //
+//   return kTRUE; //More accurate creteria to be added
+// }
+// Bool_t AliTPCcalibTime::IsCosmics(const AliESDEvent *const /*event*/){
+//   //
+//   // Indicator is cosmic event not yet implemented - to be done using trigger info or event specie
+//   //
+
+//   return kTRUE; //More accurate creteria to be added
+// }
+// Bool_t AliTPCcalibTime::IsBeam(const AliESDEvent *const /*event*/) const{
+//   //
+//   // Indicator is physic event not yet implemented - to be done using trigger info or event specie
+//   //
+
+//   return kTRUE; //More accurate creteria to be added
+// }
 void AliTPCcalibTime::ResetCurrent(){
+  //
+  //ResetCurrent
+  //
   fDz=0; //Reset current dz
 }
 
@@ -369,11 +370,20 @@ void AliTPCcalibTime::Process(AliESDEvent *event){
   // main function to make calibration
   //
   if(!event) return;
-  if (event->GetNumberOfTracks()<2) return;
+  if (event->GetNumberOfTracks()<2) return; 
+  AliESDfriend *ESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  if (!ESDfriend) {
+    return;
+  }
+  if (ESDfriend->TestSkipBit()) return;
+  
   ResetCurrent();
-  if(IsLaser  (event)) ProcessLaser (event);
-  if(IsCosmics(event)) ProcessCosmic(event);
-  if(IsBeam   (event)) ProcessBeam  (event);
+  //if(IsLaser  (event)) 
+  ProcessLaser (event);
+  //if(IsCosmics(event)) 
+  ProcessCosmic(event);
+  //if(IsBeam   (event)) 
+  ProcessBeam  (event);
 }
 
 void AliTPCcalibTime::ProcessLaser(AliESDEvent *event){
@@ -449,7 +459,7 @@ void AliTPCcalibTime::ProcessLaser(AliESDEvent *event){
   //
   // fill histos
   //
-  TVectorD vdriftA(5), vdriftC(5),vdriftAC(5);
+  TVectorD vdriftA(5), vdriftC(5),vdriftAC(6);
   vdriftA=*(fLaser->fFitAside);
   vdriftC=*(fLaser->fFitCside);
   vdriftAC=*(fLaser->fFitACside);
@@ -750,23 +760,33 @@ void AliTPCcalibTime::ProcessCosmic(const AliESDEvent *const event){
 
 void AliTPCcalibTime::ProcessBeam(const AliESDEvent *const event){
   //
-  //
+  // Process beam data - calculates vartex
+  //                     from A side and C side
+  // Histogram the differences                 
   // 
   const Int_t kMinClusters  =80;
-  const Int_t kMinTracks    =2;    // minimal number of tracks to define the vertex
+  const Int_t kMinTracks    =2;      // minimal number of tracks to define the vertex
+  const Int_t kMinTracksVertex=30;   // minimal number of tracks to define the cumulative vertex
   const Double_t kMaxTgl    =1.2;    // maximal Tgl (z angle)
-  const Double_t kMinPt     =0.2;  // minimal pt
-  const Double_t kMaxD0     =10;   // cut on distance to the primary vertex first guess
+  const Double_t kMinPt     =0.2;    // minimal pt
+  const Double_t kMaxD0     =5.;     // cut on distance to the primary vertex first guess
   const Double_t kMaxZ0     =20; 
-  const Double_t kMaxD      =5;    // cut on distance to the primary vertex 
-  const Double_t kMaxZ      =4;    // maximal z distance between tracks form the same side
-  const Double_t kMaxChi2   =15;   // maximal chi2 of the TPCvertex 
-  const Double_t kCumulCovarXY=0.01; //increase the error of cumul vertex 100 microns profile
-  const Double_t kCumulCovarZ=250.; //increase the error of cumul vertex
+  const Double_t kMaxD      =2.5;    // cut on distance to the primary vertex 
+  const Double_t kMaxZ      =4;      // maximal z distance between tracks form the same side
+  const Double_t kMaxChi2   =15;     // maximal chi2 of the TPCvertex 
+  const Double_t kCumulCovarXY=0.003; //increase the error of cumul vertex 30 microns profile
+  const Double_t kCumulCovarZ=250.;  //increase the error of cumul vertex
+  const Double_t kMaxDvertex = 1.0;  // cut to accept the vertex; 
+  //
+  Int_t  flags=0;
+  const  Int_t  kBuffSize=100;
+  static Double_t deltaZ[kBuffSize]={0};
+  static Int_t counterZ=0;
+  static AliKFVertex cumulVertexA, cumulVertexC, cumulVertexAC; // cumulative vertex 
+  AliKFVertex vertexA, vertexC;
 
   Float_t  dca0[2]={0,0};
   Double_t dcaVertex[2]={0,0};
-
   Int_t ntracks=event->GetNumberOfTracks();
   if (ntracks==0) return;
   if (ntracks > fCutTracks) return;
@@ -816,20 +836,15 @@ void AliTPCcalibTime::ProcessBeam(const AliESDEvent *const event){
       }
     }
   }
-  Double_t medianZA=TMath::Median(ntracksA, vertexZA);
-  Double_t medianZC=TMath::Median(ntracksC, vertexZC);
-  Int_t flags=0;
-  static Double_t deltaZ[1000]={0};
-  static Int_t counterZ=0;
-  static AliKFVertex cumulVertexA, cumulVertexC, cumulVertexAC; // cumulative vertex 
-  AliKFVertex vertexA, vertexC;
+  Double_t medianZA=TMath::Median(ntracksA, vertexZA);  // tracks median
+  Double_t medianZC=TMath::Median(ntracksC, vertexZC);  // tracks median
   //
   ntracksA= tracksA.GetEntriesFast();
   ntracksC= tracksC.GetEntriesFast();
   if (ntracksA>kMinTracks && ntracksC>kMinTracks){
-    deltaZ[counterZ%1000]=medianZA-medianZC;
+    deltaZ[counterZ%kBuffSize]=medianZA-medianZC;
     counterZ+=1;
-    Double_t medianDelta=(counterZ>=1000)? TMath::Median(1000, deltaZ): TMath::Median(counterZ, deltaZ);
+    Double_t medianDelta=(counterZ>=kBuffSize)? TMath::Median(kBuffSize, deltaZ): TMath::Median(counterZ, deltaZ);
     if (TMath::Abs(medianDelta-(medianZA-medianZC))>kMaxZ) flags+=16;
     // increse the error of cumulative vertex at the beginning of event
     cumulVertexA.Covariance(0,0)+=kCumulCovarXY*kCumulCovarXY;
@@ -848,8 +863,6 @@ void AliTPCcalibTime::ProcessBeam(const AliESDEvent *const event){
       if (TMath::Abs(aliTrack->GetZ()-medianZA)>kMaxZ) continue;
       AliKFParticle part(*aliTrack,211);
       vertexA+=part;
-      cumulVertexA+=part;
-      cumulVertexAC+=part;
     }  
     for (Int_t iC=0; iC<ntracksC; iC++){
       if (flags!=0) continue;
@@ -857,46 +870,90 @@ void AliTPCcalibTime::ProcessBeam(const AliESDEvent *const event){
       if (TMath::Abs(aliTrack->GetZ()-medianZC)>kMaxZ) continue;
       AliKFParticle part(*aliTrack,211);
       vertexC+=part;
-      cumulVertexC+=part;
-      cumulVertexAC+=part;
     }   
+    //
     if (vertexA.GetNDF()<kMinTracks) flags+=32;
     if (vertexC.GetNDF()<kMinTracks) flags+=32;
     if (TMath::Abs(vertexA.Z()-medianZA)>kMaxZ) flags+=1;   //apply cuts
     if (TMath::Abs(vertexC.Z()-medianZC)>kMaxZ) flags+=2;
     if (TMath::Abs(vertexA.GetChi2()/vertexA.GetNDF()+vertexC.GetChi2()/vertexC.GetNDF())> kMaxChi2) flags+=4;
-    if (flags==0 &&cumulVertexC.GetNDF()>20&&cumulVertexA.GetNDF()){
-      Double_t cont[2]={0,fTime};
-      //
-      cont[0]= cumulVertexA.X();
-      fTPCVertex[0]->Fill(cont);
-      cont[0]= cumulVertexC.X();
-      fTPCVertex[1]->Fill(cont);
-      cont[0]= 0.5*(cumulVertexA.X()-cumulVertexC.X());
-      fTPCVertex[2]->Fill(cont);
-      cont[0]= 0.5*(cumulVertexA.X()+cumulVertexC.X())-vertex->GetX();
-      fTPCVertex[3]->Fill(cont);
-      //
-      cont[0]= cumulVertexA.Y();
-      fTPCVertex[4]->Fill(cont);
-      cont[0]= cumulVertexC.Y();
-      fTPCVertex[5]->Fill(cont);
-      cont[0]= 0.5*(cumulVertexA.Y()-cumulVertexC.Y());
-      fTPCVertex[6]->Fill(cont);
-      cont[0]= 0.5*(cumulVertexA.Y()+cumulVertexC.Y())-vertex->GetY();
-      fTPCVertex[7]->Fill(cont);
+    //
+    if (flags==0){
+      for (Int_t iA=0; iA<ntracksA; iA++){
+       if (flags!=0) continue;
+       AliExternalTrackParam *aliTrack =  (AliExternalTrackParam *)tracksA.At(iA);
+       if (TMath::Abs(aliTrack->GetZ()-medianZA)>kMaxZ) continue;
+       AliKFParticle part(*aliTrack,211);
+       cumulVertexA+=part;
+       cumulVertexAC+=part;
+      }        
+      for (Int_t iC=0; iC<ntracksC; iC++){
+       if (flags!=0) continue;
+       AliExternalTrackParam *aliTrack =  (AliExternalTrackParam *)tracksC.At(iC);
+       if (TMath::Abs(aliTrack->GetZ()-medianZC)>kMaxZ) continue;
+       AliKFParticle part(*aliTrack,211);
+       cumulVertexC+=part;
+       cumulVertexAC+=part;
+      }             
       //
+      if (TMath::Abs(cumulVertexA.X()-vertexA.X())>kMaxDvertex) flags+=64;
+      if (TMath::Abs(cumulVertexA.Y()-vertexA.Y())>kMaxDvertex) flags+=64;
+      if (TMath::Abs(cumulVertexA.Z()-vertexA.Z())>kMaxDvertex) flags+=64;
       //
-      cont[0]= 0.5*(cumulVertexA.Z()+cumulVertexC.Z());
-      fTPCVertex[8]->Fill(cont);
-      cont[0]= 0.5*(cumulVertexA.Z()-cumulVertexC.Z());
-      fTPCVertex[9]->Fill(cont);
-      cont[0]= 0.5*(cumulVertexA.Z()-cumulVertexC.Z());
-      fTPCVertex[10]->Fill(cont);      
-      cont[0]= 0.5*(cumulVertexA.Z()+cumulVertexC.Z())-vertex->GetZ();
-      fTPCVertex[11]->Fill(cont);
-    }
-    //        
+      if (TMath::Abs(cumulVertexC.X()-vertexC.X())>kMaxDvertex) flags+=64;
+      if (TMath::Abs(cumulVertexC.Y()-vertexC.Y())>kMaxDvertex) flags+=64;
+      if (TMath::Abs(cumulVertexC.Z()-vertexC.Z())>kMaxDvertex) flags+=64;
+      
+      
+      if ( flags==0 && cumulVertexC.GetNDF()>kMinTracksVertex&&cumulVertexA.GetNDF()>kMinTracksVertex){
+       Double_t cont[2]={0,fTime};
+       //
+       cont[0]= cumulVertexA.X();
+       fTPCVertex[0]->Fill(cont);
+       cont[0]= cumulVertexC.X();
+       fTPCVertex[1]->Fill(cont);
+       cont[0]= 0.5*(cumulVertexA.X()-cumulVertexC.X());
+       fTPCVertex[2]->Fill(cont);
+       cont[0]= 0.5*(cumulVertexA.X()+cumulVertexC.X())-vertexSPD->GetX();
+       fTPCVertex[3]->Fill(cont);
+       //
+       cont[0]= cumulVertexA.Y();
+       fTPCVertex[4]->Fill(cont);
+       cont[0]= cumulVertexC.Y();
+       fTPCVertex[5]->Fill(cont);
+       cont[0]= 0.5*(cumulVertexA.Y()-cumulVertexC.Y());
+       fTPCVertex[6]->Fill(cont);
+       cont[0]= 0.5*(cumulVertexA.Y()+cumulVertexC.Y())-vertexSPD->GetY();
+       fTPCVertex[7]->Fill(cont);
+       //
+       //
+       cont[0]= 0.5*(cumulVertexA.Z()+cumulVertexC.Z());
+       fTPCVertex[8]->Fill(cont);
+       cont[0]= 0.5*(cumulVertexA.Z()-cumulVertexC.Z());
+       fTPCVertex[9]->Fill(cont);
+       cont[0]= 0.5*(cumulVertexA.Z()-cumulVertexC.Z());
+       fTPCVertex[10]->Fill(cont);      
+       cont[0]= 0.5*(cumulVertexA.Z()+cumulVertexC.Z())-vertexSPD->GetZ();
+       fTPCVertex[11]->Fill(cont);
+       //
+       Double_t correl[2]={0,0};
+       //
+       correl[0]=cumulVertexC.Z();
+       correl[1]=cumulVertexA.Z();
+       fTPCVertexCorrelation[0]->Fill(correl);   // fill A side :TPC
+       correl[0]=cumulVertexA.Z();
+       correl[1]=cumulVertexC.Z(); 
+       fTPCVertexCorrelation[1]->Fill(correl);   // fill C side :TPC
+       //
+       correl[0]=vertexSPD->GetZ();
+       correl[1]=cumulVertexA.Z()-correl[0];
+       fTPCVertexCorrelation[2]->Fill(correl);   // fill A side :ITS
+       correl[1]=cumulVertexC.Z()-correl[0]; 
+       fTPCVertexCorrelation[3]->Fill(correl);   // fill C side :ITS
+       correl[1]=0.5*(cumulVertexA.Z()+cumulVertexC.Z())-correl[0]; 
+       fTPCVertexCorrelation[4]->Fill(correl);   // fill C side :ITS
+      }
+    }        
     TTreeSRedirector *cstream = GetDebugStreamer();
     if (cstream){
       /*
@@ -906,8 +963,8 @@ void AliTPCcalibTime::ProcessBeam(const AliESDEvent *const event){
        tree->Draw("sqrt(vA.fChi2/vA.fNDF)","sqrt(vA.fChi2/vA.fNDF)<100","")
        
       */
-      vertexA.Print();
-      vertexC.Print();      
+      //vertexA.Print();
+      //vertexC.Print();      
       (*cstream)<<"vertexTPC"<<
        "flags="<<flags<<        // rejection flags
        "vSPD.="<<vertexSPD<<    // SPD vertex
@@ -951,7 +1008,7 @@ THnSparse* AliTPCcalibTime::GetHistoDrift(const char* name) const
   THnSparse* newHist=new THnSparseF(newName,"HistVdrift;time;p/T ratio;Vdrift;run",4,fBinsVdrift,fXminVdrift,fXmaxVdrift);
   THnSparse* addHist=NULL;
   while((addHist=(THnSparseF*)iterator->Next())){
-  if(!addHist) continue;
+    //  if(!addHist) continue;
     TString histName=addHist->GetName();
     if(!histName.Contains(newName)) continue;
     addHist->Print();
@@ -1031,7 +1088,7 @@ Long64_t AliTPCcalibTime::Merge(TCollection *const li) {
   //
   TIterator* iter = li->MakeIterator();
   AliTPCcalibTime* cal = 0;
-
+  //
   while ((cal = (AliTPCcalibTime*)iter->Next())) {
     if (!cal->InheritsFrom(AliTPCcalibTime::Class())) {
       Error("Merge","Attempt to add object of class %s to a %s", cal->ClassName(), this->ClassName());
@@ -1044,34 +1101,45 @@ Long64_t AliTPCcalibTime::Merge(TCollection *const li) {
       }
     }
     //
-    if (fTPCVertex && cal->fTPCVertex) 
+    if (fTPCVertexCorrelation[0] && cal->fTPCVertexCorrelation[0]){
+      for (Int_t imeas=0; imeas<5; imeas++){
+       if (fTPCVertexCorrelation[imeas] && cal->fTPCVertexCorrelation[imeas]) fTPCVertexCorrelation[imeas]->Add(cal->fTPCVertexCorrelation[imeas]);
+      }
+    }
+      
+    if (fTPCVertex[0] && cal->fTPCVertex[0]) 
       for (Int_t imeas=0; imeas<12; imeas++){
-       fTPCVertex[imeas]->Add(cal->fTPCVertex[imeas]);
+       if (fTPCVertex[imeas] && cal->fTPCVertex[imeas]) fTPCVertex[imeas]->Add(cal->fTPCVertex[imeas]);
       }
     
-    for (Int_t imeas=0; imeas<5; imeas++){
-      if (cal->GetResHistoTPCCE(imeas) && cal->GetResHistoTPCCE(imeas)){
-       fResHistoTPCCE[imeas]->Add(cal->fResHistoTPCCE[imeas]);
-      }else{
-        fResHistoTPCCE[imeas]=(THnSparse*)cal->fResHistoTPCCE[imeas]->Clone();
+    if (fMemoryMode>0) for (Int_t imeas=0; imeas<5; imeas++){
+      if (fMemoryMode>1){
+       if ( cal->GetResHistoTPCCE(imeas) && cal->GetResHistoTPCCE(imeas)){
+         fResHistoTPCCE[imeas]->Add(cal->fResHistoTPCCE[imeas]);
+       }else{
+         fResHistoTPCCE[imeas]=(THnSparse*)cal->fResHistoTPCCE[imeas]->Clone();
+       }
       }
-      if (cal->GetResHistoTPCITS(imeas) && cal->GetResHistoTPCITS(imeas)){
-       fResHistoTPCITS[imeas]->Add(cal->fResHistoTPCITS[imeas]);
-       fResHistoTPCvertex[imeas]->Add(cal->fResHistoTPCvertex[imeas]);
+      //
+      if ((fMemoryMode>0) &&cal->GetResHistoTPCITS(imeas) && cal->GetResHistoTPCITS(imeas)){
+       if (fMemoryMode>1 || (imeas%2)==1) fResHistoTPCITS[imeas]->Add(cal->fResHistoTPCITS[imeas]);
+       if (fMemoryMode>1) fResHistoTPCvertex[imeas]->Add(cal->fResHistoTPCvertex[imeas]);
       }
-      if (cal->fResHistoTPCTRD[imeas]){
+      //
+      if ((fMemoryMode>1) && cal->fResHistoTPCTRD[imeas]){
        if (fResHistoTPCTRD[imeas])
          fResHistoTPCTRD[imeas]->Add(cal->fResHistoTPCTRD[imeas]);
        else
          fResHistoTPCTRD[imeas]=(THnSparse*)cal->fResHistoTPCTRD[imeas]->Clone();
       }
-      if  (cal->fResHistoTPCTOF[imeas]){
+      //
+      if  ((fMemoryMode>1) && cal->fResHistoTPCTOF[imeas]){
        if (fResHistoTPCTOF[imeas])
          fResHistoTPCTOF[imeas]->Add(cal->fResHistoTPCTOF[imeas]);
        else
          fResHistoTPCTOF[imeas]=(THnSparse*)cal->fResHistoTPCTOF[imeas]->Clone();      
       }
-
+      //
       if (cal->fArrayLaserA){
        fArrayLaserA->Expand(fArrayLaserA->GetEntriesFast()+cal->fArrayLaserA->GetEntriesFast());
        fArrayLaserC->Expand(fArrayLaserC->GetEntriesFast()+cal->fArrayLaserC->GetEntriesFast());
@@ -1082,26 +1150,28 @@ Long64_t AliTPCcalibTime::Merge(TCollection *const li) {
       }
 
     }
-    TObjArray* addArray=cal->GetHistoDrift();
-    if(!addArray) return 0;
-    TIterator* iterator = addArray->MakeIterator();
-    iterator->Reset();
-    THnSparse* addHist=NULL;
-    while((addHist=(THnSparseF*)iterator->Next())){
-      if(!addHist) continue;
-      addHist->Print();
-      THnSparse* localHist=(THnSparseF*)fArrayDz->FindObject(addHist->GetName());
-      if(!localHist){
-        localHist=new THnSparseF(addHist->GetName(),"HistVdrift;time;p/T ratio;Vdrift;run",4,fBinsVdrift,fXminVdrift,fXmaxVdrift);
-        fArrayDz->AddLast(localHist);
-      }
-      localHist->Add(addHist);
-    }
-
+//     TObjArray* addArray=cal->GetHistoDrift();
+//     if(!addArray) return 0;
+//     TIterator* iterator = addArray->MakeIterator();
+//     iterator->Reset();
+//     THnSparse* addHist=NULL;
+//     if ((fMemoryMode>1)) while((addHist=(THnSparseF*)iterator->Next())){
+//       //      if(!addHist) continue;
+//       addHist->Print();
+//       THnSparse* localHist=(THnSparseF*)fArrayDz->FindObject(addHist->GetName());
+//       if(!localHist){
+//         localHist=new THnSparseF(addHist->GetName(),"HistVdrift;time;p/T ratio;Vdrift;run",4,fBinsVdrift,fXminVdrift,fXmaxVdrift);
+//         fArrayDz->AddLast(localHist);
+//       }
+//       localHist->Add(addHist);
+//     }
+//     delete iterator;
     for(Int_t i=0;i<10;i++) if (cal->GetCosmiMatchingHisto(i)) fCosmiMatchingHisto[i]->Add(cal->GetCosmiMatchingHisto(i));
     //
     // Merge alignment
     //
+    const Int_t kMinUpdates=10;
+    const Float_t kMaxOut=0.1;
     for (Int_t itype=0; itype<3; itype++){
       //
       //
@@ -1119,6 +1189,8 @@ Long64_t AliTPCcalibTime::Merge(TCollection *const li) {
        AliRelAlignerKalman *kalman1 = (AliRelAlignerKalman *)arr1->UncheckedAt(i);
        AliRelAlignerKalman *kalman0 = (AliRelAlignerKalman *)arr0->UncheckedAt(i);
        if (!kalman1)  continue;
+       if (kalman1->GetNUpdates()<kMinUpdates) continue;
+       if (kalman1->GetNOutliers()>(kalman1->GetNUpdates()*kMaxOut)) continue;
        if (!kalman0) {arr0->AddAt(new AliRelAlignerKalman(*kalman1),i); continue;}
        kalman0->SetRejectOutliers(kFALSE);
        kalman0->Merge(kalman1);
@@ -1126,10 +1198,11 @@ Long64_t AliTPCcalibTime::Merge(TCollection *const li) {
     }
 
   }
+  delete iter;
   return 0;
 }
 
-Bool_t  AliTPCcalibTime::IsPair(AliExternalTrackParam *tr0, AliExternalTrackParam *tr1){
+Bool_t  AliTPCcalibTime::IsPair(const AliExternalTrackParam *tr0, const AliExternalTrackParam *tr1){
   /*
   // 0. Same direction - OPOSITE  - cutDir +cutT    
   TCut cutDir("cutDir","dir<-0.99")
@@ -1166,7 +1239,7 @@ Bool_t  AliTPCcalibTime::IsPair(AliExternalTrackParam *tr0, AliExternalTrackPara
 
   return kTRUE;  
 }
-Bool_t AliTPCcalibTime::IsCross(AliESDtrack *const tr0, AliESDtrack *const tr1){
+Bool_t AliTPCcalibTime::IsCross(const AliESDtrack *const tr0, const AliESDtrack *const tr1){
   //
   // check if the cosmic pair of tracks crossed A/C side
   // 
@@ -1176,7 +1249,7 @@ Bool_t AliTPCcalibTime::IsCross(AliESDtrack *const tr0, AliESDtrack *const tr1){
   return result;
 }
 
-Bool_t AliTPCcalibTime::IsSame(AliESDtrack *const tr0, AliESDtrack *const tr1){
+Bool_t AliTPCcalibTime::IsSame(const AliESDtrack *const tr0, const AliESDtrack *const tr1){
   // 
   // track crossing the CE
   // 0. minimal number of clusters 
@@ -1229,7 +1302,7 @@ Bool_t AliTPCcalibTime::IsSame(AliESDtrack *const tr0, AliESDtrack *const tr1){
 }
 
 
-void  AliTPCcalibTime::ProcessSame(AliESDtrack *const track, AliESDfriendTrack *const friendTrack, const AliESDEvent *const event){
+void  AliTPCcalibTime::ProcessSame(const AliESDtrack *const track, AliESDfriendTrack *const friendTrack, const AliESDEvent *const event){
   //
   // Process  TPC tracks crossing CE
   //
@@ -1293,7 +1366,7 @@ void  AliTPCcalibTime::ProcessSame(AliESDtrack *const track, AliESDfriendTrack *
     Double_t r[3]={cl->GetX(),cl->GetY(),cl->GetZ()};
     trackIn.GetXYZ(xyz);
     bz = AliTracker::GetBz(xyz);
-    AliTracker::PropagateTrackToBxByBz(&trackIn,r[0],1.,pimass,kFALSE);
+    AliTracker::PropagateTrackToBxByBz(&trackIn,r[0],pimass,1.,kFALSE);
     if (!trackIn.PropagateTo(r[0],bz)) break;
     nclIn++;
     trackIn.Update(&r[1],cov);    
@@ -1322,7 +1395,7 @@ void  AliTPCcalibTime::ProcessSame(AliESDtrack *const track, AliESDfriendTrack *
     Double_t r[3]={cl->GetX(),cl->GetY(),cl->GetZ()};
     trackOut.GetXYZ(xyz);
     bz = AliTracker::GetBz(xyz);
-    AliTracker::PropagateTrackToBxByBz(&trackOut,r[0],1.,pimass,kFALSE);
+    AliTracker::PropagateTrackToBxByBz(&trackOut,r[0],pimass,1.,kFALSE);
     if (!trackOut.PropagateTo(r[0],bz)) break;
     nclOut++;
     trackOut.Update(&r[1],cov);    
@@ -1392,7 +1465,7 @@ void  AliTPCcalibTime::ProcessSame(AliESDtrack *const track, AliESDfriendTrack *
 
 }
 
-void  AliTPCcalibTime::ProcessAlignITS(AliESDtrack *const track, AliESDfriendTrack *const friendTrack, const AliESDEvent *const event, AliESDfriend *const esdFriend){
+void  AliTPCcalibTime::ProcessAlignITS(AliESDtrack *const track, const AliESDfriendTrack *const friendTrack, const AliESDEvent *const event, AliESDfriend *const esdFriend){
   //
   // Process track - Update TPC-ITS alignment
   // Updates: 
@@ -1405,28 +1478,23 @@ void  AliTPCcalibTime::ProcessAlignITS(AliESDtrack *const track, AliESDfriendTra
   const Int_t    kMinITS  = 3;     // minimal number of ITS cluster
   const Double_t kMinZ    = 10;    // maximal dz distance
   const Double_t kMaxDy   = 2.;    // maximal dy distance
-  const Double_t kMaxAngle= 0.05;  // maximal angular distance
+  const Double_t kMaxAngle= 0.07;  // maximal angular distance
   const Double_t kSigmaCut= 5;     // maximal sigma distance to median
   const Double_t kVdErr   = 0.1;  // initial uncertainty of the vd correction 
   const Double_t kT0Err   = 3.;  // initial uncertainty of the T0 time
   const Double_t kVdYErr  = 0.05;  // initial uncertainty of the vd correction 
-  const Double_t kOutCut  = 1.0;   // outlyer cut in AliRelAlgnmentKalman
+  const Double_t kOutCut  = 3.0;   // outlyer cut in AliRelAlgnmentKalman
   const Double_t kMinPt   = 0.3;   // minimal pt
+  const Double_t kMax1Pt=0.5;        //maximal 1/pt distance
   const  Int_t     kN=50;         // deepnes of history
   static Int_t     kglast=0;
   static Double_t* kgdP[4]={new Double_t[kN], new Double_t[kN], new Double_t[kN], new Double_t[kN]};
-  /*
-    0. Standrd cuts:
-    TCut cut="abs(pTPC.fP[2]-pITS.fP[2])<0.01&&abs(pTPC.fP[3]-pITS.fP[3])<0.01&&abs(pTPC.fP[2]-pITS.fP[2])<1";
-  */
   //
   // 0. Apply standard cuts
-  //
+  // 
   Int_t dummycl[1000];
   if (track->GetTPCNcls()<kMinTPC) return;  // minimal amount of clusters cut
-  if (track->GetITSclusters(dummycl)<kMinITS) return;  // minimal amount of clusters
   if (!track->IsOn(AliESDtrack::kTPCrefit)) return;
-  if (!friendTrack->GetITSOut()) return;  
   if (!track->GetInnerParam())   return;
   if (!track->GetOuterParam())   return;
   if (track->GetInnerParam()->Pt()<kMinPt)  return;
@@ -1436,11 +1504,14 @@ void  AliTPCcalibTime::ProcessAlignITS(AliESDtrack *const track, AliESDfriendTra
   if (track->GetInnerParam()->GetX()>90)   return;
   //
   AliExternalTrackParam &pTPC=(AliExternalTrackParam &)(*(track->GetInnerParam()));
-  AliExternalTrackParam pITS(*(friendTrack->GetITSOut()));   // ITS standalone if possible
-  AliExternalTrackParam pITS2(*(friendTrack->GetITSOut()));  //TPC-ITS track
-  pITS2.Rotate(pTPC.GetAlpha());
-  //  pITS2.PropagateTo(pTPC.GetX(),fMagF);
-  AliTracker::PropagateTrackToBxByBz(&pITS2,pTPC.GetX(),0.1,0.1,kFALSE);
+  //  
+  AliExternalTrackParam pITS;   // ITS standalone if possible
+  AliExternalTrackParam pITS2;  //TPC-ITS track
+  if (friendTrack->GetITSOut()){
+    pITS2=(*(friendTrack->GetITSOut()));  //TPC-ITS track - snapshot ITS out
+    pITS2.Rotate(pTPC.GetAlpha());
+    AliTracker::PropagateTrackToBxByBz(&pITS2,pTPC.GetX(),0.1,0.1,kFALSE);
+  }
 
   AliESDfriendTrack *itsfriendTrack=0;
   //
@@ -1449,21 +1520,27 @@ void  AliTPCcalibTime::ProcessAlignITS(AliESDtrack *const track, AliESDfriendTra
   Bool_t hasAlone=kFALSE;
   Int_t ntracks=event->GetNumberOfTracks();
   for (Int_t i=0; i<ntracks; i++){
-    AliESDtrack *trackS = event->GetTrack(i);
-    if (trackS->GetTPCNcls()>0) continue;   //continue if has TPC info
+    AliESDtrack * trackITS = event->GetTrack(i); 
+    if (!trackITS) continue;
+    if (trackITS->GetITSclusters(dummycl)<kMinITS) continue;  // minimal amount of clusters
     itsfriendTrack = esdFriend->GetTrack(i);
     if (!itsfriendTrack) continue;
     if (!itsfriendTrack->GetITSOut()) continue;
-    if (TMath::Abs(pITS2.GetTgl()-itsfriendTrack->GetITSOut()->GetTgl())> kMaxAngle) continue;
+     
+    if (TMath::Abs(pTPC.GetTgl()-itsfriendTrack->GetITSOut()->GetTgl())> kMaxAngle) continue;
+    if (TMath::Abs(pTPC.GetSigned1Pt()-itsfriendTrack->GetITSOut()->GetSigned1Pt())> kMax1Pt) continue;
     pITS=(*(itsfriendTrack->GetITSOut()));
     //
     pITS.Rotate(pTPC.GetAlpha());
-    //pITS.PropagateTo(pTPC.GetX(),fMagF);
     AliTracker::PropagateTrackToBxByBz(&pITS,pTPC.GetX(),0.1,0.1,kFALSE);
-    if (TMath::Abs(pITS2.GetY()-pITS.GetY())> kMaxDy) continue;
+    if (TMath::Abs(pTPC.GetY()-pITS.GetY())> kMaxDy) continue;
+    if (TMath::Abs(pTPC.GetSnp()-pITS.GetSnp())> kMaxAngle) continue;
     hasAlone=kTRUE;
   }
-  if (!hasAlone) pITS=pITS2;
+  if (!hasAlone) {
+    if (track->GetITSclusters(dummycl)<kMinITS) return;
+    pITS=pITS2;  // use combined track if it has ITS
+  }
   //
   if (TMath::Abs(pITS.GetY()-pTPC.GetY())    >kMaxDy)    return;
   if (TMath::Abs(pITS.GetSnp()-pTPC.GetSnp())>kMaxAngle) return;
@@ -1511,7 +1588,9 @@ void  AliTPCcalibTime::ProcessAlignITS(AliESDtrack *const track, AliESDfriendTra
     (*align->GetStateCov())(7,7)=kT0Err*kT0Err;
     (*align->GetStateCov())(8,8)=kVdYErr*kVdYErr;
     align->SetOutRejSigma(kOutCut+kOutCut*kN);
-    align->SetRejectOutliers(kFALSE);
+    //    align->SetRejectOutliers(kFALSE);
+    align->SetRejectOutliers(kTRUE);
+    align->SetRejectOutliersSigma2Median(kTRUE);
 
     align->SetTPCvd(AliTPCcalibDB::Instance()->GetParameters()->GetDriftV()/1000000.);
     align->SetMagField(fMagF); 
@@ -1533,8 +1612,11 @@ void  AliTPCcalibTime::ProcessAlignITS(AliESDtrack *const track, AliESDfriendTra
   }
   //
   Int_t nupdates=align->GetNUpdates();
-  align->SetOutRejSigma(kOutCut+kOutCut*kN/Double_t(nupdates));
-  align->SetRejectOutliers(kFALSE);
+  align->SetOutRejSigma(kOutCut+kOutCut*kN/Double_t(nupdates+1));
+  //  align->SetRejectOutliers(kFALSE);
+  align->SetRejectOutliers(kTRUE);
+  align->SetRejectOutliersSigma2Median(kTRUE);
+
   TTreeSRedirector *cstream = GetDebugStreamer();  
   if (cstream && align->GetState() && align->GetState()->GetNrows()>2 ){
     TVectorD gpTPC(3), gdTPC(3);
@@ -1557,7 +1639,6 @@ void  AliTPCcalibTime::ProcessAlignITS(AliESDtrack *const track, AliESDfriendTra
       "vRMS.="<<&vecRMS<<       // rms of deltas
       "vDelta.="<<&vecDelta<<   // delta in respect to median
       "vDeltaN.="<<&vecDeltaN<< // normalized delta in respect to median
-      "t.="<<track<<            // ful track - find proper cuts
       "a.="<<align<<            // current alignment
       "pITS.="<<&pITS<<         // track param ITS 
       "pITS2.="<<&pITS2<<       // track param ITS+TPC
@@ -1573,7 +1654,7 @@ void  AliTPCcalibTime::ProcessAlignITS(AliESDtrack *const track, AliESDfriendTra
 
 
 
-void  AliTPCcalibTime::ProcessAlignTRD(AliESDtrack *const track, AliESDfriendTrack *const friendTrack){
+void  AliTPCcalibTime::ProcessAlignTRD(AliESDtrack *const track, const AliESDfriendTrack *const friendTrack){
   //
   // Process track - Update TPC-TRD alignment
   // Updates: 
@@ -1583,16 +1664,16 @@ void  AliTPCcalibTime::ProcessAlignTRD(AliESDtrack *const track, AliESDfriendTra
   // 3. Update kalman filter
   //
   const Int_t    kMinTPC  = 80;    // minimal number of TPC cluster
-  const Int_t    kMinTRD  = 50;    // minimal number of TRD cluster
-  const Double_t kMinZ    = 20;    // maximal dz distance
+  const Int_t    kMinTRD  = 60;    // minimal number of TRD cluster
+  //  const Double_t kMinZ    = 20;    // maximal dz distance
   const Double_t kMaxDy   = 5.;    // maximal dy distance
   const Double_t kMaxAngle= 0.1;  // maximal angular distance
   const Double_t kSigmaCut= 10;     // maximal sigma distance to median
   const Double_t kVdErr   = 0.1;  // initial uncertainty of the vd correction 
   const Double_t kT0Err   = 3.;  // initial uncertainty of the T0 time
   const Double_t kVdYErr  = 0.05;  // initial uncertainty of the vd correction 
-  const Double_t kOutCut  = 1.0;   // outlyer cut in AliRelAlgnmentKalman
-  const Double_t kRefX    = 275;   // reference X
+  const Double_t kOutCut  = 3.0;   // outlyer cut in AliRelAlgnmentKalman
+  const Double_t kRefX    = 330;   // reference X
   const  Int_t     kN=50;         // deepnes of history
   static Int_t     kglast=0;
   static Double_t* kgdP[4]={new Double_t[kN], new Double_t[kN], new Double_t[kN], new Double_t[kN]};
@@ -1602,18 +1683,25 @@ void  AliTPCcalibTime::ProcessAlignTRD(AliESDtrack *const track, AliESDfriendTra
   Int_t dummycl[1000];
   if (track->GetTRDclusters(dummycl)<kMinTRD) return;  // minimal amount of clusters
   if (track->GetTPCNcls()<kMinTPC) return;  // minimal amount of clusters cut
-  if (!friendTrack->GetTRDIn()) return;  
-  if (!track->IsOn(AliESDtrack::kTRDrefit)) return;  
+  //  if (!friendTrack->GetTRDIn()) return;  
+  //  if (!track->IsOn(AliESDtrack::kTRDrefit)) return;   
   if (!track->IsOn(AliESDtrack::kTRDout)) return;  
   if (!track->GetInnerParam())   return;
   if (!friendTrack->GetTPCOut())   return;
   // exclude crossing track
   if (friendTrack->GetTPCOut()->GetZ()*track->GetInnerParam()->GetZ()<0)   return;
-  if (TMath::Abs(track->GetInnerParam()->GetZ())<kMinZ)   return;
   //
   AliExternalTrackParam &pTPC=(AliExternalTrackParam &)(*(friendTrack->GetTPCOut()));
   AliTracker::PropagateTrackToBxByBz(&pTPC,kRefX,0.1,0.1,kFALSE);
-  AliExternalTrackParam pTRD(*(friendTrack->GetTRDIn()));
+  AliExternalTrackParam *pTRDtrack = 0; 
+  TObject *calibObject=0;
+  for (Int_t l=0;(calibObject=((AliESDfriendTrack*)friendTrack)->GetCalibObject(l));++l) {
+    if ((dynamic_cast< AliTPCseed*>(calibObject))) continue;
+    if ((pTRDtrack=dynamic_cast< AliExternalTrackParam*>(calibObject))) break;
+  }
+  if (!pTRDtrack) return;
+  //  AliExternalTrackParam pTRD(*(friendTrack->GetTRDIn()));
+  AliExternalTrackParam pTRD(*(pTRDtrack));
   pTRD.Rotate(pTPC.GetAlpha());
   //  pTRD.PropagateTo(pTPC.GetX(),fMagF);
   AliTracker::PropagateTrackToBxByBz(&pTRD,pTPC.GetX(),0.1,0.1,kFALSE);
@@ -1669,7 +1757,10 @@ void  AliTPCcalibTime::ProcessAlignTRD(AliESDtrack *const track, AliESDfriendTra
     (*align->GetStateCov())(7,7)=kT0Err*kT0Err;
     (*align->GetStateCov())(8,8)=kVdYErr*kVdYErr;
     align->SetOutRejSigma(kOutCut+kOutCut*kN);
-    align->SetRejectOutliers(kFALSE);
+    //    align->SetRejectOutliers(kFALSE);
+    align->SetRejectOutliers(kTRUE);
+    align->SetRejectOutliersSigma2Median(kTRUE);
+
     align->SetTPCvd(AliTPCcalibDB::Instance()->GetParameters()->GetDriftV()/1000000.);
     align->SetMagField(fMagF); 
     fAlignTRDTPC->AddAt(align,htime);
@@ -1693,8 +1784,11 @@ void  AliTPCcalibTime::ProcessAlignTRD(AliESDtrack *const track, AliESDfriendTra
   }
   //
   Int_t nupdates=align->GetNUpdates();
-  align->SetOutRejSigma(kOutCut+kOutCut*kN/Double_t(nupdates));
-  align->SetRejectOutliers(kFALSE);
+  align->SetOutRejSigma(kOutCut+kOutCut*kN/Double_t(nupdates+1));
+  //  align->SetRejectOutliers(kFALSE);
+  align->SetRejectOutliers(kTRUE);
+  align->SetRejectOutliersSigma2Median(kTRUE);
+
   TTreeSRedirector *cstream = GetDebugStreamer();  
   if (cstream && align->GetState() && align->GetState()->GetNrows()>2 ){
     TVectorD gpTPC(3), gdTPC(3);
@@ -1728,7 +1822,7 @@ void  AliTPCcalibTime::ProcessAlignTRD(AliESDtrack *const track, AliESDfriendTra
 }
 
 
-void  AliTPCcalibTime::ProcessAlignTOF(AliESDtrack *const track, AliESDfriendTrack *const friendTrack){
+void  AliTPCcalibTime::ProcessAlignTOF(AliESDtrack *const track, const AliESDfriendTrack *const friendTrack){
   //
   //
   // Process track - Update TPC-TOF alignment
@@ -1748,7 +1842,7 @@ void  AliTPCcalibTime::ProcessAlignTOF(AliESDtrack *const track, AliESDfriendTra
   const Double_t   kT0Err   = 3.;  // initial uncertainty of the T0 time
   const Double_t   kVdYErr  = 0.05;  // initial uncertainty of the vd correction 
 
-  const Double_t   kOutCut  = 1.0;   // outlyer cut in AliRelAlgnmentKalman
+  const Double_t   kOutCut  = 3.0;   // outlyer cut in AliRelAlgnmentKalman
   const  Int_t     kN=50;         // deepnes of history
   static Int_t     kglast=0;
   static Double_t* kgdP[4]={new Double_t[kN], new Double_t[kN], new Double_t[kN], new Double_t[kN]};
@@ -1846,7 +1940,10 @@ void  AliTPCcalibTime::ProcessAlignTOF(AliESDtrack *const track, AliESDfriendTra
     (*align->GetStateCov())(7,7)=kT0Err*kT0Err;
     (*align->GetStateCov())(8,8)=kVdYErr*kVdYErr;
     align->SetOutRejSigma(kOutCut+kOutCut*kN);
-    align->SetRejectOutliers(kFALSE);
+    //    align->SetRejectOutliers(kFALSE);
+    align->SetRejectOutliers(kTRUE);
+    align->SetRejectOutliersSigma2Median(kTRUE);
+
     align->SetTPCvd(AliTPCcalibDB::Instance()->GetParameters()->GetDriftV()/1000000.);
     align->SetMagField(fMagF); 
     fAlignTOFTPC->AddAt(align,htime);
@@ -1870,8 +1967,11 @@ void  AliTPCcalibTime::ProcessAlignTOF(AliESDtrack *const track, AliESDfriendTra
   align->SetRunNumber(fRun );
   //
   Int_t nupdates=align->GetNUpdates();
-  align->SetOutRejSigma(kOutCut+kOutCut*kN/Double_t(nupdates));
-  align->SetRejectOutliers(kFALSE);
+  align->SetOutRejSigma(kOutCut+kOutCut*kN/Double_t(nupdates+1));
+  //  align->SetRejectOutliers(kFALSE);
+  align->SetRejectOutliers(kTRUE);
+  align->SetRejectOutliersSigma2Median(kTRUE);
+
   TTreeSRedirector *cstream = GetDebugStreamer();  
   if (cstream && align->GetState() && align->GetState()->GetNrows()>2 ){
     TVectorD gpTPC(3), gdTPC(3);
@@ -1951,7 +2051,7 @@ void  AliTPCcalibTime::BookDistortionMaps(){
   fResHistoTPCTOF[0] = new THnSparseS("TPCTOF#Delta_{Y} (cm)","#Delta_{Y} (cm)", 4, binsTrack,xminTrack, xmaxTrack);
   //
   // delta z
-  xminTrack[0] =-3.; xmaxTrack[0]=3.;  // 
+  xminTrack[0] =-6.; xmaxTrack[0]=6.;  // 
   fResHistoTPCCE[1] = new THnSparseS("TPCCE#Delta_{Z} (cm)","#Delta_{Z} (cm)",    5, binsTrack,xminTrack, xmaxTrack);
   fResHistoTPCITS[1] = new THnSparseS("TPCITS#Delta_{Z} (cm)","#Delta_{Z} (cm)",    4, binsTrack,xminTrack, xmaxTrack);
   fResHistoTPCvertex[1]    = new THnSparseS("TPCVertex#Delta_{Z} (cm)","#Delta_{Z} (cm)", 4, binsTrack,xminTrack, xmaxTrack);
@@ -1968,7 +2068,7 @@ void  AliTPCcalibTime::BookDistortionMaps(){
   fResHistoTPCTOF[2] = new THnSparseS("TPCTOF#Delta_{#phi}","#Delta_{#phi}", 4, binsTrack,xminTrack, xmaxTrack);
   //
   // delta theta-P3
-  xminTrack[0] =-0.025; xmaxTrack[0]=0.025;  // 
+  xminTrack[0] =-0.05; xmaxTrack[0]=0.05;  // 
   fResHistoTPCCE[3] = new THnSparseS("TPCCE#Delta_{#theta}","#Delta_{#theta}",    5, binsTrack,xminTrack, xmaxTrack);
   fResHistoTPCITS[3] = new THnSparseS("TPCITS#Delta_{#theta}","#Delta_{#theta}",    4, binsTrack,xminTrack, xmaxTrack);
   fResHistoTPCvertex[3] = new THnSparseS("TPCITSv#Delta_{#theta}","#Delta_{#theta}",    4, binsTrack,xminTrack, xmaxTrack);
@@ -2016,6 +2116,16 @@ void  AliTPCcalibTime::BookDistortionMaps(){
     fTPCVertex[ihis]->GetAxis(1)->SetTitle("Time");
     fTPCVertex[ihis]->GetAxis(0)->SetTitle(anames[ihis]);
   }
+  
+  Int_t    binsVertexC[2]={40, 300};
+  Double_t aminVertexC[2]={-20,-30};
+  Double_t amaxVertexC[2]={20,30};
+  const char* hnamesC[5]={"TPCA_TPC","TPCC_TPC","TPCA_ITS","TPCC_ITS","TPC_ITS"};
+  for (Int_t ihis=0; ihis<5; ihis++) {
+    fTPCVertexCorrelation[ihis]=new THnSparseF(hnamesC[ihis],hnamesC[ihis],2,binsVertexC,aminVertexC,amaxVertexC);
+    fTPCVertexCorrelation[ihis]->GetAxis(1)->SetTitle("z (cm)");
+    fTPCVertexCorrelation[ihis]->GetAxis(0)->SetTitle("z (cm)");
+  }
 }
 
 
@@ -2024,6 +2134,7 @@ void        AliTPCcalibTime::FillResHistoTPCCE(const AliExternalTrackParam * pTP
   // fill residual histograms pTPCOut-pTPCin - trac crossing CE
   // Histogram 
   //
+  if (fMemoryMode<2) return;
   Double_t histoX[5];
   Double_t xyz[3];
   pTPCIn->GetXYZ(xyz);
@@ -2069,11 +2180,13 @@ void        AliTPCcalibTime::FillResHistoTPC(const AliESDtrack * pTrack){
   // fill residual histograms pTPC - vertex
   // Histogram is filled only for primary tracks
   //
+  if (fMemoryMode<2) return;
   Double_t histoX[4];
   const AliExternalTrackParam * pTPCIn = pTrack->GetInnerParam();
   AliExternalTrackParam pTPCvertex(*(pTrack->GetInnerParam()));
   //
-  AliExternalTrackParam lits(*pTrack);
+  if (!(pTrack->GetConstrainedParam())) return;
+  AliExternalTrackParam lits(*(pTrack->GetConstrainedParam()));
   if (TMath::Abs(pTrack->GetY())>3) return;  // beam pipe
   pTPCvertex.Rotate(lits.GetAlpha());
   //pTPCvertex.PropagateTo(pTPCvertex->GetX(),fMagF);
@@ -2100,6 +2213,7 @@ void        AliTPCcalibTime::FillResHistoTPCTRD(const AliExternalTrackParam * pT
   //
   // fill resuidual histogram TPCout-TRDin
   //
+  if (fMemoryMode<2) return;
   Double_t histoX[4];
   Double_t xyz[3];
   pTPCOut->GetXYZ(xyz);
@@ -2124,6 +2238,7 @@ void        AliTPCcalibTime::FillResHistoTPCTOF(const AliExternalTrackParam * pT
   //
   // fill resuidual histogram TPCout-TOFin
   // track propagated to the TOF position
+  if (fMemoryMode<2) return;
   Double_t histoX[4];
   Double_t xyz[3];