X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=HLT%2FTPCLib%2Ftracking-ca%2FAliHLTTPCCATracker.cxx;h=bae170b2c39a784e962b751759011185c0d2f64e;hb=e4c523293f950684595d8e7a923e55532e0c2b5f;hp=fc24d4a16bb5de65e561df1563b67b831ab1deea;hpb=31649d4ba7ed37a194bec002433cf6d32acd04dc;p=u%2Fmrichter%2FAliRoot.git

diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.cxx b/HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.cxx
index fc24d4a16bb..bae170b2c39 100644
--- a/HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.cxx
+++ b/HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.cxx
@@ -18,14 +18,12 @@
 //***************************************************************************
 
 #include "AliHLTTPCCATracker.h"
-#include "AliHLTTPCCAOutTrack.h"
 #include "AliHLTTPCCARow.h"
 #include "AliHLTTPCCATrack.h"
 #include "AliHLTTPCCATracklet.h"
 #include "AliHLTTPCCAMath.h"
 #include "MemoryAssignmentHelpers.h"
 
-#include "TStopwatch.h"
 #include "AliHLTTPCCAHitArea.h"
 #include "AliHLTTPCCANeighboursFinder.h"
 #include "AliHLTTPCCANeighboursCleaner.h"
@@ -33,8 +31,6 @@
 #include "AliHLTTPCCATrackletConstructor.h"
 #include "AliHLTTPCCATrackletSelector.h"
 #include "AliHLTTPCCAProcess.h"
-#include "AliHLTTPCCASliceTrack.h"
-#include "AliHLTTPCCASliceOutput.h"
 #include "AliHLTTPCCAClusterData.h"
 
 #include "AliHLTTPCCATrackParam.h"
@@ -42,9 +38,11 @@
 #include "AliHLTTPCCAGPUConfig.h"
 
 #if !defined(HLTCA_GPUCODE)
+#include "TStopwatch.h"
 #include <iostream>
 #include <iomanip>
 #include <string.h>
+#include <cmath>
 #endif
 
 //#define DRAW1
@@ -57,18 +55,15 @@
 //#include "AliHLTTPCCAPerformance.h"
 #endif
 
-#ifdef HLTCA_STANDALONE
-#include "AliHLTTPCCAStandaloneFramework.h"
-#endif
-
 ClassImp( AliHLTTPCCATracker )
 
+#if !defined(__OPENCL__) || defined(HLTCA_HOSTCODE)
 
 #if !defined(HLTCA_GPUCODE)
 
 AliHLTTPCCATracker::~AliHLTTPCCATracker()
 {
-  // destructor
+	// destructor
 	if (!fIsGPUTracker)
 	{
 		if (fCommonMem) delete fCommonMem;
@@ -78,24 +73,27 @@ AliHLTTPCCATracker::~AliHLTTPCCATracker()
 		fCommonMem = NULL;
 		fHitMemory = fTrackMemory = NULL;
 	}
+#ifdef HLTCA_STANDALONE
+	if (fLinkTmpMemory) delete[] fLinkTmpMemory;
+#endif
 }
 
 // ----------------------------------------------------------------------------------
 void AliHLTTPCCATracker::Initialize( const AliHLTTPCCAParam &param )
 {
-  // initialisation
-  fParam = param;
-  fParam.Update();
-  fData.InitializeRows( fParam );
+	// initialisation
+	fParam = param;
+	fParam.Update();
+	fData.InitializeRows( fParam );
 
-  StartEvent();
+	StartEvent();
 }
 
 void AliHLTTPCCATracker::StartEvent()
 {
-  // start new event and fresh the memory
+	// start new event and fresh the memory
 
-  SetupCommonMemory();
+	SetupCommonMemory();
 }
 
 void AliHLTTPCCATracker::SetGPUTracker()
@@ -108,8 +106,8 @@ void AliHLTTPCCATracker::SetGPUTracker()
 char* AliHLTTPCCATracker::SetGPUTrackerCommonMemory(char* const pGPUMemory)
 {
 	//Set up common Memory Pointer for GPU Tracker
-  fCommonMem = (commonMemoryStruct*) pGPUMemory;
-  return(pGPUMemory + sizeof(commonMemoryStruct));
+	fCommonMem = (commonMemoryStruct*) pGPUMemory;
+	return(pGPUMemory + sizeof(commonMemoryStruct));
 }
 
 
@@ -125,16 +123,22 @@ char* AliHLTTPCCATracker::SetGPUTrackerHitsMemory(char* pGPUMemory, int MaxNHits
 	return(pGPUMemory);
 }
 
-char* AliHLTTPCCATracker::SetGPUTrackerTrackletsMemory(char* pGPUMemory, int MaxNTracks)
+char* AliHLTTPCCATracker::SetGPUTrackerTrackletsMemory(char* pGPUMemory, int MaxNTracks, int 
+#ifndef HLTCA_GPU_ALTERNATIVE_SCHEDULER
+constructorBlockCount
+#endif
+)
 {
 	//Set up Tracklet Memory Pointers for GPU Tracker
 	fTrackletMemory = (char*) pGPUMemory;
 	SetPointersTracklets(MaxNTracks);
 	pGPUMemory += fTrackletMemorySize;
+#ifndef HLTCA_GPU_ALTERNATIVE_SCHEDULER
 	AssignMemory(fGPUTrackletTemp, pGPUMemory, MaxNTracks);
 	AssignMemory(fRowBlockTracklets, pGPUMemory, MaxNTracks * 2 * (Param().NRows() / HLTCA_GPU_SCHED_ROW_STEP + 1));
 	AssignMemory(fRowBlockPos, pGPUMemory, 2 * (Param().NRows() / HLTCA_GPU_SCHED_ROW_STEP + 1));
-	AssignMemory(fBlockStartingTracklet, pGPUMemory, HLTCA_GPU_BLOCK_COUNT);
+	AssignMemory(fBlockStartingTracklet, pGPUMemory, constructorBlockCount);
+#endif
 
 	return(pGPUMemory);
 }
@@ -149,12 +153,30 @@ char* AliHLTTPCCATracker::SetGPUTrackerTracksMemory(char* pGPUMemory, int MaxNTr
 	return(pGPUMemory);
 }
 
+void AliHLTTPCCATracker::DumpOutput(FILE* out)
+{
+	fprintf(out, "Slice %d\n", fParam.ISlice());
+	const AliHLTTPCCASliceOutTrack* track = (*(Output()))->GetFirstTrack();
+	for (int j = 0;j < (*(Output()))->NTracks();j++)
+	{
+		fprintf(out, "Track %d (%d): ", j, track->NClusters());
+		for (int k = 0;k < track->NClusters();k++)
+		{
+			fprintf(out, "(%2.3f,%2.3f,%2.4f) ", track->Cluster(k).GetX(), track->Cluster(k).GetY(), track->Cluster(k).GetZ());
+		}
+		fprintf(out, " - (%8.5f %8.5f %8.5f %8.5f %8.5f)", track->Param().Y(), track->Param().Z(), track->Param().SinPhi(), track->Param().DzDs(), track->Param().QPt());
+		fprintf(out, "\n");
+		track = track->GetNextTrack();
+	}
+}
+
 void AliHLTTPCCATracker::DumpSliceData(std::ostream &out)
 {
 	//Dump Slice Input Data to File
-	out << "Slice Data:" << std::endl;
+	out << "Slice Data (Slice" << Param().ISlice() << "):" << std::endl;
 	for (int i = 0;i < Param().NRows();i++)
 	{
+		if (Row(i).NHits() == 0) continue;
 		out << "Row: " << i << std::endl;
 		for (int j = 0;j < Row(i).NHits();j++)
 		{
@@ -168,13 +190,14 @@ void AliHLTTPCCATracker::DumpSliceData(std::ostream &out)
 void AliHLTTPCCATracker::DumpLinks(std::ostream &out)
 {
 	//Dump Links (after Neighbours Finder / Cleaner) to file
-	out << "Hit Links:" << std::endl;
+	out << "Hit Links(Slice" << Param().ISlice() << "):" << std::endl;
 	for (int i = 0;i < Param().NRows();i++)
 	{
+		if (Row(i).NHits() == 0) continue;
 		out << "Row: " << i << std::endl;
 		for (int j = 0;j < Row(i).NHits();j++)
 		{
-	    		if (j && j % 32 == 0) out << std::endl;
+			if (j && j % 32 == 0) out << std::endl;
 			out << HitLinkUpData(Row(i), j) << "/" << HitLinkDownData(Row(i), j) << ", ";
 		}
 		out << std::endl;
@@ -184,17 +207,18 @@ void AliHLTTPCCATracker::DumpLinks(std::ostream &out)
 void AliHLTTPCCATracker::DumpHitWeights(std::ostream &out)
 {
 	//dump hit weights to file
-    out << "Hit Weights:" << std::endl;
-    for (int i = 0;i < Param().NRows();i++)
-    {
-	out << "Row: " << i << ":" << std::endl;
-	for (int j = 0;j < Row(i).NHits();j++)
+	out << "Hit Weights(Slice" << Param().ISlice() << "):" << std::endl;
+	for (int i = 0;i < Param().NRows();i++)
 	{
-	    if (j && j % 32 == 0) out << std::endl;
-	    out << HitWeight(Row(i), j) << ", ";
+		if (Row(i).NHits() == 0) continue;
+		out << "Row: " << i << ":" << std::endl;
+		for (int j = 0;j < Row(i).NHits();j++)
+		{
+			if (j && j % 32 == 0) out << std::endl;
+			out << HitWeight(Row(i), j) << ", ";
+		}
+		out << std::endl;
 	}
-	out << std::endl;
-    }
 }
 
 int AliHLTTPCCATracker::StarthitSortComparison(const void*a, const void* b)
@@ -210,7 +234,7 @@ int AliHLTTPCCATracker::StarthitSortComparison(const void*a, const void* b)
 void AliHLTTPCCATracker::DumpStartHits(std::ostream &out)
 {
 	//sort start hits and dump to file
-	out << "Start Hits: (" << *NTracklets() << ")" << std::endl;
+	out << "Start Hits: (Slice" << Param().ISlice() << ") (" << *NTracklets() << ")" << std::endl;
 #ifdef HLTCA_GPU_SORT_DUMPDATA
 	qsort(TrackletStartHits(), *NTracklets(), sizeof(AliHLTTPCCAHitId), StarthitSortComparison);
 #endif
@@ -224,7 +248,7 @@ void AliHLTTPCCATracker::DumpStartHits(std::ostream &out)
 void AliHLTTPCCATracker::DumpTrackHits(std::ostream &out)
 {
 	//dump tracks to file
-	out << "Tracks: (" << *NTracks() << ")" << std::endl;
+	out << "Tracks: (Slice" << Param().ISlice() << ") (" << *NTracks() << ")" << std::endl;
 #ifdef HLTCA_GPU_SORT_DUMPDATA
 	for (int k = 0;k < Param().NRows();k++)
 	{
@@ -242,7 +266,10 @@ void AliHLTTPCCATracker::DumpTrackHits(std::ostream &out)
 					{
 						out << TrackHits()[Tracks()[j].FirstHitID() + i].RowIndex() << "-" << TrackHits()[Tracks()[j].FirstHitID() + i].HitIndex() << ", ";
 					}
-					out << "(Track: " << j << ")" << std::endl;
+#ifndef BITWISE_COMPATIBLE_DEBUG_OUTPUT
+					out << "(Track: " << j << ")";
+#endif
+					out << std::endl;
 #ifdef HLTCA_GPU_SORT_DUMPDATA
 				}
 			}	
@@ -256,30 +283,33 @@ void AliHLTTPCCATracker::DumpTrackHits(std::ostream &out)
 void AliHLTTPCCATracker::DumpTrackletHits(std::ostream &out)
 {
 	//dump tracklets to file
-	out << "Tracklets: (" << *NTracklets() << ")" << std::endl;
+	int nTracklets = *NTracklets();
+	if( nTracklets<0 ) nTracklets = 0;
+	if( nTracklets>HLTCA_GPU_MAX_TRACKLETS ) nTracklets = HLTCA_GPU_MAX_TRACKLETS;
+	out << "Tracklets: (Slice" << Param().ISlice() << ") (" << nTracklets << ")" << std::endl;
 #ifdef HLTCA_GPU_SORT_DUMPDATA
-	AliHLTTPCCAHitId* tmpIds = new AliHLTTPCCAHitId[*NTracklets()];
-	AliHLTTPCCATracklet* tmpTracklets = new AliHLTTPCCATracklet[*NTracklets()];
-	memcpy(tmpIds, TrackletStartHits(), *NTracklets() * sizeof(AliHLTTPCCAHitId));
-	memcpy(tmpTracklets, Tracklets(), *NTracklets() * sizeof(AliHLTTPCCATracklet));
+	AliHLTTPCCAHitId* tmpIds = new AliHLTTPCCAHitId[nTracklets];
+	AliHLTTPCCATracklet* tmpTracklets = new AliHLTTPCCATracklet[nTracklets];
+	memcpy(tmpIds, TrackletStartHits(), nTracklets * sizeof(AliHLTTPCCAHitId));
+	memcpy(tmpTracklets, Tracklets(), nTracklets * sizeof(AliHLTTPCCATracklet));
 #ifdef EXTERN_ROW_HITS
-	int* tmpHits = new int[*NTracklets() * Param().NRows()];
-	memcpy(tmpHits, TrackletRowHits(), *NTracklets() * Param().NRows() * sizeof(int));
+	int* tmpHits = new int[nTracklets * Param().NRows()];
+	memcpy(tmpHits, TrackletRowHits(), nTracklets * Param().NRows() * sizeof(int));
 #endif
-	qsort(TrackletStartHits(), *NTracklets(), sizeof(AliHLTTPCCAHitId), StarthitSortComparison);
-	for (int i = 0;i < *NTracklets();i++)
-	{
-		for (int j = 0;j < *NTracklets();j++)
-		{
-			if (tmpIds[i].RowIndex() == TrackletStartHit(j).RowIndex() && tmpIds[i].HitIndex() == TrackletStartHit(j).HitIndex())
-			{
+	qsort(TrackletStartHits(), nTracklets, sizeof(AliHLTTPCCAHitId), StarthitSortComparison);
+	for (int i = 0;i < nTracklets; i++ ){
+		for (int j = 0;j < nTracklets; j++ ){
+			if (tmpIds[i].RowIndex() == TrackletStartHit(j).RowIndex() && tmpIds[i].HitIndex() == TrackletStartHit(j).HitIndex() ){
 				memcpy(&Tracklets()[j], &tmpTracklets[i], sizeof(AliHLTTPCCATracklet));
 #ifdef EXTERN_ROW_HITS
-				if (tmpTracklets[i].NHits())
-				{
-					for (int k = tmpTracklets[i].FirstRow();k <= tmpTracklets[i].LastRow();k++)
-					{
-						fTrackletRowHits[k * *NTracklets() + j] = tmpHits[k * *NTracklets() + i];
+				if (tmpTracklets[i].NHits() ){
+					for (int k = tmpTracklets[i].FirstRow();k <= tmpTracklets[i].LastRow();k++){
+						const int pos = k * nTracklets + j;
+						if (pos < 0 || pos >= HLTCA_GPU_MAX_TRACKLETS * fParam.NRows()){
+							printf("internal error\n");	      
+						} else {
+							fTrackletRowHits[pos] = tmpHits[k * nTracklets + i];
+						}
 					}
 				}
 #endif
@@ -293,26 +323,48 @@ void AliHLTTPCCATracker::DumpTrackletHits(std::ostream &out)
 	delete[] tmpHits;
 #endif
 #endif
-	for (int j = 0;j < *NTracklets();j++)
+	for (int j = 0;j < nTracklets; j++ )
 	{
-		out << "Tracklet " << j << " (Hits: " << std::setw(3) << Tracklets()[j].NHits() << ", Start: " << std::setw(3) << TrackletStartHit(j).RowIndex() << "-" << std::setw(3) << TrackletStartHit(j).HitIndex() << ") ";
+		out << "Tracklet " << std::setw(4) << j << " (Hits: " << std::setw(3) << Tracklets()[j].NHits() << ", Start: " << std::setw(3) << TrackletStartHit(j).RowIndex() << "-" << std::setw(3) << TrackletStartHit(j).HitIndex() << ", Rows: " << (Tracklets()[j].NHits() ? Tracklets()[j].FirstRow() : -1) << " - " << (Tracklets()[j].NHits() ? Tracklets()[j].LastRow() : -1) << ") ";
 		if (Tracklets()[j].NHits() == 0);
 		else if (Tracklets()[j].LastRow() > Tracklets()[j].FirstRow() && (Tracklets()[j].FirstRow() >= Param().NRows() || Tracklets()[j].LastRow() >= Param().NRows()))
 		{
 #ifdef HLTCA_STANDALONE
-			printf("\nError: First %d Last %d Num %d", Tracklets()[j].FirstRow(), Tracklets()[j].LastRow(), Tracklets()[j].NHits());
+			printf("\nError: Tracklet %d First %d Last %d Hits %d", j, Tracklets()[j].FirstRow(), Tracklets()[j].LastRow(), Tracklets()[j].NHits());
+			out << " (Error: Tracklet " << j << " First " << Tracklets()[j].FirstRow() << " Last " << Tracklets()[j].LastRow() << " Hits " << Tracklets()[j].NHits() << ") ";
+			for (int i = 0;i < Param().NRows();i++)
+			{
+				//if (Tracklets()[j].RowHit(i) != -1)
+#ifdef EXTERN_ROW_HITS
+				out << i << "-" << fTrackletRowHits[i * fCommonMem->fNTracklets + j] << ", ";
+#else
+				out << i << "-" << Tracklets()[j].RowHit(i) << ", ";
+#endif
+			}
 #endif
 		}
 		else if (Tracklets()[j].NHits() && Tracklets()[j].LastRow() > Tracklets()[j].FirstRow())
 		{
+			int nHits = 0;;
 			for (int i = Tracklets()[j].FirstRow();i <= Tracklets()[j].LastRow();i++)
 			{
-				//if (Tracklets()[j].RowHit(i) != -1)
 #ifdef EXTERN_ROW_HITS
-					out << i << "-" << fTrackletRowHits[i * fCommonMem->fNTracklets + j] << ", ";
+				if (fTrackletRowHits[i * fCommonMem->fNTracklets + j] != -1)
 #else
-					out << i << "-" << Tracklets()[j].RowHit(i) << ", ";
+				if (Tracklets()[j].RowHit(i) != -1)
 #endif
+				{
+					nHits++;
+				}
+#ifdef EXTERN_ROW_HITS
+				out << i << "-" << fTrackletRowHits[i * fCommonMem->fNTracklets + j] << ", ";
+#else
+				out << i << "-" << Tracklets()[j].RowHit(i) << ", ";
+#endif
+			}
+			if (nHits != Tracklets()[j].NHits())
+			{
+				out << std::endl << "Wrong NHits!: Expected " << Tracklets()[j].NHits() << ", fount " << nHits;
 			}
 		}
 		out << std::endl;
@@ -322,116 +374,114 @@ void AliHLTTPCCATracker::DumpTrackletHits(std::ostream &out)
 
 void AliHLTTPCCATracker::SetupCommonMemory()
 {
-  // set up common memory
-
-  if (!fIsGPUTracker)
-  {
-    if ( !fCommonMem ) {
-      // the 1600 extra bytes are not used unless fCommonMemorySize increases with a later event
-      //fCommonMemory = reinterpret_cast<char*> ( new uint4 [ fCommonMemorySize/sizeof( uint4 ) + 100] );
-	  fCommonMem = new commonMemoryStruct;
-    }
-
-	if (fHitMemory)	delete[] fHitMemory;
-	if (fTrackletMemory) delete[] fTrackletMemory;
-	if (fTrackMemory) delete[] fTrackMemory;
-  }
-
-  fHitMemory = fTrackletMemory = fTrackMemory = 0;
-
-  fData.Clear();
-  fCommonMem->fNTracklets = 0;
-  fCommonMem->fNTracks = 0 ;
-  fCommonMem->fNTrackHits = 0;
+	// set up common memory
+
+	if (!fIsGPUTracker)
+	{
+		if ( !fCommonMem ) {
+			// the 1600 extra bytes are not used unless fCommonMemorySize increases with a later event
+			//fCommonMemory = reinterpret_cast<char*> ( new uint4 [ fCommonMemorySize/sizeof( uint4 ) + 100] );
+			fCommonMem = new commonMemoryStruct;
+		}
+
+		if (fHitMemory)	delete[] fHitMemory;
+		if (fTrackletMemory) delete[] fTrackletMemory;
+		if (fTrackMemory) delete[] fTrackMemory;
+	}
+
+	fHitMemory = fTrackletMemory = fTrackMemory = 0;
+
+	fData.Clear();
+	fCommonMem->fNTracklets = 0;
+	fCommonMem->fNTracks = 0 ;
+	fCommonMem->fNTrackHits = 0;
 }
 
 void AliHLTTPCCATracker::ReadEvent( AliHLTTPCCAClusterData *clusterData )
 {
-  // read event
+	// read event
 
-  fClusterData = clusterData;
+	fClusterData = clusterData;
 
-  StartEvent();
+	StartEvent();
 
-  //* Convert input hits, create grids, etc.
-  fData.InitFromClusterData( *clusterData );
-  {
-    if (!fIsGPUTracker)
+	//* Convert input hits, create grids, etc.
+	fData.InitFromClusterData( *clusterData );
 	{
-		SetPointersHits( fData.NumberOfHits() ); // to calculate the size
-		fHitMemory = reinterpret_cast<char*> ( new uint4 [ fHitMemorySize/sizeof( uint4 ) + 100] );
+		if (!fIsGPUTracker)
+		{
+			SetPointersHits( fData.NumberOfHits() ); // to calculate the size
+			fHitMemory = reinterpret_cast<char*> ( new uint4 [ fHitMemorySize/sizeof( uint4 ) + 100] );
+		}
+		SetPointersHits( fData.NumberOfHits() ); // set pointers for hits
 	}
-    SetPointersHits( fData.NumberOfHits() ); // set pointers for hits
-  }
 }
 
 GPUhd() void  AliHLTTPCCATracker::SetPointersHits( int MaxNHits )
 {
-  // set all pointers to the event memory
+	// set all pointers to the event memory
 
-  char *mem = fHitMemory;
+	char *mem = fHitMemory;
 
-  // extra arrays for tpc clusters
+	// extra arrays for tpc clusters
 
 #ifdef HLTCA_GPU_SORT_STARTHITS_2
-  AssignMemory( fTrackletStartHits, mem, MaxNHits + 32);
+	AssignMemory( fTrackletStartHits, mem, MaxNHits + 32);
 #else
-  AssignMemory( fTrackletStartHits, mem, MaxNHits);
+	AssignMemory( fTrackletStartHits, mem, MaxNHits);
 #endif
 
-  // calculate the size
+	// calculate the size
 
-  fHitMemorySize = mem - fHitMemory;
+	fHitMemorySize = mem - fHitMemory;
 }
 
 GPUhd() void  AliHLTTPCCATracker::SetPointersTracklets( int MaxNTracklets )
 {
-  // set all pointers to the tracklets memory
-  char *mem = fTrackletMemory;
+	// set all pointers to the tracklets memory
+	char *mem = fTrackletMemory;
 
-  // memory for tracklets
+	// memory for tracklets
 
-  AssignMemory( fTracklets, mem, MaxNTracklets );
+	AssignMemory( fTracklets, mem, MaxNTracklets );
 #ifdef EXTERN_ROW_HITS
-  AssignMemory( fTrackletRowHits, mem, MaxNTracklets * Param().NRows());
+	AssignMemory( fTrackletRowHits, mem, MaxNTracklets * Param().NRows());
 #endif
 
-  fTrackletMemorySize = mem - fTrackletMemory;
+	fTrackletMemorySize = mem - fTrackletMemory;
 }
 
 
 GPUhd() void  AliHLTTPCCATracker::SetPointersTracks( int MaxNTracks, int MaxNHits )
 {
-  // set all pointers to the tracks memory
-  char *mem = fTrackMemory;
+	// set all pointers to the tracks memory
+	char *mem = fTrackMemory;
 
-  // memory for selected tracks
+	// memory for selected tracks
 
-  AssignMemory( fTracks, mem, MaxNTracks );
-  AssignMemory( fTrackHits, mem, 2 * MaxNHits );
+	AssignMemory( fTracks, mem, MaxNTracks );
+	AssignMemory( fTrackHits, mem, 2 * MaxNHits );
 
-  // calculate the size
+	// calculate the size
 
-  fTrackMemorySize = mem - fTrackMemory;
+	fTrackMemorySize = mem - fTrackMemory;
 }
 
 GPUh() int AliHLTTPCCATracker::CheckEmptySlice() const
 {
 	//Check if the Slice is empty, if so set the output apropriate and tell the reconstuct procesdure to terminate
-  if ( NHitsTotal() < 1 ) {
-    {
-      AliHLTTPCCASliceOutput::Allocate(*fOutput, 0, 0, fOutputControl);
-      AliHLTTPCCASliceOutput* useOutput = *fOutput;
-      if (fOutput == NULL) return(1);
-      useOutput->SetNTracks( 0 );
-      useOutput->SetNTrackClusters( 0 );
-      useOutput->SetNOutTracks(0);
-      useOutput->SetNOutTrackHits(0);
-    }
-
-    return 1;
-  }
-  return 0;
+	if ( NHitsTotal() < 1 ) {
+		{
+			AliHLTTPCCASliceOutput::Allocate(*fOutput, 0, 0, fOutputControl);
+			AliHLTTPCCASliceOutput* useOutput = *fOutput;
+			if (useOutput == NULL) return(1);
+			useOutput->SetNTracks( 0 );
+			useOutput->SetNTrackClusters( 0 );
+		}
+
+		return 1;
+	}
+	return 0;
 }
 
 void AliHLTTPCCATracker::RunNeighboursFinder()
@@ -455,577 +505,574 @@ void AliHLTTPCCATracker::RunStartHitsFinder()
 void AliHLTTPCCATracker::RunTrackletConstructor()
 {
 	//Run CPU Tracklet Constructor
-  AliHLTTPCCATrackletConstructor::AliHLTTPCCATrackletConstructorNewCPU(*this);
+	AliHLTTPCCATrackletConstructor::AliHLTTPCCATrackletConstructorCPU(*this);
 }
 
 void AliHLTTPCCATracker::RunTrackletSelector()
 {
 	//Run CPU Tracklet Selector
-  AliHLTTPCCAProcess<AliHLTTPCCATrackletSelector>( 1, fCommonMem->fNTracklets, *this );
+	AliHLTTPCCAProcess<AliHLTTPCCATrackletSelector>( 1, fCommonMem->fNTracklets, *this );
 }
 
 #ifdef HLTCA_STANDALONE
 void AliHLTTPCCATracker::StandalonePerfTime(int i)
 {
-  //Query Performance Timer for Standalone Version of Tracker
-  if (fGPUDebugLevel >= 1)
-  {
-    AliHLTTPCCAStandaloneFramework::StandaloneQueryTime(&fPerfTimers[i]);
-  }
+	//Query Performance Timer for Standalone Version of Tracker
+	if (fGPUDebugLevel >= 1)
+	{
+		StandaloneQueryTime(&fPerfTimers[i]);
+	}
 }
 #else
 void AliHLTTPCCATracker::StandalonePerfTime(int /*i*/) {}
 #endif
 
-GPUh() void AliHLTTPCCATracker::Reconstruct()
+GPUh() void AliHLTTPCCATracker::DoTracking()
 {
-  //* reconstruction of event
-  //std::cout<<"Reconstruct slice "<<fParam.ISlice()<<", nHits="<<NHitsTotal()<<std::endl;
-
-  fTimers[0] = 0; // find neighbours
-  fTimers[1] = 0; // construct tracklets
-  fTimers[2] = 0; // fit tracklets
-  fTimers[3] = 0; // prolongation of tracklets
-  fTimers[4] = 0; // selection
-  fTimers[5] = 0; // write output
-  fTimers[6] = 0;
-  fTimers[7] = 0;
-
-  //if( fParam.ISlice()<1 ) return; //SG!!!
-
-  TStopwatch timer0;
-
-  StandalonePerfTime(0);
-
-  if (CheckEmptySlice()) return;
-
-#ifdef DRAW1
-  //if( fParam.ISlice()==2 || fParam.ISlice()==3)
-    {
-  AliHLTTPCCADisplay::Instance().ClearView();
-  AliHLTTPCCADisplay::Instance().SetSliceView();
-  AliHLTTPCCADisplay::Instance().SetCurrentSlice( this );
-  AliHLTTPCCADisplay::Instance().DrawSlice( this, 1 );
-  if ( NHitsTotal() > 0 ) {
-    AliHLTTPCCADisplay::Instance().DrawSliceHits( kRed, .5 );
-    AliHLTTPCCADisplay::Instance().Ask();
-  }
-  }
-#endif //DRAW1
-
 	fCommonMem->fNTracklets = fCommonMem->fNTracks = fCommonMem->fNTrackHits = 0;
 
-#if !defined(HLTCA_GPUCODE)
+	if (fGPUDebugLevel >= 6)
+	{
+#ifndef BITWISE_COMPATIBLE_DEBUG_OUTPUT
+		*fGPUDebugOut << std::endl << std::endl << "Slice: " << Param().ISlice() << std::endl;
+		*fGPUDebugOut << "Slice Data:" << std::endl;
+#endif
+		DumpSliceData(*fGPUDebugOut);
+	}
 
-  if (fGPUDebugLevel >= 6)
-  {
-	  *fGPUDebugOut << std::endl << std::endl << "Slice: " << Param().ISlice() << std::endl;
-	  *fGPUDebugOut << "Slice Data:" << std::endl;
-	  DumpSliceData(*fGPUDebugOut);
-  }
+	StandalonePerfTime(1);
 
-  StandalonePerfTime(1);
+	RunNeighboursFinder();
 
-  RunNeighboursFinder();
+	StandalonePerfTime(2);
 
-  StandalonePerfTime(2);
+#ifdef TRACKER_KEEP_TEMPDATA
+	if (fLinkTmpMemory) delete[] fLinkTmpMemory;
+	fLinkTmpMemory = new char[fData.MemorySize()];
+	memcpy(fLinkTmpMemory, fData.Memory(), fData.MemorySize());
+#endif
+
+	if (fGPUDebugLevel >= 6) DumpLinks(*fGPUDebugOut);
 
-  if (fGPUDebugLevel >= 6) DumpLinks(*fGPUDebugOut);
-  
 #ifdef HLTCA_INTERNAL_PERFORMANCE
-  //if( Param().ISlice()<=2 )
-  //AliHLTTPCCAPerformance::Instance().LinkPerformance( Param().ISlice() );
+	//if( Param().ISlice()<=2 )
+	//AliHLTTPCCAPerformance::Instance().LinkPerformance( Param().ISlice() );
 #endif
 
 
 #ifdef DRAW1
-  if ( NHitsTotal() > 0 ) {
-    AliHLTTPCCADisplay::Instance().DrawSliceLinks( -1, -1, 1 );
-    AliHLTTPCCADisplay::Instance().Ask();
-  }
+	if ( NHitsTotal() > 0 ) {
+		AliHLTTPCCADisplay::Instance().DrawSliceLinks( -1, -1, 1 );
+		AliHLTTPCCADisplay::Instance().Ask();
+	}
 #endif //DRAW1
 
-  RunNeighboursCleaner();
+	RunNeighboursCleaner();
 
-  StandalonePerfTime(3);
+	StandalonePerfTime(3);
 
-  if (fGPUDebugLevel >= 6) DumpLinks(*fGPUDebugOut);
+	if (fGPUDebugLevel >= 6) DumpLinks(*fGPUDebugOut);
 
-  RunStartHitsFinder();
+	RunStartHitsFinder();
 
-  StandalonePerfTime(4);
-  StandalonePerfTime(5);
+	StandalonePerfTime(4);
+	StandalonePerfTime(5);
 
-  if (fGPUDebugLevel >= 6) DumpStartHits(*fGPUDebugOut);
-  
-  fData.ClearHitWeights();
+	if (fGPUDebugLevel >= 6) DumpStartHits(*fGPUDebugOut);
 
-  SetPointersTracklets( fCommonMem->fNTracklets * 2 ); // to calculate the size
-  fTrackletMemory = reinterpret_cast<char*> ( new uint4 [ fTrackletMemorySize/sizeof( uint4 ) + 100] );
-  SetPointersTracklets( fCommonMem->fNTracklets * 2 ); // set pointers for hits
+	fData.ClearHitWeights();
 
-  SetPointersTracks( fCommonMem->fNTracklets * 2, NHitsTotal() ); // to calculate the size
-  fTrackMemory = reinterpret_cast<char*> ( new uint4 [ fTrackMemorySize/sizeof( uint4 ) + 100] );
-  SetPointersTracks( fCommonMem->fNTracklets * 2, NHitsTotal() ); // set pointers for hits
+	if (!fIsGPUTracker)
+	{
+		SetPointersTracklets( fCommonMem->fNTracklets * 2 ); // to calculate the size
+		fTrackletMemory = reinterpret_cast<char*> ( new uint4 [ fTrackletMemorySize/sizeof( uint4 ) + 100] );
+		SetPointersTracks( fCommonMem->fNTracklets * 2, NHitsTotal() ); // to calculate the size
+		fTrackMemory = reinterpret_cast<char*> ( new uint4 [ fTrackMemorySize/sizeof( uint4 ) + 100] );
+	}
 
-  StandalonePerfTime(6);
-  StandalonePerfTime(7);
+	SetPointersTracklets( fCommonMem->fNTracklets * 2 ); // set pointers for hits
+	SetPointersTracks( fCommonMem->fNTracklets * 2, NHitsTotal() ); // set pointers for hits
 
-  RunTrackletConstructor();
+	StandalonePerfTime(6);
+	StandalonePerfTime(7);
 
-  StandalonePerfTime(8);
+	RunTrackletConstructor();
 
-  if (fGPUDebugLevel >= 6) DumpTrackletHits(*fGPUDebugOut);
-  if (fGPUDebugLevel >= 6) DumpHitWeights(*fGPUDebugOut);
+	StandalonePerfTime(8);
 
-  //std::cout<<"Slice "<<Param().ISlice()<<": NHits="<<NHitsTotal()<<", NTracklets="<<*NTracklets()<<std::endl;
+	if (fGPUDebugLevel >= 6) DumpTrackletHits(*fGPUDebugOut);
+#ifndef BITWISE_COMPATIBLE_DEBUG_OUTPUT
+	if (fGPUDebugLevel >= 6) DumpHitWeights(*fGPUDebugOut);
+#endif
 
-  RunTrackletSelector();
+	//std::cout<<"Slice "<<Param().ISlice()<<": NHits="<<NHitsTotal()<<", NTracklets="<<*NTracklets()<<std::endl;
 
-  StandalonePerfTime(9);
+	RunTrackletSelector();
 
-  //std::cout<<"Slice "<<Param().ISlice()<<": N start hits/tracklets/tracks = "<<nStartHits<<" "<<nStartHits<<" "<<*fNTracks<<std::endl;
+	StandalonePerfTime(9);
 
-  if (fGPUDebugLevel >= 6) DumpTrackHits(*fGPUDebugOut);
+	//std::cout<<"Slice "<<Param().ISlice()<<": N start hits/tracklets/tracks = "<<nStartHits<<" "<<nStartHits<<" "<<*fNTracks<<std::endl;
 
-  //std::cout<<"Memory used for slice "<<fParam.ISlice()<<" : "<<fCommonMemorySize/1024./1024.<<" + "<<fHitMemorySize/1024./1024.<<" + "<<fTrackMemorySize/1024./1024.<<" = "<<( fCommonMemorySize+fHitMemorySize+fTrackMemorySize )/1024./1024.<<" Mb "<<std::endl;
+	if (fGPUDebugLevel >= 6) DumpTrackHits(*fGPUDebugOut);
 
-  WriteOutput();
+	//std::cout<<"Memory used for slice "<<fParam.ISlice()<<" : "<<fCommonMemorySize/1024./1024.<<" + "<<fHitMemorySize/1024./1024.<<" + "<<fTrackMemorySize/1024./1024.<<" = "<<( fCommonMemorySize+fHitMemorySize+fTrackMemorySize )/1024./1024.<<" Mb "<<std::endl;
+}
 
-  StandalonePerfTime(10);
+GPUh() void AliHLTTPCCATracker::Reconstruct()
+{
+	//* reconstruction of event
+	//std::cout<<"Reconstruct slice "<<fParam.ISlice()<<", nHits="<<NHitsTotal()<<std::endl;
 
-#endif
+	fTimers[0] = 0; // find neighbours
+	fTimers[1] = 0; // construct tracklets
+	fTimers[2] = 0; // fit tracklets
+	fTimers[3] = 0; // prolongation of tracklets
+	fTimers[4] = 0; // selection
+	fTimers[5] = 0; // write output
+	fTimers[6] = 0;
+	fTimers[7] = 0;
+
+	//if( fParam.ISlice()<1 ) return; //SG!!!
+
+	TStopwatch timer0;
+
+	if (CheckEmptySlice()) return;
 
 #ifdef DRAW1
-  {
-    AliHLTTPCCADisplay &disp = AliHLTTPCCADisplay::Instance();
-    AliHLTTPCCATracker &slice = *this;
-    std::cout << "N out tracks = " << slice.NOutTracks() << std::endl;
-    AliHLTTPCCADisplay::Instance().SetSliceView();
-    AliHLTTPCCADisplay::Instance().SetCurrentSlice( this );
-    AliHLTTPCCADisplay::Instance().DrawSlice( this, 1 );
-    disp.DrawSliceHits( kRed, .5 );
-    disp.Ask();
-    for ( int itr = 0; itr < slice.NOutTracks(); itr++ ) {
-      std::cout << "track N " << itr << ", nhits=" << slice.OutTracks()[itr].NHits() << std::endl;
-      disp.DrawSliceOutTrack( itr, kBlue );      
-      //disp.Ask();
-      //int id = slice.OutTracks()[itr].OrigTrackID();
-      //AliHLTTPCCATrack &tr = Tracks()[id];
-      //for( int ih=0; ih<tr.NHits(); ih++ ){
-      //int ic = (fTrackHits[tr.FirstHitID()+ih]);
-      //std::cout<<ih<<" "<<ID2IRow(ic)<<" "<<ID2IHit(ic)<<std::endl;
-      //}
-      //disp.DrawSliceTrack( id, kBlue );
-      //disp.Ask();
-    }
-    disp.Ask();
-  }
+	//if( fParam.ISlice()==2 || fParam.ISlice()==3)
+	{
+		AliHLTTPCCADisplay::Instance().ClearView();
+		AliHLTTPCCADisplay::Instance().SetSliceView();
+		AliHLTTPCCADisplay::Instance().SetCurrentSlice( this );
+		AliHLTTPCCADisplay::Instance().DrawSlice( this, 1 );
+		if ( NHitsTotal() > 0 ) {
+			AliHLTTPCCADisplay::Instance().DrawSliceHits( kRed, .5 );
+			AliHLTTPCCADisplay::Instance().Ask();
+		}
+	}
 #endif //DRAW1
 
-  timer0.Stop();
-  fTimers[0] = timer0.CpuTime() / 100.;
-
+	DoTracking();
+	fTimers[0] = timer0.CpuTime() / 100.;
 }
 
-GPUh() void AliHLTTPCCATracker::WriteOutput()
+GPUh() void AliHLTTPCCATracker::ReconstructOutput()
 {
-  // write output
+	TStopwatch timer0;
+	WriteOutputPrepare();
+	WriteOutput();
 
-  TStopwatch timer;
+	StandalonePerfTime(10);
 
-  //cout<<"output: nTracks = "<<*fNTracks<<", nHitsTotal="<<NHitsTotal()<<std::endl;
+#ifdef DRAW1
+	{
+		AliHLTTPCCADisplay &disp = AliHLTTPCCADisplay::Instance();
+		AliHLTTPCCATracker &slice = *this;
+		std::cout << "N out tracks = " << slice.NOutTracks() << std::endl;
+		AliHLTTPCCADisplay::Instance().SetSliceView();
+		AliHLTTPCCADisplay::Instance().SetCurrentSlice( this );
+		AliHLTTPCCADisplay::Instance().DrawSlice( this, 1 );
+		disp.DrawSliceHits( kRed, .5 );
+		disp.Ask();
+		for ( int itr = 0; itr < slice.NOutTracks(); itr++ ) {
+			std::cout << "track N " << itr << ", nhits=" << slice.OutTracks()[itr].NHits() << std::endl;
+			disp.DrawSliceOutTrack( itr, kBlue );      
+			//disp.Ask();
+			//int id = slice.OutTracks()[itr].OrigTrackID();
+			//AliHLTTPCCATrack &tr = Tracks()[id];
+			//for( int ih=0; ih<tr.NHits(); ih++ ){
+			//int ic = (fTrackHits[tr.FirstHitID()+ih]);
+			//std::cout<<ih<<" "<<ID2IRow(ic)<<" "<<ID2IHit(ic)<<std::endl;
+			//}
+			//disp.DrawSliceTrack( id, kBlue );
+			//disp.Ask();
+		}
+		disp.Ask();
+	}
+#endif //DRAW1
 
-  if (fOutputControl == NULL) fOutputControl = new AliHLTTPCCASliceOutput::outputControlStruct;
-  AliHLTTPCCASliceOutput::Allocate(*fOutput, fCommonMem->fNTracks, fCommonMem->fNTrackHits, fOutputControl);
-  AliHLTTPCCASliceOutput* useOutput = *fOutput;
-  if (useOutput == NULL) return;
+	timer0.Stop();
+	fTimers[0] += timer0.CpuTime() / 100.;
+}
 
-  if (fOutputControl->fDefaultOutput)
-  {
-	  useOutput->SetNTracks( fCommonMem->fNTracks );
-	  useOutput->SetNTrackClusters( fCommonMem->fNTrackHits );
+GPUh() void AliHLTTPCCATracker::WriteOutputPrepare()
+{
+	if (fOutputControl == NULL) fOutputControl = new AliHLTTPCCASliceOutput::outputControlStruct;
+	AliHLTTPCCASliceOutput::Allocate(*fOutput, fCommonMem->fNTracks, fCommonMem->fNTrackHits, fOutputControl);
+}
 
-	  int nStoredHits = 0;
+GPUh() int AliHLTTPCCATracker::SortComparison(const void* a, const void* b)
+{
+	return(((trackSortData*) a)->fSortVal < ((trackSortData*) b)->fSortVal ? 1 : -1);
+}
 
-	  for ( int iTr = 0; iTr < fCommonMem->fNTracks; iTr++ ) {
-		AliHLTTPCCATrack &iTrack = fTracks[iTr];
+GPUh() void AliHLTTPCCATracker::WriteOutput()
+{
+	// write output
+	AliHLTTPCCASliceOutput* useOutput = *fOutput;
 
-		AliHLTTPCCASliceTrack out;
-		out.SetFirstClusterRef( nStoredHits );
-		out.SetNClusters( iTrack.NHits() );
-		out.SetParam( iTrack.Param() );
+	TStopwatch timer;
 
-		useOutput->SetTrack( iTr, out );
-
-		int iID = iTrack.FirstHitID();
-		for ( int ith = 0; ith < iTrack.NHits(); ith++ ) {
-		  const AliHLTTPCCAHitId &ic = fTrackHits[iID + ith];
-		  int iRow = ic.RowIndex();
-		  int ih = ic.HitIndex();
-
-		  const AliHLTTPCCARow &row = fData.Row( iRow );
-
-		  //float y0 = row.Grid().YMin();
-		  //float z0 = row.Grid().ZMin();
-		  //float stepY = row.HstepY();
-		  //float stepZ = row.HstepZ();
-		  //float x = row.X();
-
-		  //const uint4 *tmpint4 = RowData() + row.FullOffset();
-		  //const ushort2 *hits = reinterpret_cast<const ushort2*>(tmpint4);
-		  //ushort2 hh = hits[ih];
-		  //float y = y0 + hh.x*stepY;
-		  //float z = z0 + hh.y*stepZ;
-
-		  int clusterIndex = fData.ClusterDataIndex( row, ih );
-		  int clusterRowIndex = clusterIndex - fClusterData->RowOffset( iRow );
-
-		  if ( clusterIndex < 0 || clusterIndex >= fClusterData->NumberOfClusters() ) {
-			//std::cout << inpIDtot << ", " << fClusterData->NumberOfClusters()
-			//<< "; " << inpID << ", " << fClusterData->NumberOfClusters( iRow ) << std::endl;
-			//abort();
-			continue;
-		  }
-		  if ( clusterRowIndex < 0 || clusterRowIndex >= fClusterData->NumberOfClusters( iRow ) ) {
-			//std::cout << inpIDtot << ", " << fClusterData->NumberOfClusters()
-			//<< "; " << inpID << ", " << fClusterData->NumberOfClusters( iRow ) << std::endl;
-			//abort();
-			continue;
-		  }
-
-		  float origX = fClusterData->X( clusterIndex );
-		  float origY = fClusterData->Y( clusterIndex );
-		  float origZ = fClusterData->Z( clusterIndex );
-
-
-		  int id = fClusterData->Id( clusterIndex );
-
-		  float2 hUnpackedYZ;
-		  hUnpackedYZ.x = origY;
-		  hUnpackedYZ.y = origZ;
-		  float hUnpackedX = origX;
-
-		  useOutput->SetClusterId( nStoredHits, id  );
-		  useOutput->SetClusterRow( nStoredHits, ( unsigned char ) iRow  );
-		  useOutput->SetClusterUnpackedYZ( nStoredHits, hUnpackedYZ );
-		  useOutput->SetClusterUnpackedX( nStoredHits, hUnpackedX );
-		  nStoredHits++;
-		}
-	  }
-  }
+	//cout<<"output: nTracks = "<<*fNTracks<<", nHitsTotal="<<NHitsTotal()<<std::endl;
 
+	if (useOutput == NULL) return;
 
-  // old stuff
-  if (fOutputControl->fObsoleteOutput)
-  {
-	  useOutput->SetNOutTrackHits(0);
-	  useOutput->SetNOutTracks(0);
+	useOutput->SetNTracks( 0 );
+	useOutput->SetNTrackClusters( 0 );
 
+	int nStoredHits = 0;
+	int nStoredTracks = 0;
+	int nStoredLocalTracks = 0;
 
-	  for ( int iTr = 0; iTr < fCommonMem->fNTracks; iTr++ ) {
+	AliHLTTPCCASliceOutTrack *out = useOutput->FirstTrack();
 
-		const AliHLTTPCCATrack &iTrack = fTracks[iTr];
+	trackSortData* trackOrder = new trackSortData[fCommonMem->fNTracks];
+	for (int i = 0;i < fCommonMem->fNTracks;i++)
+	{
+		trackOrder[i].fTtrack = i;
+		trackOrder[i].fSortVal = fTracks[trackOrder[i].fTtrack].NHits() / 1000.f + fTracks[trackOrder[i].fTtrack].Param().GetZ() * 100.f + fTracks[trackOrder[i].fTtrack].Param().GetY();
+	}
+	qsort(trackOrder, fCommonMem->fNLocalTracks, sizeof(trackSortData), SortComparison);
+	qsort(trackOrder + fCommonMem->fNLocalTracks, fCommonMem->fNTracks - fCommonMem->fNLocalTracks, sizeof(trackSortData), SortComparison);
 
-		//std::cout<<"iTr = "<<iTr<<", nHits="<<iTrack.NHits()<<std::endl;
+	for ( int iTrTmp = 0; iTrTmp < fCommonMem->fNTracks; iTrTmp++ ) {
+		int iTr = trackOrder[iTrTmp].fTtrack;
+		AliHLTTPCCATrack &iTrack = fTracks[iTr];    
 
-		//if( !iTrack.Alive() ) continue;
-		if ( iTrack.NHits() < 3 ) continue;
-		AliHLTTPCCAOutTrack &out = useOutput->OutTracks()[useOutput->NOutTracks()];
-		out.SetFirstHitRef( useOutput->NOutTrackHits() );
-		out.SetNHits( 0 );
-		out.SetOrigTrackID( iTr );
-		AliHLTTPCCATrackParam tmpParam;
-		tmpParam.InitParam();
-		tmpParam.SetParam(iTrack.Param());
-		out.SetStartPoint( tmpParam );
-		out.SetEndPoint( tmpParam );
+		if( iTr < fCommonMem->fNLocalTracks && iTrack.NHits() < fParam.MinNTrackClusters() ) continue;
+		if( CAMath::Abs(iTrack.Param().GetQPt())> fParam.MaxTrackQPt() ) continue;
 
+		out->SetParam( iTrack.Param() );
+		out->SetLocalTrackId( iTrack.LocalTrackId() );
+		int nClu = 0;
 		int iID = iTrack.FirstHitID();
-		int nOutTrackHitsOld = useOutput->NOutTrackHits();
 
 		for ( int ith = 0; ith < iTrack.NHits(); ith++ ) {
-		  const AliHLTTPCCAHitId &ic = fTrackHits[iID + ith];
-		  const AliHLTTPCCARow &row = Row( ic );
-		  int ih = ic.HitIndex();
-		  useOutput->SetOutTrackHit(useOutput->NOutTrackHits(), HitInputID( row, ih ));
-		  useOutput->SetNOutTrackHits(useOutput->NOutTrackHits() + 1 );
-		  //std::cout<<"write i,row,hit,id="<<ith<<", "<<ID2IRow(ic)<<", "<<ih<<", "<<HitInputID( row, ih )<<std::endl;
-		  if ( useOutput->NOutTrackHits() >= 10*NHitsTotal() ) {
-			std::cout << "fNOutTrackHits>NHitsTotal()" << std::endl;
-			//exit(0);
-			return;//SG!!!
-		  }
-		  out.SetNHits( out.NHits() + 1 );
-		}
-		if ( out.NHits() >= 2 ) {
-		  useOutput->SetNOutTracks(useOutput->NOutTracks() + 1);
-		} else {
-		  useOutput->SetNOutTrackHits(nOutTrackHitsOld);
+			const AliHLTTPCCAHitId &ic = fTrackHits[iID + ith];
+			int iRow = ic.RowIndex();
+			int ih = ic.HitIndex();
+
+			const AliHLTTPCCARow &row = fData.Row( iRow );
+
+			int clusterIndex = fData.ClusterDataIndex( row, ih );
+
+			float origX = fClusterData->X( clusterIndex );
+			float origY = fClusterData->Y( clusterIndex );
+			float origZ = fClusterData->Z( clusterIndex );      
+			int id = fClusterData->Id( clusterIndex );
+			AliHLTTPCCASliceOutCluster c;
+			c.Set( id, iRow, origX, origY, origZ );
+			out->SetCluster( nClu, c );
+			nClu++;
 		}
-	  }
-  }
 
-  timer.Stop();
-  fTimers[5] += timer.CpuTime();
+		nStoredTracks++;
+		if (iTr < fCommonMem->fNLocalTracks) nStoredLocalTracks++;
+		nStoredHits+=nClu; 
+		out->SetNClusters( nClu );
+		out = out->NextTrack();    
+	}
+	delete[] trackOrder;
+
+	useOutput->SetNTracks( nStoredTracks );
+	useOutput->SetNLocalTracks( nStoredLocalTracks );
+	useOutput->SetNTrackClusters( nStoredHits );
+
+	timer.Stop();
+	fTimers[5] += timer.CpuTime();
 }
 
 #endif
 
-GPUh() void AliHLTTPCCATracker::FitTrackFull( const AliHLTTPCCATrack &/**/, float * /**/ ) const
+GPUh() void AliHLTTPCCATracker::FitTrackFull( const MEM_LG2(AliHLTTPCCATrack) &/**/, float * /**/ ) const
 {
-  // fit track with material
+	// fit track with material
 #ifdef XXX
-  //* Fit the track
-  FitTrack( iTrack, tt0 );
-  if ( iTrack.NHits() <= 3 ) return;
-
-  AliHLTTPCCATrackParam &t = iTrack.Param();
-  AliHLTTPCCATrackParam t0 = t;
-
-  t.Chi2() = 0;
-  t.NDF() = -5;
-  bool first = 1;
-
-  int iID = iTrack.FirstHitID();
-  for ( int ih = 0; ih < iTrack.NHits(); ih++, iID++ ) {
-    const AliHLTTPCCAHitId &ic = fTrackHits[iID];
-    int iRow = ic.rowIndex();
-    const AliHLTTPCCARow &row = fData.Row( iRow );
-    if ( !t0.TransportToX( row.X() ) ) continue;
-    float dy, dz;
-    const AliHLTTPCCAHit &h = ic.hitIndex();
-
-    // check for wrong hits
-    if ( 0 ) {
-      dy = t0.GetY() - h.Y();
-      dz = t0.GetZ() - h.Z();
-
-      //if( dy*dy > 3.5*3.5*(/*t0.GetErr2Y() + */h.ErrY()*h.ErrY() ) ) continue;//SG!!!
-      //if( dz*dz > 3.5*3.5*(/*t0.GetErr2Z() + */h.ErrZ()*h.ErrZ() ) ) continue;
-    }
-
-    if ( !t.TransportToX( row.X() ) ) continue;
-
-    //* Update the track
-
-    if ( first ) {
-      t.Cov()[ 0] = .5 * .5;
-      t.Cov()[ 1] = 0;
-      t.Cov()[ 2] = .5 * .5;
-      t.Cov()[ 3] = 0;
-      t.Cov()[ 4] = 0;
-      t.Cov()[ 5] = .2 * .2;
-      t.Cov()[ 6] = 0;
-      t.Cov()[ 7] = 0;
-      t.Cov()[ 8] = 0;
-      t.Cov()[ 9] = .2 * .2;
-      t.Cov()[10] = 0;
-      t.Cov()[11] = 0;
-      t.Cov()[12] = 0;
-      t.Cov()[13] = 0;
-      t.Cov()[14] = .2 * .2;
-      t.Chi2() = 0;
-      t.NDF() = -5;
-    }
-    float err2Y, err2Z;
-    GetErrors2( iRow, t, err2Y, err2Z );
-
-    if ( !t.Filter2( h.Y(), h.Z(), err2Y, err2Z ) ) continue;
-
-    first = 0;
-  }
-  /*
-  float cosPhi = iTrack.Param().GetCosPhi();
-  p0.Param().TransportToX(ID2Row( iTrack.PointID()[0] ).X());
-  p2.Param().TransportToX(ID2Row( iTrack.PointID()[1] ).X());
-  if( p0.Param().GetCosPhi()*cosPhi<0 ){ // change direction
-  float *par = p0.Param().Par();
-  float *cov = p0.Param().Cov();
-  par[2] = -par[2]; // sin phi
-  par[3] = -par[3]; // DzDs
-    par[4] = -par[4]; // kappa
-    cov[3] = -cov[3];
-    cov[4] = -cov[4];
-    cov[6] = -cov[6];
-    cov[7] = -cov[7];
-    cov[10] = -cov[10];
-    cov[11] = -cov[11];
-    p0.Param().CosPhi() = -p0.Param().GetCosPhi();
-  }
-  */
+	//* Fit the track
+	FitTrack( iTrack, tt0 );
+	if ( iTrack.NHits() <= 3 ) return;
+
+	AliHLTTPCCATrackParam &t = iTrack.Param();
+	AliHLTTPCCATrackParam t0 = t;
+
+	t.Chi2() = 0;
+	t.NDF() = -5;
+	bool first = 1;
+
+	int iID = iTrack.FirstHitID();
+	for ( int ih = 0; ih < iTrack.NHits(); ih++, iID++ ) {
+		const AliHLTTPCCAHitId &ic = fTrackHits[iID];
+		int iRow = ic.rowIndex();
+		const AliHLTTPCCARow &row = fData.Row( iRow );
+		if ( !t0.TransportToX( row.X() ) ) continue;
+		float dy, dz;
+		const AliHLTTPCCAHit &h = ic.hitIndex();
+
+		// check for wrong hits
+		if ( 0 ) {
+			dy = t0.GetY() - h.Y();
+			dz = t0.GetZ() - h.Z();
+
+			//if( dy*dy > 3.5*3.5*(/*t0.GetErr2Y() + */h.ErrY()*h.ErrY() ) ) continue;//SG!!!
+			//if( dz*dz > 3.5*3.5*(/*t0.GetErr2Z() + */h.ErrZ()*h.ErrZ() ) ) continue;
+		}
+
+		if ( !t.TransportToX( row.X() ) ) continue;
+
+		//* Update the track
+
+		if ( first ) {
+			t.Cov()[ 0] = .5 * .5;
+			t.Cov()[ 1] = 0;
+			t.Cov()[ 2] = .5 * .5;
+			t.Cov()[ 3] = 0;
+			t.Cov()[ 4] = 0;
+			t.Cov()[ 5] = .2 * .2;
+			t.Cov()[ 6] = 0;
+			t.Cov()[ 7] = 0;
+			t.Cov()[ 8] = 0;
+			t.Cov()[ 9] = .2 * .2;
+			t.Cov()[10] = 0;
+			t.Cov()[11] = 0;
+			t.Cov()[12] = 0;
+			t.Cov()[13] = 0;
+			t.Cov()[14] = .2 * .2;
+			t.Chi2() = 0;
+			t.NDF() = -5;
+		}
+		float err2Y, err2Z;
+		GetErrors2( iRow, t, err2Y, err2Z );
+
+		if ( !t.Filter2( h.Y(), h.Z(), err2Y, err2Z ) ) continue;
+
+		first = 0;
+	}
+	/*
+	float cosPhi = iTrack.Param().GetCosPhi();
+	p0.Param().TransportToX(ID2Row( iTrack.PointID()[0] ).X());
+	p2.Param().TransportToX(ID2Row( iTrack.PointID()[1] ).X());
+	if( p0.Param().GetCosPhi()*cosPhi<0 ){ // change direction
+	float *par = p0.Param().Par();
+	float *cov = p0.Param().Cov();
+	par[2] = -par[2]; // sin phi
+	par[3] = -par[3]; // DzDs
+	par[4] = -par[4]; // kappa
+	cov[3] = -cov[3];
+	cov[4] = -cov[4];
+	cov[6] = -cov[6];
+	cov[7] = -cov[7];
+	cov[10] = -cov[10];
+	cov[11] = -cov[11];
+	p0.Param().CosPhi() = -p0.Param().GetCosPhi();
+	}
+	*/
 #endif
 }
 
 GPUh() void AliHLTTPCCATracker::FitTrack( const AliHLTTPCCATrack &/*track*/, float * /*t0[]*/ ) const
 {
-  //* Fit the track
+	//* Fit the track
 #ifdef XXX
-  AliHLTTPCCAEndPoint &p2 = ID2Point( track.PointID()[1] );
-  const AliHLTTPCCAHit &c0 = ID2Hit( fTrackHits[p0.TrackHitID()].HitID() );
-  const AliHLTTPCCAHit &c1 = ID2Hit( fTrackHits[track.HitID()[1]].HitID() );
-  const AliHLTTPCCAHit &c2 = ID2Hit( fTrackHits[p2.TrackHitID()].HitID() );
-  const AliHLTTPCCARow &row0 = ID2Row( fTrackHits[p0.TrackHitID()].HitID() );
-  const AliHLTTPCCARow &row1 = ID2Row( fTrackHits[track.HitID()[1]].HitID() );
-  const AliHLTTPCCARow &row2 = ID2Row( fTrackHits[p2.TrackHitID()].HitID() );
-  float sp0[5] = {row0.X(), c0.Y(), c0.Z(), c0.ErrY(), c0.ErrZ() };
-  float sp1[5] = {row1.X(), c1.Y(), c1.Z(), c1.ErrY(), c1.ErrZ() };
-  float sp2[5] = {row2.X(), c2.Y(), c2.Z(), c2.ErrY(), c2.ErrZ() };
-  //std::cout<<"Fit track, points ="<<sp0[0]<<" "<<sp0[1]<<" / "<<sp1[0]<<" "<<sp1[1]<<" / "<<sp2[0]<<" "<<sp2[1]<<std::endl;
-  if ( track.NHits() >= 3 ) {
-    p0.Param().ConstructXYZ3( sp0, sp1, sp2, p0.Param().CosPhi(), t0 );
-    p2.Param().ConstructXYZ3( sp2, sp1, sp0, p2.Param().CosPhi(), t0 );
-    //p2.Param() = p0.Param();
-    //p2.Param().TransportToX(row2.X());
-    //p2.Param().Par()[1] = -p2.Param().Par()[1];
-    //p2.Param().Par()[4] = -p2.Param().Par()[4];
-  } else {
-    p0.Param().X() = row0.X();
-    p0.Param().Y() = c0.Y();
-    p0.Param().Z() = c0.Z();
-    p0.Param().Err2Y() = c0.ErrY() * c0.ErrY();
-    p0.Param().Err2Z() = c0.ErrZ() * c0.ErrZ();
-    p2.Param().X() = row2.X();
-    p2.Param().Y() = c2.Y();
-    p2.Param().Z() = c2.Z();
-    p2.Param().Err2Y() = c2.ErrY() * c2.ErrY();
-    p2.Param().Err2Z() = c2.ErrZ() * c2.ErrZ();
-  }
+	AliHLTTPCCAEndPoint &p2 = ID2Point( track.PointID()[1] );
+	const AliHLTTPCCAHit &c0 = ID2Hit( fTrackHits[p0.TrackHitID()].HitID() );
+	const AliHLTTPCCAHit &c1 = ID2Hit( fTrackHits[track.HitID()[1]].HitID() );
+	const AliHLTTPCCAHit &c2 = ID2Hit( fTrackHits[p2.TrackHitID()].HitID() );
+	const AliHLTTPCCARow &row0 = ID2Row( fTrackHits[p0.TrackHitID()].HitID() );
+	const AliHLTTPCCARow &row1 = ID2Row( fTrackHits[track.HitID()[1]].HitID() );
+	const AliHLTTPCCARow &row2 = ID2Row( fTrackHits[p2.TrackHitID()].HitID() );
+	float sp0[5] = {row0.X(), c0.Y(), c0.Z(), c0.ErrY(), c0.ErrZ() };
+	float sp1[5] = {row1.X(), c1.Y(), c1.Z(), c1.ErrY(), c1.ErrZ() };
+	float sp2[5] = {row2.X(), c2.Y(), c2.Z(), c2.ErrY(), c2.ErrZ() };
+	//std::cout<<"Fit track, points ="<<sp0[0]<<" "<<sp0[1]<<" / "<<sp1[0]<<" "<<sp1[1]<<" / "<<sp2[0]<<" "<<sp2[1]<<std::endl;
+	if ( track.NHits() >= 3 ) {
+		p0.Param().ConstructXYZ3( sp0, sp1, sp2, p0.Param().CosPhi(), t0 );
+		p2.Param().ConstructXYZ3( sp2, sp1, sp0, p2.Param().CosPhi(), t0 );
+		//p2.Param() = p0.Param();
+		//p2.Param().TransportToX(row2.X());
+		//p2.Param().Par()[1] = -p2.Param().Par()[1];
+		//p2.Param().Par()[4] = -p2.Param().Par()[4];
+	} else {
+		p0.Param().X() = row0.X();
+		p0.Param().Y() = c0.Y();
+		p0.Param().Z() = c0.Z();
+		p0.Param().Err2Y() = c0.ErrY() * c0.ErrY();
+		p0.Param().Err2Z() = c0.ErrZ() * c0.ErrZ();
+		p2.Param().X() = row2.X();
+		p2.Param().Y() = c2.Y();
+		p2.Param().Z() = c2.Z();
+		p2.Param().Err2Y() = c2.ErrY() * c2.ErrY();
+		p2.Param().Err2Z() = c2.ErrZ() * c2.ErrZ();
+	}
 #endif
 }
 
+#if !defined(HLTCA_GPUCODE)
 
-GPUd() void AliHLTTPCCATracker::GetErrors2( int iRow, float z, float sinPhi, float cosPhi, float DzDs, float &Err2Y, float &Err2Z ) const
+GPUh() void AliHLTTPCCATracker::WriteEvent( std::ostream &out )
 {
-  //
-  // Use calibrated cluster error from OCDB
-  //
-
-  fParam.GetClusterErrors2( iRow, z, sinPhi, cosPhi, DzDs, Err2Y, Err2Z );
-  Err2Y*=fParam.ClusterError2CorrectionY();
-  Err2Z*=fParam.ClusterError2CorrectionZ();
+	// write event to the file
+	for ( int iRow = 0; iRow < fParam.NRows(); iRow++ ) {
+		out << fData.Row( iRow ).HitNumberOffset() << " " << fData.Row( iRow ).NHits() << std::endl;
+	}
+	out << NHitsTotal() << std::endl;
+
+	AliHLTResizableArray<float> y( NHitsTotal() ), z( NHitsTotal() );
+
+	for ( int iRow = 0; iRow < fParam.NRows(); iRow++ ) {
+		const AliHLTTPCCARow &row = Row( iRow );
+		float y0 = row.Grid().YMin();
+		float z0 = row.Grid().ZMin();
+		float stepY = row.HstepY();
+		float stepZ = row.HstepZ();
+		for ( int ih = 0; ih < fData.Row( iRow ).NHits(); ih++ ) {
+			int id = HitInputID( row, ih );
+			y[id] = y0 + HitDataY( row, ih ) * stepY;
+			z[id] = z0 + HitDataZ( row, ih ) * stepZ;
+		}
+	}
+	for ( int ih = 0; ih < NHitsTotal(); ih++ ) {
+		out << y[ih] << " " << z[ih] << std::endl;
+	}
 }
 
-GPUd() void AliHLTTPCCATracker::GetErrors2( int iRow, const AliHLTTPCCATrackParam &t, float &Err2Y, float &Err2Z ) const
+GPUh() void AliHLTTPCCATracker::WriteTracks( std::ostream &/*out*/ )
 {
-  //
-  // Use calibrated cluster error from OCDB
-  //
-
-  fParam.GetClusterErrors2( iRow, t.GetZ(), t.SinPhi(), t.GetCosPhi(), t.DzDs(), Err2Y, Err2Z );
+	//* Write tracks to file --- dummy
 }
 
-
-#if !defined(HLTCA_GPUCODE)
-
-GPUh() void AliHLTTPCCATracker::WriteEvent( std::ostream &out )
+GPUh() void AliHLTTPCCATracker::ReadTracks( std::istream &/*in*/ )
 {
-  // write event to the file
-  for ( int iRow = 0; iRow < fParam.NRows(); iRow++ ) {
-    out << fData.Row( iRow ).HitNumberOffset() << " " << fData.Row( iRow ).NHits() << std::endl;
-  }
-  out << NHitsTotal() << std::endl;
-
-  AliHLTResizableArray<float> y( NHitsTotal() ), z( NHitsTotal() );
-
-  for ( int iRow = 0; iRow < fParam.NRows(); iRow++ ) {
-    const AliHLTTPCCARow &row = Row( iRow );
-    float y0 = row.Grid().YMin();
-    float z0 = row.Grid().ZMin();
-    float stepY = row.HstepY();
-    float stepZ = row.HstepZ();
-    for ( int ih = 0; ih < fData.Row( iRow ).NHits(); ih++ ) {
-      int id = HitInputID( row, ih );
-      y[id] = y0 + HitDataY( row, ih ) * stepY;
-      z[id] = z0 + HitDataZ( row, ih ) * stepZ;
-    }
-  }
-  for ( int ih = 0; ih < NHitsTotal(); ih++ ) {
-    out << y[ih] << " " << z[ih] << std::endl;
-  }
+	//* Read tracks  from file -- dummy
 }
 
-GPUh() void AliHLTTPCCATracker::WriteTracks( std::ostream &out )
+GPUh() int AliHLTTPCCATracker::PerformGlobalTrackingRun(AliHLTTPCCATracker& sliceNeighbour, int iTrack, int rowIndex, float angle, int direction)
 {
-  //* Write tracks to file
-  AliHLTTPCCASliceOutput* useOutput = *fOutput;
-
-  out << fTimers[0] << std::endl;
-  out << useOutput->NOutTrackHits() << std::endl;
-  for ( int ih = 0; ih < useOutput->NOutTrackHits(); ih++ ) {
-    out << useOutput->OutTrackHit(ih) << " ";
-  }
-  out << std::endl;
-
-  out << useOutput->NOutTracks() << std::endl;
-
-  for ( int itr = 0; itr < useOutput->NOutTracks(); itr++ ) {
-    const AliHLTTPCCAOutTrack &t = useOutput->OutTrack(itr);
-    AliHLTTPCCATrackParam p1 = t.StartPoint();
-    AliHLTTPCCATrackParam p2 = t.EndPoint();
-    out << t.NHits() << " ";
-    out << t.FirstHitRef() << " ";
-    out << t.OrigTrackID() << " ";
-    out << std::endl;
-    out << p1.X() << " ";
-    out << p1.SignCosPhi() << " ";
-    out << p1.Chi2() << " ";
-    out << p1.NDF() << std::endl;
-    for ( int i = 0; i < 5; i++ ) out << p1.Par()[i] << " ";
-    out << std::endl;
-    for ( int i = 0; i < 15; i++ ) out << p1.Cov()[i] << " ";
-    out << std::endl;
-    out << p2.X() << " ";
-    out << p2.SignCosPhi() << " ";
-    out << p2.Chi2() << " ";
-    out << p2.NDF() << std::endl;
-    for ( int i = 0; i < 5; i++ ) out << p2.Par()[i] << " ";
-    out << std::endl;
-    for ( int i = 0; i < 15; i++ ) out << p2.Cov()[i] << " ";
-    out << std::endl;
-  }
+	/*for (int j = 0;j < fTracks[j].NHits();j++)
+	{
+		printf("Hit %3d: Row %3d: X %3.7lf Y %3.7lf\n", j, fTrackHits[fTracks[iTrack].FirstHitID() + j].RowIndex(), Row(fTrackHits[fTracks[iTrack].FirstHitID() + j].RowIndex()).X(),
+		(float) Data().HitDataY(Row(fTrackHits[fTracks[iTrack].FirstHitID() + j].RowIndex()), fTrackHits[fTracks[iTrack].FirstHitID() + j].HitIndex()) * Row(fTrackHits[fTracks[iTrack].FirstHitID() + j].RowIndex()).HstepY() + Row(fTrackHits[fTracks[iTrack].FirstHitID() + j].RowIndex()).Grid().YMin());
+		}*/
+
+	if (sliceNeighbour.fCommonMem->fNTracklets == 0) return(0);
+
+	AliHLTTPCCATrackParam tParam;
+	tParam.InitParam();
+	tParam.SetCov( 0, 0.05 );
+	tParam.SetCov( 2, 0.05 );
+	tParam.SetCov( 5, 0.001 );
+	tParam.SetCov( 9, 0.001 );
+	tParam.SetCov( 14, 0.05 );
+	tParam.SetParam(fTracks[iTrack].Param());
+
+	//printf("Parameters X %f Y %f Z %f SinPhi %f DzDs %f QPt %f SignCosPhi %f\n", tParam.X(), tParam.Y(), tParam.Z(), tParam.SinPhi(), tParam.DzDs(), tParam.QPt(), tParam.SignCosPhi());
+	if (!tParam.Rotate(angle, .999)) return(0);
+	//printf("Rotated X %f Y %f Z %f SinPhi %f DzDs %f QPt %f SignCosPhi %f\n", tParam.X(), tParam.Y(), tParam.Z(), tParam.SinPhi(), tParam.DzDs(), tParam.QPt(), tParam.SignCosPhi());
+
+	int maxRowGap = 6;
+	do
+	{
+		rowIndex += direction;
+		if (!tParam.TransportToX(sliceNeighbour.Row(rowIndex).X(), fParam.ConstBz(), .999)) {maxRowGap = 0;break;}
+		//printf("Transported X %f Y %f Z %f SinPhi %f DzDs %f QPt %f SignCosPhi %f (MaxY %f)\n", tParam.X(), tParam.Y(), tParam.Z(), tParam.SinPhi(), tParam.DzDs(), tParam.QPt(), tParam.SignCosPhi(), sliceNeighbour.Row(rowIndex).MaxY());
+	} while (fabs(tParam.Y()) > sliceNeighbour.Row(rowIndex).MaxY() && --maxRowGap);
+	if (maxRowGap == 0) return(0);
+
+	int nHits = AliHLTTPCCATrackletConstructor::AliHLTTPCCATrackletConstructorGlobalTracking(sliceNeighbour, tParam, rowIndex, direction);
+	if (nHits >= GLOBAL_TRACKING_MIN_HITS)
+	{
+		//printf("%d hits found\n", nHits);
+		AliHLTTPCCATrack& track = sliceNeighbour.fTracks[sliceNeighbour.fCommonMem->fNTracks];
+		if (direction == 1)
+		{
+			int i = 0;
+			while (i < nHits)
+			{
+				if (sliceNeighbour.fTrackletRowHits[rowIndex * sliceNeighbour.fCommonMem->fNTracklets] != -1)
+				{
+					//printf("New track: entry %d, row %d, hitindex %d\n", i, rowIndex, sliceNeighbour.fTrackletRowHits[rowIndex * sliceNeighbour.fCommonMem->fNTracklets]);
+					sliceNeighbour.fTrackHits[sliceNeighbour.fCommonMem->fNTrackHits + i].Set(rowIndex, sliceNeighbour.fTrackletRowHits[rowIndex * sliceNeighbour.fCommonMem->fNTracklets]);
+					if (i == 0) tParam.TransportToX(sliceNeighbour.Row(rowIndex).X(), fParam.ConstBz(), .999);
+					i++;
+				}
+				rowIndex ++;
+			}
+		}
+		else
+		{
+			int i = nHits - 1;
+			while (i >= 0)
+			{
+				if (sliceNeighbour.fTrackletRowHits[rowIndex * sliceNeighbour.fCommonMem->fNTracklets] != -1)
+				{
+					//printf("New track: entry %d, row %d, hitindex %d\n", i, rowIndex, sliceNeighbour.fTrackletRowHits[rowIndex * sliceNeighbour.fCommonMem->fNTracklets]);
+					sliceNeighbour.fTrackHits[sliceNeighbour.fCommonMem->fNTrackHits + i].Set(rowIndex, sliceNeighbour.fTrackletRowHits[rowIndex * sliceNeighbour.fCommonMem->fNTracklets]);
+					i--;
+				}
+				rowIndex--;
+			}
+		}
+		track.SetAlive(1);
+		track.SetParam(tParam.GetParam());
+		track.SetNHits(nHits);
+		track.SetFirstHitID(sliceNeighbour.fCommonMem->fNTrackHits);
+		const int kMaxTrackIdInSlice = AliHLTTPCCASliceOutTrack::MaxTrackId();
+		track.SetLocalTrackId(fParam.ISlice() * kMaxTrackIdInSlice + fTracks[iTrack].LocalTrackId());
+		sliceNeighbour.fCommonMem->fNTracks++;
+		sliceNeighbour.fCommonMem->fNTrackHits += nHits;
+		return(1);
+	}
+	return(0);
 }
 
-GPUh() void AliHLTTPCCATracker::ReadTracks( std::istream &in )
+GPUh() void AliHLTTPCCATracker::PerformGlobalTracking(AliHLTTPCCATracker& sliceLeft, AliHLTTPCCATracker& sliceRight, int MaxTracks)
 {
-  //* Read tracks  from file
-  AliHLTTPCCASliceOutput::Allocate(*fOutput, 4096, 16384, fOutputControl);//Just some max values
-  AliHLTTPCCASliceOutput* useOutput = *fOutput;
-
-  int tmpval;
-  in >> fTimers[0];
-  in >> tmpval;
-  useOutput->SetNOutTrackHits(tmpval);
-
-  for ( int ih = 0; ih < useOutput->NOutTrackHits(); ih++ ) {
-    in >> tmpval;
-	useOutput->SetOutTrackHit(ih, tmpval);
-  }
-  in >> tmpval;
-  useOutput->SetNOutTracks(tmpval);
-
-  for ( int itr = 0; itr < useOutput->NOutTracks(); itr++ ) {
-    AliHLTTPCCAOutTrack &t = useOutput->OutTracks()[itr];
-    AliHLTTPCCATrackParam p1, p2;
-    int i;
-    float f;
-    in >> i; t.SetNHits( i );
-    in >> i; t.SetFirstHitRef( i );
-    in >> i; t.SetOrigTrackID( i );
-    in >> f; p1.SetX( f );
-    in >> f; p1.SetSignCosPhi( f );
-    in >> f; p1.SetChi2( f );
-    in >> i; p1.SetNDF( i );
-    for ( int j = 0; j < 5; j++ ) { in >> f; p1.SetPar( j, f ); }
-    for ( int j = 0; j < 15; j++ ) { in >> f; p1.SetCov( j, f ); }
-    in >> f; p2.SetX( f );
-    in >> f; p2.SetSignCosPhi( f );
-    in >> f; p2.SetChi2( f );
-    in >> i; p2.SetNDF( i );
-    for ( int j = 0; j < 5; j++ ) { in >> f; p2.SetPar( j, f ); }
-    for ( int j = 0; j < 15; j++ ) { in >> f; p2.SetCov( j, f ); }
-    t.SetStartPoint( p1 );
-    t.SetEndPoint( p2 );
-  }
+	int ul = 0, ur = 0, ll = 0, lr = 0;
+	for (int i = 0;i < fCommonMem->fNLocalTracks;i++)
+	{
+		if (sliceLeft.fCommonMem->fNTracks >= MaxTracks || sliceRight.fCommonMem->fNTracks >= MaxTracks) return;
+
+		{
+			const int tmpHit = fTracks[i].FirstHitID();
+			if (fTrackHits[tmpHit].RowIndex() >= GLOBAL_TRACKING_MIN_ROWS && fTrackHits[tmpHit].RowIndex() < GLOBAL_TRACKING_RANGE)
+			{
+				int rowIndex = fTrackHits[tmpHit].RowIndex();
+				const AliHLTTPCCARow& row = Row(rowIndex);
+				float Y = (float) Data().HitDataY(row, fTrackHits[tmpHit].HitIndex()) * row.HstepY() + row.Grid().YMin();
+				if (Y < -row.MaxY() * GLOBAL_TRACKING_Y_RANGE_LOWER_LEFT)
+				{
+					//printf("Track %d, lower row %d, left border (%f of %f)\n", i, fTrackHits[tmpHit].RowIndex(), Y, -row.MaxY());
+					ll += PerformGlobalTrackingRun(sliceLeft, i, rowIndex, -fParam.DAlpha(), -1);
+				}
+				if (Y > row.MaxY() * GLOBAL_TRACKING_Y_RANGE_LOWER_RIGHT)
+				{
+					//printf("Track %d, lower row %d, right border (%f of %f)\n", i, fTrackHits[tmpHit].RowIndex(), Y, row.MaxY());
+					lr += PerformGlobalTrackingRun(sliceRight, i, rowIndex, fParam.DAlpha(), -1);
+				}
+			}
+		}
+		
+		{
+			const int tmpHit = fTracks[i].FirstHitID() + fTracks[i].NHits() - 1;
+			if (fTrackHits[tmpHit].RowIndex() < HLTCA_ROW_COUNT - GLOBAL_TRACKING_MIN_ROWS && fTrackHits[tmpHit].RowIndex() >= HLTCA_ROW_COUNT - GLOBAL_TRACKING_RANGE)
+			{
+				int rowIndex = fTrackHits[tmpHit].RowIndex();
+				const AliHLTTPCCARow& row = Row(rowIndex);
+				float Y = (float) Data().HitDataY(row, fTrackHits[tmpHit].HitIndex()) * row.HstepY() + row.Grid().YMin();
+				if (Y < -row.MaxY() * GLOBAL_TRACKING_Y_RANGE_UPPER_LEFT)
+				{
+					//printf("Track %d, upper row %d, left border (%f of %f)\n", i, fTrackHits[tmpHit].RowIndex(), Y, -row.MaxY());
+					ul += PerformGlobalTrackingRun(sliceLeft, i, rowIndex, -fParam.DAlpha(), 1);
+				}
+				if (Y > row.MaxY() * GLOBAL_TRACKING_Y_RANGE_UPPER_RIGHT)
+				{
+					//printf("Track %d, upper row %d, right border (%f of %f)\n", i, fTrackHits[tmpHit].RowIndex(), Y, row.MaxY());
+					ur += PerformGlobalTrackingRun(sliceRight, i, rowIndex, fParam.DAlpha(), 1);
+				}
+			}
+		}
+	}
+	//printf("Global Tracking Result: Slide %2d: LL %3d LR %3d UL %3d UR %3d\n", fParam.ISlice(), ll, lr, ul, ur);
 }
+
 #endif
+#endif
\ No newline at end of file