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