]> git.uio.no Git - u/mrichter/AliRoot.git/blob - TRD/AliTRDSignalIndex.cxx
Remove a run from LHC10e wo AODs; added run list for the new PbPb MC LHC11a10b_bis
[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) ((AliTRDSignalIndex &) a).Copy(*this);
187   return *this;
188
189 }
190
191 //_____________________________________________________________________________
192 void AliTRDSignalIndex::Allocate(const Int_t nrow, const Int_t ncol, const Int_t ntime)
193 {
194   //
195   // Create the arrays
196   //
197
198   fNrows = nrow;
199   fNcols = ncol;
200   fNtbins = ntime;
201
202   fMaxLimit = nrow * ncol + 1;
203
204   if (fBoolIndex) {
205     delete [] fBoolIndex;
206     fBoolIndex = NULL;
207   }
208   if (fSortedIndex) {
209     delete [] fSortedIndex;
210     fSortedIndex = NULL;
211   }
212
213   fBoolIndex = new Bool_t[fMaxLimit];
214   fSortedIndex = new RowCol[fMaxLimit+1];
215
216   fCountRC = fMaxLimit+1;
217
218   ResetArrays();
219   ResetCounters();
220
221   fCountRC = 1;
222
223 }
224
225 //_____________________________________________________________________________
226 void AliTRDSignalIndex::ResetArrays()
227 {
228   if (!IsAllocated())
229     return;
230   memset(fBoolIndex,0x00,sizeof(Bool_t)*fMaxLimit);
231   memset(fSortedIndex,0xFF,sizeof(RowCol)*fCountRC); 
232   fSortedWasInit = kFALSE;
233 }
234
235 //_____________________________________________________________________________
236 void AliTRDSignalIndex::Reset()
237 {
238   //
239   // Reset the array but keep the size - realloc
240   //
241
242   fDet   = -1;
243   fLayer = -1;
244   fStack = -1;
245   fSM    = -1;
246
247   // All will be lost 
248   Allocate(fNrows, fNcols, fNtbins);
249
250 }
251
252 //_____________________________________________________________________________
253 void AliTRDSignalIndex::ResetContent()
254 {
255   //
256   // Reset the array but keep the size - no realloc
257   //
258
259   fDet   = -1;
260   fLayer = -1;
261   fStack = -1;
262   fSM    = -1;
263
264   ResetArrays();
265   ResetCounters();
266
267   fCountRC = 1;
268
269 }
270
271 //_____________________________________________________________________________
272 void AliTRDSignalIndex::ResetContentConditional(const Int_t nrow, const Int_t ncol, const Int_t ntime)
273 {
274   //
275   // Reset the array but keep the size if no need to enlarge - no realloc
276   //
277
278   fDet   = -1;
279   fLayer = -1;
280   fStack = -1;
281   fSM    = -1;
282
283   if ((nrow  > fNrows) || 
284       (ncol  > fNcols) || 
285       (ntime > fNtbins)) {
286     Allocate(nrow, ncol, ntime);
287   }
288   else {
289     ResetArrays();
290     ResetCounters();
291     fCountRC = 1;
292   }
293
294 }
295
296 //_____________________________________________________________________________
297 void AliTRDSignalIndex::ClearAll()
298 {
299   //
300   // Reset the values - clear all!
301   //
302
303   fDet    = -1;
304   fLayer  = -1;
305   fStack  = -1;
306   fSM     = -1;
307
308   fNrows  = -1;
309   fNcols  = -1;
310   fNtbins = -1;
311
312   if (fBoolIndex) {
313     delete [] fBoolIndex;
314     fBoolIndex = NULL;
315   }
316
317   if (fSortedIndex) {
318     delete [] fSortedIndex;
319     fSortedIndex = NULL;
320   }
321   
322   ResetCounters();
323
324   fCountRC = 1;
325   fSortedWasInit = kFALSE;
326   fMaxLimit = 0;
327
328 }
329
330 //_____________________________________________________________________________
331 Bool_t  AliTRDSignalIndex::CheckSorting(Int_t &row, Int_t &col)
332 {
333   //
334   // Check whether array was read to end or it was not sorted until now
335   //
336
337   if(fSortedWasInit || fCountRC==1)
338     { //we already reached the end of the array
339       ResetCounters();
340       row = fCurrRow;
341       col = fCurrCol;
342       return kFALSE;
343     }
344   else
345     { //we have not sorted the array up to now, let's do so
346       InitSortedIndex();
347       return NextRCIndex(row, col);
348     }
349 }
350
351 //_____________________________________________________________________________
352 Bool_t AliTRDSignalIndex::NextRCTbinIndex(Int_t &row, Int_t &col, Int_t &tbin)
353 {
354   //
355   // Returns the next tbin, or if there is no next time bin, it returns the
356   // next used RC combination.
357   //  
358
359   if (NextTbinIndex(tbin)) {
360     row = fCurrRow;
361     col = fCurrCol;
362     return kTRUE;
363   }
364   else {
365     if (NextRCIndex(row, col)) {
366       return NextRCTbinIndex(row, col, tbin);
367     }
368   }
369
370   return kFALSE;
371
372 }
373
374 //_____________________________________________________________________________
375 Bool_t AliTRDSignalIndex::NextTbinIndex(Int_t &tbin)
376 {
377   //
378   // Returns the next tbin of the current RC combination
379   //
380   
381   if(fCurrTbin<fNtbins)
382     {
383       tbin = fCurrTbin++;
384       return kTRUE;
385     }
386
387   return kFALSE;
388
389 }
390
391 //_____________________________________________________________________________
392 void AliTRDSignalIndex::InitSortedIndex()
393 {
394   //
395   // Creates the SortedIndex
396   //
397
398   fSortedWasInit = kTRUE;
399   std::sort((UShort_t*)fSortedIndex, ((UShort_t*)fSortedIndex) + fCountRC);
400
401 }
402
403 //_____________________________________________________________________________
404 void AliTRDSignalIndex::ResetCounters()    
405
406   //
407   // Reset the counters/iterators
408   //
409
410   fCurrRow    = -1;
411   fCurrCol    = -1;
412   fCurrTbin   = -1;
413   fPositionRC =  0;
414 }