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