TRD/AliTRDSignalIndex.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 /* $Id$ */
  17
  18 ///////////////////////////////////////////////////////////////////////////////
  19 //                                                                           //
  20 //  General container for data from TRD detector segments                    //
  21 //  Adapted from AliDigits, origin M.Ivanov                                  //
  22 //                                                                           //
  23 //  Author:                                                                  //
  24 //    Mateusz Ploskon (ploskon@ikf.uni-frankfurt.de)                         //
  25 //                                                                           //
  26 ///////////////////////////////////////////////////////////////////////////////
  27
  28 #include <algorithm>
  29 #include "TObject.h"
  30 #include "AliLog.h"
  31 #include "AliTRDSignalIndex.h"
  32
  33 ClassImp(AliTRDSignalIndex)
  34
  35 //_____________________________________________________________________________
  36 AliTRDSignalIndex::AliTRDSignalIndex()
  37   :TObject()
  38   ,fDet(-1)
  39   ,fLayer(-1)
  40   ,fStack(-1)
  41   ,fSM(-1)
  42   ,fBoolIndex(NULL)
  43   ,fSortedIndex(NULL)
  44   ,fMaxLimit(0)
  45   ,fPositionRC(0)
  46   ,fCountRC(1)
  47   ,fSortedWasInit(kFALSE)
  48   ,fCurrRow(0)
  49   ,fCurrCol(0)
  50   ,fCurrTbin(0)
  51   ,fNrows(0)
  52   ,fNcols(0)
  53   ,fNtbins(0)
  54 {
  55   //
  56   // Default contructor
  57   //
  58
  59   ResetCounters();
  60
  61 }
  62
  63 //_____________________________________________________________________________
  64 AliTRDSignalIndex::AliTRDSignalIndex(Int_t nrow, Int_t ncol,Int_t ntime)
  65   :TObject()
  66   ,fDet(-1)
  67   ,fLayer(-1)
  68   ,fStack(-1)
  69   ,fSM(-1)
  70   ,fBoolIndex(NULL)
  71   ,fSortedIndex(NULL)
  72   ,fMaxLimit(0)
  73   ,fPositionRC(0)
  74   ,fCountRC(1)
  75   ,fSortedWasInit(kFALSE)
  76   ,fCurrRow(0)
  77   ,fCurrCol(0)
  78   ,fCurrTbin(0)
  79   ,fNrows(0)
  80   ,fNcols(0)
  81   ,fNtbins(0)
  82 {
  83   //
  84   // Not the default contructor... hmmm...
  85   //
  86
  87   Allocate(nrow, ncol, ntime);
  88
  89 }
  90
  91 //_____________________________________________________________________________
  92 AliTRDSignalIndex::AliTRDSignalIndex(const AliTRDSignalIndex &a)
  93   :TObject(a)
  94   ,fDet(a.fDet)
  95   ,fLayer(a.fLayer)
  96   ,fStack(a.fStack)
  97   ,fSM(a.fSM)
  98   ,fBoolIndex(NULL)
  99   ,fSortedIndex(NULL)
 100   ,fMaxLimit(a.fMaxLimit)
 101   ,fPositionRC(a.fPositionRC)
 102   ,fCountRC(a.fCountRC)
 103   ,fSortedWasInit(a.fSortedWasInit)
 104   ,fCurrRow(a.fCurrRow)
 105   ,fCurrCol(a.fCurrCol)
 106   ,fCurrTbin(a.fCurrTbin)
 107   ,fNrows(a.fNrows)
 108   ,fNcols(a.fNcols)
 109   ,fNtbins(a.fNtbins)
 110 {
 111   //
 112   // Copy constructor
 113   //
 114
 115   fBoolIndex = new Bool_t[fMaxLimit];
 116   memcpy(fBoolIndex, a.fBoolIndex, fMaxLimit*sizeof(Bool_t));
 117
 118   fSortedIndex = new RowCol[fMaxLimit+1];
 119   memcpy(fSortedIndex, a.fSortedIndex, (fMaxLimit+1)*sizeof(RowCol));
 120 }
 121
 122 //_____________________________________________________________________________
 123 AliTRDSignalIndex::~AliTRDSignalIndex()
 124 {
 125   //
 126   // Destructor
 127   //
 128
 129   if (fBoolIndex) {
 130     delete [] fBoolIndex;
 131     fBoolIndex = NULL;
 132   }
 133
 134 if (fSortedIndex) {
 135     delete [] fSortedIndex;
 136     fSortedIndex = NULL;
 137   }
 138
 139 }
 140
 141 //_____________________________________________________________________________
 142 void AliTRDSignalIndex::Copy(TObject &a) const
 143 {
 144   //
 145   // Copy function
 146   //
 147
 148   ((AliTRDSignalIndex &)a).fDet           = fDet;
 149   ((AliTRDSignalIndex &)a).fLayer         = fLayer;
 150   ((AliTRDSignalIndex &)a).fStack         = fStack;
 151   ((AliTRDSignalIndex &)a).fSM            = fSM;
 152   ((AliTRDSignalIndex &)a).fMaxLimit      = fMaxLimit;
 153   ((AliTRDSignalIndex &)a).fPositionRC    = fPositionRC;
 154   ((AliTRDSignalIndex &)a).fCountRC       = fCountRC;
 155   ((AliTRDSignalIndex &)a).fSortedWasInit = fSortedWasInit;
 156   ((AliTRDSignalIndex &)a).fCurrRow       = fCurrRow;
 157   ((AliTRDSignalIndex &)a).fCurrCol       = fCurrCol;
 158   ((AliTRDSignalIndex &)a).fCurrTbin      = fCurrTbin;
 159   ((AliTRDSignalIndex &)a).fNrows         = fNrows;
 160   ((AliTRDSignalIndex &)a).fNcols         = fNcols;
 161   ((AliTRDSignalIndex &)a).fNtbins        = fNtbins;
 162
 163   if(((AliTRDSignalIndex &)a).fBoolIndex)
 164     {
 165       delete [] ((AliTRDSignalIndex &)a).fBoolIndex;
 166     }
 167   ((AliTRDSignalIndex &)a).fBoolIndex = new Bool_t[fMaxLimit];
 168   memcpy(((AliTRDSignalIndex &)a).fBoolIndex, fBoolIndex, fMaxLimit*sizeof(Bool_t));
 169
 170   if(((AliTRDSignalIndex &)a).fSortedIndex)
 171     {
 172       delete [] ((AliTRDSignalIndex &)a).fSortedIndex;
 173     }
 174   ((AliTRDSignalIndex &)a).fSortedIndex = new RowCol[fMaxLimit+1];
 175   memcpy(((AliTRDSignalIndex &)a).fSortedIndex, fSortedIndex, (fMaxLimit+1)*sizeof(RowCol));
 176
 177 }
 178
 179 //_____________________________________________________________________________
 180 AliTRDSignalIndex& AliTRDSignalIndex::operator = (const AliTRDSignalIndex& a)
 181 {
 182   //
 183   // Assignment operator
 184   //
 185
 186   if (this == &a) {
 187     return *this;
 188   }
 189
 190   fDet           = a.fDet;
 191   fLayer         = a.fLayer;
 192   fStack         = a.fStack;
 193   fSM            = a.fSM;
 194   fMaxLimit      = a.fMaxLimit;
 195   fPositionRC    = a.fPositionRC;
 196   fCountRC       = a.fCountRC;
 197   fSortedWasInit = a.fSortedWasInit;
 198   fCurrRow       = a.fCurrRow;
 199   fCurrCol       = a.fCurrCol;
 200   fCurrTbin      = a.fCurrTbin;
 201   fNrows         = a.fNrows;
 202   fNcols         = a.fNcols;
 203   fNtbins        = a.fNtbins;
 204
 205   if (fBoolIndex) {
 206     delete [] fBoolIndex;
 207   }
 208   fBoolIndex = new Bool_t[fMaxLimit];
 209   memcpy(fBoolIndex, fBoolIndex, fMaxLimit*sizeof(Bool_t));
 210
 211   if (fSortedIndex) {
 212     delete [] fSortedIndex;
 213   }
 214   fSortedIndex = new RowCol[fMaxLimit+1];
 215   memcpy(fSortedIndex, fSortedIndex, (fMaxLimit+1)*sizeof(RowCol));
 216
 217   ResetCounters();
 218
 219   return *this;
 220
 221 }
 222
 223 //_____________________________________________________________________________
 224 void AliTRDSignalIndex::Allocate(const Int_t nrow, const Int_t ncol, const Int_t ntime)
 225 {
 226   //
 227   // Create the arrays
 228   //
 229
 230   fNrows = nrow;
 231   fNcols = ncol;
 232   fNtbins = ntime;
 233
 234   fMaxLimit = nrow * ncol + 1;
 235
 236   if (fBoolIndex) {
 237     delete [] fBoolIndex;
 238     fBoolIndex = NULL;
 239   }
 240   if (fSortedIndex) {
 241     delete [] fSortedIndex;
 242     fSortedIndex = NULL;
 243   }
 244
 245   fBoolIndex = new Bool_t[fMaxLimit];
 246   fSortedIndex = new RowCol[fMaxLimit+1];
 247
 248   fCountRC = fMaxLimit+1;
 249
 250   ResetArrays();
 251   ResetCounters();
 252
 253   fCountRC = 1;
 254
 255 }
 256
 257 //_____________________________________________________________________________
 258 void AliTRDSignalIndex::ResetArrays()
 259 {
 260   if (!IsAllocated())
 261     return;
 262   memset(fBoolIndex,0x00,sizeof(Bool_t)*fMaxLimit);
 263   memset(fSortedIndex,0xFF,sizeof(RowCol)*fCountRC);
 264   fSortedWasInit = kFALSE;
 265 }
 266
 267 //_____________________________________________________________________________
 268 void AliTRDSignalIndex::Reset()
 269 {
 270   //
 271   // Reset the array but keep the size - realloc
 272   //
 273
 274   fDet   = -1;
 275   fLayer = -1;
 276   fStack = -1;
 277   fSM    = -1;
 278
 279   // All will be lost
 280   Allocate(fNrows, fNcols, fNtbins);
 281
 282 }
 283
 284 //_____________________________________________________________________________
 285 void AliTRDSignalIndex::ResetContent()
 286 {
 287   //
 288   // Reset the array but keep the size - no realloc
 289   //
 290
 291   fDet   = -1;
 292   fLayer = -1;
 293   fStack = -1;
 294   fSM    = -1;
 295
 296   ResetArrays();
 297   ResetCounters();
 298
 299   fCountRC = 1;
 300
 301 }
 302
 303 //_____________________________________________________________________________
 304 void AliTRDSignalIndex::ResetContentConditional(const Int_t nrow, const Int_t ncol, const Int_t ntime)
 305 {
 306   //
 307   // Reset the array but keep the size if no need to enlarge - no realloc
 308   //
 309
 310   fDet   = -1;
 311   fLayer = -1;
 312   fStack = -1;
 313   fSM    = -1;
 314
 315   if ((nrow  > fNrows) ||
 316       (ncol  > fNcols) ||
 317       (ntime > fNtbins)) {
 318     Allocate(nrow, ncol, ntime);
 319   }
 320   else {
 321     ResetArrays();
 322     ResetCounters();
 323     fCountRC = 1;
 324   }
 325
 326 }
 327
 328 //_____________________________________________________________________________
 329 void AliTRDSignalIndex::ClearAll()
 330 {
 331   //
 332   // Reset the values - clear all!
 333   //
 334
 335   fDet    = -1;
 336   fLayer  = -1;
 337   fStack  = -1;
 338   fSM     = -1;
 339
 340   fNrows  = -1;
 341   fNcols  = -1;
 342   fNtbins = -1;
 343
 344   if (fBoolIndex) {
 345     delete [] fBoolIndex;
 346     fBoolIndex = NULL;
 347   }
 348
 349   if (fSortedIndex) {
 350     delete [] fSortedIndex;
 351     fSortedIndex = NULL;
 352   }
 353
 354   ResetCounters();
 355
 356   fCountRC = 1;
 357   fSortedWasInit = kFALSE;
 358   fMaxLimit = 0;
 359
 360 }
 361
 362 //_____________________________________________________________________________
 363 Bool_t  AliTRDSignalIndex::CheckSorting(Int_t &row, Int_t &col)
 364 {
 365   //
 366   // Check whether array was read to end or it was not sorted until now
 367   //
 368
 369   if(fSortedWasInit || fCountRC==1)
 370     { //we already reached the end of the array
 371       ResetCounters();
 372       row = fCurrRow;
 373       col = fCurrCol;
 374       return kFALSE;
 375     }
 376   else
 377     { //we have not sorted the array up to now, let's do so
 378       InitSortedIndex();
 379       return NextRCIndex(row, col);
 380     }
 381 }
 382
 383 //_____________________________________________________________________________
 384 Bool_t AliTRDSignalIndex::NextRCTbinIndex(Int_t &row, Int_t &col, Int_t &tbin)
 385 {
 386   //
 387   // Returns the next tbin, or if there is no next time bin, it returns the
 388   // next used RC combination.
 389   //
 390
 391   if (NextTbinIndex(tbin)) {
 392     row = fCurrRow;
 393     col = fCurrCol;
 394     return kTRUE;
 395   }
 396   else {
 397     if (NextRCIndex(row, col)) {
 398       return NextRCTbinIndex(row, col, tbin);
 399     }
 400   }
 401
 402   return kFALSE;
 403
 404 }
 405
 406 //_____________________________________________________________________________
 407 Bool_t AliTRDSignalIndex::NextTbinIndex(Int_t &tbin)
 408 {
 409   //
 410   // Returns the next tbin of the current RC combination
 411   //
 412
 413   if(fCurrTbin<fNtbins)
 414     {
 415       tbin = fCurrTbin++;
 416       return kTRUE;
 417     }
 418
 419   return kFALSE;
 420
 421 }
 422
 423 //_____________________________________________________________________________
 424 void AliTRDSignalIndex::InitSortedIndex()
 425 {
 426   //
 427   // Creates the SortedIndex
 428   //
 429
 430   fSortedWasInit = kTRUE;
 431   std::sort((UShort_t*)fSortedIndex, ((UShort_t*)fSortedIndex) + fCountRC);
 432
 433 }
 434
 435 //_____________________________________________________________________________
 436 void AliTRDSignalIndex::ResetCounters()
 437 {
 438   //
 439   // Reset the counters/iterators
 440   //
 441
 442   fCurrRow    = -1;
 443   fCurrCol    = -1;
 444   fCurrTbin   = -1;
 445   fPositionRC =  0;
 446 }