The present commit corresponds to an important change in the way the
[u/mrichter/AliRoot.git] / TRD / AliTRDdataArrayI.cxx
CommitLineData
6f1e466d 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
88cb7938 16/* $Id$ */
6f1e466d 17
18///////////////////////////////////////////////////////////////////////////////
19// //
20// General container for integer data of a TRD detector segment. //
21// Adapted from AliDigits (origin: M.Ivanov). //
22// //
23///////////////////////////////////////////////////////////////////////////////
24
2745a409 25#include "AliLog.h"
26
6f1e466d 27#include "AliTRDdataArrayI.h"
793ff80c 28#include "AliTRDarrayI.h"
6f1e466d 29
30ClassImp(AliTRDdataArrayI)
31
32//_____________________________________________________________________________
2745a409 33AliTRDdataArrayI::AliTRDdataArrayI()
34 :AliTRDdataArray()
35 ,fElements(0)
36 ,fThreshold(0)
6f1e466d 37{
38 //
39 // Default constructor
40 //
41
6f1e466d 42}
43
44//_____________________________________________________________________________
45AliTRDdataArrayI::AliTRDdataArrayI(Int_t nrow, Int_t ncol, Int_t ntime)
2745a409 46 :AliTRDdataArray(nrow,ncol,ntime)
47 ,fElements(0)
48 ,fThreshold(0)
6f1e466d 49{
50 //
51 // Creates a AliTRDdataArrayI with the dimensions <nrow>, <ncol>, and <ntime>.
52 // The row- and column dimensions are compressible.
53 //
54
55 Allocate(nrow,ncol,ntime);
56
57}
58
59//_____________________________________________________________________________
2745a409 60AliTRDdataArrayI::AliTRDdataArrayI(const AliTRDdataArrayI &a)
61 :AliTRDdataArray(a)
62 ,fElements(a.fElements)
63 ,fThreshold(a.fThreshold)
8230f242 64{
65 //
66 // AliTRDdataArrayI copy constructor
67 //
68
8230f242 69}
70
71//_____________________________________________________________________________
6f1e466d 72AliTRDdataArrayI::~AliTRDdataArrayI()
73{
74 //
75 // Destructor
76 //
77
a6dd11e9 78 if (fElements) {
79 delete fElements;
80 fElements = 0;
81 }
6f1e466d 82
83}
84
85//_____________________________________________________________________________
86void AliTRDdataArrayI::Allocate(Int_t nrow, Int_t ncol, Int_t ntime)
87{
88 //
89 // Allocates memory for a AliTRDdataArrayI with the dimensions
90 // <nrow>, <ncol>, and <ntime>.
91 // The row- and column dimensions are compressible.
92 //
93
a6dd11e9 94 if (fNelems < 0) {
95 AliTRDdataArray::Allocate(nrow,ncol,ntime);
96 }
97
98 if (fElements) {
99 delete fElements;
100 }
6f1e466d 101
fa6b9ac3 102 fElements = new AliTRDarrayI();
6f1e466d 103 fElements->Set(fNelems);
104
105}
106
107//_____________________________________________________________________________
e0d47c25 108void AliTRDdataArrayI::Copy(TObject &a) const
8230f242 109{
110 //
111 // Copy function
112 //
113
43da34c0 114 fElements->Copy(*((AliTRDdataArrayI &) a).fElements);
8230f242 115
43da34c0 116 ((AliTRDdataArrayI &) a).fThreshold = fThreshold;
8230f242 117
118 AliTRDdataArray::Copy(a);
119
120}
121
122//_____________________________________________________________________________
6f1e466d 123void AliTRDdataArrayI::Reset()
124{
125 //
126 // Reset the array (old content gets deleted)
127 //
128
a6dd11e9 129 if (fElements) {
130 delete fElements;
131 }
132
133
fa6b9ac3 134 fElements = new AliTRDarrayI();
6f1e466d 135 fElements->Set(0);
136
137 AliTRDdataArray::Reset();
138
139
140}
141
142//_____________________________________________________________________________
0a29d0f1 143Int_t AliTRDdataArrayI::GetSize() const
6f1e466d 144{
145 //
146 // Returns the size of the complete object
147 //
148
149 Int_t size = sizeof(this);
150
151 if (fIndex) size += sizeof(fIndex)
152 + fIndex->GetSize() * sizeof(Int_t);
153 if (fElements) size += sizeof(fElements)
154 + fElements->GetSize() * sizeof(Int_t);
155
156 return size;
157
158}
159
160//_____________________________________________________________________________
0a29d0f1 161Int_t AliTRDdataArrayI::GetDataSize() const
6f1e466d 162{
163 //
164 // Returns the size of only the data part
165 //
166
167 if (fElements == 0)
168 return 0;
169 else
170 return sizeof(fElements) + fElements->GetSize() * sizeof(Int_t);
171
172}
173
174//_____________________________________________________________________________
175Int_t AliTRDdataArrayI::GetOverThreshold(Int_t threshold)
176{
177 //
178 // Returns the number of entries over threshold
179 //
180
181 if ((fElements == 0) || (fElements->GetSize() <= 0))
182 return 0;
183
184 Int_t over = 0;
185
186 for (Bool_t cont = First(); cont == kTRUE; cont = Next()) {
855bfffd 187 if ((fCurrentIdx1 < 0) || (fCurrentIdx1 >= fNdim1)) continue;
188 if ((fCurrentIdx2 < 0) || (fCurrentIdx2 >= fNdim2)) continue;
6f1e466d 189 if (fElements->At(fCurrentIndex) > threshold) over++;
190 }
191
192 return over;
193
194}
195
196//_____________________________________________________________________________
793ff80c 197Int_t AliTRDdataArrayI::GetData(Int_t row, Int_t col, Int_t time) const
6f1e466d 198{
199 //
200 // Returns the data value at a given position of the array
201 //
202
203 if ((row >= 0) && (col >= 0) && (time >= 0)) {
204 Int_t idx1 = GetIdx1(row,col);
205 if ((idx1 >= 0) && (time < fNdim2)) {
206 if (fBufType == 0) return GetDataFast(idx1,time);
207 if (fBufType == 1) return GetData1(idx1,time);
208 }
209 else {
210 if (idx1 >= 0) {
2745a409 211 AliError(Form("time %d out of bounds (size: %d, this: 0x%08x)"
212 ,time,fNdim2,this));
6f1e466d 213 }
214 }
215 }
216
217 return -1;
218
219}
220
221//_____________________________________________________________________________
a2b90f83 222Int_t AliTRDdataArrayI::GetDataFast(Int_t idx1, Int_t idx2) const
223{
224 //
225 // Returns the data value at a given position of the array
226 // No boundary checking
227 //
228
229 return fElements->At(fIndex->At(idx2)+idx1);
230
231}
232
233//_____________________________________________________________________________
6f1e466d 234void AliTRDdataArrayI::Compress(Int_t bufferType, Int_t threshold)
235{
236 //
237 // Compresses the buffer
238 //
239
240 fThreshold = threshold;
241 Compress(bufferType);
242
243}
244
245//_____________________________________________________________________________
246void AliTRDdataArrayI::Compress(Int_t bufferType)
247{
248 //
249 // Compresses the buffer
250 //
251
252 if (fBufType < 0) {
2745a409 253 AliError("Buffer does not exist");
6f1e466d 254 return;
255 }
256 if (fBufType == bufferType) {
257 return;
258 }
259 if (fBufType > 0) {
260 Expand();
261 }
262 if (fBufType !=0) {
2745a409 263 AliError("Buffer does not exist");
6f1e466d 264 return;
265 }
266
267 // Compress a buffer of type 1
268 if (bufferType == 1) {
269 Compress1();
270 }
271
272}
273
274//_____________________________________________________________________________
275void AliTRDdataArrayI::Expand()
276{
277 //
278 // Expands the compressed buffer
279 //
280
281 if (fBufType < 0) {
2745a409 282 AliError("Buffer does not exist");
6f1e466d 283 return;
284 }
285 if (fBufType == 0) {
286 return;
287 }
288
289 // Expand a buffer of type 1
290 if (fBufType == 1) Expand1();
291
292 fBufType = 0;
293
294}
295
296//_____________________________________________________________________________
297Bool_t AliTRDdataArrayI::First()
298{
299 //
300 // Returns the position of the first valid data value
301 //
302
303 if (fBufType == 0) return First0();
304 if (fBufType == 1) return First1();
305 return kFALSE;
306
307}
308
309//_____________________________________________________________________________
310Bool_t AliTRDdataArrayI::Next()
311{
312 //
313 // Returns the position of the next valid data value
314 //
315
316 if (fBufType == 0) return Next0();
317 if (fBufType == 1) return Next1();
318 return kFALSE;
319
320}
321
322//_____________________________________________________________________________
323void AliTRDdataArrayI::Expand1()
324{
325 //
326 // Expands a buffer of type 1
327 //
328
329 Int_t i, k;
330
331 fNelems = fNdim1 * fNdim2;
332
333 Int_t *buf = new Int_t[fNelems];
259b9e4b 334 memset(buf,0,fNelems*sizeof(Int_t));
6f1e466d 335
336 fIndex->Set(fNdim2);
337
338 for (i = 0, k = 0; i < fNdim2; i++, k += fNdim1) (*fIndex)[i] = k;
339
340 Int_t idx1 = 0;
341 Int_t idx2 = 0;
8230f242 342 Int_t n = fElements->fN;
6f1e466d 343
8230f242 344 for (i = 0; i < n; i++){
6f1e466d 345
346 // Negative sign counts the unwritten values (under threshold)
347 if ((*fElements)[i] < 0) {
259b9e4b 348 idx1 -= (*fElements)[i];
6f1e466d 349 }
350 else {
259b9e4b 351 buf[(*fIndex)[idx2] + idx1] = (*fElements)[i];
6f1e466d 352 idx1++;
353 }
354 if (idx1 == fNdim1) {
355 idx1 = 0;
356 idx2++;
357 }
358 else {
359 if (idx1 > fNdim1){
360 Reset();
361 return;
362 }
363 }
364 }
365
366 fElements->Adopt(fNelems,buf);
367
368}
369
370//_____________________________________________________________________________
371void AliTRDdataArrayI::Compress1()
372{
373 //
374 // Compress a buffer of type 1
375 //
376
fa6b9ac3 377 AliTRDarrayI *buf = new AliTRDarrayI();
378 buf->Set(fNelems);
379 AliTRDarrayI *index = new AliTRDarrayI();
380 index->Set(fNdim2);
6f1e466d 381
382 Int_t icurrent = -1;
383 Int_t izero;
384 for (Int_t idx2 = 0; idx2 < fNdim2; idx2++){
385
386 // Set the idx2 pointer
fa6b9ac3 387 (*index)[idx2] = icurrent + 1;
6f1e466d 388
389 // Reset the zero counter
390 izero = 0;
391
392 for (Int_t idx1 = 0; idx1 < fNdim1; idx1++){
393 // If below threshold
394 if (GetDataFast(idx1,idx2) <= fThreshold) {
395 izero++;
396 }
397 else {
398 if (izero > 0) {
399 // If we have currently izero counts under threshold
400 icurrent++;
fa6b9ac3 401 if (icurrent >= buf->fN) buf->Expand(icurrent*2);
6f1e466d 402 // Store the number of entries below zero
fa6b9ac3 403 (*buf)[icurrent] = -izero;
6f1e466d 404 izero = 0;
405 }
406 icurrent++;
fa6b9ac3 407 if (icurrent >= buf->fN) buf->Expand(icurrent*2);
fa6b9ac3 408 (*buf)[icurrent] = GetDataFast(idx1,idx2);
6f1e466d 409 } // If signal larger than threshold
410 } // End of loop over idx1
411
412 if (izero > 0) {
413 icurrent++;
fa6b9ac3 414 if (icurrent >= buf->fN) buf->Expand(icurrent*2);
6f1e466d 415 // Store the number of entries below zero
fa6b9ac3 416 (*buf)[icurrent] = -izero;
6f1e466d 417 }
418
419 }
420
fa6b9ac3 421 buf->Expand(icurrent+1);
422 if (fElements) delete fElements;
423 fElements = buf;
6f1e466d 424 fNelems = fElements->fN;
425 fBufType = 1;
fa6b9ac3 426 if (fIndex) delete fIndex;
427 fIndex = index;
6f1e466d 428
429}
430
431//_____________________________________________________________________________
432void AliTRDdataArrayI::Expand2()
433{
434 //
435 // Expands a buffer of type 2
436 //
437
438 Int_t i, k;
259b9e4b 439
6f1e466d 440 Int_t *buf = new Int_t[fNelems];
259b9e4b 441 memset(buf,0,fNelems*sizeof(Int_t));
6f1e466d 442
443 fNelems = fNdim1 * fNdim2;
444 fIndex->Set(fNdim2);
445
446 for (i = 0, k = 0; i < fNdim2; i++, k += fNdim1) (*fIndex)[i] = k;
447
448 Int_t idx1 = 0;
449 Int_t idx2 = 0;
8230f242 450 Int_t n = fElements->fN;
451 for (i = 0; i < n; i++){
6f1e466d 452 // Negative sign counts the unwritten values (under threshold)
453 if ((*fElements)[i] < 0) {
454 idx1 -= fElements->At(i);
455 }
456 else {
457 buf[(*fIndex)[idx2]+idx1] = fElements->At(i);
458 idx1++;
459 }
460 if (idx1 == fNdim1) {
461 idx1 = 0;
462 idx2++;
463 }
464 else {
465 if (idx1 > fNdim1){
466 Reset();
467 return;
468 }
469 }
470 }
471
472 fElements->Adopt(fNelems,buf);
473
474}
475
476//_____________________________________________________________________________
477void AliTRDdataArrayI::Compress2()
478{
8230f242 479 //
480 // Compress a buffer of type 2 - not implemented!
481 //
6f1e466d 482
483}
484
485//_____________________________________________________________________________
486Bool_t AliTRDdataArrayI::First0()
487{
488 //
489 // Returns the first entry for a buffer of type 0
490 //
491
492 fCurrentIdx1 = -1;
493 fCurrentIdx2 = -1;
494 fCurrentIndex = -1;
495
496 Int_t i;
497 for (i = 0; ((i < fNelems) && (fElements->At(i) <= fThreshold)); i++)
498 if (i == fNelems) return kFALSE;
499
500 fCurrentIdx1 = i % fNdim1;
501 fCurrentIdx2 = i / fNdim1;
502 fCurrentIndex = i;
503 return kTRUE;
504
505}
506
507//_____________________________________________________________________________
793ff80c 508Bool_t AliTRDdataArrayI::Next0()
6f1e466d 509{
510 //
511 // Returns the next entry for a buffer of type 0
512 //
513
514 if (fCurrentIndex < 0) return kFALSE;
515
516 Int_t i;
517 for (i = fCurrentIndex + 1;
518 ((i < fNelems) && (fElements->At(i) <= fThreshold));
4f57cad7 519 i++) {}
6f1e466d 520 if (i >= fNelems) {
521 fCurrentIndex = -1;
522 return kFALSE;
523 }
524
525 fCurrentIdx1 = i % fNdim1;
526 fCurrentIdx2 = i / fNdim1;
527 fCurrentIndex = i;
528 return kTRUE;
529
530}
531
532//_____________________________________________________________________________
793ff80c 533Bool_t AliTRDdataArrayI::First1()
6f1e466d 534{
535 //
536 // Returns the first entry for a buffer of type 1
537 //
538
539 fCurrentIdx1 = -1;
540 fCurrentIdx2 = 0;
541 fCurrentIndex = -1;
542
543 Int_t i;
544 for (i = 0; i < fNelems; i++){
545 if (fElements->At(i) < 0) {
546 fCurrentIdx1 -= fElements->At(i);
547 }
548 else {
549 fCurrentIdx1++;
550 }
551 if (fCurrentIdx1 >= fNdim1) {
552 fCurrentIdx2++;
553 fCurrentIdx1 -= fNdim1;
554 }
555 if (fElements->At(i) > fThreshold) break;
556 }
557
558 fCurrentIndex = i;
559 if (fCurrentIndex >= 0) return kTRUE;
560 fCurrentIdx1 = -1;
561 fCurrentIdx2 = -1;
562 return kFALSE;
563
564}
565
566//_____________________________________________________________________________
793ff80c 567Bool_t AliTRDdataArrayI::Next1()
6f1e466d 568{
569 //
570 // Returns the next entry for a buffer of type 1
571 //
572
573 if (fCurrentIndex < 0) return kFALSE;
574
575 Int_t i;
576 for (i = fCurrentIndex + 1; i < fNelems; i++){
577 if (fElements->At(i) < 0) {
578 fCurrentIdx1 -= fElements->At(i);
579 }
580 else {
581 fCurrentIdx1++;
582 }
583 if (fCurrentIdx1 >= fNdim1) {
584 fCurrentIdx2++;
585 fCurrentIdx1 -= fNdim1;
586 }
587 if (fElements->At(i) > fThreshold) break;
588 }
589
590 fCurrentIndex = i;
591 if ((i >= 0) && (i < fNelems)) return kTRUE;
592 fCurrentIdx1 = -1;
593 fCurrentIdx2 = -1;
594 return kFALSE;
595
596}
597
598//_____________________________________________________________________________
793ff80c 599Int_t AliTRDdataArrayI::GetData1(Int_t idx1, Int_t idx2) const
6f1e466d 600{
601 //
602 // Returns the value at a given position of the array
603 //
604
605 Int_t i, n2;
606
607 if ((idx2 + 1) >= fNdim2) {
608 n2 = fNelems;
609 }
610 else {
611 n2 = fIndex->At(idx2 + 1);
612 }
613
614 // Current idx1
615 Int_t curidx1 = 0;
616
617 for (i = fIndex->At(idx2); ((i < n2) && (curidx1 < idx1)); i++){
618 if (fElements->At(i) < 0) {
619 curidx1 -= fElements->At(i);
620 }
621 else {
622 curidx1++;
623 }
624 }
625
626 if ((curidx1 == idx1) && (fElements->At(i) > 0)) {
627 return fElements->At(i);
628 }
629 else {
630 return 0;
631 }
632
633}
634
dd9a6ee3 635//_____________________________________________________________________________
dd9a6ee3 636void AliTRDdataArrayI::SetData(Int_t row, Int_t col, Int_t time, Int_t value)
637{
638 //
639 // Sets the data value at a given position of the array
640 // Includes boundary checking
641 //
642
643 if ((row >= 0) && (col >= 0) && (time >= 0)) {
644 Int_t idx1 = GetIdx1(row,col);
645 if ((idx1 >= 0) && (time < fNdim2)) {
646 SetDataFast(idx1,time,value);
647 }
648 else {
649 if (idx1 >= 0) {
2745a409 650 AliError(Form("time %d out of bounds (size: %d, this: 0x%08x)"
651 ,time,fNdim2,this));
dd9a6ee3 652 }
653 }
654 }
655
656}
657
658//_____________________________________________________________________________
a2b90f83 659void AliTRDdataArrayI::SetDataFast(Int_t idx1, Int_t idx2, Int_t value)
dd9a6ee3 660{
661 //
a2b90f83 662 // Sets the data value at a given position of the array
663 // No boundary checking
dd9a6ee3 664 //
665
a2b90f83 666 (*fElements)[fIndex->fArray[idx2]+idx1] = value;
dd9a6ee3 667
668}
669
670//_____________________________________________________________________________
671AliTRDdataArrayI &AliTRDdataArrayI::operator=(const AliTRDdataArrayI &a)
672{
673 //
674 // Assignment operator
675 //
676
677 if (this != &a) ((AliTRDdataArrayI &) a).Copy(*this);
678 return *this;
679
680}