Merge branch 'master' of https://git.cern.ch/reps/AliRoot
[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 <algorithm>
29 #include "TObject.h"
30 #include "AliLog.h"
31 #include "AliTRDSignalIndex.h"
32
33 ClassImp(AliTRDSignalIndex)
34
35 //_____________________________________________________________________________
36 AliTRDSignalIndex::AliTRDSignalIndex()
37   :TObject()
38   ,fDet(-1)
39   ,fLayer(-1)
40   ,fStack(-1)
41   ,fSM(-1)
42   ,fBoolIndex(NULL)
43   ,fSortedIndex(NULL)
44   ,fMaxLimit(0)
45   ,fPositionRC(0)
46   ,fCountRC(1)
47   ,fSortedWasInit(kFALSE)
48   ,fCurrRow(0)
49   ,fCurrCol(0)
50   ,fCurrTbin(0)
51   ,fNrows(0)
52   ,fNcols(0)
53   ,fNtbins(0)
54 {
55   //
56   // Default contructor
57   //
58
59   ResetCounters();
60
61 }
62
63 //_____________________________________________________________________________
64 AliTRDSignalIndex::AliTRDSignalIndex(Int_t nrow, Int_t ncol,Int_t ntime)
65   :TObject()
66   ,fDet(-1)
67   ,fLayer(-1)
68   ,fStack(-1)
69   ,fSM(-1)
70   ,fBoolIndex(NULL)
71   ,fSortedIndex(NULL)
72   ,fMaxLimit(0)
73   ,fPositionRC(0)
74   ,fCountRC(1)
75   ,fSortedWasInit(kFALSE)
76   ,fCurrRow(0)
77   ,fCurrCol(0)
78   ,fCurrTbin(0)
79   ,fNrows(0)
80   ,fNcols(0)
81   ,fNtbins(0)
82 {
83   //
84   // Not the default contructor... hmmm...
85   //
86
87   Allocate(nrow, ncol, ntime);  
88
89 }
90
91 //_____________________________________________________________________________
92 AliTRDSignalIndex::AliTRDSignalIndex(const AliTRDSignalIndex &a)
93   :TObject(a)
94   ,fDet(a.fDet)
95   ,fLayer(a.fLayer)
96   ,fStack(a.fStack)
97   ,fSM(a.fSM)
98   ,fBoolIndex(NULL)
99   ,fSortedIndex(NULL)
100   ,fMaxLimit(a.fMaxLimit)
101   ,fPositionRC(a.fPositionRC)
102   ,fCountRC(a.fCountRC)
103   ,fSortedWasInit(a.fSortedWasInit)
104   ,fCurrRow(a.fCurrRow)
105   ,fCurrCol(a.fCurrCol)
106   ,fCurrTbin(a.fCurrTbin)
107   ,fNrows(a.fNrows)
108   ,fNcols(a.fNcols)
109   ,fNtbins(a.fNtbins)
110 {
111   //
112   // Copy constructor
113   //
114
115   fBoolIndex = new Bool_t[fMaxLimit];
116   memcpy(fBoolIndex, a.fBoolIndex, fMaxLimit*sizeof(Bool_t));
117
118   fSortedIndex = new RowCol[fMaxLimit+1];
119   memcpy(fSortedIndex, a.fSortedIndex, (fMaxLimit+1)*sizeof(RowCol));
120 }
121
122 //_____________________________________________________________________________
123 AliTRDSignalIndex::~AliTRDSignalIndex()
124 {
125   //
126   // Destructor
127   //
128
129   if (fBoolIndex) {
130     delete [] fBoolIndex;
131     fBoolIndex = NULL;
132   }
133
134 if (fSortedIndex) {
135     delete [] fSortedIndex;
136     fSortedIndex = NULL;
137   }
138
139 }
140
141 //_____________________________________________________________________________
142 void AliTRDSignalIndex::Copy(TObject &a) const
143 {
144   //
145   // Copy function
146   //
147
148   ((AliTRDSignalIndex &)a).fDet           = fDet;
149   ((AliTRDSignalIndex &)a).fLayer         = fLayer;
150   ((AliTRDSignalIndex &)a).fStack         = fStack;
151   ((AliTRDSignalIndex &)a).fSM            = fSM;
152   ((AliTRDSignalIndex &)a).fMaxLimit      = fMaxLimit;
153   ((AliTRDSignalIndex &)a).fPositionRC    = fPositionRC;
154   ((AliTRDSignalIndex &)a).fCountRC       = fCountRC;
155   ((AliTRDSignalIndex &)a).fSortedWasInit = fSortedWasInit;
156   ((AliTRDSignalIndex &)a).fCurrRow       = fCurrRow;
157   ((AliTRDSignalIndex &)a).fCurrCol       = fCurrCol;
158   ((AliTRDSignalIndex &)a).fCurrTbin      = fCurrTbin;
159   ((AliTRDSignalIndex &)a).fNrows         = fNrows;
160   ((AliTRDSignalIndex &)a).fNcols         = fNcols;
161   ((AliTRDSignalIndex &)a).fNtbins        = fNtbins;
162
163   if(((AliTRDSignalIndex &)a).fBoolIndex)
164     {
165       delete [] ((AliTRDSignalIndex &)a).fBoolIndex;
166     }
167   ((AliTRDSignalIndex &)a).fBoolIndex = new Bool_t[fMaxLimit];
168   memcpy(((AliTRDSignalIndex &)a).fBoolIndex, fBoolIndex, fMaxLimit*sizeof(Bool_t));
169
170   if(((AliTRDSignalIndex &)a).fSortedIndex)
171     {
172       delete [] ((AliTRDSignalIndex &)a).fSortedIndex;
173     }
174   ((AliTRDSignalIndex &)a).fSortedIndex = new RowCol[fMaxLimit+1];
175   memcpy(((AliTRDSignalIndex &)a).fSortedIndex, fSortedIndex, (fMaxLimit+1)*sizeof(RowCol));
176
177 }
178
179 //_____________________________________________________________________________
180 AliTRDSignalIndex& AliTRDSignalIndex::operator = (const AliTRDSignalIndex& a)
181 {
182   //
183   // Assignment operator
184   //
185
186   if (this == &a) {
187     return *this;
188   }
189
190   fDet           = a.fDet;
191   fLayer         = a.fLayer;
192   fStack         = a.fStack;
193   fSM            = a.fSM;
194   fMaxLimit      = a.fMaxLimit;
195   fPositionRC    = a.fPositionRC;
196   fCountRC       = a.fCountRC;
197   fSortedWasInit = a.fSortedWasInit;
198   fCurrRow       = a.fCurrRow;
199   fCurrCol       = a.fCurrCol;
200   fCurrTbin      = a.fCurrTbin;
201   fNrows         = a.fNrows;
202   fNcols         = a.fNcols;
203   fNtbins        = a.fNtbins;
204
205   if (fBoolIndex) {
206     delete [] fBoolIndex;
207   }
208   fBoolIndex = new Bool_t[fMaxLimit];
209   memcpy(fBoolIndex, fBoolIndex, fMaxLimit*sizeof(Bool_t));
210
211   if (fSortedIndex) {
212     delete [] fSortedIndex;
213   }
214   fSortedIndex = new RowCol[fMaxLimit+1];
215   memcpy(fSortedIndex, fSortedIndex, (fMaxLimit+1)*sizeof(RowCol));
216
217   ResetCounters();
218
219   return *this;
220
221 }
222
223 //_____________________________________________________________________________
224 void AliTRDSignalIndex::Allocate(const Int_t nrow, const Int_t ncol, const Int_t ntime)
225 {
226   //
227   // Create the arrays
228   //
229
230   fNrows = nrow;
231   fNcols = ncol;
232   fNtbins = ntime;
233
234   fMaxLimit = nrow * ncol + 1;
235
236   if (fBoolIndex) {
237     delete [] fBoolIndex;
238     fBoolIndex = NULL;
239   }
240   if (fSortedIndex) {
241     delete [] fSortedIndex;
242     fSortedIndex = NULL;
243   }
244
245   fBoolIndex = new Bool_t[fMaxLimit];
246   fSortedIndex = new RowCol[fMaxLimit+1];
247
248   fCountRC = fMaxLimit+1;
249
250   ResetArrays();
251   ResetCounters();
252
253   fCountRC = 1;
254
255 }
256
257 //_____________________________________________________________________________
258 void AliTRDSignalIndex::ResetArrays()
259 {
260   if (!IsAllocated())
261     return;
262   memset(fBoolIndex,0x00,sizeof(Bool_t)*fMaxLimit);
263   memset(fSortedIndex,0xFF,sizeof(RowCol)*fCountRC); 
264   fSortedWasInit = kFALSE;
265 }
266
267 //_____________________________________________________________________________
268 void AliTRDSignalIndex::Reset()
269 {
270   //
271   // Reset the array but keep the size - realloc
272   //
273
274   fDet   = -1;
275   fLayer = -1;
276   fStack = -1;
277   fSM    = -1;
278
279   // All will be lost 
280   Allocate(fNrows, fNcols, fNtbins);
281
282 }
283
284 //_____________________________________________________________________________
285 void AliTRDSignalIndex::ResetContent()
286 {
287   //
288   // Reset the array but keep the size - no realloc
289   //
290
291   fDet   = -1;
292   fLayer = -1;
293   fStack = -1;
294   fSM    = -1;
295
296   ResetArrays();
297   ResetCounters();
298
299   fCountRC = 1;
300
301 }
302
303 //_____________________________________________________________________________
304 void AliTRDSignalIndex::ResetContentConditional(const Int_t nrow, const Int_t ncol, const Int_t ntime)
305 {
306   //
307   // Reset the array but keep the size if no need to enlarge - no realloc
308   //
309
310   fDet   = -1;
311   fLayer = -1;
312   fStack = -1;
313   fSM    = -1;
314
315   if ((nrow  > fNrows) || 
316       (ncol  > fNcols) || 
317       (ntime > fNtbins)) {
318     Allocate(nrow, ncol, ntime);
319   }
320   else {
321     ResetArrays();
322     ResetCounters();
323     fCountRC = 1;
324   }
325
326 }
327
328 //_____________________________________________________________________________
329 void AliTRDSignalIndex::ClearAll()
330 {
331   //
332   // Reset the values - clear all!
333   //
334
335   fDet    = -1;
336   fLayer  = -1;
337   fStack  = -1;
338   fSM     = -1;
339
340   fNrows  = -1;
341   fNcols  = -1;
342   fNtbins = -1;
343
344   if (fBoolIndex) {
345     delete [] fBoolIndex;
346     fBoolIndex = NULL;
347   }
348
349   if (fSortedIndex) {
350     delete [] fSortedIndex;
351     fSortedIndex = NULL;
352   }
353   
354   ResetCounters();
355
356   fCountRC = 1;
357   fSortedWasInit = kFALSE;
358   fMaxLimit = 0;
359
360 }
361
362 //_____________________________________________________________________________
363 Bool_t  AliTRDSignalIndex::CheckSorting(Int_t &row, Int_t &col)
364 {
365   //
366   // Check whether array was read to end or it was not sorted until now
367   //
368
369   if(fSortedWasInit || fCountRC==1)
370     { //we already reached the end of the array
371       ResetCounters();
372       row = fCurrRow;
373       col = fCurrCol;
374       return kFALSE;
375     }
376   else
377     { //we have not sorted the array up to now, let's do so
378       InitSortedIndex();
379       return NextRCIndex(row, col);
380     }
381 }
382
383 //_____________________________________________________________________________
384 Bool_t AliTRDSignalIndex::NextRCTbinIndex(Int_t &row, Int_t &col, Int_t &tbin)
385 {
386   //
387   // Returns the next tbin, or if there is no next time bin, it returns the
388   // next used RC combination.
389   //  
390
391   if (NextTbinIndex(tbin)) {
392     row = fCurrRow;
393     col = fCurrCol;
394     return kTRUE;
395   }
396   else {
397     if (NextRCIndex(row, col)) {
398       return NextRCTbinIndex(row, col, tbin);
399     }
400   }
401
402   return kFALSE;
403
404 }
405
406 //_____________________________________________________________________________
407 Bool_t AliTRDSignalIndex::NextTbinIndex(Int_t &tbin)
408 {
409   //
410   // Returns the next tbin of the current RC combination
411   //
412   
413   if(fCurrTbin<fNtbins)
414     {
415       tbin = fCurrTbin++;
416       return kTRUE;
417     }
418
419   return kFALSE;
420
421 }
422
423 //_____________________________________________________________________________
424 void AliTRDSignalIndex::InitSortedIndex()
425 {
426   //
427   // Creates the SortedIndex
428   //
429
430   fSortedWasInit = kTRUE;
431   std::sort((UShort_t*)fSortedIndex, ((UShort_t*)fSortedIndex) + fCountRC);
432
433 }
434
435 //_____________________________________________________________________________
436 void AliTRDSignalIndex::ResetCounters()    
437
438   //
439   // Reset the counters/iterators
440   //
441
442   fCurrRow    = -1;
443   fCurrCol    = -1;
444   fCurrTbin   = -1;
445   fPositionRC =  0;
446 }