treatment of MC labels added
[u/mrichter/AliRoot.git] / HLT / TPCLib / HWCFemulator / AliHLTTPCHWClusterMerger.h
1 //-*- Mode: C++ -*-
2 // $Id$
3
4 #ifndef ALIHLTTPCHWCLUSTERMERGER_H
5 #define ALIHLTTPCHWCLUSTERMERGER_H
6 //* This file is property of and copyright by the ALICE HLT Project        * 
7 //* ALICE Experiment at CERN, All rights reserved.                         *
8 //* See cxx source for full Copyright notice                               *
9
10 //  @file   AliHLTTPCHWClusterMerger.h
11 //  @author Matthias Richter, Sergey Gorbunov
12 //  @date   2011-11-25
13 //  @brief  Merger class for HLT TPC Hardware clusters
14 //          Handles merging of branch border clusters
15
16 #include "AliHLTTPCRawCluster.h"
17 #include "AliHLTTPCClusterMCData.h"
18 #include "AliHLTLogging.h"
19 #include <vector>
20 #include "TObject.h"
21
22 /**
23  * @class AliHLTTPCHWClusterMerger
24  *
25  * @ingroup alihlt_base
26  */
27 class AliHLTTPCHWClusterMerger : public AliHLTLogging
28 {
29  public:
30   /// standard constructor
31   AliHLTTPCHWClusterMerger();
32   /// destructor
33   ~AliHLTTPCHWClusterMerger();
34
35   void Init();
36
37   //////////////////////////////////////////////////////////////////////////////////////////////////////////
38   //////////////////////////////////////////////////////////////////////////////////////////////////////////
39
40   /// check if a cluster is a candidate for merging
41   template<typename T> 
42   bool CheckCandidate(int slice, int partition, const T& c) {
43     return CheckCandidate(slice, partition, c.GetPadRow(), c.GetPad(), c.GetTime(), c.GetSigmaY2() );
44   }
45
46   /// check if a cluster is a candidate for merging
47   bool CheckCandidate(int slice,
48                       int partition,
49                       int partitionrow, // local row in partition
50                       float pad,
51                       float time,
52                       float sigmaPad2) ;
53
54   /// cache cluster for later merging
55   template<typename T> 
56   int AddCandidate(int slice,
57                    int partition,
58                    AliHLTUInt32_t id,
59                    const T& c) {
60     return AddCandidate(slice,
61                         partition,
62                         c.GetPadRow(),
63                         c.GetPad(),
64                         c.GetTime(),
65                         c.GetSigmaY2(),
66                         c.GetSigmaZ2(),
67                         c.GetCharge(),
68                         c.GetQMax(),
69                         id
70                         );
71   }
72
73   // cache cluster for later merging
74   template<typename T> 
75   int AddCandidate(int slice,
76                    int partition,
77                    AliHLTUInt32_t id,
78                    const T& c,
79                    const AliHLTTPCClusterMCLabel &mc) {
80     return AddCandidate(slice,
81                         partition,
82                         c.GetPadRow(),
83                         c.GetPad(),
84                         c.GetTime(),
85                         c.GetSigmaY2(),
86                         c.GetSigmaZ2(),
87                         c.GetCharge(),
88                         c.GetQMax(),
89                         id,
90                         mc
91                         );
92   }
93
94   /// cache cluster for later merging
95   int AddCandidate(int slice,
96                    int partition,
97                    short partitionrow, // local row in the partition
98                    float pad,
99                    float time,
100                    float sigmaY2,
101                    float sigmaZ2,
102                    unsigned short charge,
103                    unsigned short qmax,
104                    AliHLTUInt32_t id=~AliHLTUInt32_t(0),
105                    const AliHLTTPCClusterMCLabel &mc=AliHLTTPCClusterMCLabel()
106                    );
107
108   /// merge clusters
109   int Merge();
110
111   /// cleanup
112   void Clear();
113
114   //////////////////////////////////////////////////////////////////////////////////////////////////////////
115   //////////////////////////////////////////////////////////////////////////////////////////////////////////
116
117   /// helper class to store relevant data for a cluster at border
118   struct AliBorderRecord {
119     AliHLTInt64_t fClusterRecordID;
120     AliHLTUInt32_t fTimeBin;    
121   };
122  
123   
124   /// helper class to store relevant data for a cluster candidate
125   class AliClusterRecord {
126   public:
127     AliClusterRecord()
128       : fSlice(-1), fPartition(-1), fBorder(-1), fMergedFlag(0), fId(~AliHLTUInt32_t(0)), fCluster(), fMC() {}
129     AliClusterRecord(int slice, int partition, int border,bool merged, AliHLTUInt32_t id, const AliHLTTPCRawCluster &cluster)
130       : fSlice(slice), fPartition(partition), fBorder(border), fMergedFlag(merged), fId(id), fCluster(cluster), fMC() {}
131     AliClusterRecord(int slice, int partition, int border,bool merged, AliHLTUInt32_t id, const AliHLTTPCRawCluster &cluster, const AliHLTTPCClusterMCLabel &mc)
132       : fSlice(slice), fPartition(partition), fBorder(border), fMergedFlag(merged), fId(id), fCluster(cluster), fMC(mc) {}
133
134     AliClusterRecord(const AliClusterRecord& other)
135       : fSlice(other.fSlice), fPartition(other.fPartition), fBorder(other.fBorder), fMergedFlag(other.fMergedFlag), fId(other.fId), fCluster(other.fCluster), fMC(other.fMC) {}
136     AliClusterRecord& operator=(const AliClusterRecord& other) {
137       if (this==&other) return *this;
138       this->~AliClusterRecord();
139       new (this) AliClusterRecord(other);
140       return *this;
141     }
142
143     ~AliClusterRecord() {}    
144     
145     AliClusterRecord& operator=(const AliHLTTPCRawCluster& c) {
146       fCluster=c;
147       return *this;
148     }
149
150     bool GetMergedFlag() const { return fMergedFlag; }
151     int GetSlice() const {return fSlice;}
152     int GetBorder() const {return fBorder;}
153     int GetPartition() const {return fPartition;}
154     AliHLTUInt32_t GetId() const {return fId;}
155     operator AliHLTTPCRawCluster() const {return fCluster;}
156     const AliHLTTPCRawCluster& GetCluster() const {return fCluster;}
157     const AliHLTTPCClusterMCLabel& GetMCLabel() const {return fMC;}
158     void SetMergedFlag(bool v ){ fMergedFlag = v;}
159     AliHLTTPCRawCluster &Cluster(){ return fCluster; }
160     AliHLTTPCClusterMCLabel& MCLabel(){ return fMC; }
161   private:
162     int fSlice; //!
163     int fPartition; //!
164     int fBorder; //!
165     bool fMergedFlag; //!
166     AliHLTUInt32_t fId; //!
167     AliHLTTPCRawCluster fCluster; //!
168     AliHLTTPCClusterMCLabel fMC; //!
169   };
170
171   //////////////////////////////////////////////////////////////////////////////////////////////////////////
172   //////////////////////////////////////////////////////////////////////////////////////////////////////////
173
174   /// iterator class to access merged and remaining clusters
175   class iterator {
176   public:
177     iterator() : fArray(NULL), fIter() {}
178     iterator(vector<AliClusterRecord>* pArray) : fArray(pArray), fIter() {if (fArray) fIter=fArray->begin();}
179     iterator(const iterator& other) : fArray(other.fArray), fIter(other.fIter) {}
180     iterator& operator=(const iterator& other) {
181       if (this==&other) return *this;
182       fArray=other.fArray; fIter=other.fIter; return *this;
183     }
184     ~iterator() {}
185
186     AliClusterRecord operator*() {return *fIter;}
187
188     // prefix operators
189     iterator& operator++() {
190       if (!fArray || fIter==fArray->end()) return *this;
191       while ((++fIter)!=fArray->end()) {
192         // cout<<"Read flag: "<<fIter->GetMergedFlag()<<endl;
193         if (!fIter->GetMergedFlag() ) break;    
194       }      
195       return *this;
196     }
197     iterator& operator--() {
198       if (!fArray) return *this;
199       while (fIter!=fArray->begin()) {
200         --fIter;
201         if (!fIter->GetMergedFlag()) break;     
202       }
203       return *this;
204     }
205
206     // postfix operators
207     iterator operator++(int) {iterator i(*this); this->operator++(); return i;}
208     iterator operator--(int) {iterator i(*this); this->operator--(); return i;}
209
210     iterator& operator+=(int step) {
211       if (!fArray) return *this;
212       while ((fIter)!=fArray->end() && step-->0) {++fIter;}
213       return *this;
214     }
215
216     bool operator==(const iterator& other) {
217       return (other.fArray!=NULL && fArray!=NULL && other.fIter==fIter);
218     }
219
220     bool operator!=(const iterator& other) {
221       return (other.fArray!=NULL && fArray!=NULL && other.fIter!=fIter);
222     }
223
224   protected:
225   private:
226     vector<AliClusterRecord>* fArray; //!
227     vector<AliClusterRecord>::iterator fIter; //!
228   };
229
230   //////////////////////////////////////////////////////////////////////////////////////////////////////////
231   //////////////////////////////////////////////////////////////////////////////////////////////////////////
232
233   /// iterator function, start iteration
234   iterator& begin() {
235     fIter.~iterator();
236     new (&fIter) iterator(&fClusters);
237     fEnd=fIter;  fEnd+=fClusters.size();    
238     // skip empty (merged) clusters
239     while (fIter!=fEnd && (*fIter).GetMergedFlag() ) {
240       fIter++;
241     }
242     return fIter;
243   }
244
245   /// iterator function, end marker
246   iterator& end() {
247     return fEnd;
248   }
249
250   //////////////////////////////////////////////////////////////////////////////////////////////////////////
251   //////////////////////////////////////////////////////////////////////////////////////////////////////////
252
253  protected:
254
255  private:
256   /// copy constructor
257   AliHLTTPCHWClusterMerger(const AliHLTTPCHWClusterMerger&);
258   /// assignment operator
259   AliHLTTPCHWClusterMerger& operator=(const AliHLTTPCHWClusterMerger&);
260
261   int FillIndex();
262   static bool CompareTime( const AliBorderRecord &b1, const AliBorderRecord &b2){
263     return b1.fTimeBin > b2.fTimeBin;
264   }
265  
266   static bool CompareMCWeights(const AliHLTTPCClusterMCWeight &a, const AliHLTTPCClusterMCWeight &b){
267     return a.fWeight > b.fWeight;
268   }
269   static bool CompareMCLabels(const AliHLTTPCClusterMCWeight &a, const AliHLTTPCClusterMCWeight &b){
270     return a.fMCID < b.fMCID;
271   }
272
273   AliHLTInt16_t *fMapping;//!
274   int fNRows;//!
275   int fNRowPads;//!
276   int fNBorders;//!
277   AliHLTFloat32_t *fBorders; //!
278   int *fBorderNClusters; //!
279   int *fBorderFirstCluster; //!
280   AliBorderRecord *fBorderClusters;
281   int fBorderNClustersTotal; //!
282
283   vector<AliClusterRecord> fClusters; //! array of candidates
284   vector<AliHLTUInt32_t> fRemovedClusterIds; //! array of removed clusters by id
285   iterator fIter; //!
286   iterator fEnd; //!
287   static const int fkMergeWidth = 3;
288   static const int fkNSlices = 36;
289   static const int fkMergeTimeWindow = 2;
290   ClassDef(AliHLTTPCHWClusterMerger, 0)
291 };
292
293 #endif //ALIHLTTPCHWCLUSTERMERGER_H