[u/mrichter/AliRoot.git] / HLT / TPCLib / tracking-ca / AliHLTTPCCATracker.h

//-*- Mode: C++ -*-
// @(#) $Id$
// ************************************************************************
// This file is property of and copyright by the ALICE HLT Project        *
// ALICE Experiment at CERN, All rights reserved.                         *
// See cxx source for full Copyright notice                               *
//                                                                        *
//*************************************************************************

#ifndef ALIHLTTPCCATRACKER_H
#define ALIHLTTPCCATRACKER_H


#include "AliHLTTPCCADef.h"
#include "AliHLTTPCCAGPUConfig.h"
#include "AliHLTTPCCAParam.h"
#include "AliHLTTPCCARow.h"
#include "AliHLTTPCCAHit.h"
#include <iostream>
#include "AliHLTArray.h"
#include "AliHLTTPCCAHitId.h"
#include "AliHLTTPCCASliceData.h"
#include "AliHLTTPCCATracklet.h"
#include "AliHLTTPCCAOutTrack.h"
#include "AliHLTTPCCASliceOutput.h"
#include "AliHLTTPCCATrackletConstructor.h"

class AliHLTTPCCATrack;
class AliHLTTPCCATrackParam;
class AliHLTTPCCAClusterData;

/**
 * @class AliHLTTPCCATracker
 *
 * Slice tracker for ALICE HLT.
 * The class reconstructs tracks in one slice of TPC.
 * The reconstruction algorithm is based on the Cellular Automaton method
 *
 * The CA tracker is designed stand-alone.
 * It is integrated to the HLT framework via AliHLTTPCCATrackerComponent interface.
 * The class is under construction.
 *
 */

class AliHLTTPCCAClusterData;

class AliHLTTPCCATracker
{
  public:

	AliHLTTPCCATracker()
		: fParam(),
		fOutputControl(),
		fClusterData( 0 ),
		fData(),
		fIsGPUTracker( false ),
		fGPUDebugLevel( 0 ),
		fGPUDebugOut( 0 ),
		fRowStartHitCountOffset( NULL ),
		fTrackletTmpStartHits( NULL ),
		fGPUTrackletTemp( NULL ),
		fRowBlockTracklets( NULL ),
		fRowBlockPos( NULL ),
		fBlockStartingTracklet( NULL ),
		fGPUParametersConst(),
		fCommonMem( 0 ),
		fHitMemory( 0 ),
		fHitMemorySize( 0 ),
		fTrackletMemory( 0 ),
		fTrackletMemorySize( 0 ),
		fTrackMemory( 0 ),
		fTrackMemorySize( 0 ),
		fTrackletStartHits( 0 ),
		fTracklets( 0 ),
		fTrackletRowHits( NULL ),
		fTracks( 0 ),
		fTrackHits( 0 ),
		fOutput( 0 )
	{
	  // constructor
	}
    ~AliHLTTPCCATracker();

	struct StructGPUParameters
	{
		StructGPUParameters() : fScheduleFirstDynamicTracklet( 0 ), fGPUError( 0 ) {}
		int fScheduleFirstDynamicTracklet;		//Last Tracklet with fixed position in sheduling
		int fGPUError;							//Signalizes error on GPU during GPU Reconstruction, kind of return value
	};

	struct StructGPUParametersConst
	{
		StructGPUParametersConst() : fGPUFixedBlockCount( 0 ), fGPUiSlice( 0 ), fGPUnSlices( 0 ) {}
		int fGPUFixedBlockCount;				//Count of blocks that is used for this tracker in fixed schedule situations
		int fGPUiSlice;
		int fGPUnSlices;
	};

	struct commonMemoryStruct
	{
		commonMemoryStruct() : fNTracklets( 0 ), fNTracks( 0 ), fNTrackHits( 0 ), fGPUParameters() {}
	    int fNTracklets;     // number of tracklets
	    int fNTracks;            // number of reconstructed tracks
	    int fNTrackHits;           // number of track hits
		StructGPUParameters fGPUParameters;
	};

    void Initialize( const AliHLTTPCCAParam &param );

    void StartEvent();

	int CheckEmptySlice();
	void WriteOutput();

#if !defined(HLTCA_GPUCODE)
    void Reconstruct();
#endif

	//Make Reconstruction steps directly callable (Used for GPU debugging)
	void RunNeighboursFinder();
	void RunNeighboursCleaner();
	void RunStartHitsFinder();
	void RunTrackletConstructor();
	void RunTrackletSelector();

	//GPU Tracker Interface
	void SetGPUTracker();
	void SetGPUDebugLevel(int Level, std::ostream *NewDebugOut = NULL) {fGPUDebugLevel = Level;if (NewDebugOut) fGPUDebugOut = NewDebugOut;}

	char* SetGPUTrackerCommonMemory(char* pGPUMemory);
	char* SetGPUTrackerHitsMemory(char* pGPUMemory, int MaxNHits);
	char* SetGPUTrackerTrackletsMemory(char* pGPUMemory, int MaxNTracklets);
	char* SetGPUTrackerTracksMemory(char* pGPUMemory, int MaxNTracks, int MaxNHits );

	//Debugging Stuff
	void DumpSliceData(std::ostream &out);	//Dump Input Slice Data
	void DumpLinks(std::ostream &out);		//Dump all links to file (for comparison after NeighboursFinder/Cleaner)
	void DumpStartHits(std::ostream &out);	//Same for Start Hits
	void DumpHitWeights(std::ostream &out); //....
	void DumpTrackHits(std::ostream &out);	//Same for Track Hits
	void DumpTrackletHits(std::ostream &out);	//Same for Track Hits

    GPUd() void GetErrors2( int iRow,  const AliHLTTPCCATrackParam &t, float &Err2Y, float &Err2Z ) const;
    GPUd() void GetErrors2( int iRow, float z, float sinPhi, float cosPhi, float DzDs, float &Err2Y, float &Err2Z ) const;

    void FitTrack( const AliHLTTPCCATrack &track, float *t0 = 0 ) const;
    void FitTrackFull( const AliHLTTPCCATrack &track, float *t0 = 0 ) const;

    void SetupCommonMemory();
    void SetPointersHits( int MaxNHits );
	void SetPointersTracklets ( int MaxNTracklets );
    void SetPointersTracks( int MaxNTracks, int MaxNHits );

	void SetOutput( AliHLTTPCCASliceOutput** out ) { fOutput = out; }

    void ReadEvent( AliHLTTPCCAClusterData *clusterData );

#if !defined(HLTCA_GPUCODE)
    GPUh() void WriteEvent( std::ostream &out );
    GPUh() void WriteTracks( std::ostream &out ) ;
    GPUh() void ReadTracks( std::istream &in );
#endif

    GPUhd() const AliHLTTPCCAParam &Param() const { return fParam; }
    GPUhd() void SetParam( const AliHLTTPCCAParam &v ) { fParam = v; }

	GPUhd() const AliHLTTPCCASliceOutput::outputControlStruct* OutputControl() const { return fOutputControl; }
	GPUh() void SetOutputControl( AliHLTTPCCASliceOutput::outputControlStruct* val)	{ fOutputControl = val;	}

    GPUhd() AliHLTTPCCAClusterData *ClusterData() const { return fClusterData; }
    GPUhd() const AliHLTTPCCASliceData &Data() const { return fData; }
	GPUhd() AliHLTTPCCASliceData *pData() {return &fData; }

	GPUh() void ClearSliceDataHitWeights() {fData.ClearHitWeights();}

    GPUhd() const AliHLTTPCCARow &Row( int rowIndex ) const { return fData.Row( rowIndex ); }
    GPUh() const AliHLTTPCCARow &Row( const AliHLTTPCCAHitId &HitId ) const { return fData.Row( HitId.RowIndex() ); }

    GPUhd() double Timer( int i ) const { return fTimers[i]; }
    GPUhd() void SetTimer( int i, double v ) { fTimers[i] = v; }

    GPUhd() int NHitsTotal() const { return fData.NumberOfHits(); }

    GPUd() void SetHitLinkUpData( const AliHLTTPCCARow &row, int hitIndex, short v ) { fData.SetHitLinkUpData( row, hitIndex, v ); }
    GPUd() void SetHitLinkDownData( const AliHLTTPCCARow &row, int hitIndex, short v ) { fData.SetHitLinkDownData( row, hitIndex, v ); }
    GPUd() short HitLinkUpData( const AliHLTTPCCARow &row, int hitIndex ) const { return fData.HitLinkUpData( row, hitIndex ); }
    GPUd() short HitLinkDownData( const AliHLTTPCCARow &row, int hitIndex ) const { return fData.HitLinkDownData( row, hitIndex ); }

	GPUd() const ushort2 *HitData( const AliHLTTPCCARow &row ) const { return fData.HitData(row); }
	GPUd() const short_v *HitLinkUpData  ( const AliHLTTPCCARow &row ) const { return fData.HitLinkUpData(row); }
	GPUd() const short_v *HitLinkDownData( const AliHLTTPCCARow &row ) const { return fData.HitLinkDownData(row); }
	GPUd() const ushort_v *FirstHitInBin( const AliHLTTPCCARow &row ) const { return fData.FirstHitInBin(row); }
	
	GPUd() int FirstHitInBin( const AliHLTTPCCARow &row, int binIndex ) const { return fData.FirstHitInBin( row, binIndex ); }

    GPUd() unsigned short HitDataY( const AliHLTTPCCARow &row, int hitIndex ) const {
      return fData.HitDataY( row, hitIndex );
    }
    GPUd() unsigned short HitDataZ( const AliHLTTPCCARow &row, int hitIndex ) const {
      return fData.HitDataZ( row, hitIndex );
    }
    GPUd() ushort2 HitData( const AliHLTTPCCARow &row, int hitIndex ) const {
      return fData.HitData( row, hitIndex );
    }

    GPUhd() int HitInputID( const AliHLTTPCCARow &row, int hitIndex ) const { return fData.ClusterDataIndex( row, hitIndex ); }

    /**
     * The hit weight is used to determine whether a hit belongs to a certain tracklet or another one
     * competing for the same hit. The tracklet that has a higher weight wins. Comparison is done
     * using the the number of hits in the tracklet (the more hits it has the more it keeps). If
     * tracklets have the same number of hits then it doesn't matter who gets it, but it should be
     * only one. So a unique number (row index is good) is added in the least significant part of
     * the weight
     */
    static int CalculateHitWeight( int NHits, int unique ) {
      return ( NHits << 16 ) + unique;
    }
    GPUd() void MaximizeHitWeight( const AliHLTTPCCARow &row, int hitIndex, int weight ) {
      fData.MaximizeHitWeight( row, hitIndex, weight );
    }
    GPUd() int HitWeight( const AliHLTTPCCARow &row, int hitIndex ) const {
      return fData.HitWeight( row, hitIndex );
    }

    GPUhd() int NTracklets() const { return fCommonMem->fNTracklets; }
    GPUhd() int  *NTracklets() { return &fCommonMem->fNTracklets; }

    GPUhd() const AliHLTTPCCAHitId &TrackletStartHit( int i ) const { return fTrackletStartHits[i]; }
    GPUhd() AliHLTTPCCAHitId *TrackletStartHits() const { return fTrackletStartHits; }
    GPUhd() AliHLTTPCCAHitId *TrackletTmpStartHits() const { return fTrackletTmpStartHits; }
    GPUhd() const AliHLTTPCCATracklet &Tracklet( int i ) const { return fTracklets[i]; }
    GPUhd() AliHLTTPCCATracklet  *Tracklets() const { return fTracklets;}
	GPUhd() int* TrackletRowHits() { return fTrackletRowHits; }

    GPUhd() int *NTracks()  const { return &fCommonMem->fNTracks; }
    GPUhd() AliHLTTPCCATrack *Tracks() const { return  fTracks; }
    GPUhd() int *NTrackHits()  const { return &fCommonMem->fNTrackHits; }
    GPUhd() AliHLTTPCCAHitId *TrackHits() const { return fTrackHits; }

    GPUhd() AliHLTTPCCASliceOutput** Output() const { return fOutput; }

	GPUh() commonMemoryStruct *CommonMemory() {return(fCommonMem); }
	static GPUh() size_t CommonMemorySize() { return(sizeof(AliHLTTPCCATracker::commonMemoryStruct)); }
	GPUh() char* &HitMemory() {return(fHitMemory); }
	GPUh() size_t HitMemorySize() const {return(fHitMemorySize); }
	GPUh() char* &TrackletMemory() {return(fTrackletMemory); }
	GPUh() size_t TrackletMemorySize() const {return(fTrackletMemorySize); }
	GPUh() char* &TrackMemory() {return(fTrackMemory); }
	GPUh() size_t TrackMemorySize() const {return(fTrackMemorySize); }
	GPUhd() AliHLTTPCCARow* SliceDataRows() {return(fData.Rows()); }

	GPUhd() uint3* RowStartHitCountOffset() const {return(fRowStartHitCountOffset);}
	GPUhd() AliHLTTPCCATrackletConstructor::AliHLTTPCCAGPUTempMemory* GPUTrackletTemp() const {return(fGPUTrackletTemp);}
	GPUhd() int* RowBlockTracklets(int reverse, int iRowBlock) const {return(&fRowBlockTracklets[(reverse * ((fParam.NRows() / HLTCA_GPU_SCHED_ROW_STEP) + 1) + iRowBlock) * fCommonMem->fNTracklets]);}
	GPUhd() int* RowBlockTracklets() const {return(fRowBlockTracklets);}
	GPUhd() int4* RowBlockPos(int reverse, int iRowBlock) const {return(&fRowBlockPos[reverse * ((fParam.NRows() / HLTCA_GPU_SCHED_ROW_STEP) + 1) + iRowBlock]);}
	GPUhd() int4* RowBlockPos() const {return(fRowBlockPos);}
	GPUhd() uint2* BlockStartingTracklet() const {return(fBlockStartingTracklet);}
	GPUhd() StructGPUParameters* GPUParameters() const {return(&fCommonMem->fGPUParameters);}
	GPUhd() StructGPUParametersConst* GPUParametersConst() {return(&fGPUParametersConst);}
	
	GPUh() unsigned long long int* PerfTimer(unsigned int i) {return &fPerfTimers[i]; }

#ifdef HLTCA_GPU_TRACKLET_CONSTRUCTOR_DO_PROFILE
	char* fStageAtSync;				//Pointer to array storing current stage for every thread at every sync point
	int* fThreadTimes;
#endif

  private:
    AliHLTTPCCAParam fParam; // parameters
	double fTimers[10];
    unsigned long long int fPerfTimers[16]; // running CPU time for different parts of the algorithm
	void StandalonePerfTime(int i);

	AliHLTTPCCASliceOutput::outputControlStruct* fOutputControl;

    /** A pointer to the ClusterData object that the SliceData was created from. This can be used to
     * merge clusters from inside the SliceTracker code and recreate the SliceData. */
    AliHLTTPCCAClusterData *fClusterData; // ^
    AliHLTTPCCASliceData fData; // The SliceData object. It is used to encapsulate the storage in memory from the access

	bool fIsGPUTracker; // is it GPU tracker object
	int fGPUDebugLevel; // debug level
	std::ostream *fGPUDebugOut; // debug stream

	//GPU Temp Arrays
	uint3* fRowStartHitCountOffset;				//Offset, length and new offset of start hits in row
	AliHLTTPCCAHitId *fTrackletTmpStartHits;	//Unsorted start hits
	AliHLTTPCCATrackletConstructor::AliHLTTPCCAGPUTempMemory *fGPUTrackletTemp;	//Temp Memory for GPU Tracklet Constructor
	int* fRowBlockTracklets;					//Reference which tracklet is processed in which rowblock next
	int4* fRowBlockPos;							//x is last tracklet to be processed, y is last tracklet already processed, z is last tracklet to be processed in next iteration, w is initial x value to check if tracklet must be initialized
	uint2* fBlockStartingTracklet;

	StructGPUParametersConst fGPUParametersConst;

	// event

	commonMemoryStruct *fCommonMem; // common event memory

    char *fHitMemory; // event memory for hits
    size_t   fHitMemorySize; // size of the event memory [bytes]

	char *fTrackletMemory;
	size_t fTrackletMemorySize;

    char *fTrackMemory; // event memory for tracks
    size_t   fTrackMemorySize; // size of the event memory [bytes]

    AliHLTTPCCAHitId *fTrackletStartHits;   // start hits for the tracklets
    AliHLTTPCCATracklet *fTracklets; // tracklets
	int *fTrackletRowHits;

    //
    AliHLTTPCCATrack *fTracks;  // reconstructed tracks
    AliHLTTPCCAHitId *fTrackHits;          // array of track hit numbers

    // output

    AliHLTTPCCASliceOutput **fOutput;

    // disable copy
    AliHLTTPCCATracker( const AliHLTTPCCATracker& );
    AliHLTTPCCATracker &operator=( const AliHLTTPCCATracker& );

	static int starthitSortComparison(const void*a, const void* b);
};


#endif
Commit	Line	Data
326c2d4b	1	//-- Mode: C++ --
326c2d4b	2	// @(#) $Id$
ce565086	3	// ************************************************************************
fbb9b71b	4	// This file is property of and copyright by the ALICE HLT Project *
ce565086	5	// ALICE Experiment at CERN, All rights reserved. *
	6	// See cxx source for full Copyright notice *
	7	// *
	8	//*************************************************************************
326c2d4b	9
	10	#ifndef ALIHLTTPCCATRACKER_H
	11	#define ALIHLTTPCCATRACKER_H
	12
	13
00d07bcd	14	#include "AliHLTTPCCADef.h"
b22af1bf	15	#include "AliHLTTPCCAGPUConfig.h"
326c2d4b	16	#include "AliHLTTPCCAParam.h"
326c2d4b	17	#include "AliHLTTPCCARow.h"
00d07bcd	18	#include "AliHLTTPCCAHit.h"
4687b8fc	19	#include <iostream>
4acc2401	20	#include "AliHLTArray.h"
	21	#include "AliHLTTPCCAHitId.h"
	22	#include "AliHLTTPCCASliceData.h"
	23	#include "AliHLTTPCCATracklet.h"
	24	#include "AliHLTTPCCAOutTrack.h"
b22af1bf	25	#include "AliHLTTPCCASliceOutput.h"
b22af1bf	26	#include "AliHLTTPCCATrackletConstructor.h"
326c2d4b	27
d54804bf	28	class AliHLTTPCCATrack;
d54804bf	29	class AliHLTTPCCATrackParam;
4acc2401	30	class AliHLTTPCCAClusterData;
326c2d4b	31
	32	/**
	33	* @class AliHLTTPCCATracker
fbb9b71b	34	*
fbb9b71b	35	* Slice tracker for ALICE HLT.
dc4788ec	36	* The class reconstructs tracks in one slice of TPC.
	37	* The reconstruction algorithm is based on the Cellular Automaton method
	38	*
fbb9b71b	39	* The CA tracker is designed stand-alone.
dc4788ec	40	* It is integrated to the HLT framework via AliHLTTPCCATrackerComponent interface.
	41	* The class is under construction.
	42	*
326c2d4b	43	*/
b22af1bf	44
	45	class AliHLTTPCCAClusterData;
	46
326c2d4b	47	class AliHLTTPCCATracker
326c2d4b	48	{
fbb9b71b	49	public:
326c2d4b	50
7be9b0d7	51	AliHLTTPCCATracker()
b22af1bf	52	: fParam(),
d4594e7d	53	fOutputControl(),
7be9b0d7	54	fClusterData( 0 ),
	55	fData(),
	56	fIsGPUTracker( false ),
	57	fGPUDebugLevel( 0 ),
	58	fGPUDebugOut( 0 ),
b22af1bf	59	fRowStartHitCountOffset( NULL ),
	60	fTrackletTmpStartHits( NULL ),
	61	fGPUTrackletTemp( NULL ),
	62	fRowBlockTracklets( NULL ),
	63	fRowBlockPos( NULL ),
	64	fBlockStartingTracklet( NULL ),
	65	fGPUParametersConst(),
	66	fCommonMem( 0 ),
7be9b0d7	67	fHitMemory( 0 ),
7be9b0d7	68	fHitMemorySize( 0 ),
b22af1bf	69	fTrackletMemory( 0 ),
b22af1bf	70	fTrackletMemorySize( 0 ),
7be9b0d7	71	fTrackMemory( 0 ),
7be9b0d7	72	fTrackMemorySize( 0 ),
7be9b0d7	73	fTrackletStartHits( 0 ),
7be9b0d7	74	fTracklets( 0 ),
b22af1bf	75	fTrackletRowHits( NULL ),
7be9b0d7	76	fTracks( 0 ),
7be9b0d7	77	fTrackHits( 0 ),
b22af1bf	78	fOutput( 0 )
7be9b0d7	79	{
	80	// constructor
	81	}
b22af1bf	82	~AliHLTTPCCATracker();
	83
	84	struct StructGPUParameters
	85	{
d4594e7d	86	StructGPUParameters() : fScheduleFirstDynamicTracklet( 0 ), fGPUError( 0 ) {}
b22af1bf	87	int fScheduleFirstDynamicTracklet; //Last Tracklet with fixed position in sheduling
	88	int fGPUError; //Signalizes error on GPU during GPU Reconstruction, kind of return value
	89	};
	90
	91	struct StructGPUParametersConst
	92	{
d4594e7d	93	StructGPUParametersConst() : fGPUFixedBlockCount( 0 ), fGPUiSlice( 0 ), fGPUnSlices( 0 ) {}
b22af1bf	94	int fGPUFixedBlockCount; //Count of blocks that is used for this tracker in fixed schedule situations
	95	int fGPUiSlice;
	96	int fGPUnSlices;
	97	};
	98
	99	struct commonMemoryStruct
	100	{
d4594e7d	101	commonMemoryStruct() : fNTracklets( 0 ), fNTracks( 0 ), fNTrackHits( 0 ), fGPUParameters() {}
b22af1bf	102	int fNTracklets; // number of tracklets
	103	int fNTracks; // number of reconstructed tracks
	104	int fNTrackHits; // number of track hits
	105	StructGPUParameters fGPUParameters;
	106	};
326c2d4b	107
7be9b0d7	108	void Initialize( const AliHLTTPCCAParam &param );
fbb9b71b	109
7be9b0d7	110	void StartEvent();
fbb9b71b	111
7be9b0d7	112	int CheckEmptySlice();
7be9b0d7	113	void WriteOutput();
fbb9b71b	114
7be9b0d7	115	#if !defined(HLTCA_GPUCODE)
fbb9b71b	116	void Reconstruct();
7be9b0d7	117	#endif
	118
	119	//Make Reconstruction steps directly callable (Used for GPU debugging)
	120	void RunNeighboursFinder();
	121	void RunNeighboursCleaner();
	122	void RunStartHitsFinder();
	123	void RunTrackletConstructor();
	124	void RunTrackletSelector();
	125
	126	//GPU Tracker Interface
	127	void SetGPUTracker();
	128	void SetGPUDebugLevel(int Level, std::ostream *NewDebugOut = NULL) {fGPUDebugLevel = Level;if (NewDebugOut) fGPUDebugOut = NewDebugOut;}
	129
	130	char* SetGPUTrackerCommonMemory(char* pGPUMemory);
b22af1bf	131	char* SetGPUTrackerHitsMemory(char* pGPUMemory, int MaxNHits);
b22af1bf	132	char* SetGPUTrackerTrackletsMemory(char* pGPUMemory, int MaxNTracklets);
7be9b0d7	133	char* SetGPUTrackerTracksMemory(char* pGPUMemory, int MaxNTracks, int MaxNHits );
	134
	135	//Debugging Stuff
b22af1bf	136	void DumpSliceData(std::ostream &out); //Dump Input Slice Data
7be9b0d7	137	void DumpLinks(std::ostream &out); //Dump all links to file (for comparison after NeighboursFinder/Cleaner)
7be9b0d7	138	void DumpStartHits(std::ostream &out); //Same for Start Hits
b22af1bf	139	void DumpHitWeights(std::ostream &out); //....
7be9b0d7	140	void DumpTrackHits(std::ostream &out); //Same for Track Hits
7be9b0d7	141	void DumpTrackletHits(std::ostream &out); //Same for Track Hits
fbb9b71b	142
	143	GPUd() void GetErrors2( int iRow, const AliHLTTPCCATrackParam &t, float &Err2Y, float &Err2Z ) const;
	144	GPUd() void GetErrors2( int iRow, float z, float sinPhi, float cosPhi, float DzDs, float &Err2Y, float &Err2Z ) const;
	145
4acc2401	146	void FitTrack( const AliHLTTPCCATrack &track, float *t0 = 0 ) const;
4acc2401	147	void FitTrackFull( const AliHLTTPCCATrack &track, float *t0 = 0 ) const;
fbb9b71b	148
b22af1bf	149	void SetupCommonMemory();
7be9b0d7	150	void SetPointersHits( int MaxNHits );
b22af1bf	151	void SetPointersTracklets ( int MaxNTracklets );
7be9b0d7	152	void SetPointersTracks( int MaxNTracks, int MaxNHits );
fbb9b71b	153
98512261	154	void SetOutput( AliHLTTPCCASliceOutput** out ) { fOutput = out; }
b22af1bf	155
7be9b0d7	156	void ReadEvent( AliHLTTPCCAClusterData *clusterData );
7be9b0d7	157
b22af1bf	158	#if !defined(HLTCA_GPUCODE)
fbb9b71b	159	GPUh() void WriteEvent( std::ostream &out );
fbb9b71b	160	GPUh() void WriteTracks( std::ostream &out ) ;
fbb9b71b	161	GPUh() void ReadTracks( std::istream &in );
4687b8fc	162	#endif
4687b8fc	163
fbb9b71b	164	GPUhd() const AliHLTTPCCAParam &Param() const { return fParam; }
	165	GPUhd() void SetParam( const AliHLTTPCCAParam &v ) { fParam = v; }
	166
d4594e7d	167	GPUhd() const AliHLTTPCCASliceOutput::outputControlStruct* OutputControl() const { return fOutputControl; }
	168	GPUh() void SetOutputControl( AliHLTTPCCASliceOutput::outputControlStruct* val) { fOutputControl = val; }
	169
b22af1bf	170	GPUhd() AliHLTTPCCAClusterData *ClusterData() const { return fClusterData; }
6de2bc40	171	GPUhd() const AliHLTTPCCASliceData &Data() const { return fData; }
b22af1bf	172	GPUhd() AliHLTTPCCASliceData *pData() {return &fData; }
	173
	174	GPUh() void ClearSliceDataHitWeights() {fData.ClearHitWeights();}
	175
4acc2401	176	GPUhd() const AliHLTTPCCARow &Row( int rowIndex ) const { return fData.Row( rowIndex ); }
7be9b0d7	177	GPUh() const AliHLTTPCCARow &Row( const AliHLTTPCCAHitId &HitId ) const { return fData.Row( HitId.RowIndex() ); }
4acc2401	178
fbb9b71b	179	GPUhd() double Timer( int i ) const { return fTimers[i]; }
	180	GPUhd() void SetTimer( int i, double v ) { fTimers[i] = v; }
	181
4acc2401	182	GPUhd() int NHitsTotal() const { return fData.NumberOfHits(); }
fbb9b71b	183
7be9b0d7	184	GPUd() void SetHitLinkUpData( const AliHLTTPCCARow &row, int hitIndex, short v ) { fData.SetHitLinkUpData( row, hitIndex, v ); }
	185	GPUd() void SetHitLinkDownData( const AliHLTTPCCARow &row, int hitIndex, short v ) { fData.SetHitLinkDownData( row, hitIndex, v ); }
	186	GPUd() short HitLinkUpData( const AliHLTTPCCARow &row, int hitIndex ) const { return fData.HitLinkUpData( row, hitIndex ); }
	187	GPUd() short HitLinkDownData( const AliHLTTPCCARow &row, int hitIndex ) const { return fData.HitLinkDownData( row, hitIndex ); }
4acc2401	188
b22af1bf	189	GPUd() const ushort2 *HitData( const AliHLTTPCCARow &row ) const { return fData.HitData(row); }
	190	GPUd() const short_v *HitLinkUpData ( const AliHLTTPCCARow &row ) const { return fData.HitLinkUpData(row); }
	191	GPUd() const short_v *HitLinkDownData( const AliHLTTPCCARow &row ) const { return fData.HitLinkDownData(row); }
	192	GPUd() const ushort_v *FirstHitInBin( const AliHLTTPCCARow &row ) const { return fData.FirstHitInBin(row); }
	193
	194	GPUd() int FirstHitInBin( const AliHLTTPCCARow &row, int binIndex ) const { return fData.FirstHitInBin( row, binIndex ); }
4acc2401	195
7be9b0d7	196	GPUd() unsigned short HitDataY( const AliHLTTPCCARow &row, int hitIndex ) const {
4acc2401	197	return fData.HitDataY( row, hitIndex );
4acc2401	198	}
7be9b0d7	199	GPUd() unsigned short HitDataZ( const AliHLTTPCCARow &row, int hitIndex ) const {
4acc2401	200	return fData.HitDataZ( row, hitIndex );
4acc2401	201	}
b22af1bf	202	GPUd() ushort2 HitData( const AliHLTTPCCARow &row, int hitIndex ) const {
	203	return fData.HitData( row, hitIndex );
	204	}
fbb9b71b	205
7be9b0d7	206	GPUhd() int HitInputID( const AliHLTTPCCARow &row, int hitIndex ) const { return fData.ClusterDataIndex( row, hitIndex ); }
4acc2401	207
	208	/**
	209	* The hit weight is used to determine whether a hit belongs to a certain tracklet or another one
	210	* competing for the same hit. The tracklet that has a higher weight wins. Comparison is done
	211	* using the the number of hits in the tracklet (the more hits it has the more it keeps). If
	212	* tracklets have the same number of hits then it doesn't matter who gets it, but it should be
	213	* only one. So a unique number (row index is good) is added in the least significant part of
	214	* the weight
	215	*/
6de2bc40	216	static int CalculateHitWeight( int NHits, int unique ) {
4acc2401	217	return ( NHits << 16 ) + unique;
4acc2401	218	}
7be9b0d7	219	GPUd() void MaximizeHitWeight( const AliHLTTPCCARow &row, int hitIndex, int weight ) {
4acc2401	220	fData.MaximizeHitWeight( row, hitIndex, weight );
4acc2401	221	}
7be9b0d7	222	GPUd() int HitWeight( const AliHLTTPCCARow &row, int hitIndex ) const {
4acc2401	223	return fData.HitWeight( row, hitIndex );
4acc2401	224	}
fbb9b71b	225
b22af1bf	226	GPUhd() int NTracklets() const { return fCommonMem->fNTracklets; }
b22af1bf	227	GPUhd() int *NTracklets() { return &fCommonMem->fNTracklets; }
fbb9b71b	228
4acc2401	229	GPUhd() const AliHLTTPCCAHitId &TrackletStartHit( int i ) const { return fTrackletStartHits[i]; }
4acc2401	230	GPUhd() AliHLTTPCCAHitId *TrackletStartHits() const { return fTrackletStartHits; }
b22af1bf	231	GPUhd() AliHLTTPCCAHitId *TrackletTmpStartHits() const { return fTrackletTmpStartHits; }
4acc2401	232	GPUhd() const AliHLTTPCCATracklet &Tracklet( int i ) const { return fTracklets[i]; }
fbb9b71b	233	GPUhd() AliHLTTPCCATracklet *Tracklets() const { return fTracklets;}
b22af1bf	234	GPUhd() int* TrackletRowHits() { return fTrackletRowHits; }
fbb9b71b	235
b22af1bf	236	GPUhd() int *NTracks() const { return &fCommonMem->fNTracks; }
fbb9b71b	237	GPUhd() AliHLTTPCCATrack *Tracks() const { return fTracks; }
b22af1bf	238	GPUhd() int *NTrackHits() const { return &fCommonMem->fNTrackHits; }
4acc2401	239	GPUhd() AliHLTTPCCAHitId *TrackHits() const { return fTrackHits; }
fbb9b71b	240
98512261	241	GPUhd() AliHLTTPCCASliceOutput** Output() const { return fOutput; }
b22af1bf	242
	243	GPUh() commonMemoryStruct *CommonMemory() {return(fCommonMem); }
	244	static GPUh() size_t CommonMemorySize() { return(sizeof(AliHLTTPCCATracker::commonMemoryStruct)); }
	245	GPUh() char* &HitMemory() {return(fHitMemory); }
	246	GPUh() size_t HitMemorySize() const {return(fHitMemorySize); }
	247	GPUh() char* &TrackletMemory() {return(fTrackletMemory); }
	248	GPUh() size_t TrackletMemorySize() const {return(fTrackletMemorySize); }
	249	GPUh() char* &TrackMemory() {return(fTrackMemory); }
	250	GPUh() size_t TrackMemorySize() const {return(fTrackMemorySize); }
b22af1bf	251	GPUhd() AliHLTTPCCARow* SliceDataRows() {return(fData.Rows()); }
	252
	253	GPUhd() uint3* RowStartHitCountOffset() const {return(fRowStartHitCountOffset);}
	254	GPUhd() AliHLTTPCCATrackletConstructor::AliHLTTPCCAGPUTempMemory* GPUTrackletTemp() const {return(fGPUTrackletTemp);}
	255	GPUhd() int* RowBlockTracklets(int reverse, int iRowBlock) const {return(&fRowBlockTracklets[(reverse * ((fParam.NRows() / HLTCA_GPU_SCHED_ROW_STEP) + 1) + iRowBlock) * fCommonMem->fNTracklets]);}
	256	GPUhd() int* RowBlockTracklets() const {return(fRowBlockTracklets);}
	257	GPUhd() int4* RowBlockPos(int reverse, int iRowBlock) const {return(&fRowBlockPos[reverse * ((fParam.NRows() / HLTCA_GPU_SCHED_ROW_STEP) + 1) + iRowBlock]);}
	258	GPUhd() int4* RowBlockPos() const {return(fRowBlockPos);}
	259	GPUhd() uint2* BlockStartingTracklet() const {return(fBlockStartingTracklet);}
	260	GPUhd() StructGPUParameters* GPUParameters() const {return(&fCommonMem->fGPUParameters);}
	261	GPUhd() StructGPUParametersConst* GPUParametersConst() {return(&fGPUParametersConst);}
	262
	263	GPUh() unsigned long long int* PerfTimer(unsigned int i) {return &fPerfTimers[i]; }
	264
	265	#ifdef HLTCA_GPU_TRACKLET_CONSTRUCTOR_DO_PROFILE
	266	char* fStageAtSync; //Pointer to array storing current stage for every thread at every sync point
	267	int* fThreadTimes;
7be9b0d7	268	#endif
7be9b0d7	269
b22af1bf	270	private:
fbb9b71b	271	AliHLTTPCCAParam fParam; // parameters
b22af1bf	272	double fTimers[10];
	273	unsigned long long int fPerfTimers[16]; // running CPU time for different parts of the algorithm
	274	void StandalonePerfTime(int i);
fbb9b71b	275
d4594e7d	276	AliHLTTPCCASliceOutput::outputControlStruct* fOutputControl;
d4594e7d	277
4acc2401	278	/** A pointer to the ClusterData object that the SliceData was created from. This can be used to
	279	* merge clusters from inside the SliceTracker code and recreate the SliceData. */
	280	AliHLTTPCCAClusterData *fClusterData; // ^
	281	AliHLTTPCCASliceData fData; // The SliceData object. It is used to encapsulate the storage in memory from the access
fbb9b71b	282
b22af1bf	283	bool fIsGPUTracker; // is it GPU tracker object
	284	int fGPUDebugLevel; // debug level
	285	std::ostream *fGPUDebugOut; // debug stream
7be9b0d7	286
b22af1bf	287	//GPU Temp Arrays
	288	uint3* fRowStartHitCountOffset; //Offset, length and new offset of start hits in row
	289	AliHLTTPCCAHitId *fTrackletTmpStartHits; //Unsorted start hits
	290	AliHLTTPCCATrackletConstructor::AliHLTTPCCAGPUTempMemory *fGPUTrackletTemp; //Temp Memory for GPU Tracklet Constructor
	291	int* fRowBlockTracklets; //Reference which tracklet is processed in which rowblock next
	292	int4* fRowBlockPos; //x is last tracklet to be processed, y is last tracklet already processed, z is last tracklet to be processed in next iteration, w is initial x value to check if tracklet must be initialized
	293	uint2* fBlockStartingTracklet;
fbb9b71b	294
b22af1bf	295	StructGPUParametersConst fGPUParametersConst;
	296
	297	// event
	298
	299	commonMemoryStruct *fCommonMem; // common event memory
fbb9b71b	300
fbb9b71b	301	char *fHitMemory; // event memory for hits
7be9b0d7	302	size_t fHitMemorySize; // size of the event memory [bytes]
fbb9b71b	303
b22af1bf	304	char *fTrackletMemory;
	305	size_t fTrackletMemorySize;
	306
fbb9b71b	307	char *fTrackMemory; // event memory for tracks
7be9b0d7	308	size_t fTrackMemorySize; // size of the event memory [bytes]
fbb9b71b	309
4acc2401	310	AliHLTTPCCAHitId *fTrackletStartHits; // start hits for the tracklets
fbb9b71b	311	AliHLTTPCCATracklet *fTracklets; // tracklets
b22af1bf	312	int *fTrackletRowHits;
fbb9b71b	313
fbb9b71b	314	//
fbb9b71b	315	AliHLTTPCCATrack *fTracks; // reconstructed tracks
4acc2401	316	AliHLTTPCCAHitId *fTrackHits; // array of track hit numbers
fbb9b71b	317
	318	// output
	319
98512261	320	AliHLTTPCCASliceOutput **fOutput;
fbb9b71b	321
4acc2401	322	// disable copy
	323	AliHLTTPCCATracker( const AliHLTTPCCATracker& );
	324	AliHLTTPCCATracker &operator=( const AliHLTTPCCATracker& );
b22af1bf	325
b22af1bf	326	static int starthitSortComparison(const voida, const void b);
326c2d4b	327	};
326c2d4b	328
00d07bcd	329
326c2d4b	330	#endif