When Pt is bad defined (ex. no field), the multiple scattering effect is calculated...
[u/mrichter/AliRoot.git] / HLT / TPCLib / tracking-ca / AliTPCtrackerCA.cxx
index 294ae6a..1654b2f 100644 (file)
@@ -1,6 +1,6 @@
 // $Id$
-//***************************************************************************
-// This file is property of and copyright by the ALICE HLT Project          * 
+// **************************************************************************
+// This file is property of and copyright by the ALICE HLT Project          *
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
 // Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
@@ -14,6 +14,7 @@
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
 #include "AliTPCtrackerCA.h"
 //#include "AliCluster.h"
 #include "AliTPCClustersRow.h"
 #include "AliTPCParam.h"
+#include "AliTPCClusterParam.h"
+
 #include "AliRun.h"
 #include "AliRunLoader.h"
 #include "AliStack.h"
 
-#include "AliHLTTPCCAGBTracker.h"
-#include "AliHLTTPCCAGBHit.h"
-#include "AliHLTTPCCAGBTrack.h"
 #include "AliHLTTPCCAPerformance.h"
 #include "AliHLTTPCCAParam.h"
 #include "AliHLTTPCCATrackConvertor.h"
 #include "AliHLTTPCCATracker.h"
+#include "AliHLTTPCCAStandaloneFramework.h"
 
 #include "TMath.h"
 #include "AliTPCLoader.h"
 #include "AliTPCTransform.h"
 #include "AliTPCcalibDB.h"
 #include "AliTPCtrack.h"
+#include "AliTPCseed.h"
 #include "AliESDtrack.h"
 #include "AliESDEvent.h"
 #include "AliTrackReference.h"
 #include "TStopwatch.h"
+#include "AliTPCReconstructor.h"
+#include "AliHLTTPCCAMergerOutput.h"
 
 //#include <fstream.h>
 
-ClassImp(AliTPCtrackerCA)
+ClassImp( AliTPCtrackerCA )
 
 AliTPCtrackerCA::AliTPCtrackerCA()
-  :AliTracker(),fParam(0), fClusters(0), fNClusters(0), fHLTTracker(0),fHLTPerformance(0),fDoHLTPerformance(0),fDoHLTPerformanceClusters(0),fStatNEvents(0)
+    : AliTracker(), fkParam( 0 ), fClusters( 0 ), fClusterSliceRow( 0 ), fNClusters( 0 ), fDoHLTPerformance( 0 ), fDoHLTPerformanceClusters( 0 ), fStatCPUTime( 0 ), fStatRealTime( 0 ), fStatNEvents( 0 )
 {
   //* default constructor
 }
 
-AliTPCtrackerCA::AliTPCtrackerCA(const AliTPCtrackerCA &):
-  AliTracker(),fParam(0), fClusters(0), fNClusters(0), fHLTTracker(0),fHLTPerformance(0),fDoHLTPerformance(0),fDoHLTPerformanceClusters(0),fStatNEvents(0)
+AliTPCtrackerCA::AliTPCtrackerCA( const AliTPCtrackerCA & ):
+    AliTracker(), fkParam( 0 ), fClusters( 0 ), fClusterSliceRow( 0 ), fNClusters( 0 ), fDoHLTPerformance( 0 ), fDoHLTPerformanceClusters( 0 ), fStatCPUTime( 0 ), fStatRealTime( 0 ), fStatNEvents( 0 )
 {
   //* dummy
 }
 
-AliTPCtrackerCA & AliTPCtrackerCA::operator=(const AliTPCtrackerCA& )
+const AliTPCtrackerCA & AliTPCtrackerCA::operator=( const AliTPCtrackerCA& ) const
 {
-  //* dummy 
+  //* dummy
   return *this;
 }
 
 
-AliTPCtrackerCA::~AliTPCtrackerCA() 
+AliTPCtrackerCA::~AliTPCtrackerCA()
 {
   //* destructor
-  if( fClusters ) delete[] fClusters;
-  if( fHLTTracker ) delete fHLTTracker;
-  if( fHLTPerformance ) delete fHLTPerformance;
+  delete[] fClusters;
+  delete[] fClusterSliceRow;
 }
 
-AliTPCtrackerCA::AliTPCtrackerCA(const AliTPCParam *par): 
-  AliTracker(),fParam(par), fClusters(0), fNClusters(0), fHLTTracker(0), fHLTPerformance(0),fDoHLTPerformance(0),fDoHLTPerformanceClusters(0),fStatNEvents(0)
+//#include "AliHLTTPCCADisplay.h"
+
+AliTPCtrackerCA::AliTPCtrackerCA( const AliTPCParam *par ):
+    AliTracker(), fkParam( par ), fClusters( 0 ), fClusterSliceRow( 0 ), fNClusters( 0 ), fDoHLTPerformance( 0 ), fDoHLTPerformanceClusters( 0 ), fStatCPUTime( 0 ), fStatRealTime( 0 ), fStatNEvents( 0 )
 {
   //* constructor
-  DoHLTPerformance() = 1;
-  DoHLTPerformanceClusters() = 0;
 
-  fHLTTracker = new AliHLTTPCCAGBTracker;
-  fHLTTracker->SetNSlices( fParam->GetNSector()/2 );
+  fDoHLTPerformance = 0;
+  fDoHLTPerformanceClusters = 0;
+
+  AliHLTTPCCAStandaloneFramework &hlt = AliHLTTPCCAStandaloneFramework::Instance();
 
-  if( fDoHLTPerformance ){
-    fHLTPerformance = new AliHLTTPCCAPerformance;
-    fHLTPerformance->SetTracker( fHLTTracker );
-  }
 
-  for( int iSlice=0; iSlice<fHLTTracker->NSlices(); iSlice++ ){
-  
-    Float_t bz = AliTracker::GetBz();
-
-    Float_t inRmin = fParam->GetInnerRadiusLow();
-    //Float_t inRmax = fParam->GetInnerRadiusUp();
-    //Float_t outRmin = fParam->GetOuterRadiusLow(); 
-    Float_t outRmax = fParam->GetOuterRadiusUp();
-    Float_t plusZmin = 0.0529937; 
-    Float_t plusZmax = 249.778; 
-    Float_t minusZmin = -249.645; 
-    Float_t minusZmax = -0.0799937; 
-    Float_t dalpha = 0.349066;
-    Float_t alpha = 0.174533 + dalpha*iSlice;
-    
-    Bool_t zPlus = (iSlice<18 );
-    Float_t zMin =  zPlus ?plusZmin :minusZmin;
-    Float_t zMax =  zPlus ?plusZmax :minusZmax;
-    //TPCZmin = -249.645, ZMax = 249.778    
-    //Float_t rMin =  inRmin;
-    //Float_t rMax =  outRmax;
-        
-    Float_t padPitch = 0.4;
-    Float_t sigmaZ = 0.228808;
-
-    Int_t nRows = fParam->GetNRowLow()+fParam->GetNRowUp();
-    Float_t rowX[200];
-    for( Int_t irow=0; irow<fParam->GetNRowLow(); irow++){
-      rowX[irow] = fParam->GetPadRowRadiiLow(irow);
-    }     
-    for( Int_t irow=0; irow<fParam->GetNRowUp(); irow++){
-      rowX[fParam->GetNRowLow()+irow] = fParam->GetPadRowRadiiUp(irow);
+  for ( int iSlice = 0; iSlice < hlt.NSlices(); iSlice++ ) {
+
+    float bz = AliTracker::GetBz();
+
+    float inRmin = fkParam->GetInnerRadiusLow();
+    //float inRmax = fkParam->GetInnerRadiusUp();
+    //float outRmin = fkParam->GetOuterRadiusLow();
+    float outRmax = fkParam->GetOuterRadiusUp();
+    float plusZmin = 0.0529937;
+    float plusZmax = 249.778;
+    float minusZmin = -249.645;
+    float minusZmax = -0.0799937;
+    float dalpha = 0.349066;
+    float alpha = 0.174533 + dalpha * iSlice;
+
+    bool zPlus = ( iSlice < 18 );
+    float zMin =  zPlus ? plusZmin : minusZmin;
+    float zMax =  zPlus ? plusZmax : minusZmax;
+    //TPCZmin = -249.645, ZMax = 249.778
+    //float rMin =  inRmin;
+    //float rMax =  outRmax;
+
+    float padPitch = 0.4;
+    float sigmaZ = 0.228808;
+
+    int nRows = fkParam->GetNRowLow() + fkParam->GetNRowUp();
+    float rowX[200];
+    for ( int irow = 0; irow < fkParam->GetNRowLow(); irow++ ) {
+      rowX[irow] = fkParam->GetPadRowRadiiLow( irow );
+    }
+    for ( int irow = 0; irow < fkParam->GetNRowUp(); irow++ ) {
+      rowX[fkParam->GetNRowLow()+irow] = fkParam->GetPadRowRadiiUp( irow );
     }
     AliHLTTPCCAParam param;
     param.Initialize( iSlice, nRows, rowX, alpha, dalpha,
-                     inRmin, outRmax, zMin, zMax, padPitch, sigmaZ, bz );
-    param.YErrorCorrection() = 1.;// .33;
-    param.ZErrorCorrection() = 1.;//.33;
-    param.MaxTrackMatchDRow() = 5;
-    param.TrackConnectionFactor() = 3.5;
-    fHLTTracker->Slices()[iSlice].Initialize( param ); 
+                      inRmin, outRmax, zMin, zMax, padPitch, sigmaZ, bz );
+    param.SetHitPickUpFactor( 1. );
+    param.SetMaxTrackMatchDRow( 5 );
+    param.SetTrackConnectionFactor( 3.5 );
+
+    AliTPCClusterParam * clparam = AliTPCcalibDB::Instance()->GetClusterParam();
+    for ( int iRow = 0; iRow < nRows; iRow++ ) {
+      int    type = ( iRow < 63 ) ? 0 : ( ( iRow > 126 ) ? 1 : 2 );
+      for ( int iyz = 0; iyz < 2; iyz++ ) {
+        for ( int k = 0; k < 7; k++ ) {
+          //std::cout<<param.fParamS0Par[iyz][type][k]<<" "<<clparam->fParamS0Par[iyz][type][k] - param.fParamS0Par[iyz][type][k]<<std::endl;
+          param.SetParamS0Par( iyz, type, k, clparam->fParamS0Par[iyz][type][k] );
+        }
+      }
+    }
+    //hlt.SliceTracker( iSlice ).Initialize( param );
+       hlt.InitializeSliceParam(iSlice, param);
   }
 }
 
 
 
-Int_t AliTPCtrackerCA::LoadClusters (TTree * fromTree)
-{ 
+int AliTPCtrackerCA::LoadClusters ( TTree * fromTree )
+{
   // load clusters to the local arrays
   fNClusters = 0;
-  if( fClusters ) delete[] fClusters;
+  delete[] fClusters;
+  delete[] fClusterSliceRow;
 
-  fHLTTracker->StartEvent();
-  if( fDoHLTPerformance ) fHLTPerformance->StartEvent();
+  AliHLTTPCCAStandaloneFramework &hlt = AliHLTTPCCAStandaloneFramework::Instance();
 
-  if( !fParam ) return 1;
+  if ( fDoHLTPerformance ) {
+    AliHLTTPCCAPerformance::Instance().StartEvent();
+    if ( fDoHLTPerformanceClusters ) AliHLTTPCCAPerformance::Instance().SetDoClusterPulls( 1 );
+  }
+
+  if ( !fkParam ) return 1;
 
   // load mc tracks
-  while( fDoHLTPerformance ){
-    if( !gAlice ) break;
-    AliRunLoader *rl = gAlice->GetRunLoader(); 
-    if( !rl ) break;
+  while ( fDoHLTPerformance ) {
+    if ( !gAlice ) break;
+#ifndef HAVE_NOT_ALIRUNLOADER30859
+    AliRunLoader *rl = AliRunLoader::Instance();//gAlice->GetRunLoader();
+#else
+    // the old way before rev 30859
+    AliRunLoader *rl = AliRunLoader::GetRunLoader();
+#endif
+    if ( !rl ) break;
     rl->LoadKinematics();
     AliStack *stack = rl->Stack();
-    if( !stack ) break;
+    if ( !stack ) break;
+
+    AliHLTTPCCAPerformance::Instance().SetNMCTracks( stack->GetNtrack() );
 
-    fHLTPerformance->SetNMCTracks( stack->GetNtrack() );
-    
-    for( Int_t itr=0; itr<stack->GetNtrack(); itr++ ){
-      TParticle *part = stack->Particle(itr);
-      fHLTPerformance->ReadMCTrack( itr, part );
+    for ( int itr = 0; itr < stack->GetNtrack(); itr++ ) {
+      TParticle *part = stack->Particle( itr );
+      AliHLTTPCCAPerformance::Instance().ReadMCTrack( itr, part );
     }
 
     { // check for MC tracks at the TPC entrance
-      Bool_t *isTPC = 0;
-      isTPC = new Bool_t [stack->GetNtrack()];
-      for( Int_t i=0; i<stack->GetNtrack(); i++ ) isTPC[i] = 0;
+
+      bool *isTPC = 0;
+      isTPC = new bool [stack->GetNtrack()];
+      for ( int i = 0; i < stack->GetNtrack(); i++ ) isTPC[i] = 0;
       rl->LoadTrackRefs();
       TTree *mcTree = rl->TreeTR();
-      if( !mcTree ) break;
-      TBranch *branch=mcTree->GetBranch("TrackReferences");
-      if (!branch ) break;     
-      TClonesArray tpcdummy("AliTrackReference",1000), *tpcRefs=&tpcdummy;
-      branch->SetAddress(&tpcRefs);
-      Int_t nr=(Int_t)mcTree->GetEntries();
-      for (Int_t r=0; r<nr; r++) {
-       mcTree->GetEvent(r);
-       Int_t nref = tpcRefs->GetEntriesFast();
-       if (!nref) continue;
-       AliTrackReference *tpcRef= 0x0;  
-       for (Int_t iref=0; iref<nref; ++iref) {
-         tpcRef = (AliTrackReference*)tpcRefs->UncheckedAt(iref);
-         if (tpcRef->DetectorId() == AliTrackReference::kTPC) break;
-         tpcRef = 0x0;
-       }
-       if (!tpcRef) continue;
-
-       if( isTPC[tpcRef->Label()] ) continue;  
-
-       fHLTPerformance->ReadMCTPCTrack(tpcRef->Label(),
-                                       tpcRef->X(),tpcRef->Y(),tpcRef->Z(),
-                                       tpcRef->Px(),tpcRef->Py(),tpcRef->Pz() );
-       isTPC[tpcRef->Label()] = 1;
-       tpcRefs->Clear();
-      }        
-      if( isTPC ) delete[] isTPC;
+      if ( !mcTree ) break;
+      TBranch *branch = mcTree->GetBranch( "TrackReferences" );
+      if ( !branch ) break;
+      TClonesArray tpcdummy( "AliTrackReference", 1000 ), *tpcRefs = &tpcdummy;
+      branch->SetAddress( &tpcRefs );
+      int nr = ( int )mcTree->GetEntries();
+      for ( int r = 0; r < nr; r++ ) {
+        mcTree->GetEvent( r );
+        int nref = tpcRefs->GetEntriesFast();
+        if ( !nref ) continue;
+        AliTrackReference *tpcRef = 0x0;
+        for ( int iref = 0; iref < nref; ++iref ) {
+          tpcRef = ( AliTrackReference* )tpcRefs->UncheckedAt( iref );
+          if ( tpcRef->DetectorId() == AliTrackReference::kTPC ) break;
+          tpcRef = 0x0;
+        }
+        if ( !tpcRef ) continue;
+
+        if ( isTPC[tpcRef->Label()] ) continue;
+
+        AliHLTTPCCAPerformance::Instance().ReadMCTPCTrack( tpcRef->Label(),
+            tpcRef->X(), tpcRef->Y(), tpcRef->Z(),
+            tpcRef->Px(), tpcRef->Py(), tpcRef->Pz() );
+        isTPC[tpcRef->Label()] = 1;
+        tpcRefs->Clear();
+      }
+      if ( isTPC ) delete[] isTPC;
     }
 
-    while( fDoHLTPerformanceClusters ){
-      AliTPCLoader *tpcl = (AliTPCLoader*) rl->GetDetectorLoader("TPC");
-      if( !tpcl ) break;
-      if( tpcl->TreeH() == 0x0 ){
-       if( tpcl->LoadHits() ) break;
+    while ( fDoHLTPerformanceClusters ) {
+      AliTPCLoader *tpcl = ( AliTPCLoader* ) rl->GetDetectorLoader( "TPC" );
+      if ( !tpcl ) break;
+      if ( tpcl->TreeH() == 0x0 ) {
+        if ( tpcl->LoadHits() ) break;
       }
-      if( tpcl->TreeH() == 0x0 ) break;
-      
-      AliTPC *tpc = (AliTPC*) gAlice->GetDetector("TPC");
-      Int_t nEnt=(Int_t)tpcl->TreeH()->GetEntries();
-      Int_t nPoints = 0;
-      for (Int_t iEnt=0; iEnt<nEnt; iEnt++) {    
-       tpc->ResetHits();
-       tpcl->TreeH()->GetEvent(iEnt);
-       AliTPChit *phit = (AliTPChit*)tpc->FirstHit(-1);
-       for ( ; phit; phit=(AliTPChit*)tpc->NextHit() ) nPoints++;
+      if ( tpcl->TreeH() == 0x0 ) break;
+
+      AliTPC *tpc = ( AliTPC* ) gAlice->GetDetector( "TPC" );
+      int nEnt = ( int )tpcl->TreeH()->GetEntries();
+      int nPoints = 0;
+      for ( int iEnt = 0; iEnt < nEnt; iEnt++ ) {
+        tpc->ResetHits();
+        tpcl->TreeH()->GetEvent( iEnt );
+        AliTPChit *phit = ( AliTPChit* )tpc->FirstHit( -1 );
+        for ( ; phit; phit = ( AliTPChit* )tpc->NextHit() ) nPoints++;
       }
-      fHLTPerformance->SetNMCPoints( nPoints );
-
-      for (Int_t iEnt=0; iEnt<nEnt; iEnt++) {    
-       tpc->ResetHits();
-       tpcl->TreeH()->GetEvent(iEnt);
-       AliTPChit *phit = (AliTPChit*)tpc->FirstHit(-1);
-       for ( ; phit; phit=(AliTPChit*)tpc->NextHit() ){
-         fHLTPerformance->ReadMCPoint( phit->GetTrack(),phit->X(), phit->Y(),phit->Z(),phit->Time(), phit->fSector%36);
-       }      
+      AliHLTTPCCAPerformance::Instance().SetNMCPoints( nPoints );
+
+      for ( int iEnt = 0; iEnt < nEnt; iEnt++ ) {
+        tpc->ResetHits();
+        tpcl->TreeH()->GetEvent( iEnt );
+        AliTPChit *phit = ( AliTPChit* )tpc->FirstHit( -1 );
+        for ( ; phit; phit = ( AliTPChit* )tpc->NextHit() ) {
+          AliHLTTPCCAPerformance::Instance().ReadMCPoint( phit->GetTrack(), phit->X(), phit->Y(), phit->Z(), phit->Time(), phit->fSector % 36 );
+        }
       }
       break;
     }
     break;
   }
-  
-  TBranch * br = fromTree->GetBranch("Segment");
-  if( !br ) return 1;
+
+  TBranch * br = fromTree->GetBranch( "Segment" );
+  if ( !br ) return 1;
 
   AliTPCClustersRow *clrow = new AliTPCClustersRow;
-  clrow->SetClass("AliTPCclusterMI");
-  clrow->SetArray(0);
-  clrow->GetArray()->ExpandCreateFast(10000);
-  
-  br->SetAddress(&clrow);
-  
+  clrow->SetClass( "AliTPCclusterMI" );
+  clrow->SetArray( 0 );
+  clrow->GetArray()->ExpandCreateFast( 10000 );
+
+  br->SetAddress( &clrow );
+
   //
-  Int_t nEnt=Int_t(fromTree->GetEntries());
+  int nEnt = int( fromTree->GetEntries() );
 
   fNClusters = 0;
-  for (Int_t i=0; i<nEnt; i++) {
-    br->GetEntry(i);
-    Int_t sec,row;
-    fParam->AdjustSectorRow(clrow->GetID(),sec,row);
+  for ( int i = 0; i < nEnt; i++ ) {
+    br->GetEntry( i );
+    int sec, row;
+    fkParam->AdjustSectorRow( clrow->GetID(), sec, row );
     fNClusters += clrow->GetArray()->GetEntriesFast();
   }
 
   fClusters = new AliTPCclusterMI [fNClusters];
-  fHLTTracker->SetNHits( fNClusters );
-  if( fDoHLTPerformance ) fHLTPerformance->SetNHits( fNClusters );
-  int ind=0;
-  for (Int_t i=0; i<nEnt; i++) {
-    br->GetEntry(i);
-    Int_t sec,row;
-    fParam->AdjustSectorRow(clrow->GetID(),sec,row);
+  fClusterSliceRow = new unsigned int [fNClusters];
+
+  hlt.StartDataReading( fNClusters );
+
+  if ( fDoHLTPerformance ) AliHLTTPCCAPerformance::Instance().SetNHits( fNClusters );
+
+  int ind = 0;
+  for ( int i = 0; i < nEnt; i++ ) {
+    br->GetEntry( i );
+    int sec, row;
+    fkParam->AdjustSectorRow( clrow->GetID(), sec, row );
     int nClu = clrow->GetArray()->GetEntriesFast();
-    Float_t x = fParam->GetPadRowRadii(sec,row);
-    for (Int_t icl=0; icl<nClu; icl++){
-      Int_t lab0 = -1;
-      Int_t lab1 = -1;
-      Int_t lab2 = -1;
-      AliTPCclusterMI* cluster = (AliTPCclusterMI*)(clrow->GetArray()->At(icl));
-      if( !cluster ) continue;
-      lab0 = cluster->GetLabel(0);
-      lab1 = cluster->GetLabel(1);
-      lab2 = cluster->GetLabel(2);
+    float x = fkParam->GetPadRowRadii( sec, row );
+
+    if ( sec >= 36 ) {
+      sec = sec - 36;
+      row = row + fkParam->GetNRowLow();
+    }
+
+    unsigned int sliceRow = ( sec << 8 ) + row;
+
+    for ( int icl = 0; icl < nClu; icl++ ) {
+      int lab0 = -1;
+      int lab1 = -1;
+      int lab2 = -1;
+      AliTPCclusterMI* cluster = ( AliTPCclusterMI* )( clrow->GetArray()->At( icl ) );
+      if ( !cluster ) continue;
+      lab0 = cluster->GetLabel( 0 );
+      lab1 = cluster->GetLabel( 1 );
+      lab2 = cluster->GetLabel( 2 );
 
       AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
-      if (!transform) {
-       AliFatal("Tranformations not in calibDB");
+      transform->SetCurrentRecoParam((AliTPCRecoParam*)AliTPCReconstructor::GetRecoParam());
+
+      if ( !transform ) {
+        AliFatal( "Tranformations not in calibDB" );
       }
-      Double_t xx[3]={cluster->GetRow(),cluster->GetPad(),cluster->GetTimeBin()};
-      Int_t id[1]={cluster->GetDetector()};
-      transform->Transform(xx,id,0,1);  
-      //if (!AliTPCReconstructor::GetRecoParam()->GetBYMirror()){
-      //if (cluster->GetDetector()%36>17){
-      //xx[1]*=-1;
-      //}
-      //}
-
-      cluster->SetX(xx[0]);
-      cluster->SetY(xx[1]);
-      cluster->SetZ(xx[2]);
-
-      TGeoHMatrix  *mat = fParam->GetClusterMatrix(cluster->GetDetector());
-      Double_t pos[3]= {cluster->GetX(),cluster->GetY(),cluster->GetZ()};
-      Double_t posC[3]={cluster->GetX(),cluster->GetY(),cluster->GetZ()};
-      if (mat) mat->LocalToMaster(pos,posC);
-      else{
-       // chack Loading of Geo matrices from GeoManager - TEMPORARY FIX
+      double xx[3] = {cluster->GetRow(), cluster->GetPad(), cluster->GetTimeBin()};
+      int id[1] = {cluster->GetDetector()};
+      transform->Transform( xx, id, 0, 1 );
+
+      cluster->SetX( xx[0] );
+      cluster->SetY( xx[1] );
+      cluster->SetZ( xx[2] );
+
+      TGeoHMatrix  *mat = fkParam->GetClusterMatrix( cluster->GetDetector() );
+      double pos[3] = {cluster->GetX(), cluster->GetY(), cluster->GetZ()};
+      double posC[3] = {cluster->GetX(), cluster->GetY(), cluster->GetZ()};
+      if ( mat ) mat->LocalToMaster( pos, posC );
+      else {
+        // chack Loading of Geo matrices from GeoManager - TEMPORARY FIX
       }
-      cluster->SetX(posC[0]);
-      cluster->SetY(posC[1]);
-      cluster->SetZ(posC[2]);
+      cluster->SetX( posC[0] );
+      cluster->SetY( posC[1] );
+      cluster->SetZ( posC[2] );
 
-      Float_t y = cluster->GetY();
-      Float_t z = cluster->GetZ();        
+      x = cluster->GetX();
+      float y = cluster->GetY();
+      float z = cluster->GetZ();
 
-      if( sec>=36 ){
-       sec = sec - 36;
-       row = row + fParam->GetNRowLow(); 
-      }
-      
-      Int_t index = ind++;
+
+      int index = ind++;
       fClusters[index] = *cluster;
-      fHLTTracker->ReadHit( x, y, z, 
-                           TMath::Sqrt(cluster->GetSigmaY2()), TMath::Sqrt(cluster->GetSigmaZ2()),                         
-                           cluster->GetMax(), index, sec, row );
-      if( fDoHLTPerformance ) fHLTPerformance->ReadHitLabel(index, lab0, lab1, lab2 );
+
+      fClusterSliceRow[index] = sliceRow;
+
+      hlt.ReadCluster( index, sec, row, x, y, z, cluster->GetQ() );
+
+      if ( fDoHLTPerformance ) AliHLTTPCCAPerformance::Instance().ReadHitLabel( index, lab0, lab1, lab2 );
     }
   }
   delete clrow;
+
+  hlt.FinishDataReading();
+
+  //AliHLTTPCCAPerformance::Instance().SmearClustersMC();
+
   return 0;
 }
 
-AliCluster * AliTPCtrackerCA::GetCluster(Int_t index) const
+AliCluster * AliTPCtrackerCA::GetCluster( int index ) const
 {
-  return &(fClusters[index]);
+  return &( fClusters[index] );
 }
 
-Int_t AliTPCtrackerCA::Clusters2Tracks( AliESDEvent *event )
+int AliTPCtrackerCA::Clusters2Tracks( AliESDEvent *event )
 {
   // reconstruction
-  cout<<"Start of AliTPCtrackerCA"<<endl;
+  //cout<<"Start of AliTPCtrackerCA"<<endl;
   TStopwatch timer;
 
-  fHLTTracker->FindTracks();
-  cout<<"Do performance.."<<endl;
-  if( fDoHLTPerformance ) fHLTPerformance->Performance();
+  AliHLTTPCCAStandaloneFramework &hlt = AliHLTTPCCAStandaloneFramework::Instance();
+
+  hlt.ProcessEvent();
+
+  if ( event ) {
+
+    const AliHLTTPCCAMergerOutput &hltOut = *( hlt.Merger().Output() );
+
+    for ( int itr = 0; itr < hltOut.NTracks(); itr++ ) {
+
+      AliTPCseed tTPC;
+
+      const AliHLTTPCCAMergedTrack &tCA = hltOut.Track( itr );
+
+      AliHLTTPCCATrackParam par = tCA.InnerParam();
+      AliHLTTPCCATrackConvertor::GetExtParam( par, tTPC, tCA.InnerAlpha() );
+      tTPC.SetMass( 0.13957 );
+      if ( TMath::Abs( tTPC.GetSigned1Pt() ) > 1. / 0.02 ) continue;
+      int nhits = tCA.NClusters();
+      int firstHit = 0;
+      if ( nhits > 160 ) {
+        firstHit = nhits - 160;
+        nhits = 160;
+      }
+      tTPC.SetNumberOfClusters( nhits );
+      float alpha = tCA.InnerAlpha();
+      AliHLTTPCCATrackParam t0 = par;
+      for ( int ih = 0; ih < nhits; ih++ ) {
+        int index = hltOut.ClusterId( tCA.FirstClusterRef() + firstHit + ih );
+        tTPC.SetClusterIndex( ih, index );
+        AliTPCclusterMI *c = &( fClusters[index] );
+        int iSlice = fClusterSliceRow[index] >> 8;
+        int row = fClusterSliceRow[index] & 0xff;
+
+        tTPC.SetClusterPointer( row, c );
+        AliTPCTrackerPoint &point = *( tTPC.GetTrackPoint( row ) );
+        {
+          //AliHLTTPCCATracker &slice = hlt.SliceTracker( iSlice );
+          if ( hlt.Param(iSlice).Alpha() != alpha ) {
+            if ( ! t0.Rotate(  hlt.Param(iSlice).Alpha() - alpha, .999 ) ) continue;
+            alpha = hlt.Param(iSlice).Alpha();
+          }
+          float x = hlt.Row(iSlice, row).X();
+          if ( !t0.TransportToX( x, hlt.Param(iSlice).GetBz( t0 ), .999 ) ) continue;
+          float sy2, sz2;
+          //slice.GetErrors2( row, t0, sy2, sz2 );
+                 hlt.Param(iSlice).GetClusterErrors2( row, t0.GetZ(), t0.SinPhi(), t0.GetCosPhi(), t0.DzDs(), sy2, sz2 );
+          point.SetSigmaY( c->GetSigmaY2() / sy2 );
+          point.SetSigmaZ( c->GetSigmaZ2() / sz2 );
+          point.SetAngleY( TMath::Abs( t0.GetSinPhi() / t0.GetCosPhi() ) );
+          point.SetAngleZ( TMath::Abs( t0.GetDzDs() ) );
+        }
+      }
+      tTPC.CookdEdx( 0.02, 0.6 );
+
+      CookLabel( &tTPC, 0.1 );
+
+      if ( 1 ) { // correction like in off-line --- Adding systematic error
+
+        const double *param = AliTPCReconstructor::GetRecoParam()->GetSystematicError();
+        double covar[15];
+        for ( int i = 0; i < 15; i++ ) covar[i] = 0;
+        covar[0] = param[0] * param[0];
+        covar[2] = param[1] * param[1];
+        covar[5] = param[2] * param[2];
+        covar[9] = param[3] * param[3];
+        double facC =  AliTracker::GetBz() * kB2C;
+        covar[14] = param[4] * param[4] * facC * facC;
+        tTPC.AddCovariance( covar );
+      }
+
+      AliESDtrack tESD;
+      tESD.UpdateTrackParams( &( tTPC ), AliESDtrack::kTPCin );
+      //tESD.SetStatus( AliESDtrack::kTPCrefit );
+      //tESD.SetTPCPoints(tTPC.GetPoints());
+      int   ndedx = tTPC.GetNCDEDX( 0 );
+      float sdedx = tTPC.GetSDEDX( 0 );
+      float dedx  = tTPC.GetdEdx();
+      tESD.SetTPCsignal( dedx, sdedx, ndedx );
+      //tESD.myTPC = tTPC;
+
+      event->AddTrack( &tESD );
+    }
+  }
+
+
+  timer.Stop();
+
+  fStatCPUTime += timer.CpuTime();
+  fStatRealTime += timer.RealTime();
+
+  //cout << "\n\nCA tracker speed: cpu = " << fStatCPUTime / ( fStatNEvents + 1 )*1.e3 << " [ms/ev], real = " << fStatRealTime / ( fStatNEvents + 1 )*1.e3 << " [ms/ev], n calls = " << ( fStatNEvents + 1 ) << endl << endl;
 
-  if( 0 ) {// Write Event    
-    if( fStatNEvents == 0 ){
+
+  //cout<<"Do performance.."<<endl;
+
+  if ( fDoHLTPerformance ) AliHLTTPCCAPerformance::Instance().Performance();
+
+  if ( 0 ) {// Write Event
+    if ( fStatNEvents == 0 ) {
       fstream geo;
-      geo.open("CAEvents/settings.dat", ios::out);
-      if( geo.is_open() ){
-       fHLTTracker->WriteSettings(geo);        
+      geo.open( "CAEvents/settings.dat", ios::out );
+      if ( geo.is_open() ) {
+        hlt.WriteSettings( geo );
       }
       geo.close();
     }
 
     fstream hits;
     char name[255];
-    sprintf( name,"CAEvents/%i.event.dat",fStatNEvents ); 
-    hits.open(name, ios::out);
-    if( hits.is_open() ){
-      fHLTTracker->WriteEvent(hits);   
+    sprintf( name, "CAEvents/%i.event.dat", fStatNEvents );
+    hits.open( name, ios::out );
+    if ( hits.is_open() ) {
+      hlt.WriteEvent( hits );
       fstream tracks;
-      sprintf( name,"CAEvents/%i.tracks.dat",fStatNEvents ); 
-      tracks.open(name, ios::out);
-      fHLTTracker->WriteTracks(tracks);        
+      sprintf( name, "CAEvents/%i.tracks.dat", fStatNEvents );
+      tracks.open( name, ios::out );
+      hlt.WriteTracks( tracks );
     }
-    hits.close();   
-    if( fDoHLTPerformance ){
+    hits.close();
+    if ( fDoHLTPerformance ) {
       fstream mcevent, mcpoints;
       char mcname[255];
-      sprintf( mcname,"CAEvents/%i.mcevent.dat",fStatNEvents ); 
-      mcevent.open(mcname, ios::out);
-      if( mcevent.is_open() ){      
-       fHLTPerformance->WriteMCEvent(mcevent);
+      sprintf( mcname, "CAEvents/%i.mcevent.dat", fStatNEvents );
+      mcevent.open( mcname, ios::out );
+      if ( mcevent.is_open() ) {
+        AliHLTTPCCAPerformance::Instance().WriteMCEvent( mcevent );
       }
-      if(1 && fDoHLTPerformanceClusters ){
-       sprintf( mcname,"CAEvents/%i.mcpoints.dat",fStatNEvents ); 
-       mcpoints.open(mcname, ios::out);
-       if( mcpoints.is_open() ){      
-         fHLTPerformance->WriteMCPoints(mcpoints);
-       }
-       mcpoints.close();
+      if ( 1 && fDoHLTPerformanceClusters ) {
+        sprintf( mcname, "CAEvents/%i.mcpoints.dat", fStatNEvents );
+        mcpoints.open( mcname, ios::out );
+        if ( mcpoints.is_open() ) {
+          AliHLTTPCCAPerformance::Instance().WriteMCPoints( mcpoints );
+        }
+        mcpoints.close();
       }
-      mcevent.close();   
+      mcevent.close();
     }
   }
+
   fStatNEvents++;
 
-  if( event ){
-   
-    Float_t bz = fHLTTracker->Slices()[0].Param().Bz();
-
-    for( Int_t itr=0; itr<fHLTTracker->NTracks(); itr++ ){
-      AliTPCtrack tTPC;
-      AliHLTTPCCAGBTrack &tCA = fHLTTracker->Tracks()[itr];
-      AliHLTTPCCATrackParam &par = tCA.Param();        
-      AliHLTTPCCATrackConvertor::GetExtParam( par, tTPC, tCA.Alpha(), bz );
-      tTPC.SetMass(0.13957);
-      tTPC.SetdEdx( tCA.DeDx() );
-      if( TMath::Abs(tTPC.GetSigned1Pt())>1./0.02 ) continue;
-      int nhits = tCA.NHits();
-      if( nhits>kMaxRow ) nhits = kMaxRow;
-      tTPC.SetNumberOfClusters(nhits);      
-      for( Int_t ih=0; ih<nhits; ih++ ){
-       Int_t index = fHLTTracker->TrackHits()[tCA.FirstHitRef()+ih];
-       Int_t extIndex = fHLTTracker->Hits()[index].ID();
-       tTPC.SetClusterIndex(ih, extIndex);
-      }
-      CookLabel(&tTPC,0.1);          
-      if(0){
-       Double_t xTPC=fParam->GetInnerRadiusLow();
-       Double_t dAlpha = fParam->GetInnerAngle()/180.*TMath::Pi();
-       if (tTPC.AliExternalTrackParam::PropagateTo(xTPC,bz)) {   
-         Double_t y=tTPC.GetY();
-         Double_t ymax=xTPC*TMath::Tan(dAlpha/2.); 
-         if (y > ymax) {
-           if (tTPC.Rotate(dAlpha)) tTPC.AliExternalTrackParam::PropagateTo(xTPC,bz);
-         } else if (y <-ymax) {
-           if (tTPC.Rotate(-dAlpha)) tTPC.AliExternalTrackParam::PropagateTo(xTPC,bz);
-         }         
-       }
-      }
-
-      AliESDtrack tESD;
-      tESD.UpdateTrackParams( &(tTPC),AliESDtrack::kTPCin);
-      //tESD.SetStatus( AliESDtrack::kTPCrefit );
-      //tESD.SetTPCPoints(tTPC.GetPoints());
-      //tESD.myTPC = tTPC;            
-      event->AddTrack(&tESD);
-    }
-  }
-  timer.Stop();
-  static double time=0, time1 = 0;
-  static int ncalls = 0;
-  time+=timer.CpuTime();
-  time1+=timer.RealTime();
-  ncalls++;
-  cout<<"\n\nCA tracker speed: cpu = "<<time/ncalls*1.e3<<" [ms/ev], real = "<<time1/ncalls*1.e3<<" [ms/ev], n calls = "<<ncalls<<endl<<endl;
 
   //cout<<"End of AliTPCtrackerCA"<<endl;
   return 0;
 }
 
 
-Int_t AliTPCtrackerCA::RefitInward (AliESDEvent *event)
-{ 
-  //* back propagation of ESD tracks (not fully functional)
+int AliTPCtrackerCA::RefitInward ( AliESDEvent *event )
+{
+  //* forward propagation of ESD tracks
+
+  float xTPC = fkParam->GetInnerRadiusLow();
+  float dAlpha = fkParam->GetInnerAngle() / 180.*TMath::Pi();
+  float yMax = xTPC * TMath::Tan( dAlpha / 2. );
+
+  AliHLTTPCCAStandaloneFramework &hlt = AliHLTTPCCAStandaloneFramework::Instance();
 
-  Float_t bz = fHLTTracker->Slices()[0].Param().Bz();
-  Float_t xTPC = fParam->GetInnerRadiusLow();
-  Float_t dAlpha = fParam->GetInnerAngle()/180.*TMath::Pi();
-  Float_t yMax = xTPC*TMath::Tan(dAlpha/2.); 
+  int nentr = event->GetNumberOfTracks();
 
-  Int_t nentr=event->GetNumberOfTracks();
-     
-  for (Int_t i=0; i<nentr; i++) {
-    AliESDtrack *esd=event->GetTrack(i);
-    ULong_t status=esd->GetStatus(); 
-    if (!(status&AliESDtrack::kTPCin)) continue;
+  for ( int itr = 0; itr < nentr; itr++ ) {
+    AliESDtrack *esd = event->GetTrack( itr );
+    ULong_t status = esd->GetStatus();
+    if ( !( status&AliESDtrack::kTPCin ) ) continue;
     AliHLTTPCCATrackParam t0;
-    AliHLTTPCCATrackConvertor::SetExtParam(t0,*esd, bz );
-    Float_t alpha = esd->GetAlpha();
-    if( t0.TransportToXWithMaterial( xTPC, bz) ){
-      if (t0.GetY() > yMax) {
-       if (t0.Rotate(dAlpha)){ 
-         alpha+=dAlpha;  
-         t0.TransportToXWithMaterial( xTPC, bz);
-       }
-      } else if (t0.GetY() <-yMax) {
-       if (t0.Rotate(-dAlpha)){
-         alpha+=-dAlpha;
-         t0.TransportToXWithMaterial( xTPC, bz);
-       }
-      }    
+    AliHLTTPCCATrackConvertor::SetExtParam( t0, *esd );
+    AliHLTTPCCATrackParam t = t0;
+    float alpha = esd->GetAlpha();
+    //float dEdX=0;
+    AliHLTTPCCAMerger::AliHLTTPCCAClusterInfo infos[500];
+    int hits[500], hits1[500];
+    int nHits = esd->GetTPCclusters( hits );
+    for ( int i = 0; i < nHits; i++ ) {
+      hits1[i] = i;
+      int index = hits[i];
+      infos[i].SetISlice( fClusterSliceRow[index] >> 8 );
+      infos[i].SetIRow( fClusterSliceRow[index] & 0xff );
+      infos[i].SetId( index );
+      infos[i].SetX( fClusters[index].GetX() );
+      infos[i].SetY( fClusters[index].GetY() );
+      infos[i].SetZ( fClusters[index].GetZ() );
+    }
+
+    bool ok = hlt.Merger().FitTrack( t, alpha, t0, alpha, hits1, nHits, 0, 0,infos );
+
+    if ( ok &&  nHits > 15 ) {
+      if ( t.TransportToXWithMaterial( xTPC, hlt.Merger().SliceParam().GetBz( t ) ) ) {
+        if ( t.GetY() > yMax ) {
+          if ( t.Rotate( dAlpha ) ) {
+            alpha += dAlpha;
+            t.TransportToXWithMaterial( xTPC, hlt.Merger().SliceParam().GetBz( t ) );
+          }
+        } else if ( t.GetY() < -yMax ) {
+          if ( t.Rotate( -dAlpha ) ) {
+            alpha += -dAlpha;
+            t.TransportToXWithMaterial( xTPC, hlt.Merger().SliceParam().GetBz( t ) );
+          }
+        }
+      }
+
+      AliTPCtrack tt( *esd );
+      if ( AliHLTTPCCATrackConvertor::GetExtParam( t, tt, alpha ) ) {
+        if ( t.X() > 50 ) esd->UpdateTrackParams( &tt, AliESDtrack::kTPCrefit );
+      }
     }
-    AliTPCtrack tt(*esd);
-    AliHLTTPCCATrackConvertor::GetExtParam(t0,tt,alpha,bz);
-    esd->UpdateTrackParams( &tt,AliESDtrack::kTPCrefit); 
   }
   return 0;
 }
 
-Int_t AliTPCtrackerCA::PropagateBack(AliESDEvent *)
-{ 
-  //* not implemented yet
-  return 0; 
+int AliTPCtrackerCA::PropagateBack( AliESDEvent *event )
+{
+
+  //* backward propagation of ESD tracks
+
+  AliHLTTPCCAStandaloneFramework &hlt = AliHLTTPCCAStandaloneFramework::Instance();
+
+  int nentr = event->GetNumberOfTracks();
+
+  for ( int itr = 0; itr < nentr; itr++ ) {
+
+    AliESDtrack *esd = event->GetTrack( itr );
+    ULong_t status = esd->GetStatus();
+    if ( !( status&AliESDtrack::kTPCin ) ) continue;
+
+    AliHLTTPCCATrackParam t0;
+    AliHLTTPCCATrackConvertor::SetExtParam( t0, *esd  );
+    AliHLTTPCCATrackParam t = t0;
+    float alpha = esd->GetAlpha();
+    //float dEdX=0;
+    AliHLTTPCCAMerger::AliHLTTPCCAClusterInfo infos[500];
+    int hits[500], hits1[500];
+    int nHits = esd->GetTPCclusters( hits );
+    for ( int i = 0; i < nHits; i++ ) {
+      hits1[i] = i;
+      int index = hits[i];
+      infos[i].SetISlice( fClusterSliceRow[index] >> 8 );
+      infos[i].SetIRow( fClusterSliceRow[index] & 0xff );
+      infos[i].SetId( index );
+      infos[i].SetX( fClusters[index].GetX() );
+      infos[i].SetY( fClusters[index].GetY() );
+      infos[i].SetZ( fClusters[index].GetZ() );
+    }
+
+    bool ok = hlt.Merger().FitTrack( t, alpha, t0, alpha, hits1, nHits, 1, 0, infos );
+
+    if ( ok &&  nHits > 15 ) {
+      AliTPCtrack tt( *esd );
+      if ( AliHLTTPCCATrackConvertor::GetExtParam( t, tt, alpha ) ) {
+        if ( t.X() > 50 ) esd->UpdateTrackParams( &tt, AliESDtrack::kTPCout );
+      }
+    }
+  }
+  return 0;
 }