]> 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
Undoing changes to AliGlauberMC
[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) {
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//_____________________________________________________________________________
224void 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//_____________________________________________________________________________
258void 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//_____________________________________________________________________________
268void 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//_____________________________________________________________________________
285void 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//_____________________________________________________________________________
304void 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//_____________________________________________________________________________
329void 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//_____________________________________________________________________________
363Bool_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//_____________________________________________________________________________
384Bool_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//_____________________________________________________________________________
407Bool_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//_____________________________________________________________________________
424void 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//_____________________________________________________________________________
436void AliTRDSignalIndex::ResetCounters()
437{
438 //
439 // Reset the counters/iterators
440 //
441
442 fCurrRow = -1;
443 fCurrCol = -1;
444 fCurrTbin = -1;
445 fPositionRC = 0;
446}