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