gcc 4.3 warnings fixed
[u/mrichter/AliRoot.git] / TRD / AliTRDSignalIndex.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 ///////////////////////////////////////////////////////////////////////////////
19 //                                                                           //
20 //  General container for data from TRD detector segments                    //
21 //  Adapted from AliDigits, origin M.Ivanov                                  //
22 //                                                                           //
23 //  Author:                                                                  //
24 //    Mateusz Ploskon (ploskon@ikf.uni-frankfurt.de)                         //
25 //                                                                           //
26 ///////////////////////////////////////////////////////////////////////////////
27
28 #include "TArrayI.h"
29
30 #include "AliLog.h"
31
32 #include "AliTRDSignalIndex.h"
33
34 ClassImp(AliTRDSignalIndex)
35
36 //_____________________________________________________________________________
37 AliTRDSignalIndex::AliTRDSignalIndex()
38   :TObject()
39   ,fDet(-1)
40   ,fLayer(-1)
41   ,fStack(-1)
42   ,fSM(-1)
43   ,fIndex(NULL)
44   ,fPositionRow(0)
45   ,fPositionCol(0)
46   ,fPositionTbin(0)
47   ,fLastRow(0)
48   ,fLastCol(0)
49   ,fLastTbin(0)
50   ,fNrows(0)
51   ,fNcols(0)
52   ,fNtbins(0)
53   ,fMaxLimit(0)
54   ,fResetCounters(kTRUE)
55   ,fHasEntry(kFALSE)
56 {
57   //
58   // Default contructor
59   //
60
61   ResetCounters();
62
63 }
64
65 //_____________________________________________________________________________
66 AliTRDSignalIndex::AliTRDSignalIndex(Int_t nrow, Int_t ncol,Int_t ntime)
67   :TObject()
68   ,fDet(-1)
69   ,fLayer(-1)
70   ,fStack(-1)
71   ,fSM(-1)
72   ,fIndex(NULL)
73   ,fPositionRow(0)
74   ,fPositionCol(0)
75   ,fPositionTbin(0)
76   ,fLastRow(0)
77   ,fLastCol(0)
78   ,fLastTbin(0)
79   ,fNrows(0)
80   ,fNcols(0)
81   ,fNtbins(0)
82   ,fMaxLimit(0)
83   ,fResetCounters(kTRUE)
84   ,fHasEntry(kFALSE)
85 {
86   //
87   // Not the default contructor... hmmm...
88   //
89
90   Allocate(nrow, ncol, ntime);  
91
92 }
93
94 //_____________________________________________________________________________
95 AliTRDSignalIndex::AliTRDSignalIndex(const AliTRDSignalIndex &a)
96   :TObject(a)
97   ,fDet(a.fDet)
98   ,fLayer(a.fLayer)
99   ,fStack(a.fStack)
100   ,fSM(a.fSM)
101   ,fIndex(a.fIndex)
102   ,fPositionRow(a.fPositionRow)
103   ,fPositionCol(a.fPositionCol)
104   ,fPositionTbin(a.fPositionTbin)
105   ,fLastRow(a.fLastRow)
106   ,fLastCol(a.fLastCol)
107   ,fLastTbin(a.fLastTbin)
108   ,fNrows(a.fNrows)
109   ,fNcols(a.fNcols)
110   ,fNtbins(a.fNtbins)
111   ,fMaxLimit(a.fMaxLimit)
112   ,fResetCounters(a.fResetCounters)
113   ,fHasEntry(a.fHasEntry)
114 {
115   //
116   // Copy constructor
117   //
118
119 }
120
121 //_____________________________________________________________________________
122 AliTRDSignalIndex::~AliTRDSignalIndex()
123 {
124   //
125   // Destructor
126   //
127
128   if (fIndex) {
129     delete fIndex;
130     fIndex = NULL;
131   }
132
133 }
134
135 //_____________________________________________________________________________
136 void AliTRDSignalIndex::Copy(TObject &a) const
137 {
138   //
139   // Copy function
140   //
141
142   ((AliTRDSignalIndex &)a).fDet           = fDet;
143   ((AliTRDSignalIndex &)a).fLayer         = fLayer;
144   ((AliTRDSignalIndex &)a).fStack         = fStack;
145   ((AliTRDSignalIndex &)a).fSM            = fSM;
146   ((AliTRDSignalIndex &)a).fIndex         = fIndex;
147   ((AliTRDSignalIndex &)a).fPositionRow   = fPositionRow;
148   ((AliTRDSignalIndex &)a).fPositionTbin  = fPositionTbin;
149   ((AliTRDSignalIndex &)a).fLastRow       = fLastRow;
150   ((AliTRDSignalIndex &)a).fLastCol       = fLastCol;
151   ((AliTRDSignalIndex &)a).fLastTbin      = fLastTbin;
152   ((AliTRDSignalIndex &)a).fNrows         = fNrows;
153   ((AliTRDSignalIndex &)a).fNcols         = fNcols;
154   ((AliTRDSignalIndex &)a).fNtbins        = fNtbins;
155   ((AliTRDSignalIndex &)a).fMaxLimit      = fMaxLimit;
156   ((AliTRDSignalIndex &)a).fResetCounters = fResetCounters;
157   ((AliTRDSignalIndex &)a).fHasEntry      = fHasEntry;
158
159 }
160
161 //_____________________________________________________________________________
162 AliTRDSignalIndex& AliTRDSignalIndex::operator = (const AliTRDSignalIndex& a)
163 {
164   //
165   // Assignment operator
166   //
167
168   if (this != &a) ((AliTRDSignalIndex &) a).Copy(*this);
169   return *this;
170
171 }
172
173 //_____________________________________________________________________________
174 void AliTRDSignalIndex::Allocate(Int_t nrow, Int_t ncol,Int_t ntime)
175 {
176   //
177   // Create the arrays
178   //
179
180   fNrows = nrow;
181   fNcols = ncol;
182   fNtbins = ntime;
183
184   fMaxLimit = nrow * ncol * ntime + nrow * ncol * 2;
185   if (fIndex) {
186     delete fIndex;
187     fIndex = NULL;
188   }
189
190   fIndex = new TArrayI(fMaxLimit);
191   fIndex->Reset(-1);
192
193   ResetCounters();
194
195   fHasEntry = kFALSE;
196
197 }
198
199 //_____________________________________________________________________________
200 void AliTRDSignalIndex::Reset()
201 {
202   //
203   // Reset the array but keep the size - realloc
204   //
205
206   fDet   = -1;
207   fLayer = -1;
208   fStack = -1;
209   fSM    = -1;
210
211   // All will be lost 
212   Allocate(fNrows, fNcols, fNtbins);
213
214 }
215
216 //_____________________________________________________________________________
217 void AliTRDSignalIndex::ResetContent()
218 {
219   //
220   // Reset the array but keep the size - no realloc
221   //
222
223   fIndex->Reset(-1);
224   ResetCounters();
225
226   fHasEntry = kFALSE;
227
228 }
229
230 //_____________________________________________________________________________
231 void AliTRDSignalIndex::ResetContentConditional(Int_t nrow, Int_t ncol,Int_t ntime)
232 {
233   //
234   // Reset the array but keep the size if no need to enlarge - no realloc
235   //
236
237   fDet   = -1;
238   fLayer = -1;
239   fStack = -1;
240   fSM    = -1;
241
242   if ((nrow  > fNrows) || 
243       (ncol  > fNcols) || 
244       (ntime > fNtbins)) {
245     Allocate(nrow, ncol, ntime);
246   }
247   else {
248     fIndex->Reset(-1);
249     ResetCounters();
250     fHasEntry = kFALSE;
251   }
252
253 }
254
255 //_____________________________________________________________________________
256 void AliTRDSignalIndex::ClearAll()
257 {
258   //
259   // Reset the values - clear all!
260   //
261
262   fDet    = -1;
263   fLayer  = -1;
264   fStack  = -1;
265   fSM     = -1;
266
267   fNrows  = -1;
268   fNcols  = -1;
269   fNtbins = -1;
270
271   if (fIndex) {
272     delete fIndex;
273     fIndex = NULL;
274   }
275   fIndex = new TArrayI();
276   ResetCounters();
277
278   fHasEntry = kFALSE;
279
280 }
281
282 //_____________________________________________________________________________
283 void AliTRDSignalIndex::AddIndexTBin(Int_t row, Int_t col, Int_t tbin)
284 {
285   //
286   // Store the index row-column-tbin as an interesting one
287   // The RC index is updated to!!!
288   // This is to be used in the TRD clusterizer!
289   //
290
291   if (row * col * tbin + row * col * 2 >= fMaxLimit) {
292     AliError(Form("Out-of-limits fPositionCol + fNtbins %d. Limit is: %d"
293                  ,fPositionCol + fNtbins
294                  ,fMaxLimit));
295     return;
296   }
297
298   if ((row != fLastRow) || 
299       (col != fLastCol)) {
300
301     // New RC combination
302     if (fResetCounters == kTRUE) {
303       fPositionRow    = 0;
304       fPositionCol   = 1;  
305       fResetCounters = kFALSE;
306     }
307     else {
308       fPositionRow += fNtbins + 2;
309       fPositionCol += fNtbins + 2;
310     }
311
312     fPositionTbin = 1;
313
314     (*fIndex)[fPositionRow] = row;
315     (*fIndex)[fPositionCol] = col;
316     (*fIndex)[fPositionCol + fPositionTbin] = tbin;
317     ++fPositionTbin;
318
319   }
320   else {
321
322     // Same RCT combination ?
323       
324     (*fIndex)[fPositionCol + fPositionTbin] = tbin;
325     ++fPositionTbin;      
326   
327   }
328   
329   fLastRow  = row;
330   fLastCol  = col;
331   fLastTbin = tbin;
332
333   fHasEntry = kTRUE;
334
335 }
336
337 //_____________________________________________________________________________
338 Bool_t  AliTRDSignalIndex::NextRCIndex(Int_t &row, Int_t &col)
339 {
340   //
341   // Return the position (index in the data array) of the next available pad
342   //
343
344   if (fResetCounters == kTRUE) {
345     fPositionRow   = 0;
346     fPositionCol   = 1;
347     fResetCounters = kFALSE;
348   }
349   else {
350     fPositionRow  += fNtbins + 2;
351     fPositionCol  += fNtbins + 2;
352   }
353
354   if (fPositionRow >= fMaxLimit) {
355     return kFALSE;
356   }
357
358   fPositionTbin = 1;
359
360   row = (*fIndex)[fPositionRow];
361   col = (*fIndex)[fPositionCol];
362
363   if ((row > -1) && 
364       (col > -1)) { 
365     return kTRUE;
366   }
367   
368   return kFALSE;
369
370 }
371
372 //_____________________________________________________________________________
373 Bool_t AliTRDSignalIndex::NextRCTbinIndex(Int_t &row, Int_t &col, Int_t &tbin)
374 {
375   //
376   // Return the position (index in the data array) of the next available tbin 
377   // within the current pad
378   //
379
380   if (fPositionRow >= fMaxLimit) {
381     return kFALSE;
382   }
383
384   if (NextTbinIndex(tbin)) {
385     row  = (*fIndex)[fPositionRow];
386     col  = (*fIndex)[fPositionCol];
387     fResetCounters = kFALSE;
388     return kTRUE;
389   }
390   else {
391     if (NextRCIndex(row, col)) {
392       return NextRCTbinIndex(row, col, tbin);
393     }
394   }
395
396   return kFALSE;
397
398 }
399
400 //_____________________________________________________________________________
401 Bool_t AliTRDSignalIndex::NextTbinIndex(Int_t &tbin)
402 {
403   //
404   // Return the position (index in the data array) of the next available tbin 
405   // within the current pad
406   //
407
408   if ((fPositionCol + fPositionTbin >= fMaxLimit) || 
409       (fPositionTbin                >  fNtbins  )) {
410     return kFALSE;
411   }
412
413   tbin = (*fIndex)[fPositionCol + fPositionTbin];
414
415   if (tbin > -1) {
416     ++fPositionTbin;
417     return kTRUE;
418   }
419
420   return kFALSE;
421
422 }
423
424 //_____________________________________________________________________________
425 void AliTRDSignalIndex::ResetCounters()    
426
427   //
428   // Reset the counters/iterators
429   //
430
431   fPositionRow   =  0;
432   fPositionCol   =  fPositionRow + 1;
433   fPositionTbin  =  1;
434   fLastRow       = -1;
435   fLastCol       = -1;
436   fLastTbin      = -1;
437   fResetCounters = kTRUE; 
438
439 }