]> git.uio.no Git - u/mrichter/AliRoot.git/blob - HLT/BASE/AliHLTSpacePointContainer.h
adding indexing of spacepoints
[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTSpacePointContainer.h
1 //-*- Mode: C++ -*-
2 // $Id$
3 #ifndef ALIHLTSPACEPOINTCONTAINER_H
4 #define ALIHLTSPACEPOINTCONTAINER_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   AliHLTSpacePointContainer.h
10 /// @author Matthias Richter
11 /// @date   2011-04-29
12 /// @brief  Base helper class for handling of HLT space point data blocks
13 ///
14
15 #include <vector>
16 #include <cmath>
17 #include <TObject.h>
18 #include "AliHLTLogging.h"
19 #include "AliHLTDataTypes.h"
20 #include "AliHLTStdIncludes.h"
21
22 class AliHLTDataDeflater;
23 class TArrayC;
24 class TH1;
25 class TTree;
26
27 /**
28  * @class AliHLTSpacePointContainer
29  * Base class of helper classes for space point data blocks.
30  * The class implements a couple of interface methods to be commonly used
31  * for space point data blocks.
32  *
33  * @ingroup alihlt_base
34  */
35 class AliHLTSpacePointContainer : public TObject, public AliHLTLogging
36 {
37  public:
38   /// standard constructor
39   AliHLTSpacePointContainer();
40   /// copy constructor
41   AliHLTSpacePointContainer(const AliHLTSpacePointContainer&);
42   /// assignment operator
43   AliHLTSpacePointContainer& operator=(const AliHLTSpacePointContainer&);
44
45   /// destructor
46   ~AliHLTSpacePointContainer();
47
48   //////////////////////////////////////////////////////////////////////////
49   //
50   // helper classes for access of space points within a grid
51   //
52   struct AliHLTSpacePointCell {
53     int fCount;
54     int fFilled;
55     int fStartIndex;
56   };
57
58   class AliHLTSpacePointGrid {
59   public:
60     AliHLTSpacePointGrid(float maxX, float stepX,
61                          float maxY, float stepY,
62                          float maxZ, float stepZ,
63                          int initialDataSize=-1);
64     virtual ~AliHLTSpacePointGrid();
65
66     // for now array of spacepoint ids
67     typedef AliHLTUInt32_t ValueType;
68
69     int GetDimensionX() const {return fDimX;}
70     int GetDimensionY() const {return fDimY;}
71     int GetDimensionZ() const {return fDimZ;}
72     int GetXIndex(float x) const {
73       if (x>fMaxX) return fDimX-1;
74       if (x<0) return 0;
75       return (int)floor(x/fStepX);
76     }
77     int GetYIndex(float y) const {
78       if (y>fMaxY) return fDimY-1;
79       if (y<0) return 0;
80       return (int)floor(y/fStepY);
81     }
82     int GetZIndex(float z) const {
83       if (z>fMaxZ) return fDimZ-1;
84       if (z<0) return 0;
85       return (int)floor(z/fStepZ);
86     }
87     float GetLowerBoundX(int cell) const {
88       if (fDimX==0 || fDimY==0 ||fDimZ==0) return 0.;
89       int index=cell/(fDimY*fDimZ);
90       return index*fStepX;
91     }
92     float GetLowerBoundY(int cell) const {
93       if (fDimX==0 || fDimY==0 ||fDimZ==0) return 0.;
94       int index=cell%(fDimY*fDimZ); index/=fDimZ;
95       return index*fStepY;
96     }
97     float GetLowerBoundZ(int cell) const {
98       if (fDimX==0 || fDimY==0 ||fDimZ==0) return 0.;
99       int index=cell%(fDimY*fDimZ); index%=fDimZ;
100       return index*fStepZ;
101     }
102     int GetCellIndex(float x, float y, float z) const {
103       return GetXIndex(x)*fDimY*fDimZ + (y<0?0:GetYIndex(y))*fDimZ + (z<0?0:GetZIndex(z));
104     }
105     int GetNumberOfSpacePoints(int index, int endIndex) const {
106       if (!fCells) return 0;
107       int count=0;
108       for (int cell=index; cell<endIndex && cell<fCellDimension && count<fCount; cell++) if (fCells[cell].fCount>0) count+=fCells[cell].fCount;
109       return count;
110     }
111
112     // increment counter of the cell where the spacepoint is
113     int CountSpacePoint(float x, float y, float z);
114
115     // add spacepoint, all spacepoints must have been counted before
116     int AddSpacePoint(ValueType t, float x, float y, float z);
117
118     void Clear(const char* option="");
119     void Print(const char* option="");
120
121     class iterator {
122     public:
123       iterator()
124         : fData(NULL) {}
125       iterator(const ValueType* pData)
126         : fData(pData) {}
127       iterator(const iterator& i)
128         : fData(i.fData) {}
129       iterator& operator=(const iterator& i)
130       { fData=i.fData; return *this;}
131       ~iterator() {fData=NULL;}
132
133       bool operator==(const iterator& i) const  {return (fData!=NULL) && (fData==i.fData);}
134       bool operator!=(const iterator& i) const  {return (fData!=NULL) && (fData!=i.fData);}
135       // prefix operators
136       iterator& operator++() {fData++; return *this;}
137       iterator& operator--() {fData--; return *this;}
138       // postfix operators
139       iterator operator++(int) {iterator i(*this); fData++; return i;}
140       iterator operator--(int) {iterator i(*this); fData--; return i;}
141
142       iterator& operator+=(int step) {fData+=step; return *this;}
143
144       const ValueType& Data() const {return *fData;}
145
146     protected:
147     private:
148       const ValueType* fData; //! data
149     };
150
151     // prepare iterator and end marker
152     iterator& begin(float x=-1., float y=-1., float z=-1.) {
153       fIterator.~iterator();
154       fIteratorEnd.~iterator();
155
156       int startIndex=0;
157       if (x<0) {
158         // get all data
159         if (fData) {
160           new (&fIterator) iterator(fData);
161           fIteratorEnd=fIterator;
162           fIteratorEnd+=fCount;
163         }
164         return fIterator;
165       }
166
167       // only search for the start index if specific x selected
168       int cell=GetCellIndex(x, y, z);
169       if (cell<0 || !fCells || cell>=fCellDimension) return fIterator;
170       // get the index of the cell
171       startIndex=fCells[cell].fStartIndex;
172       if (startIndex<0 || !fData || startIndex>=fDataDimension) return fIterator;
173
174       // get the range end position
175       int endCell=cell+1;
176       if (x<0) endCell=fCellDimension;
177       else if (y<0) endCell=GetCellIndex(x+fStepX, -1., -1.); // all entries for fixed x
178       else if (z<0) endCell=GetCellIndex(x, y+fStepY, -1.); // all entries for fixed x and y
179       if (endCell<=cell) {
180         // cell index returned is never outside the array
181         // so this is a special case where we get to the bounds of the array
182         endCell=fCellDimension;
183       }
184
185       new (&fIterator) iterator(fData+startIndex);
186       fIteratorEnd=fIterator;
187       fIteratorEnd+=GetNumberOfSpacePoints(cell, endCell);
188       return fIterator;
189     }
190
191     // get loop end marker
192     iterator& end() {
193       return fIteratorEnd;
194     }
195
196   protected:
197   private:
198     // standard constructor prohibited
199     AliHLTSpacePointGrid();
200     // copy constructor prohibited
201     AliHLTSpacePointGrid(const AliHLTSpacePointGrid&);
202     // assignment operator prohibited
203     AliHLTSpacePointGrid& operator=(const AliHLTSpacePointGrid&);
204
205     int IndexCells();
206
207     float fMaxX;
208     float fStepX;
209     float fMaxY;
210     float fStepY;
211     float fMaxZ;
212     float fStepZ;
213
214     int fDimX;
215     int fDimY;
216     int fDimZ;
217
218     AliHLTSpacePointCell* fCells; //! cell array
219     int fCellDimension; //! size of cell array
220     ValueType* fData; //! spacepoint data
221     int fDataDimension; //! size of spacepoint data
222     int fCount;
223
224     iterator fIterator; //! iterator
225     iterator fIteratorEnd; //! end marker iterator
226
227     ClassDef(AliHLTSpacePointGrid, 0)
228   };
229
230   //////////////////////////////////////////////////////////////////////////
231   //
232   // interface functions
233   //
234
235   /// add input block to the collection
236   virtual int AddInputBlock(const AliHLTComponentBlockData* pDesc)=0;
237   virtual int PopulateAccessGrid(AliHLTSpacePointGrid* /*pGrid*/, AliHLTUInt32_t /*mask*/) const {return -ENOSYS;}
238   virtual const AliHLTSpacePointGrid* GetAccessGrid(AliHLTUInt32_t /*mask*/) const {return NULL;}
239
240   virtual int GetNumberOfSpacePoints() const;
241   virtual bool Check(AliHLTUInt32_t clusterID) const;
242   virtual int GetClusterIDs(vector<AliHLTUInt32_t>& tgt) const = 0;
243   virtual const vector<AliHLTUInt32_t>* GetClusterIDs(AliHLTUInt32_t /*mask*/) {return NULL;}
244   virtual float GetX(AliHLTUInt32_t clusterID) const = 0;
245   virtual float GetXWidth(AliHLTUInt32_t clusterID) const = 0;
246   virtual float GetY(AliHLTUInt32_t clusterID) const = 0;
247   virtual float GetYWidth(AliHLTUInt32_t clusterID) const = 0;
248   virtual float GetZ(AliHLTUInt32_t clusterID) const = 0;
249   virtual float GetZWidth(AliHLTUInt32_t clusterID) const = 0;
250   virtual float GetCharge(AliHLTUInt32_t clusterID) const = 0;
251   virtual float GetMaxSignal(AliHLTUInt32_t /*clusterID*/) const {return 0.0;}
252   virtual float GetPhi(AliHLTUInt32_t /*clusterID*/) const {return 0.0;}
253
254   /// create a collection of clusters for a space point mask
255   virtual AliHLTSpacePointContainer* SelectByMask(AliHLTUInt32_t mask, bool bAlloc=false) const;
256
257   /// create a collection of clusters for a specific track
258   virtual AliHLTSpacePointContainer* SelectByTrack(int trackId, bool bAlloc=false) const;
259
260   /// create a collection of clusters for a specific MC track
261   virtual AliHLTSpacePointContainer* SelectByMC(int mcId, bool bAlloc=false) const;
262
263   /// create a collection of all used clusters
264   virtual AliHLTSpacePointContainer* UsedClusters(bool bAlloc=false) const;
265
266   /// create a collection of all unused clusters
267   virtual AliHLTSpacePointContainer* UnusedClusters(bool bAlloc=false) const;
268
269   int MarkUsed(AliHLTUInt32_t clusterID) {return MarkUsed(&clusterID, sizeof(clusterID));}
270   virtual int MarkUsed(const AliHLTUInt32_t* clusterIDs, int arraySize);
271
272   int SetTrackID(int trackID, AliHLTUInt32_t clusterID) {
273     return SetTrackID(trackID, &clusterID, sizeof(clusterID));
274   }
275   virtual int SetTrackID(int trackID, const AliHLTUInt32_t* clusterIDs, int arraySize);
276
277   virtual int GetTrackID(AliHLTUInt32_t /*clusterID*/) const {return -1;}
278
279   int SetMCID(int mcID, AliHLTUInt32_t clusterID) {
280     return SetMCID(mcID, &clusterID, sizeof(clusterID));
281   }
282   virtual int SetMCID(int clusterID, const AliHLTUInt32_t* clusterIDs, int arraySize);
283
284   /// write blocks to HLT component output
285   virtual int Write(AliHLTUInt8_t* outputPtr, AliHLTUInt32_t size,
286                     vector<AliHLTComponentBlockData>& outputBlocks,
287                     AliHLTDataDeflater* /*pDeflater*/,
288                     const char* option="") const {
289     return Write(outputPtr, size, outputBlocks, option);
290   }
291
292   /// write blocks to HLT component output: old function definition for backward compatibility
293   virtual int Write(AliHLTUInt8_t* /*outputPtr*/, AliHLTUInt32_t /*size*/,
294                     vector<AliHLTComponentBlockData>& /*outputBlocks*/,
295                     const char* /*option*/="") const {return 0;}
296
297   /// add input block from file to collection
298   int AddInputBlock(const char* filename, AliHLTComponentDataType dt, unsigned specification);
299
300   /// add input block from list of blank separated files to collection
301   int AddInputBlocks(const char* filenames, AliHLTComponentDataType dt);
302
303   /// alloc memory for a space point data block
304   AliHLTUInt8_t* Alloc(int size);
305
306   /// inherited from TObject: clear the object and reset pointer references
307   virtual void Clear(Option_t * /*option*/ ="");
308
309   /// inherited from TObject
310   virtual void Print(Option_t *option="") const;
311
312   virtual void Print(ostream& out, Option_t *option="") const;
313
314   void Draw(Option_t *option);
315
316   TH1* DrawProjection(const char* plane) const {
317     vector<AliHLTUInt32_t> selection; // empty list -> no selection
318     return DrawProjection(plane, selection);
319   }
320
321   TH1* DrawProjection(const char* plane, AliHLTUInt32_t specification) const {
322     vector<AliHLTUInt32_t> selection; selection.push_back(specification);
323     return DrawProjection(plane, selection);
324   }
325
326   TH1* DrawProjection(const char* plane, const vector<AliHLTUInt32_t>& selection) const;
327
328   TTree* FillTree(const char* name, const char* title="");
329
330  protected:
331
332  private:
333   vector<TArrayC*> fBuffers; //! buffers of loaded files
334
335   ClassDef(AliHLTSpacePointContainer, 0)
336 };
337
338 ostream& operator<<(ostream &out, const AliHLTSpacePointContainer& c);
339
340 #endif