TRD/AliTRDdataArray.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 //  Base class of a general container for data of a TRD detector segment.    //
  21 //  Adapted from AliDigits (origin: M.Ivanov).                               //
  22 //                                                                           //
  23 ///////////////////////////////////////////////////////////////////////////////
  24
  25 #include <stdlib.h>
  26
  27 #include "TClass.h"
  28 #include "TError.h"
  29
  30 #include "AliLog.h"
  31
  32 #include "AliTRDsegmentID.h"
  33 #include "AliTRDarrayI.h"
  34 #include "AliTRDdataArray.h"
  35
  36 ClassImp(AliTRDdataArray)
  37
  38 //_____________________________________________________________________________
  39 AliTRDdataArray::AliTRDdataArray()
  40    :fNrow(0)
  41    ,fNcol(0)
  42    ,fNtime(0)
  43    ,fNdim1(-1)
  44    ,fNdim2(-1)
  45    ,fIndex(0)
  46    ,fBufType(-1)
  47    ,fNelems(-1)
  48    ,fCurrentIdx1(0)
  49    ,fCurrentIdx2(0)
  50    ,fCurrentIndex(0)
  51 {
  52   //
  53   // Default constructor
  54   //
  55
  56 }
  57
  58 //_____________________________________________________________________________
  59 AliTRDdataArray::AliTRDdataArray(Int_t nrow, Int_t ncol, Int_t ntime)
  60    :fNrow(0)
  61    ,fNcol(0)
  62    ,fNtime(0)
  63    ,fNdim1(-1)
  64    ,fNdim2(-1)
  65    ,fIndex(0)
  66    ,fBufType(-1)
  67    ,fNelems(-1)
  68    ,fCurrentIdx1(0)
  69    ,fCurrentIdx2(0)
  70    ,fCurrentIndex(0)
  71 {
  72   //
  73   // Creates a AliTRDdataArray with the dimensions <nrow>, <ncol>, and <ntime>.
  74   // The row- and column dimensions are compressible.
  75   //
  76
  77   Allocate(nrow,ncol,ntime);
  78
  79 }
  80
  81 //_____________________________________________________________________________
  82 AliTRDdataArray::AliTRDdataArray(const AliTRDdataArray &d)
  83    :AliTRDsegmentID(d)
  84    ,fNrow(d.fNrow)
  85    ,fNcol(d.fNcol)
  86    ,fNtime(d.fNtime)
  87    ,fNdim1(d.fNdim1)
  88    ,fNdim2(d.fNdim2)
  89    ,fIndex(d.fIndex)
  90    ,fBufType(d.fBufType)
  91    ,fNelems(d.fNelems)
  92    ,fCurrentIdx1(0)
  93    ,fCurrentIdx2(0)
  94    ,fCurrentIndex(0)
  95 {
  96   //
  97   // AliTRDdataArray copy constructor
  98   //
  99
 100 }
 101
 102 //_____________________________________________________________________________
 103 AliTRDdataArray::~AliTRDdataArray()
 104 {
 105   //
 106   // AliTRDdataArray destructor
 107   //
 108
 109   if (fIndex) {
 110     delete fIndex;
 111     fIndex = 0;
 112   }
 113
 114 }
 115
 116 //_____________________________________________________________________________
 117 AliTRDdataArray &AliTRDdataArray::operator=(const AliTRDdataArray &d)
 118 {
 119   //
 120   // Assignment operator
 121   //
 122
 123   if (this != &d) ((AliTRDdataArray &) d).Copy(*this);
 124   return *this;
 125
 126 }
 127
 128 //_____________________________________________________________________________
 129 void AliTRDdataArray::Copy(TObject &d) const
 130 {
 131   //
 132   // Copy function
 133   //
 134
 135   ((AliTRDdataArray &) d).fNrow         = fNrow;
 136   ((AliTRDdataArray &) d).fNcol         = fNcol;
 137   ((AliTRDdataArray &) d).fNtime        = fNtime;
 138
 139   ((AliTRDdataArray &) d).fNdim1        = fNdim1;
 140   ((AliTRDdataArray &) d).fNdim2        = fNdim2;
 141
 142   ((AliTRDdataArray &) d).fBufType      = fBufType;
 143   ((AliTRDdataArray &) d).fNelems       = fNelems;
 144
 145   ((AliTRDdataArray &) d).fCurrentIdx1  = 0;
 146   ((AliTRDdataArray &) d).fCurrentIdx2  = 0;
 147   ((AliTRDdataArray &) d).fCurrentIndex = 0;
 148
 149   fIndex->Copy(*((AliTRDdataArray &) d).fIndex);
 150
 151 }
 152
 153 //_____________________________________________________________________________
 154 void AliTRDdataArray::Allocate(Int_t nrow, Int_t ncol, Int_t ntime)
 155 {
 156   //
 157   // Allocates memory for a AliTRDdataArray with the dimensions
 158   // <nrow>, <ncol>, and <ntime>.
 159   // The row- and column dimensions are compressible.
 160   //
 161
 162   if (nrow  <= 0) {
 163     AliError("The number of rows has to be positive");
 164     exit(1);
 165   }
 166   if (ncol  <= 0) {
 167     AliError("The number of columns has to be positive");
 168     exit(1);
 169   }
 170   if (ntime <= 0) {
 171     AliError("The number of timebins has to be positive");
 172     exit(1);
 173   }
 174
 175   // The two-dimensional array row/column gets mapped into the first
 176   // dimension of the array. The second array dimension, which is not compressible,
 177   // corresponds to the time direction
 178   fNdim1  = nrow * ncol;
 179   fNdim2  = ntime;
 180   fNelems = fNdim1 * fNdim2;
 181
 182   fNrow   = nrow;
 183   fNcol   = ncol;
 184   fNtime  = ntime;
 185
 186   if (fIndex) delete fIndex;
 187   fIndex = new AliTRDarrayI();
 188   fIndex->Set(fNdim2);
 189   for (Int_t i = 0, k = 0; i < fNdim2; i++, k += fNdim1) {
 190     (*fIndex)[i] = k;
 191   }
 192
 193   fBufType = 0;
 194
 195 }
 196
 197 //_____________________________________________________________________________
 198 Bool_t AliTRDdataArray::CheckBounds(Int_t idx1, Int_t idx2)
 199 {
 200   //
 201   // Does the boundary checking
 202   //
 203
 204   if ((idx2 >= fNdim2) ||
 205       (idx2 <       0)) {
 206     return OutOfBoundsError(idx1,idx2);
 207   }
 208
 209   Int_t index = (*fIndex).At(idx2) + idx1;
 210   if ((index <       0) ||
 211       (index > fNelems)) {
 212     return OutOfBoundsError(idx1,idx2);
 213   }
 214
 215   return kTRUE;
 216
 217 }
 218
 219 //_____________________________________________________________________________
 220 Bool_t AliTRDdataArray::OutOfBoundsError(Int_t idx1, Int_t idx2)
 221 {
 222   //
 223   // Generate an out-of-bounds error. Always returns false.
 224   //
 225
 226   AliError(Form("idx1 %d  idx2 %d out of bounds (size: %d x %d, this: 0x%08x)"
 227                ,idx1,idx2,fNdim1,fNdim2,this));
 228
 229   return kFALSE;
 230
 231 }
 232
 233 //_____________________________________________________________________________
 234 void AliTRDdataArray::Reset()
 235 {
 236   //
 237   // Reset the array (old content gets deleted)
 238   //
 239
 240   if (fIndex) {
 241     delete fIndex;
 242   }
 243
 244   fIndex = new AliTRDarrayI();
 245   fIndex->Set(0);
 246
 247   fNdim1   = -1;
 248   fNdim2   = -1;
 249   fNelems  = -1;
 250
 251   fBufType = -1;
 252
 253   fNrow    =  0;
 254   fNcol    =  0;
 255   fNtime   =  0;
 256
 257 }
 258
 259 //_____________________________________________________________________________
 260 Int_t AliTRDdataArray::GetIdx1(Int_t row, Int_t col) const
 261 {
 262   //
 263   // Maps the two-dimensional row/column plane into an one-dimensional array.
 264   //
 265
 266   if (row >= fNrow) {
 267     AliError(Form("row %d out of bounds (size: %d, this: 0x%08x)",row,fNrow,this));
 268     return -1;
 269   }
 270
 271   if (col >= fNcol) {
 272     AliError(Form("col %d out of bounds (size: %d, this: 0x%08x)",col,fNcol,this));
 273     return -1;
 274   }
 275
 276   return row + col * fNrow;
 277
 278 }
 279
 280 //_____________________________________________________________________________
 281 Int_t AliTRDdataArray::GetIndex(Int_t row, Int_t col, Int_t time) const
 282 {
 283   //
 284   // Maps the row/column/time into one number
 285   //
 286
 287   if (time > fNtime) {
 288     AliError(Form("time %d out of bounds (size: %d, this: 0x%08x)",time,fNtime,this));
 289     return -1;
 290   }
 291
 292   return time * fNrow*fNcol + GetIdx1(row,col);
 293
 294 }
 295