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