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