-// $Id: AliHLTTPCCATrackParam.cxx 33907 2009-07-23 13:52:49Z sgorbuno $
+// $Id: AliHLTTPCCABaseTrackParam.cxx 33907 2009-07-23 13:52:49Z sgorbuno $
// **************************************************************************
// This file is property of and copyright by the ALICE HLT Project *
// ALICE Experiment at CERN, All rights reserved. *
// *
//***************************************************************************
-#include "AliHLTTPCCATrackParam2.h"
+#include "AliHLTTPCCABaseTrackParam.h"
//-*- Mode: C++ -*-
-// $Id: AliHLTTPCCATrackParam2.h 35151 2009-10-01 13:35:10Z sgorbuno $
+// $Id: AliHLTTPCCABaseTrackParam.h 35151 2009-10-01 13:35:10Z sgorbuno $
// ************************************************************************
// This file is property of and copyright by the ALICE HLT Project *
// ALICE Experiment at CERN, All rights reserved. *
//*************************************************************************
-#ifndef ALIHLTTPCCATRACKPARAM2_H
-#define ALIHLTTPCCATRACKPARAM2_H
+#ifndef ALIHLTTPCCABASETRACKPARAM_H
+#define ALIHLTTPCCABASETRACKPARAM_H
#include "AliHLTTPCCADef.h"
-
-class AliHLTTPCCATrackLinearisation;
+class AliHLTTPCCATrackParam;
/**
- * @class AliHLTTPCCATrackParam
+ * @class AliHLTTPCCABaseTrackParam
*
- * AliHLTTPCCATrackParam class describes the track parametrisation
- * which is used by the AliHLTTPCCATracker slice tracker.
+ * AliHLTTPCCABaseTrackParam class contains track parameters
+ * used in output of the AliHLTTPCCATracker slice tracker.
* This class is used for transfer between tracker and merger and does not contain the covariance matrice
*/
-class AliHLTTPCCATrackParam2
+class AliHLTTPCCABaseTrackParam
{
public:
float fP[5]; // 'active' track parameters: Y, Z, SinPhi, DzDs, q/Pt
};
-#endif //ALIHLTTPCCATRACKPARAM2_H
+#endif
#include "AliHLTTPCCATrack.h"
#include "AliHLTTPCCAPerformance.h"
#include "AliHLTTPCCAMCTrack.h"
-#include "AliHLTTPCCAOutTrack.h"
#include "TString.h"
#include "Riostream.h"
+++ /dev/null
-// @(#) $Id$
-// **************************************************************************
-// 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> *
-// Ivan Kisel <kisel@kip.uni-heidelberg.de> *
-// for The ALICE HLT Project. *
-// *
-// Permission to use, copy, modify and distribute this software and its *
-// documentation strictly for non-commercial purposes is hereby granted *
-// without fee, provided that the above copyright notice appears in all *
-// copies and that both the copyright notice and this permission notice *
-// 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 "AliHLTTPCCAOutTrack.h"
-
-
-ClassImp( AliHLTTPCCAOutTrack )
-
-GPUh() void AliHLTTPCCAOutTrack::Dummy() const
-{
- //* do nothing
-}
+++ /dev/null
-//-*- 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 ALIHLTTPCCAOUTTRACK_H
-#define ALIHLTTPCCAOUTTRACK_H
-
-#include "AliHLTTPCCATrackParam.h"
-
-/**
- * @class AliHLTTPCCAOutTrack
- * AliHLTTPCCAOutTrack class is used to store the final
- * reconstructed tracks which will be then readed
- * by the AliHLTTPCCATrackerComponent
- *
- * The class contains no temporary variables, etc.
- *
- */
-class AliHLTTPCCAOutTrack
-{
- public:
-
- AliHLTTPCCAOutTrack(): fFirstHitRef( 0 ), fNHits( 0 ), fStartPoint(), fEndPoint(), fOrigTrackID( 0 ) {}
- virtual ~AliHLTTPCCAOutTrack() {}
-
- GPUhd() int NHits() const { return fNHits; }
- GPUhd() int FirstHitRef() const { return fFirstHitRef; }
-
- GPUhd() const AliHLTTPCCATrackParam &StartPoint() const { return fStartPoint; }
- GPUhd() const AliHLTTPCCATrackParam &EndPoint() const { return fEndPoint; }
- GPUhd() int OrigTrackID() const { return fOrigTrackID; }
-
- GPUhd() void SetNHits( int v ) { fNHits = v; }
- GPUhd() void SetFirstHitRef( int v ) { fFirstHitRef = v; }
-
- GPUhd() void SetStartPoint( const AliHLTTPCCATrackParam &v ) { fStartPoint = v; }
- GPUhd() void SetEndPoint( const AliHLTTPCCATrackParam &v ) { fEndPoint = v; }
- GPUhd() void SetOrigTrackID( int v ) { fOrigTrackID = v; }
-
- protected:
-
- int fFirstHitRef; //* index of the first hit reference in track->hit reference array
- int fNHits; //* number of track hits
- AliHLTTPCCATrackParam fStartPoint; //* fitted track parameters at the start point
- AliHLTTPCCATrackParam fEndPoint; //* fitted track parameters at the start point
- int fOrigTrackID; //* index of the original slice track
-
- private:
-
- void Dummy() const; // to make rulechecker happy by having something in .cxx file
-
- ClassDef( AliHLTTPCCAOutTrack, 1 )
-};
-
-
-#endif //ALIHLTTPCCAOUTTRACK_H
#include "AliHLTTPCCAPerformance.h"
#include "AliHLTTPCCAMCTrack.h"
#include "AliHLTTPCCAMCPoint.h"
-#include "AliHLTTPCCAOutTrack.h"
#include "AliHLTTPCCATracker.h"
#include "AliHLTTPCCATracklet.h"
#include "AliHLTTPCCAStandaloneFramework.h"
int size = 0;
- if (outputControl == NULL || outputControl->fDefaultOutput)
{
AssignNoAlignment( fTracksOffset, size, nTracks*sizeof(AliHLTTPCCASliceTrack) );
AssignNoAlignment( fClusterIdOffset, size, nTrackClusters*sizeof(int) );
AssignNoAlignment( fClusterRowOffset, size, nTrackClusters*sizeof(float) );
AssignNoAlignment( fClusterPackedXYZOffset, size, nTrackClusters*sizeof(AliHLTTPCCACompressedCluster) );
- }
-
+ }
+
char *mem = fMemory + size;
- if (outputControl == NULL || outputControl->fObsoleteOutput)
- {
- // memory for output tracks
- AssignMemory( fOutTracks, mem, nTracks );
- // arrays for track hits
- AssignMemory( fOutTrackHits, mem, nTrackClusters );
- }
if ((size_t) (mem - fMemory) + sizeof(AliHLTTPCCASliceOutput) > fMemorySize)
{
- fMemorySize = NULL;
- //printf("\nINTERNAL ERROR IN AliHLTTPCCASliceOutput MEMORY MANAGEMENT req: %d avail: %d\n", (int) ((size_t) (mem - fMemory) + sizeof(AliHLTTPCCASliceOutput)), (int) fMemorySize);
+ fMemorySize = NULL;
+ //printf("\nINTERNAL ERROR IN AliHLTTPCCASliceOutput MEMORY MANAGEMENT req: %d avail: %d\n", (int) ((size_t) (mem - fMemory) + sizeof(AliHLTTPCCASliceOutput)), (int) fMemorySize);
}
}
void AliHLTTPCCASliceOutput::Allocate(AliHLTTPCCASliceOutput* &ptrOutput, int nTracks, int nTrackHits, outputControlStruct* outputControl)
{
//Allocate All memory needed for slice output
- const int memsize = (outputControl->fDefaultOutput ? EstimateSize(nTracks, nTrackHits) : sizeof(AliHLTTPCCASliceOutput)) +
- (outputControl->fObsoleteOutput? (nTracks * sizeof(AliHLTTPCCAOutTrack) + nTrackHits * sizeof(int)) : 0);
+ const int memsize = EstimateSize(nTracks, nTrackHits);
+
if (outputControl->fOutputPtr)
{
if (outputControl->fOutputMaxSize < memsize)
#include <cstdlib>
#include "AliHLTTPCCASliceTrack.h"
#include "AliHLTTPCCACompressedInputData.h"
-//Obsolete
-#include "AliHLTTPCCAOutTrack.h"
/**
* @class AliHLTTPCCASliceOutput
{
public:
- struct outputControlStruct
- {
- outputControlStruct() : fObsoleteOutput( 1 ), fDefaultOutput( 1 ), fOutputPtr( NULL ), fOutputMaxSize ( 0 ), fEndOfSpace(0) {}
- int fObsoleteOutput; //Enable Obsolete Output
- int fDefaultOutput; //Enable Default Output
- char* fOutputPtr; //Pointer to Output Space, NULL to allocate output space
- int fOutputMaxSize; //Max Size of Output Data if Pointer to output space is given
- bool fEndOfSpace; // end of space flag
- };
-
- GPUhd() int NTracks() const { return fNTracks; }
- GPUhd() int NTrackClusters() const { return fNTrackClusters; }
-
- GPUhd() const AliHLTTPCCASliceTrack &Track( int i ) const { return TracksP()[i]; }
- GPUhd() unsigned char ClusterRow ( int i ) const { return ClusterRowP()[i]; }
- GPUhd() int ClusterId ( int i ) const { return ClusterIdP()[i]; }
- GPUhd() const AliHLTTPCCACompressedCluster &ClusterPackedXYZ ( int i ) const { return ClusterPackedXYZP()[i]; }
-
- GPUhd() static int EstimateSize( int nOfTracks, int nOfTrackClusters );
- void SetPointers(int nTracks = -1, int nTrackClusters = -1, const outputControlStruct* outputControl = NULL);
- static void Allocate(AliHLTTPCCASliceOutput* &ptrOutput, int nTracks, int nTrackHits, outputControlStruct* outputControl);
-
- GPUhd() void SetNTracks ( int v ) { fNTracks = v; }
- GPUhd() void SetNTrackClusters( int v ) { fNTrackClusters = v; }
-
- GPUhd() void SetTrack( int i, const AliHLTTPCCASliceTrack &v ) { TracksP()[i] = v; }
- GPUhd() void SetClusterRow( int i, unsigned char v ) { ClusterRowP()[i] = v; }
- GPUhd() void SetClusterId( int i, int v ) { ClusterIdP()[i] = v; }
- GPUhd() void SetClusterPackedXYZ( int i, AliHLTTPCCACompressedCluster v ) { ClusterPackedXYZP()[i] = v; }
-
- GPUhd() size_t OutputMemorySize() const { return(fMemorySize); }
-
- //Obsolete Output
-
- GPUhd() int NOutTracks() const { return(fNOutTracks); }
- GPUhd() void SetNOutTracks(int val) { fNOutTracks = val; }
- GPUhd() AliHLTTPCCAOutTrack *OutTracks() const { return fOutTracks; }
- GPUhd() const AliHLTTPCCAOutTrack &OutTrack( int index ) const { return fOutTracks[index]; }
- GPUhd() int NOutTrackHits() const { return fNOutTrackHits; }
- GPUhd() void SetNOutTrackHits(int val) { fNOutTrackHits = val; }
- GPUhd() void SetOutTrackHit(int n, int val) { fOutTrackHits[n] = val; }
- GPUhd() int OutTrackHit( int i ) const { return fOutTrackHits[i]; }
+ struct outputControlStruct
+ {
+ outputControlStruct() : fOutputPtr( NULL ), fOutputMaxSize ( 0 ), fEndOfSpace(0) {}
+ char* fOutputPtr; //Pointer to Output Space, NULL to allocate output space
+ int fOutputMaxSize; //Max Size of Output Data if Pointer to output space is given
+ bool fEndOfSpace; // end of space flag
+ };
+
+ GPUhd() int NTracks() const { return fNTracks; }
+ GPUhd() int NTrackClusters() const { return fNTrackClusters; }
+
+ GPUhd() const AliHLTTPCCASliceTrack &Track( int i ) const { return TracksP()[i]; }
+ GPUhd() unsigned char ClusterRow ( int i ) const { return ClusterRowP()[i]; }
+ GPUhd() int ClusterId ( int i ) const { return ClusterIdP()[i]; }
+ GPUhd() const AliHLTTPCCACompressedCluster &ClusterPackedXYZ ( int i ) const { return ClusterPackedXYZP()[i]; }
+
+ GPUhd() static int EstimateSize( int nOfTracks, int nOfTrackClusters );
+ void SetPointers(int nTracks = -1, int nTrackClusters = -1, const outputControlStruct* outputControl = NULL);
+ static void Allocate(AliHLTTPCCASliceOutput* &ptrOutput, int nTracks, int nTrackHits, outputControlStruct* outputControl);
+
+ GPUhd() void SetNTracks ( int v ) { fNTracks = v; }
+ GPUhd() void SetNTrackClusters( int v ) { fNTrackClusters = v; }
+
+ GPUhd() void SetTrack( int i, const AliHLTTPCCASliceTrack &v ) { TracksP()[i] = v; }
+ GPUhd() void SetClusterRow( int i, unsigned char v ) { ClusterRowP()[i] = v; }
+ GPUhd() void SetClusterId( int i, int v ) { ClusterIdP()[i] = v; }
+ GPUhd() void SetClusterPackedXYZ( int i, AliHLTTPCCACompressedCluster v ) { ClusterPackedXYZP()[i] = v; }
+
+ GPUhd() size_t OutputMemorySize() const { return(fMemorySize); }
- private:
- AliHLTTPCCASliceOutput()
- : fNTracks( 0 ), fNTrackClusters( 0 ), fTracksOffset( 0 ), fClusterIdOffset( 0 ), fClusterRowOffset( 0 ), fClusterPackedXYZOffset( 0 ),
- fMemorySize( 0 ), fNOutTracks(0), fNOutTrackHits(0), fOutTracks(0), fOutTrackHits(0) {}
- ~AliHLTTPCCASliceOutput() {}
- const AliHLTTPCCASliceOutput& operator=( const AliHLTTPCCASliceOutput& ) const { return *this; }
- AliHLTTPCCASliceOutput( const AliHLTTPCCASliceOutput& );
+ private:
+ AliHLTTPCCASliceOutput()
+ : fNTracks( 0 ), fNTrackClusters( 0 ), fTracksOffset( 0 ), fClusterIdOffset( 0 ), fClusterRowOffset( 0 ), fClusterPackedXYZOffset( 0 ),
+ fMemorySize( 0 ){}
+
+ ~AliHLTTPCCASliceOutput() {}
+ const AliHLTTPCCASliceOutput& operator=( const AliHLTTPCCASliceOutput& ) const { return *this; }
+ AliHLTTPCCASliceOutput( const AliHLTTPCCASliceOutput& );
- GPUh() void SetMemorySize(size_t val) { fMemorySize = val; }
+ GPUh() void SetMemorySize(size_t val) { fMemorySize = val; }
GPUh() AliHLTTPCCASliceTrack *TracksP() const { return (AliHLTTPCCASliceTrack*)(fMemory+fTracksOffset); }
GPUh() int *ClusterIdP() const { return (int*)(fMemory+fClusterIdOffset); }
GPUh() UChar_t *ClusterRowP() const { return (UChar_t *)(fMemory+fClusterRowOffset); }
GPUh() AliHLTTPCCACompressedCluster *ClusterPackedXYZP() const { return (AliHLTTPCCACompressedCluster *)(fMemory+fClusterPackedXYZOffset); }
- int fNTracks; // number of reconstructed tracks
- int fNTrackClusters; // total number of track clusters
- int fTracksOffset; // pointer to reconstructed tracks
- int fClusterIdOffset; // pointer to cluster Id's ( packed slice, patch, cluster )
- int fClusterRowOffset; // pointer to cluster row numbers
- int fClusterPackedXYZOffset; // pointer to cluster coordinates
- size_t fMemorySize; // Amount of memory really used
-
- // obsolete output
-
- int fNOutTracks;
- int fNOutTrackHits;
- AliHLTTPCCAOutTrack *fOutTracks; // output array of the reconstructed tracks
- int *fOutTrackHits; // output array of ID's of the reconstructed hits
+ int fNTracks; // number of reconstructed tracks
+ int fNTrackClusters; // total number of track clusters
+ int fTracksOffset; // pointer to reconstructed tracks
+ int fClusterIdOffset; // pointer to cluster Id's ( packed slice, patch, cluster )
+ int fClusterRowOffset; // pointer to cluster row numbers
+ int fClusterPackedXYZOffset; // pointer to cluster coordinates
+ size_t fMemorySize; // Amount of memory really used
- //Must be last element of this class, user has to make sure to allocate anough memory consecutive to class memory!
- //This way the whole Slice Output is one consecutive Memory Segment
+ //Must be last element of this class, user has to make sure to allocate anough memory consecutive to class memory!
+ //This way the whole Slice Output is one consecutive Memory Segment
char fMemory[1]; // the memory where the pointers above point into
};
#ifndef ALIHLTTPCCASLICETRACK_H
#define ALIHLTTPCCASLICETRACK_H
-#include "AliHLTTPCCATrackParam2.h"
+#include "AliHLTTPCCABaseTrackParam.h"
/**
* @class AliHLTTPCCASliceTrack
GPUhd() int NClusters() const { return fNClusters; }
GPUhd() int FirstClusterRef() const { return fFirstClusterRef; }
- GPUhd() const AliHLTTPCCATrackParam2 &Param() const { return fParam; }
+ GPUhd() const AliHLTTPCCABaseTrackParam &Param() const { return fParam; }
GPUhd() void SetNClusters( int v ) { fNClusters = v; }
GPUhd() void SetFirstClusterRef( int v ) { fFirstClusterRef = v; }
- GPUhd() void SetParam( const AliHLTTPCCATrackParam2 &v ) { fParam = v; }
+ GPUhd() void SetParam( const AliHLTTPCCABaseTrackParam &v ) { fParam = v; }
private:
- AliHLTTPCCATrackParam2 fParam; //* fitted track parameters at its innermost cluster
+ AliHLTTPCCABaseTrackParam fParam; //* fitted track parameters at its innermost cluster
int fFirstClusterRef; //* index of the index of the first track cluster in corresponding cluster arrays
int fNClusters; //* number of track clusters
#define ALIHLTTPCCATRACK_H
#include "AliHLTTPCCADef.h"
-#include "AliHLTTPCCATrackParam2.h"
+#include "AliHLTTPCCABaseTrackParam.h"
/**
* @class ALIHLTTPCCAtrack
GPUhd() bool Alive() const { return fAlive; }
GPUhd() int NHits() const { return fNHits; }
GPUhd() int FirstHitID() const { return fFirstHitID; }
- GPUhd() const AliHLTTPCCATrackParam2 &Param() const { return fParam; };
+ GPUhd() const AliHLTTPCCABaseTrackParam &Param() const { return fParam; };
GPUhd() void SetAlive( bool v ) { fAlive = v; }
GPUhd() void SetNHits( int v ) { fNHits = v; }
GPUhd() void SetFirstHitID( int v ) { fFirstHitID = v; }
- GPUhd() void SetParam( AliHLTTPCCATrackParam2 v ) { fParam = v; };
+ GPUhd() void SetParam( AliHLTTPCCABaseTrackParam v ) { fParam = v; };
private:
bool fAlive; // flag for mark tracks used by the track merger
int fFirstHitID; // index of the first track cell in the track->cell pointer array
int fNHits; // number of track cells
- AliHLTTPCCATrackParam2 fParam; // track parameters
+ AliHLTTPCCABaseTrackParam fParam; // track parameters
private:
//void Dummy(); // to make rulechecker happy by having something in .cxx file
#include "AliHLTTPCCADef.h"
#include "AliHLTTPCCAMath.h"
-#include "AliHLTTPCCATrackParam2.h"
+#include "AliHLTTPCCABaseTrackParam.h"
class AliHLTTPCCATrackLinearisation;
float fBethe, fE, fTheta2, fEP2, fSigmadE2, fK22, fK33, fK43, fK44;// parameters
};
- GPUd() const AliHLTTPCCATrackParam2& GetParam() const { return fParam; }
- GPUd() void SetParam(const AliHLTTPCCATrackParam2& v) { fParam = v; }
+ GPUd() const AliHLTTPCCABaseTrackParam& GetParam() const { return fParam; }
+ GPUd() void SetParam(const AliHLTTPCCABaseTrackParam& v) { fParam = v; }
GPUd() void InitParam();
GPUd() float X() const { return fParam.X(); }
#ifndef HLTCA_GPUCODE
private:
#endif //!HLTCA_GPUCODE
- AliHLTTPCCATrackParam2 fParam; // Track Parameters
+ AliHLTTPCCABaseTrackParam fParam; // Track Parameters
private:
//WARNING, Track Param Data is copied in the GPU Tracklet Constructor element by element instead of using copy constructor!!!
//***************************************************************************
#include "AliHLTTPCCATracker.h"
-#include "AliHLTTPCCAOutTrack.h"
#include "AliHLTTPCCARow.h"
#include "AliHLTTPCCATrack.h"
#include "AliHLTTPCCATracklet.h"
if (useOutput == NULL) return(1);
useOutput->SetNTracks( 0 );
useOutput->SetNTrackClusters( 0 );
- useOutput->SetNOutTracks(0);
- useOutput->SetNOutTrackHits(0);
}
return 1;
TStopwatch timer;
//cout<<"output: nTracks = "<<*fNTracks<<", nHitsTotal="<<NHitsTotal()<<std::endl;
-
+
if (fOutputControl == NULL) fOutputControl = new AliHLTTPCCASliceOutput::outputControlStruct;
AliHLTTPCCASliceOutput::Allocate(*fOutput, fCommonMem->fNTracks, fCommonMem->fNTrackHits, fOutputControl);
AliHLTTPCCASliceOutput* useOutput = *fOutput;
if (useOutput == NULL) return;
- if (fOutputControl->fDefaultOutput)
- {
- useOutput->SetNTracks( fCommonMem->fNTracks );
- useOutput->SetNTrackClusters( fCommonMem->fNTrackHits );
-
- int nStoredHits = 0;
-
- for ( int iTr = 0; iTr < fCommonMem->fNTracks; iTr++ ) {
- AliHLTTPCCATrack &iTrack = fTracks[iTr];
-
- AliHLTTPCCASliceTrack out;
- out.SetFirstClusterRef( nStoredHits );
- out.SetNClusters( iTrack.NHits() );
- out.SetParam( iTrack.Param() );
-
- 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 );
- AliHLTTPCCACompressedCluster cXYZ = AliHLTTPCCADataCompressor::PackXYZ( iRow, origX, origY, origZ );
-
- //float2 hUnpackedYZ;
- //hUnpackedYZ.x = origY;
- //hUnpackedYZ.y = origZ;
- //float hUnpackedX = origX;
-
- useOutput->SetClusterId( nStoredHits, id );
- useOutput->SetClusterRow( nStoredHits, ( unsigned char ) iRow );
- useOutput->SetClusterPackedXYZ( nStoredHits, cXYZ );
- nStoredHits++;
- }
- }
- }
-
-
- // old stuff
- if (fOutputControl->fObsoleteOutput)
- {
- useOutput->SetNOutTrackHits(0);
- useOutput->SetNOutTracks(0);
-
-
- for ( int iTr = 0; iTr < fCommonMem->fNTracks; iTr++ ) {
-
- const AliHLTTPCCATrack &iTrack = fTracks[iTr];
-
- //std::cout<<"iTr = "<<iTr<<", nHits="<<iTrack.NHits()<<std::endl;
-
- //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 );
-
- 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);
- }
- }
+ useOutput->SetNTracks( fCommonMem->fNTracks );
+ useOutput->SetNTrackClusters( fCommonMem->fNTrackHits );
+
+ int nStoredHits = 0;
+
+ for ( int iTr = 0; iTr < fCommonMem->fNTracks; iTr++ ) {
+ AliHLTTPCCATrack &iTrack = fTracks[iTr];
+ AliHLTTPCCASliceTrack out;
+ out.SetFirstClusterRef( nStoredHits );
+ out.SetNClusters( iTrack.NHits() );
+ out.SetParam( iTrack.Param() );
+
+ 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 );
+ AliHLTTPCCACompressedCluster cXYZ = AliHLTTPCCADataCompressor::PackXYZ( iRow, origX, origY, origZ );
+
+ //float2 hUnpackedYZ;
+ //hUnpackedYZ.x = origY;
+ //hUnpackedYZ.y = origZ;
+ //float hUnpackedX = origX;
+
+ useOutput->SetClusterId( nStoredHits, id );
+ useOutput->SetClusterRow( nStoredHits, ( unsigned char ) iRow );
+ useOutput->SetClusterPackedXYZ( nStoredHits, cXYZ );
+ nStoredHits++;
+ }
}
timer.Stop();
}
}
-GPUh() void AliHLTTPCCATracker::WriteTracks( std::ostream &out )
+GPUh() void AliHLTTPCCATracker::WriteTracks( std::ostream &/*out*/ )
{
- //* 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;
- }
+ //* Write tracks to file --- dummy
}
-GPUh() void AliHLTTPCCATracker::ReadTracks( std::istream &in )
+GPUh() void AliHLTTPCCATracker::ReadTracks( std::istream &/*in*/ )
{
- //* 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 );
- }
+ //* Read tracks from file -- dummy
}
#endif
#include "AliHLTTPCCATrackerComponent.h"
#include "AliHLTTPCTransform.h"
#include "AliHLTTPCCATrackerFramework.h"
-#include "AliHLTTPCCAOutTrack.h"
#include "AliHLTTPCCAParam.h"
#include "AliHLTTPCCATrackConvertor.h"
#include "AliHLTArray.h"
fClusterErrorCorrectionZ(0),
fFullTime( 0 ),
fRecoTime( 0 ),
- fNEvents( 0 ),
- fOutputTRAKSEGS( 0 ),
+ fNEvents( 0 ),
fAllowGPU( 0)
{
// see header file for class documentation
fFullTime( 0 ),
fRecoTime( 0 ),
fNEvents( 0 ),
- fOutputTRAKSEGS( 0 ),
fAllowGPU( 0)
{
// see header file for class documentation
AliHLTComponentDataType AliHLTTPCCATrackerComponent::GetOutputDataType()
{
// see header file for class documentation
- if ( fOutputTRAKSEGS ) return AliHLTTPCDefinitions::fgkTrackSegmentsDataType;
- else return AliHLTTPCCADefinitions::fgkTrackletsDataType;
+ return AliHLTTPCCADefinitions::fgkTrackletsDataType;
}
void AliHLTTPCCATrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
fNeighboursSearchArea = 0;
fClusterErrorCorrectionY = 0;
fClusterErrorCorrectionZ = 0;
- fOutputTRAKSEGS = 0;
fFullTime = 0;
fRecoTime = 0;
fNEvents = 0;
continue;
}
- if ( argument.CompareTo( "-outputTRAKSEGS" ) == 0 ) {
- fOutputTRAKSEGS = 1;
- HLTInfo( "The special output type \"TRAKSEGS\" is set" );
- continue;
- }
-
if (argument.CompareTo( "-allowGPU" ) == 0) {
fAllowGPU = 1;
HLTImportant( "Will try to run tracker on GPU" );
// Determine slice number to really use. (for obsolete output)
if ( slices.size() > 1 ) {
- Logging( fOutputTRAKSEGS ? kHLTLogError : kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
+ Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
"Multiple slice numbers found in event 0x%08lX (%lu). Determining maximum occuring slice number...",
evtData.fEventID, evtData.fEventID );
unsigned maxCntSlice = 0;
slCntIter = sliceCnts.begin();
for ( slIter = slices.begin(); slIter != slices.end(); slIter++, slCntIter++ ) {
- Logging( fOutputTRAKSEGS ? kHLTLogError : kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
+ Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
"Slice %lu found %lu times.", *slIter, *slCntIter );
- if ( fOutputTRAKSEGS && maxCntSlice < *slCntIter ) {
- maxCntSlice = *slCntIter;
- slice = *slIter;
- }
}
- if (fOutputTRAKSEGS)
- {
- Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
- "Using slice %lu.", slice );
- }
} else if ( slices.size() > 0 ) {
slice = *( slices.begin() );
}
- if (fOutputTRAKSEGS)
+ for (int islice = minslice;islice <= maxslice;islice++)
+ {
+ bool found = false;
+ for(slIter = slices.begin(); slIter != slices.end();slIter++)
{
- minslice = maxslice = slice;
+ if (*slIter == islice)
+ {
+ found = true;
+ break;
+ }
}
- else
+ if (!found)
{
- for (int islice = minslice;islice <= maxslice;islice++)
- {
- bool found = false;
- for(slIter = slices.begin(); slIter != slices.end();slIter++)
- {
- if (*slIter == islice)
- {
- found = true;
- break;
- }
- }
- if (!found)
- {
- maxslice = islice - 1;
- break;
- }
- }
- }
+ maxslice = islice - 1;
+ break;
+ }
+ }
}
if ( !fTracker ) fTracker = new AliHLTTPCCATrackerFramework(fAllowGPU);
AliHLTTPCCASliceOutput::outputControlStruct outputControl;
//Set tracker output so tracker does not have to output both formats!
outputControl.fEndOfSpace = 0;
- outputControl.fObsoleteOutput = fOutputTRAKSEGS;
- outputControl.fDefaultOutput = !fOutputTRAKSEGS;
//For new output we can write directly to output buffer
- outputControl.fOutputPtr = fOutputTRAKSEGS ? NULL : (char*) outputPtr;
+ outputControl.fOutputPtr = (char*) outputPtr;
outputControl.fOutputMaxSize = maxBufferSize;
AliHLTTPCCASliceOutput** sliceOutput = new AliHLTTPCCASliceOutput*[slicecount];
error = 1;
break;
}
- slice = minslice + islice;
-
- if (sliceOutput[islice])
- {
- // write reconstructed tracks
-
- if ( fOutputTRAKSEGS ) {
-
- Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reconstruct",
- "%d tracks found for slice %d", sliceOutput[islice]->NOutTracks(), slice );
-
- ntracks = sliceOutput[islice]->NOutTracks();
-
- AliHLTTPCTrackletData* outPtr = ( AliHLTTPCTrackletData* )( outputPtr );
-
- AliHLTTPCTrackSegmentData* currOutTracklet = outPtr->fTracklets;
-
- mySize = ( ( AliHLTUInt8_t * )currOutTracklet ) - ( ( AliHLTUInt8_t * )outputPtr );
-
- outPtr->fTrackletCnt = 0;
-
- for ( int itr = 0; itr < ntracks; itr++ ) {
-
- AliHLTTPCCAOutTrack &t = sliceOutput[islice]->OutTracks()[itr];
-
- //Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Wrtite output","track %d with %d hits", itr, t.NHits());
-
- if ( t.NHits() < fMinNTrackClusters ) continue;
-
- // calculate output track size
-
- unsigned int dSize = sizeof( AliHLTTPCTrackSegmentData ) + t.NHits() * sizeof( unsigned int );
-
- if ( mySize + dSize > maxBufferSize ) {
- HLTWarning( "Output buffer size exceed (buffer size %d, current size %d), %d tracks are not stored", maxBufferSize, mySize, ntracks - itr + 1 );
- ret = -ENOSPC;
- error = 1;
- break;
- }
-
- // convert CA track parameters to HLT Track Segment
-
- int iFirstRow = 1000;
- int iLastRow = -1;
- int iFirstHit = sliceOutput[islice]->OutTrackHit(t.FirstHitRef());
- int iLastHit = iFirstHit;
- for ( int ih = 0; ih < t.NHits(); ih++ ) {
- int hitID = sliceOutput[islice]->OutTrackHit(t.FirstHitRef() + ih);
- int iRow = clusterData[islice].RowNumber( hitID );
- if ( iRow < iFirstRow ) { iFirstRow = iRow; iFirstHit = hitID; }
- if ( iRow > iLastRow ) { iLastRow = iRow; iLastHit = hitID; }
- }
-
- AliHLTTPCCATrackParam par = t.StartPoint();
-
- par.TransportToX( clusterData[islice].X( iFirstHit ), .99 );
-
- AliExternalTrackParam tp;
- AliHLTTPCCATrackConvertor::GetExtParam( par, tp, 0 );
-
- currOutTracklet->fX = tp.GetX();
- currOutTracklet->fY = tp.GetY();
- currOutTracklet->fZ = tp.GetZ();
- currOutTracklet->fCharge = ( int ) tp.GetSign();
- currOutTracklet->fPt = TMath::Abs( tp.GetSignedPt() );
- float snp = tp.GetSnp() ;
- if ( snp > .999 ) snp = .999;
- if ( snp < -.999 ) snp = -.999;
- currOutTracklet->fPsi = TMath::ASin( snp );
- currOutTracklet->fTgl = tp.GetTgl();
-
- currOutTracklet->fY0err = tp.GetSigmaY2();
- currOutTracklet->fZ0err = tp.GetSigmaZ2();
- float h = -currOutTracklet->fPt * currOutTracklet->fPt;
- currOutTracklet->fPterr = h * h * tp.GetSigma1Pt2();
- h = 1. / TMath::Sqrt((1.-snp)*(1.+snp));
- currOutTracklet->fPsierr = h * h * tp.GetSigmaSnp2();
- currOutTracklet->fTglerr = tp.GetSigmaTgl2();
-
- if ( par.TransportToX( clusterData[islice].X( iLastHit ), .99 ) ) {
- currOutTracklet->fLastX = par.GetX();
- currOutTracklet->fLastY = par.GetY();
- currOutTracklet->fLastZ = par.GetZ();
- } else {
- currOutTracklet->fLastX = clusterData[islice].X( iLastHit );
- currOutTracklet->fLastY = clusterData[islice].Y( iLastHit );
- currOutTracklet->fLastZ = clusterData[islice].Z( iLastHit );
- }
- //if( currOutTracklet->fLastX<10. ) {
- //HLTError("CA last point: hitxyz=%f,%f,%f, track=%f,%f,%f, tracklet=%f,%f,%f, nhits=%d",clusterData[islice].X( iLastHit ),clusterData[islice].Y( iLastHit],clusterData[islice].Z( iLastHit],
- //par.GetX(), par.GetY(),par.GetZ(),currOutTracklet->fLastX,currOutTracklet->fLastY ,currOutTracklet->fLastZ, t.NHits());
- //}
- #ifdef INCLUDE_TPC_HOUGH
- #ifdef ROWHOUGHPARAMS
- currOutTracklet->fTrackID = 0;
- currOutTracklet->fRowRange1 = clusterData[islice].RowNumber( iFirstHit );
- currOutTracklet->fRowRange2 = clusterData[islice].RowNumber( iLastHit );
- currOutTracklet->fSector = slice;
- currOutTracklet->fPID = 211;
- #endif
- #endif // INCLUDE_TPC_HOUGH
-
-
- currOutTracklet->fNPoints = t.NHits();
-
- for ( int i = 0; i < t.NHits(); i++ ) {
- currOutTracklet->fPointIDs[i] = clusterData[islice].Id( sliceOutput[islice]->OutTrackHit(t.FirstHitRef()+i) );
- }
-
- currOutTracklet = ( AliHLTTPCTrackSegmentData* )( ( Byte_t * )currOutTracklet + dSize );
- mySize += dSize;
- outPtr->fTrackletCnt++;
- }
-
- } else { // default output type
-
- Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reconstruct",
- "%d tracks found for slice %d", sliceOutput[islice]->NTracks(), slice );
-
- mySize += sliceOutput[islice]->OutputMemorySize();
- ntracks += sliceOutput[islice]->NTracks();
- }
- }
- else
- {
- HLTWarning( "Output buffer size exceed (buffer size %d, current size %d), tracks are not stored", maxBufferSize, mySize );
- mySize = 0;
- ret = -ENOSPC;
- ntracks = 0;
- error = 1;
- break;
- }
+ slice = minslice + islice;
+
+ if (sliceOutput[islice])
+ {
+ // write reconstructed tracks
+ Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "Reconstruct",
+ "%d tracks found for slice %d", sliceOutput[islice]->NTracks(), slice );
+
+ mySize += sliceOutput[islice]->OutputMemorySize();
+ ntracks += sliceOutput[islice]->NTracks();
+ }
+ else
+ {
+ HLTWarning( "Output buffer size exceed (buffer size %d, current size %d), tracks are not stored", maxBufferSize, mySize );
+ mySize = 0;
+ ret = -ENOSPC;
+ ntracks = 0;
+ error = 1;
+ break;
+ }
}
-
+
size = 0;
if (error == 0)
{
- for (int islice = 0;islice < slicecount;islice++)
+ for (int islice = 0;islice < slicecount;islice++)
+ {
+ slice = minslice + islice;
+ mySize = sliceOutput[islice]->OutputMemorySize();
+ if (mySize > 0)
{
- slice = minslice + islice;
- if (!fOutputTRAKSEGS) mySize = sliceOutput[islice]->OutputMemorySize();
- if (mySize > 0)
- {
- AliHLTComponentBlockData bd;
- FillBlockData( bd );
- bd.fOffset = fOutputTRAKSEGS ? 0 : ((char*) sliceOutput[islice] - (char*) outputPtr);
- bd.fSize = mySize;
- bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, sliceminPatch[islice], slicemaxPatch[islice] );
- bd.fDataType = GetOutputDataType();
- outputBlocks.push_back( bd );
- size += mySize;
- }
+ AliHLTComponentBlockData bd;
+ FillBlockData( bd );
+ bd.fOffset = ((char*) sliceOutput[islice] - (char*) outputPtr);
+ bd.fSize = mySize;
+ bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, sliceminPatch[islice], slicemaxPatch[islice] );
+ bd.fDataType = GetOutputDataType();
+ outputBlocks.push_back( bd );
+ size += mySize;
}
+ }
}
//No longer needed
double fFullTime; //* total time for DoEvent() [s]
double fRecoTime; //* total reconstruction time [s]
Long_t fNEvents; //* number of reconstructed events
- bool fOutputTRAKSEGS; //* use old type of output
bool fAllowGPU; //* Allow this tracker to run on GPU
static bool CompareClusters( AliHLTTPCSpacePointData *a, AliHLTTPCSpacePointData *b );
#define ALIHLTTPCCATRACKLET_H
#include "AliHLTTPCCADef.h"
-#include "AliHLTTPCCATrackParam2.h"
+#include "AliHLTTPCCABaseTrackParam.h"
#include "AliHLTTPCCAGPUConfig.h"
/**
GPUhd() int NHits() const { return fNHits; }
GPUhd() int FirstRow() const { return fFirstRow; }
GPUhd() int LastRow() const { return fLastRow; }
- GPUhd() const AliHLTTPCCATrackParam2 &Param() const { return fParam; }
+ GPUhd() const AliHLTTPCCABaseTrackParam &Param() const { return fParam; }
#ifndef EXTERN_ROW_HITS
GPUhd() int RowHit( int i ) const { return fRowHits[i]; }
GPUhd() const int* RowHits() const { return(fRowHits); }
GPUhd() void SetNHits( int v ) { fNHits = v; }
GPUhd() void SetFirstRow( int v ) { fFirstRow = v; }
GPUhd() void SetLastRow( int v ) { fLastRow = v; }
- GPUhd() void SetParam( const AliHLTTPCCATrackParam2 &v ) { fParam = v; }
+ GPUhd() void SetParam( const AliHLTTPCCABaseTrackParam &v ) { fParam = v; }
private:
int fNHits; // N hits
int fFirstRow; // first TPC row
int fLastRow; // last TPC row
- AliHLTTPCCATrackParam2 fParam; // tracklet parameters
+ AliHLTTPCCABaseTrackParam fParam; // tracklet parameters
#ifndef EXTERN_ROW_HITS
int fRowHits[HLTCA_ROW_COUNT + 1]; // hit index for each TPC row
#endif //EXTERN_ROW_HITS
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff