TRD/AliTRDarraySignal.cxx

   1 /*************************************************************************
   2 * Copyright(c) 1998-2008, 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: AliTRDarraySignal.cxx 25392 2008-04-23 19:40:29Z cblume $ */
  17
  18 /////////////////////////////////////////////////////////
  19 //                                                     //
  20 // Container Class for Signals                         //
  21 //                                                     //
  22 // Author:                                             //
  23 //   Hermes Leon Vargas (hleon@ikf.uni-frankfurt.de)   //
  24 //                                                     //
  25 /////////////////////////////////////////////////////////
  26
  27 #include <TArray.h>
  28
  29 #include "AliTRDarraySignal.h"
  30 #include "AliTRDfeeParam.h"
  31
  32 ClassImp(AliTRDarraySignal)
  33
  34 Short_t *AliTRDarraySignal::fgLutPadNumbering = 0x0;
  35
  36 //_______________________________________________________________________
  37 AliTRDarraySignal::AliTRDarraySignal()
  38                   :TObject()
  39                   ,fNdet(0)
  40                   ,fNrow(0)
  41                   ,fNcol(0)
  42                   ,fNumberOfChannels(0)
  43                   ,fNtime(0)
  44                   ,fNdim(0)
  45                   ,fSignal(0)
  46 {
  47
  48   //
  49   // AliTRDarraySignal default constructor
  50   //
  51
  52   CreateLut();
  53
  54 }
  55
  56 //_______________________________________________________________________
  57 AliTRDarraySignal::AliTRDarraySignal(Int_t nrow, Int_t ncol,Int_t ntime)
  58                   :TObject()
  59                   ,fNdet(0)
  60                   ,fNrow(0)
  61                   ,fNcol(0)
  62                   ,fNumberOfChannels(0)
  63                   ,fNtime(0)
  64                   ,fNdim(0)
  65                   ,fSignal(0)
  66 {
  67   //
  68   // AliTRDarraySignal constructor
  69   //
  70
  71   CreateLut();
  72   Allocate(nrow,ncol,ntime);
  73
  74 }
  75
  76 //_______________________________________________________________________
  77 AliTRDarraySignal::AliTRDarraySignal(const AliTRDarraySignal &d)
  78                   :TObject()
  79                   ,fNdet(d.fNdet)
  80                   ,fNrow(d.fNrow)
  81                   ,fNcol(d.fNcol)
  82                   ,fNumberOfChannels(d.fNumberOfChannels)
  83                   ,fNtime(d.fNtime)
  84                   ,fNdim(d.fNdim)
  85                   ,fSignal(0)
  86 {
  87   //
  88   // AliTRDarraySignal copy constructor
  89   //
  90
  91   fSignal = new Float_t[fNdim];
  92   memcpy(fSignal, d.fSignal, fNdim*sizeof(Float_t));
  93
  94 }
  95
  96 //_______________________________________________________________________
  97 AliTRDarraySignal::~AliTRDarraySignal()
  98 {
  99   //
 100   // AliTRDarraySignal destructor
 101   //
 102
 103   if (fSignal)
 104     {
 105       delete [] fSignal;
 106       fSignal=0;
 107     }
 108
 109 }
 110
 111 //_______________________________________________________________________
 112 AliTRDarraySignal &AliTRDarraySignal::operator=(const AliTRDarraySignal &d)
 113 {
 114   //
 115   // Assignment operator
 116   //
 117
 118   if (this==&d)
 119     {
 120       return *this;
 121     }
 122
 123   if (fSignal)
 124     {
 125       delete [] fSignal;
 126     }
 127   fNdet=d.fNdet;
 128   fNrow=d.fNrow;
 129   fNcol=d.fNcol;
 130   fNumberOfChannels = d.fNumberOfChannels;
 131   fNtime=d.fNtime;
 132   fNdim=d.fNdim;
 133   fSignal = new Float_t[fNdim];
 134   memcpy(fSignal,d.fSignal, fNdim*sizeof(Float_t));
 135
 136   return *this;
 137
 138 }
 139
 140 //_______________________________________________________________________
 141 void AliTRDarraySignal::Allocate(Int_t nrow, Int_t ncol, Int_t ntime)
 142 {
 143   //
 144   // Allocates memory for an AliTRDarraySignal object with dimensions
 145   // Row*NumberOfNecessaryMCMs*ADCchannelsInMCM*Time
 146   // To be consistent with AliTRDarrayADC
 147   //
 148
 149   fNrow=nrow;
 150   fNcol=ncol;
 151   fNtime=ntime;
 152   Int_t adcchannelspermcm = AliTRDfeeParam::GetNadcMcm();
 153   Int_t padspermcm = AliTRDfeeParam::GetNcolMcm();
 154   Int_t numberofmcms = fNcol/padspermcm;
 155   fNumberOfChannels = numberofmcms*adcchannelspermcm;
 156   fNdim = nrow*fNumberOfChannels*ntime;
 157   if (fSignal)
 158     {
 159       delete [] fSignal;
 160     }
 161   fSignal = new Float_t[fNdim];
 162   memset(fSignal,0,sizeof(Float_t)*fNdim);
 163
 164 }
 165
 166 //_______________________________________________________________________
 167 Int_t AliTRDarraySignal::GetOverThreshold(Float_t threshold) const
 168 {
 169   //
 170   // Get the number of entries over the threshold
 171   //
 172
 173   Int_t counter=0;
 174   for(Int_t i=0; i<fNdim; i++)
 175     {
 176       if(fSignal[i]>threshold)
 177         {
 178           counter++;
 179         }
 180     }
 181   return counter;
 182
 183 }
 184
 185 //_______________________________________________________________________
 186 void AliTRDarraySignal::Compress(Float_t minval)
 187 {
 188   //
 189   // Compress the array, setting values equal or
 190   // below minval to zero (minval>=0)
 191   //
 192
 193   Int_t counter=0;
 194   Int_t newDim=0;
 195   Int_t j;
 196   Int_t r=0;
 197   Int_t *longArr;
 198   longArr = new Int_t[fNdim];
 199   Int_t k=0;
 200
 201   //Initialize the array
 202   memset(longArr,0,sizeof(Int_t)*fNdim);
 203
 204   for(Int_t i=0;i<fNdim; i++)
 205     {
 206       j=0;
 207       if(fSignal[i]<=minval)
 208         {
 209           for(k=i;k<fNdim;k++)
 210             {
 211               if(fSignal[k]<=minval)
 212                 {
 213                   j=j+1;
 214                   longArr[r]=j;
 215                 }
 216               else
 217                 {
 218                   break;
 219                 }
 220             }
 221           r=r+1;
 222         }
 223       i=i+j;
 224     }
 225
 226   //Calculate the size of the compressed array
 227   for(Int_t i=0; i<fNdim;i++)
 228     {
 229       if(longArr[i]!=0)
 230         {
 231           counter=counter+longArr[i]-1;
 232         }
 233     }
 234   newDim=fNdim-counter;   //New dimension
 235
 236   //Fill the buffer of the compressed array
 237   Float_t* buffer;
 238   buffer = new Float_t[newDim];
 239   Int_t counterTwo=0;
 240
 241   //Write the new array
 242   Int_t g=0;
 243   for(Int_t i=0; i<newDim; i++)
 244     {
 245       if(counterTwo<fNdim)
 246         {
 247           if(fSignal[counterTwo]>minval)
 248             {
 249               buffer[i]=fSignal[counterTwo];
 250             }
 251           if(fSignal[counterTwo]<=minval)
 252             {
 253               buffer[i]=-(longArr[g]);
 254               counterTwo=counterTwo+longArr[g]-1;
 255               g++;
 256             }
 257           counterTwo++;
 258         }
 259     }
 260
 261   //Copy the buffer
 262   if(fSignal)
 263     {
 264       delete [] fSignal;
 265       fSignal=0;
 266     }
 267   fSignal = new Float_t[newDim];
 268   fNdim = newDim;
 269   for(Int_t i=0; i<newDim; i++)
 270     {
 271       fSignal[i] = buffer[i];
 272     }
 273   if(buffer)
 274     {
 275       delete [] buffer;
 276       buffer=0;
 277     }
 278   if(longArr)
 279     {
 280       delete [] longArr;
 281       longArr=0;
 282     }
 283
 284 }
 285
 286 //_______________________________________________________________________
 287 void AliTRDarraySignal::Expand()
 288 {
 289   //
 290   // Expand the array
 291   //
 292
 293   //Check if the array has not been already expanded
 294   Int_t verif=0;
 295   for(Int_t i=0; i<fNdim; i++)
 296     {
 297       if(fSignal[i]<0)
 298         {
 299           verif++;
 300         }
 301     }
 302
 303   if(verif==0)
 304     {
 305       return;
 306     }
 307
 308   Int_t *longArr;
 309   longArr = new Int_t[fNdim];
 310   Int_t dimexp=0;
 311   memset(longArr,0,sizeof(Int_t)*fNdim);
 312
 313   Int_t r2=0;
 314   for(Int_t i=0; i<fNdim;i++)
 315     {
 316       if(fSignal[i]<0)
 317         {
 318           longArr[r2]=(Int_t)(-fSignal[i]);
 319           r2++;
 320         }
 321     }
 322
 323   //Calculate new dimensions
 324   for(Int_t i=0; i<fNdim;i++)
 325     {
 326       if(longArr[i]!=0)
 327         {
 328           dimexp=dimexp+longArr[i]-1;
 329         }
 330     }
 331   dimexp=dimexp+fNdim;   //Dimension of the expanded array
 332
 333   //Write in the buffer the new array
 334   Float_t* bufferE;
 335   bufferE = new Float_t[dimexp];
 336   Int_t contaexp =0;
 337   Int_t h=0;
 338   for(Int_t i=0; i<dimexp; i++)
 339     {
 340       if(fSignal[contaexp]>0)
 341         {
 342           bufferE[i]=fSignal[contaexp];
 343         }
 344       if(fSignal[contaexp]<0)
 345         {
 346           for(Int_t j=0; j<longArr[h];j++)
 347             {
 348               bufferE[i+j]=0;
 349             }
 350           i=i+longArr[h]-1;
 351           h++;
 352         }
 353       contaexp++;
 354     }
 355
 356   //Copy the buffer
 357   if(fSignal)
 358     {
 359       delete [] fSignal;
 360       fSignal=0;
 361     }
 362
 363   fSignal = new Float_t[dimexp];
 364   fNdim = dimexp;
 365   for(Int_t i=0; i<dimexp; i++)
 366     {
 367       fSignal[i] = bufferE[i];
 368     }
 369
 370   if(bufferE) delete [] bufferE;
 371   if(longArr) delete [] longArr;
 372
 373 }
 374 //________________________________________________________________________________
 375 void AliTRDarraySignal::Reset()
 376 {
 377   //
 378   // Reset the array, the old contents are deleted
 379   // The array keeps the same dimensions as before
 380   //
 381
 382   memset(fSignal,0,sizeof(Float_t)*fNdim);
 383
 384 }
 385 //________________________________________________________________________________
 386 Float_t AliTRDarraySignal::GetData(Int_t nrow, Int_t ncol, Int_t ntime) const
 387 {
 388   //
 389   // Get the data using the pad numbering.
 390   // To access data using the mcm scheme use instead
 391   // the method GetDataByAdcCol
 392   //
 393
 394   Int_t corrcolumn = fgLutPadNumbering[ncol];
 395
 396   return fSignal[(nrow*fNumberOfChannels+corrcolumn)*fNtime+ntime];
 397
 398 }
 399 //________________________________________________________________________________
 400 void AliTRDarraySignal::SetData(Int_t nrow, Int_t ncol, Int_t ntime, Float_t value)
 401 {
 402   //
 403   // Set the data using the pad numbering.
 404   // To write data using the mcm scheme use instead
 405   // the method SetDataByAdcCol
 406   //
 407
 408   Int_t colnumb = fgLutPadNumbering[ncol];
 409
 410   fSignal[(nrow*fNumberOfChannels+colnumb)*fNtime+ntime]=value;
 411
 412 }
 413
 414 //________________________________________________________________________________
 415 void AliTRDarraySignal::CreateLut()
 416 {
 417   //
 418   // Initializes the Look Up Table to relate
 419   // pad numbering and mcm channel numbering
 420   //
 421
 422   if(fgLutPadNumbering)  return;
 423
 424    fgLutPadNumbering = new Short_t[AliTRDfeeParam::GetNcol()];
 425    memset(fgLutPadNumbering,0,sizeof(Short_t)*AliTRDfeeParam::GetNcol());
 426
 427   for(Int_t mcm=0; mcm<8; mcm++)
 428     {
 429       Int_t lowerlimit=0+mcm*18;
 430       Int_t upperlimit=18+mcm*18;
 431       Int_t shiftposition = 1+3*mcm;
 432       for(Int_t index=lowerlimit;index<upperlimit;index++)
 433         {
 434           fgLutPadNumbering[index]=index+shiftposition;
 435         }
 436     }
 437 }