]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - TRD/AliTRDSignalIndex.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Protection against division by 0.
[u/mrichter/AliRoot.git] / TRD / AliTRDSignalIndex.cxx
... / ...
CommitLineData
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
33ClassImp(AliTRDSignalIndex)
34
35//_____________________________________________________________________________
36AliTRDSignalIndex::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//_____________________________________________________________________________
64AliTRDSignalIndex::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//_____________________________________________________________________________
92AliTRDSignalIndex::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//_____________________________________________________________________________
123AliTRDSignalIndex::~AliTRDSignalIndex()
124{
125 //
126 // Destructor
127 //
128
129 if (fBoolIndex) {
130 delete [] fBoolIndex;
131 fBoolIndex = NULL;
132 }
133
134if (fSortedIndex) {
135 delete [] fSortedIndex;
136 fSortedIndex = NULL;
137 }
138
139}
140
141//_____________________________________________________________________________
142void 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//_____________________________________________________________________________
180AliTRDSignalIndex& 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//_____________________________________________________________________________
192void 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//_____________________________________________________________________________
226void 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//_____________________________________________________________________________
236void 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//_____________________________________________________________________________
253void 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//_____________________________________________________________________________
272void 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//_____________________________________________________________________________
297void 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//_____________________________________________________________________________
331Bool_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//_____________________________________________________________________________
352Bool_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//_____________________________________________________________________________
375Bool_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//_____________________________________________________________________________
392void 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//_____________________________________________________________________________
404void AliTRDSignalIndex::ResetCounters()
405{
406 //
407 // Reset the counters/iterators
408 //
409
410 fCurrRow = -1;
411 fCurrCol = -1;
412 fCurrTbin = -1;
413 fPositionRC = 0;
414}