TRD/AliTRDarrayADC.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: AliTRDarrayADC.cxx 25392 2008-04-23 19:40:29Z cblume $ */
  17
  18 ////////////////////////////////////////////////////////
  19 //                                                    //
  20 // Container class for ADC values                     //
  21 //                                                    //
  22 // Author:                                            //
  23 // Hermes Leon Vargas  (hleon@ikf.uni-frankfurt.de)   //
  24 //                                                    //
  25 ////////////////////////////////////////////////////////
  26
  27 #include "AliTRDarrayADC.h"
  28 #include "Cal/AliTRDCalPadStatus.h"
  29 #include "AliTRDfeeParam.h"
  30 #include "AliTRDSignalIndex.h"
  31 #include "AliLog.h"
  32
  33 ClassImp(AliTRDarrayADC)
  34
  35 Short_t *AliTRDarrayADC::fgLutPadNumbering = 0x0;
  36
  37 //____________________________________________________________________________________
  38 AliTRDarrayADC::AliTRDarrayADC()
  39                :TObject()
  40                ,fNdet(0)
  41                ,fNrow(0)
  42                ,fNcol(0)
  43                ,fNumberOfChannels(0)
  44                ,fNtime(0)
  45                ,fNAdim(0)
  46                ,fADC(0)
  47 {
  48   //
  49   // AliTRDarrayADC default constructor
  50   //
  51
  52   CreateLut();
  53
  54 }
  55
  56 //____________________________________________________________________________________
  57 AliTRDarrayADC::AliTRDarrayADC(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                ,fNAdim(0)
  65                ,fADC(0)
  66 {
  67   //
  68   // AliTRDarrayADC constructor
  69   //
  70
  71   CreateLut();
  72   Allocate(nrow,ncol,ntime);
  73
  74 }
  75
  76 //____________________________________________________________________________________
  77 AliTRDarrayADC::AliTRDarrayADC(const AliTRDarrayADC &b)
  78                :TObject()
  79                ,fNdet(b.fNdet)
  80                ,fNrow(b.fNrow)
  81                ,fNcol(b.fNcol)
  82                ,fNumberOfChannels(b.fNumberOfChannels)
  83                ,fNtime(b.fNtime)
  84                ,fNAdim(b.fNAdim)
  85                ,fADC(0)
  86 {
  87   //
  88   // AliTRDarrayADC copy constructor
  89   //
  90
  91   fADC =  new Short_t[fNAdim];
  92   memcpy(fADC,b.fADC, fNAdim*sizeof(Short_t));
  93
  94 }
  95
  96 //____________________________________________________________________________________
  97 AliTRDarrayADC::~AliTRDarrayADC()
  98 {
  99   //
 100   // AliTRDarrayADC destructor
 101   //
 102
 103   delete [] fADC;
 104   fADC=0;
 105
 106 }
 107
 108 //____________________________________________________________________________________
 109 AliTRDarrayADC &AliTRDarrayADC::operator=(const AliTRDarrayADC &b)
 110 {
 111   //
 112   // Assignment operator
 113   //
 114
 115   if(this==&b)
 116     {
 117       return *this;
 118     }
 119   if(fADC)
 120     {
 121       delete [] fADC;
 122     }
 123   fNdet=b.fNdet;
 124   fNrow=b.fNrow;
 125   fNcol=b.fNcol;
 126   fNumberOfChannels = b.fNumberOfChannels;
 127   fNtime=b.fNtime;
 128   fNAdim=b.fNAdim;
 129   fADC = new Short_t[fNAdim];
 130   memcpy(fADC,b.fADC, fNAdim*sizeof(Short_t));
 131
 132   return *this;
 133
 134 }
 135
 136 //____________________________________________________________________________________
 137 void AliTRDarrayADC::Allocate(Int_t nrow, Int_t ncol, Int_t ntime)
 138 {
 139   //
 140   // Allocate memory for an AliTRDarrayADC array with dimensions
 141   // Row*NumberOfNecessaryMCMs*ADCchannelsInMCM*Time
 142   //
 143
 144   fNrow=nrow;
 145   fNcol=ncol;
 146   fNtime=ntime;
 147   Int_t adcchannelspermcm = AliTRDfeeParam::GetNadcMcm();
 148   Int_t padspermcm = AliTRDfeeParam::GetNcolMcm();
 149   Int_t numberofmcms = fNcol/padspermcm;
 150   fNumberOfChannels = numberofmcms*adcchannelspermcm;
 151   fNAdim=nrow*fNumberOfChannels*ntime;
 152
 153   if(fADC)
 154     {
 155       delete [] fADC;
 156     }
 157
 158   fADC = new Short_t[fNAdim];
 159   memset(fADC,0,sizeof(Short_t)*fNAdim);
 160
 161 }
 162
 163 //____________________________________________________________________________________
 164 Short_t AliTRDarrayADC::GetDataBits(Int_t row, Int_t col, Int_t time) const
 165 {
 166   //
 167   // Get the ADC value for a given position: row, col, time
 168   // Taking bit masking into account
 169   //
 170   // Adapted from code of the class AliTRDclusterizer
 171   //
 172
 173   Short_t tempval = GetData(row,col,time);
 174   // Be aware of manipulations introduced by pad masking in the RawReader
 175   // Only output the manipulated Value
 176   CLRBIT(tempval, 10);
 177   CLRBIT(tempval, 11);
 178   CLRBIT(tempval, 12);
 179   return tempval;
 180
 181 }
 182
 183 //____________________________________________________________________________________
 184 UChar_t AliTRDarrayADC::GetPadStatus(Int_t row, Int_t col, Int_t time) const
 185 {
 186   //
 187   // Returns the pad status stored in the pad signal
 188   //
 189   // Output is a UChar_t value
 190   // Status Codes:
 191   //               Noisy Masking:           2
 192   //               Bridged Left Masking     8
 193   //               Bridged Right Masking    8
 194   //               Not Connected Masking Digits
 195   //
 196   // Adapted from code of the class AliTRDclusterizer
 197   //
 198
 199   UChar_t padstatus = 0;
 200   Short_t signal = GetData(row,col,time);
 201   if(signal > 0 && TESTBIT(signal, 10)){
 202     if(TESTBIT(signal, 11))
 203       if(TESTBIT(signal, 12))
 204         padstatus = AliTRDCalPadStatus::kPadBridgedRight;
 205       else
 206         padstatus = AliTRDCalPadStatus::kNotConnected;
 207     else
 208       if(TESTBIT(signal, 12))
 209         padstatus = AliTRDCalPadStatus::kPadBridgedLeft;
 210       else
 211         padstatus = AliTRDCalPadStatus::kMasked;
 212   }
 213
 214   return padstatus;
 215
 216 }
 217
 218 //____________________________________________________________________________________
 219 void AliTRDarrayADC::SetPadStatus(Int_t row, Int_t col, Int_t time, UChar_t status)
 220 {
 221   //
 222   // Setting the pad status into the signal using the Bits 10 to 14
 223   // (currently used: 10 to 12)
 224   //
 225   // Input codes (Unsigned char):
 226   //               Noisy Masking:           2
 227   //               Bridged Left Masking     8
 228   //               Bridged Right Masking    8
 229   //               Not Connected Masking    32
 230   //
 231   // Status codes: Any masking:             Bit 10(1)
 232   //               Noisy masking:           Bit 11(0), Bit 12(0)
 233   //               No Connection masking:   Bit 11(1), Bit 12(0)
 234   //               Bridged Left masking:    Bit 11(0), Bit 12(1)
 235   //               Bridged Right masking:   Bit 11(1), Bit 12(1)
 236   //
 237   // Adapted from code of the class AliTRDclusterizer
 238   //
 239
 240   Short_t signal = GetData(row,col,time);
 241
 242   // Only set the Pad Status if the signal is > 0
 243   if(signal > 0)
 244     {
 245       switch(status)
 246         {
 247         case AliTRDCalPadStatus::kMasked:
 248           SETBIT(signal, 10);
 249           CLRBIT(signal, 11);
 250           CLRBIT(signal, 12);
 251           break;
 252         case AliTRDCalPadStatus::kNotConnected:
 253           SETBIT(signal, 10);
 254           SETBIT(signal, 11);
 255           CLRBIT(signal, 12);
 256           break;
 257         case AliTRDCalPadStatus::kPadBridgedLeft:
 258           SETBIT(signal, 10);
 259           CLRBIT(signal, 11);
 260           SETBIT(signal, 12);
 261           break;
 262         case AliTRDCalPadStatus::kPadBridgedRight:
 263           SETBIT(signal, 10);
 264           SETBIT(signal, 11);
 265           SETBIT(signal, 12);
 266           break;
 267         default:
 268           CLRBIT(signal, 10);
 269           CLRBIT(signal, 11);
 270           CLRBIT(signal, 12);
 271         }
 272       SetData(row, col, time, signal);
 273     }
 274
 275 }
 276
 277 //____________________________________________________________________________________
 278 Bool_t AliTRDarrayADC::IsPadCorrupted(Int_t row, Int_t col, Int_t time)
 279 {
 280   //
 281   // Checks if the pad has any masking as corrupted (Bit 10 in signal set)
 282   //
 283   // Adapted from code of the class AliTRDclusterizer
 284   //
 285
 286   Short_t signal = GetData(row,col,time);
 287   return (signal > 0 && TESTBIT(signal, 10)) ? kTRUE : kFALSE;
 288
 289 }
 290
 291 //____________________________________________________________________________________
 292 void AliTRDarrayADC::Compress()
 293 {
 294   //
 295   // Compress the array
 296   //
 297
 298   if(fNAdim!=fNrow*fNumberOfChannels*fNtime)
 299     {
 300       AliDebug(1,"The ADC array is already compressed");
 301       return;
 302     }
 303
 304   Int_t counter=0;
 305   Int_t newDim=0;
 306   Int_t j;
 307   Int_t l;
 308   Int_t r=0;
 309   Int_t s=0;
 310   Int_t k=0;
 311
 312   Int_t *longm = new Int_t[fNAdim];
 313   Int_t *longz = new Int_t[fNAdim];
 314
 315   if(longz && longm && fADC)
 316     {
 317
 318       memset(longz,0,sizeof(Int_t)*fNAdim);
 319       memset(longm,0,sizeof(Int_t)*fNAdim);
 320
 321       for(Int_t i=0;i<fNAdim; i++)
 322         {
 323           j=0;
 324           if(fADC[i]==-1)
 325             {
 326               for(k=i;k<fNAdim;k++)
 327                 {
 328                   if((fADC[k]==-1)&&(j<16000))
 329                     {
 330                       j=j+1;
 331                       longm[r]=j;
 332                     }
 333                   else
 334                     {
 335                       break;
 336                     }
 337                 }
 338               r=r+1;
 339             }
 340           l=16001;
 341           if(fADC[i]==0)
 342             {
 343               for(k=i;k<fNAdim;k++)
 344                 {
 345                   if((fADC[k]==0)&&(l<32767))
 346                     {
 347                       l=l+1;
 348                       longz[s]=l;
 349                     }
 350                   else
 351                     {
 352                       break;
 353                     }
 354                 }
 355               s=s+1;
 356             }
 357           if(fADC[i]>0)
 358             {
 359               i=i+1;
 360             }
 361           i=i+j+(l-16001-1);
 362         }
 363
 364       //Calculate the size of the compressed array
 365       for(Int_t i=0; i<fNAdim;i++)
 366         {
 367           if(longm[i]!=0)
 368             {
 369               counter=counter+longm[i]-1;
 370             }
 371           if(longz[i]!=0)
 372             {
 373               counter=counter+(longz[i]-16001)-1;
 374             }
 375         }
 376
 377       Int_t counterTwo=0;
 378       newDim = fNAdim-counter;   //Dimension of the compressed array
 379       Short_t* buffer = new Short_t[newDim];
 380
 381       if(buffer)
 382         {
 383
 384           //Fill the buffer of the compressed array
 385           Int_t g=0;
 386           Int_t h=0;
 387           for(Int_t i=0; i<newDim; i++)
 388             {
 389               if(counterTwo<fNAdim)
 390                 {
 391                   if(fADC[counterTwo]>0)
 392                     {
 393                       buffer[i]=fADC[counterTwo];
 394                     }
 395                   if(fADC[counterTwo]==-1)
 396                     {
 397                       buffer[i]=-(longm[g]);
 398                       counterTwo=counterTwo+longm[g]-1;
 399                       g++;
 400                     }
 401                   if(fADC[counterTwo]==0)
 402                     {
 403                       buffer[i]=-(longz[h]);
 404                       counterTwo=counterTwo+(longz[h]-16001)-1;
 405                       h++;
 406                     }
 407                   counterTwo++;
 408                 }
 409             }
 410
 411           //Copy the buffer
 412           delete [] fADC;
 413           fADC=0;
 414           fADC = new Short_t[newDim];
 415           fNAdim = newDim;
 416           for(Int_t i=0; i<newDim; i++)
 417             {
 418               fADC[i] = buffer[i];
 419             }
 420
 421           //Delete auxiliary arrays
 422           delete [] buffer;
 423           buffer=0;
 424         }
 425
 426     }
 427
 428   if (longz)
 429     {
 430       delete [] longz;
 431       longz=0;
 432     }
 433   if (longm)
 434     {
 435       delete [] longm;
 436       longm=0;
 437
 438     }
 439
 440 }
 441
 442 //____________________________________________________________________________________
 443 void AliTRDarrayADC::Expand()
 444 {
 445   //
 446   // Expand the array
 447   //
 448
 449   if (fADC)
 450     {
 451
 452       //Check if the array has not been already expanded
 453       Int_t verif=0;
 454       for(Int_t i=0; i<fNAdim; i++)
 455         {
 456           if(fADC[i]<-1)
 457             {
 458               verif++;
 459             }
 460         }
 461
 462       if(verif==0)
 463         {
 464           AliDebug(1,"Nothing to expand");
 465           return;
 466         }
 467
 468       Int_t dimexp=0;
 469       Int_t *longz = new Int_t[fNAdim];
 470       Int_t *longm = new Int_t[fNAdim];
 471
 472       if (longz && longm)
 473         {
 474
 475           //Initialize arrays
 476           memset(longz,0,sizeof(Int_t)*fNAdim);
 477           memset(longm,0,sizeof(Int_t)*fNAdim);
 478           Int_t r2=0;
 479           Int_t r3=0;
 480           for(Int_t i=0; i<fNAdim;i++)
 481             {
 482               if((fADC[i]<0)&&(fADC[i]>=-16000))
 483                 {
 484                   longm[r2]=-fADC[i];
 485                   r2++;
 486                 }
 487               if(fADC[i]<-16000)
 488                 {
 489                   longz[r3]=-fADC[i]-16001;
 490                   r3++;
 491                 }
 492             }
 493
 494           //Calculate the new dimensions of the array
 495           for(Int_t i=0; i<fNAdim;i++)
 496             {
 497               if(longm[i]!=0)
 498                 {
 499                   dimexp=dimexp+longm[i]-1;
 500                 }
 501               if(longz[i]!=0)
 502                 {
 503                   dimexp=dimexp+longz[i]-1;
 504                 }
 505             }
 506           dimexp=dimexp+fNAdim;
 507
 508           //Write in the buffer the new array
 509           Int_t contaexp =0;
 510           Int_t h=0;
 511           Int_t l=0;
 512           Short_t* bufferE = new Short_t[dimexp];
 513           if(bufferE)
 514             {
 515               for(Int_t i=0; i<dimexp; i++)
 516                 {
 517                   if(fADC[contaexp]>0)
 518                     {
 519                       bufferE[i]=fADC[contaexp];
 520                     }
 521                   if((fADC[contaexp]<0)&&(fADC[contaexp]>=-16000))
 522                     {
 523                       for(Int_t j=0; j<longm[h];j++)
 524                         {
 525                           bufferE[i+j]=-1;
 526                         }
 527                       i=i+longm[h]-1;
 528                       h++;
 529                     }
 530                   if(fADC[contaexp]<-16000)
 531                     {
 532                       for(Int_t j=0; j<longz[l];j++)
 533                         {
 534                           bufferE[i+j]=0;
 535                         }
 536                       i=i+longz[l]-1;
 537                       l++;
 538                     }
 539                   contaexp++;
 540                 }
 541               //Copy the buffer
 542               delete [] fADC;
 543               fADC = new Short_t[dimexp];
 544               fNAdim = dimexp;
 545               for(Int_t i=0; i<dimexp; i++)
 546                 {
 547                   fADC[i] = bufferE[i];
 548                 }
 549
 550               delete [] bufferE;
 551
 552             }
 553
 554           //Delete auxiliary arrays
 555           delete [] longm;
 556           delete [] longz;
 557
 558         }
 559
 560     }
 561
 562 }
 563 //____________________________________________________________________________________
 564 void AliTRDarrayADC::DeleteNegatives()
 565 {
 566
 567   //
 568   //This method modifies the digits array, changing the negative values (-1)
 569   //Produced during digitization into zero.
 570   //
 571
 572   for(Int_t a=0; a<fNAdim; a++)
 573     {
 574       if(fADC[a]==-1)
 575         {
 576           fADC[a]=0;
 577         }
 578     }
 579 }
 580 //________________________________________________________________________________
 581 void AliTRDarrayADC::Reset()
 582 {
 583   //
 584   // Reset the array, the old contents are deleted
 585   // The array keeps the same dimensions as before
 586   //
 587
 588   memset(fADC,0,sizeof(Short_t)*fNAdim);
 589 }
 590 //________________________________________________________________________________
 591 void AliTRDarrayADC::ConditionalReset(AliTRDSignalIndex* idx)
 592 {
 593   //
 594   // Reset the array, the old contents are deleted
 595   // The array keeps the same dimensions as before
 596   //
 597
 598   if(idx->GetNoOfIndexes()>25)
 599     memset(fADC,0,sizeof(Short_t)*fNAdim);
 600   else
 601     {
 602       Int_t row, col;
 603       while(idx->NextRCIndex(row, col)){
 604         Int_t colnumb = fgLutPadNumbering[col];
 605         memset(&fADC[(row*fNumberOfChannels+colnumb)*fNtime],0,fNtime);
 606       }
 607     }
 608
 609 }
 610
 611 //________________________________________________________________________________
 612 void AliTRDarrayADC::CreateLut()
 613 {
 614   //
 615   // Initializes the Look Up Table to relate
 616   // pad numbering and mcm channel numbering
 617   //
 618
 619   if(fgLutPadNumbering)  return;
 620
 621    fgLutPadNumbering = new Short_t[AliTRDfeeParam::GetNcol()];
 622    memset(fgLutPadNumbering,0,sizeof(Short_t)*AliTRDfeeParam::GetNcol());
 623
 624   for(Int_t mcm=0; mcm<8; mcm++)
 625     {
 626       Int_t lowerlimit=0+mcm*18;
 627       Int_t upperlimit=18+mcm*18;
 628       Int_t shiftposition = 1+3*mcm;
 629       for(Int_t index=lowerlimit;index<upperlimit;index++)
 630         {
 631           fgLutPadNumbering[index]=index+shiftposition;
 632         }
 633     }
 634 }