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