Qmax for merged clusters fixed
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCHWCFSpacePointContainer.h
1 //-*- Mode: C++ -*-
2 // $Id$
3 #ifndef ALIHLTTPCHWCFSPACEPOINTCONTAINER_H
4 #define ALIHLTTPCHWCFSPACEPOINTCONTAINER_H
5 //* This file is property of and copyright by the ALICE HLT Project        * 
6 //* ALICE Experiment at CERN, All rights reserved.                         *
7 //* See cxx source for full Copyright notice                               *
8
9 /// @file   AliHLTTPCHWCFSpacePointContainer.h
10 /// @author Matthias Richter
11 /// @date   2011-08-08
12 /// @brief  Helper class for handling of HLT TPC cluster data blocks from the
13 ///         HW ClusterFinder
14 /// @note   Class is a duplicate of AliHLTTPCHWCFSpacePointContainer and should
15 ///         be merged with it in a generic way
16
17 #include "AliHLTSpacePointContainer.h"
18 #include "AliHLTTPCHWCFData.h"
19 #include <map>
20 #include <vector>
21 using namespace std;
22
23 /**
24  * @class AliHLTTPCHWCFSpacePointContainer
25  * Handler class for HLT TPC hardware ClusterFinder space point data blocks.
26  *
27  * @ingroup alihlt_tpc
28  */
29 class AliHLTTPCHWCFSpacePointContainer : public AliHLTSpacePointContainer
30 {
31  public:
32   /// standard constructor
33   AliHLTTPCHWCFSpacePointContainer(int mode=0);
34   /// copy constructor
35   AliHLTTPCHWCFSpacePointContainer(const AliHLTTPCHWCFSpacePointContainer& c);
36   /// assignment operator
37   AliHLTTPCHWCFSpacePointContainer& operator=(const AliHLTTPCHWCFSpacePointContainer& c);
38   /// destructor
39   ~AliHLTTPCHWCFSpacePointContainer();
40
41   enum {
42     kModeSingle = 0x1,
43     kModeCreateMap = 0x2,
44     kModeDifferentialPadTime = 0x4
45   };
46
47   virtual bool Check(AliHLTUInt32_t clusterID) const;
48   virtual int GetClusterIDs(vector<AliHLTUInt32_t>& tgt) const;
49   virtual const vector<AliHLTUInt32_t>* GetClusterIDs(AliHLTUInt32_t mask);
50   virtual float GetX(AliHLTUInt32_t clusterID) const;
51   virtual float GetXWidth(AliHLTUInt32_t clusterID) const;
52   virtual float GetY(AliHLTUInt32_t clusterID) const;
53   virtual float GetYWidth(AliHLTUInt32_t clusterID) const;
54   virtual float GetZ(AliHLTUInt32_t clusterID) const;
55   virtual float GetZWidth(AliHLTUInt32_t clusterID) const;
56   virtual float GetCharge(AliHLTUInt32_t clusterID) const;
57   virtual float GetQMax(AliHLTUInt32_t clusterID) const;
58   virtual float GetPhi(AliHLTUInt32_t clusterID) const;
59
60   /// add input block to the collection
61   virtual int AddInputBlock(const AliHLTComponentBlockData* pDesc);
62
63   virtual int PopulateAccessGrid(AliHLTSpacePointPropertyGrid* pGrid, AliHLTUInt32_t mask) const;
64   int PopulateAccessGrid(AliHLTSpacePointPropertyGrid* pGrid, AliHLTTPCHWCFData* pDecoder, int slice, int partition) const;
65   virtual const AliHLTSpacePointPropertyGrid* GetSpacePointPropertyGrid(AliHLTUInt32_t mask) const;
66   virtual int SetSpacePointPropertyGrid(AliHLTUInt32_t mask, AliHLTSpacePointPropertyGrid*);
67
68   /// clear the object and reset pointer references
69   virtual void Clear(Option_t * option ="");
70
71   /// print information
72   virtual void Print(ostream& out, Option_t *option="") const;
73
74   /// create a collection of clusters for a space point mask
75   virtual AliHLTSpacePointContainer* SelectByMask(AliHLTUInt32_t mask, bool bAlloc=false) const;
76
77   /// create a collection of clusters for a specific track
78   virtual AliHLTSpacePointContainer* SelectByTrack(int trackId, bool bAlloc=false) const;
79
80   /// create a collection of clusters for a specific MC track
81   virtual AliHLTSpacePointContainer* SelectByMC(int mcId, bool bAlloc=false) const;
82
83   /// create a collection of all used clusters
84   virtual AliHLTSpacePointContainer* UsedClusters(bool bAlloc=false) const;
85
86   /// create a collection of all unused clusters
87   virtual AliHLTSpacePointContainer* UnusedClusters(bool bAlloc=false) const;
88
89   virtual int MarkUsed(const AliHLTUInt32_t* clusterIDs, int arraySize);
90   virtual int SetTrackID(int trackID, const AliHLTUInt32_t* clusterIDs, int arraySize);
91   virtual int GetTrackID(AliHLTUInt32_t clusterID) const;
92   virtual int SetMCID(int clusterID, const AliHLTUInt32_t* clusterIDs, int arraySize);
93
94   virtual int Write(AliHLTUInt8_t* outputPtr, AliHLTUInt32_t size,
95                     vector<AliHLTComponentBlockData>& outputBlocks,
96                     AliHLTDataDeflater* pDeflater,
97                     const char* option="") const;
98   virtual int Write(AliHLTUInt8_t* outputPtr, AliHLTUInt32_t size, AliHLTUInt32_t offset,
99                     vector<AliHLTComponentBlockData>& outputBlocks,
100                     AliHLTDataDeflater* pDeflater,
101                     const char* option="") const;
102
103   int WriteSorted(AliHLTUInt8_t* outputPtr, AliHLTUInt32_t size, AliHLTUInt32_t offset,
104                   vector<AliHLTComponentBlockData>& outputBlocks,
105                   AliHLTDataDeflater* pDeflater,
106                   const char* option="") const;
107
108   int WriteSorted(AliHLTUInt8_t* outputPtr, AliHLTUInt32_t size, AliHLTUInt32_t offset,
109                   AliHLTTPCHWCFData* pDecoder, AliHLTSpacePointPropertyGrid* pGrid,
110                   AliHLTUInt32_t mask,
111                   vector<AliHLTComponentBlockData>&  outputBlocks,
112                   AliHLTDataDeflater* pDeflater,
113                   const char* option) const;
114
115   /// allocate index grid, one single point to define the dimensions
116   static AliHLTSpacePointPropertyGrid* AllocateIndexGrid();
117
118   class AliHLTTPCHWCFSpacePointProperties {
119   public:
120     AliHLTTPCHWCFSpacePointProperties();
121     AliHLTTPCHWCFSpacePointProperties(const AliHLTTPCHWCFData* pDecoder, int index);
122     AliHLTTPCHWCFSpacePointProperties(const AliHLTTPCHWCFSpacePointProperties& src);
123     AliHLTTPCHWCFSpacePointProperties& operator=(const AliHLTTPCHWCFSpacePointProperties& src);
124
125     ~AliHLTTPCHWCFSpacePointProperties() {}
126
127     const AliHLTTPCHWCFData* Decoder() const {return fDecoder;}
128     int GetSpacepointIndex() const {return fIndex;}
129     bool IsUsed() const {return fUsed;}
130     void MarkUsed(bool used=true) {fUsed=used;}
131     int GetTrackId() const {return fTrackId;}
132     void SetTrackId(int trackId) {fTrackId=trackId;}
133     int GetMCId() const {return fMCId;}
134     void SetMCId(int mcId) {fMCId=mcId;}
135
136     void Print(ostream& out, Option_t *option="") const;
137
138   private:
139     const AliHLTTPCHWCFData* fDecoder; //! decoder for data block
140     int fIndex; //! index within the decoder block
141     bool fUsed; //! transient
142     int fTrackId; //! track id from reconstruction
143     int fMCId; //! MC id
144   };
145
146   class AliHLTTPCHWCFSpacePointBlock {
147   public:
148     AliHLTTPCHWCFSpacePointBlock(AliHLTUInt32_t id=0, AliHLTTPCHWCFData* pDecoder=NULL, AliHLTSpacePointPropertyGrid* pGrid=NULL)
149       : fDecoder(pDecoder), fGrid(pGrid), fId(id) {}
150     AliHLTTPCHWCFSpacePointBlock(const AliHLTTPCHWCFSpacePointBlock& s) 
151       : fDecoder(s.fDecoder), fGrid(s.fGrid), fId(s.fId) {}
152     AliHLTTPCHWCFSpacePointBlock& operator=(const AliHLTTPCHWCFSpacePointBlock& s) {
153       if (this==&s) return *this;
154       fDecoder=s.fDecoder; fGrid=s.fGrid; fId=s.fId; return *this;
155     }
156     ~AliHLTTPCHWCFSpacePointBlock() {}
157
158     int GetNofSpacepoints() const {return fDecoder?fDecoder->GetNumberOfClusters():0;}
159     AliHLTUInt32_t GetId() const {return fId;}
160     void SetId(AliHLTUInt32_t id) {fId=id;}
161     AliHLTTPCHWCFData* GetDecoder() const {return fDecoder;} 
162     void SetDecoder(AliHLTTPCHWCFData* pDecoder) {fDecoder=pDecoder;}
163     AliHLTSpacePointPropertyGrid* GetGrid() const {return fGrid;}
164     void SetGrid(AliHLTSpacePointPropertyGrid* pGrid) {fGrid=pGrid;}
165
166   protected:
167   private:
168     AliHLTTPCHWCFData* fDecoder; //!
169     AliHLTSpacePointPropertyGrid* fGrid; //!
170     AliHLTUInt32_t fId; //!
171   };
172
173  protected:
174
175  private:
176   /// map of clusters
177   std::map<AliHLTUInt32_t, AliHLTTPCHWCFSpacePointProperties> fClusters; //!
178
179   /// map of cluster id collection for different masks
180   std::map<AliHLTUInt32_t, vector<AliHLTUInt32_t>*> fSelections; //!
181
182   /// array of decoders
183   std::map<AliHLTUInt32_t, AliHLTTPCHWCFSpacePointBlock> fBlocks; //!
184
185   /// the one instance for mode single (=1)
186   AliHLTTPCHWCFSpacePointBlock fSingleBlock;
187
188   /// mode
189   int fMode; //!
190
191   /// vector of cluster ids for writing
192   vector<AliHLTUInt32_t>* fWrittenClusterIds; //!
193
194   ClassDef(AliHLTTPCHWCFSpacePointContainer, 0)
195 };
196
197 ostream& operator<<(ostream &out, const AliHLTTPCHWCFSpacePointContainer::AliHLTTPCHWCFSpacePointProperties& p);
198
199 #endif