]>
Commit | Line | Data |
---|---|---|
63d8b79d | 1 | //-*- Mode: C++ -*- |
2 | // ************************************************************************ | |
fbb9b71b | 3 | // This file is property of and copyright by the ALICE HLT Project * |
63d8b79d | 4 | // ALICE Experiment at CERN, All rights reserved. * |
5 | // See cxx source for full Copyright notice * | |
6 | // * | |
7 | //************************************************************************* | |
8 | ||
9 | ||
10 | #ifndef ALIHLTTPCCASLICEOUTPUT_H | |
11 | #define ALIHLTTPCCASLICEOUTPUT_H | |
12 | ||
13 | #include "AliHLTTPCCADef.h" | |
b22af1bf | 14 | #include <cstdlib> |
e1f2d1c3 | 15 | #include "AliHLTTPCCASliceTrack.h" |
b22af1bf | 16 | //Obsolete |
17 | #include "AliHLTTPCCAOutTrack.h" | |
63d8b79d | 18 | |
19 | /** | |
20 | * @class AliHLTTPCCASliceOutput | |
21 | * | |
22 | * AliHLTTPCCASliceOutput class is used to store the output of AliHLTTPCCATracker{Component} | |
23 | * and transport the output to AliHLTTPCCAGBMerger{Component} | |
24 | * | |
25 | * The class contains all the necessary information about TPC tracks, reconstructed in one slice. | |
fbb9b71b | 26 | * This includes the reconstructed track parameters and some compressed information |
63d8b79d | 27 | * about the assigned clusters: clusterId, position and amplitude. |
28 | * | |
29 | */ | |
30 | class AliHLTTPCCASliceOutput | |
31 | { | |
fbb9b71b | 32 | public: |
d4594e7d | 33 | |
34 | struct outputControlStruct | |
35 | { | |
90da1ad5 | 36 | outputControlStruct() : fObsoleteOutput( 1 ), fDefaultOutput( 1 ), fOutputPtr( NULL ), fOutputMaxSize ( 0 ), fEndOfSpace(0) {} |
d4594e7d | 37 | int fObsoleteOutput; //Enable Obsolete Output |
38 | int fDefaultOutput; //Enable Default Output | |
39 | char* fOutputPtr; //Pointer to Output Space, NULL to allocate output space | |
90da1ad5 | 40 | int fOutputMaxSize; //Max Size of Output Data if Pointer to output space is given |
41 | bool fEndOfSpace; // end of space flag | |
d4594e7d | 42 | }; |
43 | ||
fbb9b71b | 44 | GPUhd() int NTracks() const { return fNTracks; } |
45 | GPUhd() int NTrackClusters() const { return fNTrackClusters; } | |
63d8b79d | 46 | |
fbb9b71b | 47 | GPUhd() const AliHLTTPCCASliceTrack &Track( int i ) const { return fTracks[i]; } |
6de2bc40 | 48 | GPUhd() unsigned char ClusterRow ( int i ) const { return fClusterRow[i]; } |
49 | GPUhd() int ClusterId ( int i ) const { return fClusterId[i]; } | |
fbb9b71b | 50 | GPUhd() float2 ClusterUnpackedYZ ( int i ) const { return fClusterUnpackedYZ[i]; } |
51 | GPUhd() float ClusterUnpackedX ( int i ) const { return fClusterUnpackedX[i]; } | |
63d8b79d | 52 | |
fbb9b71b | 53 | GPUhd() static int EstimateSize( int nOfTracks, int nOfTrackClusters ); |
d4594e7d | 54 | void SetPointers(int nTracks = -1, int nTrackClusters = -1, const outputControlStruct* outputControl = NULL); |
55 | static void Allocate(AliHLTTPCCASliceOutput* &ptrOutput, int nTracks, int nTrackHits, outputControlStruct* outputControl); | |
63d8b79d | 56 | |
fbb9b71b | 57 | GPUhd() void SetNTracks ( int v ) { fNTracks = v; } |
58 | GPUhd() void SetNTrackClusters( int v ) { fNTrackClusters = v; } | |
63d8b79d | 59 | |
fbb9b71b | 60 | GPUhd() void SetTrack( int i, const AliHLTTPCCASliceTrack &v ) { fTracks[i] = v; } |
b8139972 | 61 | GPUhd() void SetClusterRow( int i, unsigned char v ) { fClusterRow[i] = v; } |
62 | GPUhd() void SetClusterId( int i, int v ) { fClusterId[i] = v; } | |
fbb9b71b | 63 | GPUhd() void SetClusterUnpackedYZ( int i, float2 v ) { fClusterUnpackedYZ[i] = v; } |
64 | GPUhd() void SetClusterUnpackedX( int i, float v ) { fClusterUnpackedX[i] = v; } | |
63d8b79d | 65 | |
d4594e7d | 66 | GPUhd() size_t OutputMemorySize() const { return(fMemorySize); } |
67 | ||
b22af1bf | 68 | //Obsolete Output |
e1f2d1c3 | 69 | |
b22af1bf | 70 | GPUhd() int NOutTracks() const { return(fNOutTracks); } |
71 | GPUhd() void SetNOutTracks(int val) { fNOutTracks = val; } | |
72 | GPUhd() AliHLTTPCCAOutTrack *OutTracks() const { return fOutTracks; } | |
73 | GPUhd() const AliHLTTPCCAOutTrack &OutTrack( int index ) const { return fOutTracks[index]; } | |
74 | GPUhd() int NOutTrackHits() const { return fNOutTrackHits; } | |
75 | GPUhd() void SetNOutTrackHits(int val) { fNOutTrackHits = val; } | |
76 | GPUhd() void SetOutTrackHit(int n, int val) { fOutTrackHits[n] = val; } | |
77 | GPUhd() int OutTrackHit( int i ) const { return fOutTrackHits[i]; } | |
78 | ||
79 | private: | |
98512261 | 80 | AliHLTTPCCASliceOutput() |
73a33d2e | 81 | : fNTracks( 0 ), fNTrackClusters( 0 ), fTracks( 0 ), fClusterId( 0 ), fClusterRow( 0 ), fClusterUnpackedYZ( 0 ), fClusterUnpackedX( 0 ), |
98512261 | 82 | fMemorySize( 0 ), fNOutTracks(0), fNOutTrackHits(0), fOutTracks(0), fOutTrackHits(0) {} |
e1f2d1c3 | 83 | |
98512261 | 84 | ~AliHLTTPCCASliceOutput() {} |
fbb9b71b | 85 | const AliHLTTPCCASliceOutput& operator=( const AliHLTTPCCASliceOutput& ) const { return *this; } |
b22af1bf | 86 | AliHLTTPCCASliceOutput( const AliHLTTPCCASliceOutput& ); |
e1f2d1c3 | 87 | |
d4594e7d | 88 | GPUh() void SetMemorySize(size_t val) { fMemorySize = val; } |
89 | ||
6de2bc40 | 90 | int fNTracks; // number of reconstructed tracks |
91 | int fNTrackClusters; // total number of track clusters | |
fbb9b71b | 92 | AliHLTTPCCASliceTrack *fTracks; // pointer to reconstructed tracks |
6de2bc40 | 93 | int *fClusterId; // pointer to cluster Id's ( packed slice, patch, cluster ) |
94 | UChar_t *fClusterRow; // pointer to cluster row numbers | |
6de2bc40 | 95 | float2 *fClusterUnpackedYZ; // pointer to cluster coordinates (temporary data, for debug proposes) |
96 | float *fClusterUnpackedX; // pointer to cluster coordinates (temporary data, for debug proposes) | |
b22af1bf | 97 | size_t fMemorySize; // Amount of memory really used |
98 | ||
99 | // obsolete output | |
100 | ||
101 | int fNOutTracks; | |
102 | int fNOutTrackHits; | |
103 | AliHLTTPCCAOutTrack *fOutTracks; // output array of the reconstructed tracks | |
104 | int *fOutTrackHits; // output array of ID's of the reconstructed hits | |
105 | ||
106 | //Must be last element of this class, user has to make sure to allocate anough memory consecutive to class memory! | |
98512261 | 107 | //This way the whole Slice Output is one consecutive Memory Segment |
108 | char fMemory[1]; // the memory where the pointers above point into | |
b22af1bf | 109 | |
63d8b79d | 110 | }; |
111 | ||
31649d4b | 112 | #endif //ALIHLTTPCCASLICEOUTPUT_H |