[u/mrichter/AliRoot.git] / TRD / AliTRDarrayADC.cxx

/************************************************************************* 
* Copyright(c) 1998-2008, ALICE Experiment at CERN, All rights reserved. * 
*                                                                        * 
* Author: The ALICE Off-line Project.                                    * 
* Contributors are mentioned in the code where appropriate.              * 
*                                                                        * 
* Permission to use, copy, modify and distribute this software and its   * 
* documentation strictly for non-commercial purposes is hereby granted   * 
* without fee, provided that the above copyright notice appears in all   * 
* copies and that both the copyright notice and this permission notice   * 
* appear in the supporting documentation. The authors make no claims     * 
* about the suitability of this software for any purpose. It is          * 
* provided "as is" without express or implied warranty.                  *
**************************************************************************/

/* $Id: AliTRDarrayADC.cxx 25392 2008-04-23 19:40:29Z cblume $ */

////////////////////////////////////////////////////////
//                                                    //
// Container class for ADC values                     //
//                                                    //
// Author:                                            //
// Hermes Leon Vargas  (hleon@ikf.uni-frankfurt.de)   //
//                                                    // 
////////////////////////////////////////////////////////

#include "AliTRDarrayADC.h"
#include "Cal/AliTRDCalPadStatus.h"
#include "AliTRDfeeParam.h"
#include "AliTRDSignalIndex.h"
#include "AliLog.h"

ClassImp(AliTRDarrayADC)

Short_t *AliTRDarrayADC::fgLutPadNumbering = 0x0;

//____________________________________________________________________________________
AliTRDarrayADC::AliTRDarrayADC()
               :TObject()
               ,fNdet(0)
               ,fNrow(0)
               ,fNcol(0)
	       ,fNumberOfChannels(0)
               ,fNtime(0) 
               ,fNAdim(0)
               ,fADC(0)
{
  //
  // AliTRDarrayADC default constructor
  //

  CreateLut();

}

//____________________________________________________________________________________
AliTRDarrayADC::AliTRDarrayADC(Int_t nrow, Int_t ncol, Int_t ntime)
               :TObject()
	       ,fNdet(0)               
               ,fNrow(0)
               ,fNcol(0)
	       ,fNumberOfChannels(0)
               ,fNtime(0) 
               ,fNAdim(0)
               ,fADC(0)
{
  //
  // AliTRDarrayADC constructor
  //

  CreateLut();
  Allocate(nrow,ncol,ntime);

}

//____________________________________________________________________________________
AliTRDarrayADC::AliTRDarrayADC(const AliTRDarrayADC &b)
               :TObject()
	       ,fNdet(b.fNdet)
               ,fNrow(b.fNrow)
               ,fNcol(b.fNcol)
	       ,fNumberOfChannels(b.fNumberOfChannels)
               ,fNtime(b.fNtime) 
               ,fNAdim(b.fNAdim)
               ,fADC(0)	 
{
  //
  // AliTRDarrayADC copy constructor
  //

  fADC =  new Short_t[fNAdim];
  memcpy(fADC,b.fADC, fNAdim*sizeof(Short_t));  

}

//____________________________________________________________________________________
AliTRDarrayADC::~AliTRDarrayADC()
{
  //
  // AliTRDarrayADC destructor
  //

  if(fADC)
    {
      delete [] fADC;
      fADC=0;
    }

}

//____________________________________________________________________________________
AliTRDarrayADC &AliTRDarrayADC::operator=(const AliTRDarrayADC &b)
{
  //
  // Assignment operator
  //

  if(this==&b)
    {
      return *this;
    }
  if(fADC)
    {
      delete [] fADC;
    }
  fNdet=b.fNdet;
  fNrow=b.fNrow;
  fNcol=b.fNcol;
  fNumberOfChannels = b.fNumberOfChannels;
  fNtime=b.fNtime;
  fNAdim=b.fNAdim;
  fADC = new Short_t[fNAdim];
  memcpy(fADC,b.fADC, fNAdim*sizeof(Short_t));

  return *this;

}

//____________________________________________________________________________________
void AliTRDarrayADC::Allocate(Int_t nrow, Int_t ncol, Int_t ntime)
{
  //
  // Allocate memory for an AliTRDarrayADC array with dimensions
  // Row*NumberOfNecessaryMCMs*ADCchannelsInMCM*Time
  //
  
  fNrow=nrow;
  fNcol=ncol;
  fNtime=ntime;
  Int_t adcchannelspermcm = AliTRDfeeParam::GetNadcMcm(); 
  Int_t padspermcm = AliTRDfeeParam::GetNcolMcm(); 
  Int_t numberofmcms = fNcol/padspermcm; 
  fNumberOfChannels = numberofmcms*adcchannelspermcm; 
  fNAdim=nrow*fNumberOfChannels*ntime;

  if(fADC)
    {
      delete [] fADC;
    }
  
  fADC = new Short_t[fNAdim];
  memset(fADC,0,sizeof(Short_t)*fNAdim);

}

//____________________________________________________________________________________
Short_t AliTRDarrayADC::GetDataBits(Int_t row, Int_t col, Int_t time) const
{
  //
  // Get the ADC value for a given position: row, col, time
  // Taking bit masking into account
  //
  // Adapted from code of the class AliTRDdataArrayDigits 
  //

  Short_t tempval = GetData(row,col,time);
  // Be aware of manipulations introduced by pad masking in the RawReader
  // Only output the manipulated Value
  CLRBIT(tempval, 10);
  CLRBIT(tempval, 11);
  CLRBIT(tempval, 12);
  return tempval;

}

//____________________________________________________________________________________
UChar_t AliTRDarrayADC::GetPadStatus(Int_t row, Int_t col, Int_t time) const
{
  // 
  // Returns the pad status stored in the pad signal
  //
  // Output is a UChar_t value
  // Status Codes:
  //               Noisy Masking:           2
  //               Bridged Left Masking     8
  //               Bridged Right Masking    8
  //               Not Connected Masking Digits
  //
  // Adapted from code of the class AliTRDdataArrayDigits
  //

  UChar_t padstatus = 0;
  Short_t signal = GetData(row,col,time);
  if(signal > 0 && TESTBIT(signal, 10)){
    if(TESTBIT(signal, 11))
      if(TESTBIT(signal, 12))
	padstatus = AliTRDCalPadStatus::kPadBridgedRight;
      else
	padstatus = AliTRDCalPadStatus::kNotConnected;
    else
      if(TESTBIT(signal, 12))
	padstatus = AliTRDCalPadStatus::kPadBridgedLeft;
      else
	padstatus = AliTRDCalPadStatus::kMasked;
  }

  return padstatus;

}

//____________________________________________________________________________________
void AliTRDarrayADC::SetPadStatus(Int_t row, Int_t col, Int_t time, UChar_t status)
{
  //
  // Setting the pad status into the signal using the Bits 10 to 14 
  // (currently used: 10 to 12)
  //
  // Input codes (Unsigned char):
  //               Noisy Masking:           2
  //               Bridged Left Masking     8
  //               Bridged Right Masking    8
  //               Not Connected Masking    32
  //
  // Status codes: Any masking:             Bit 10(1)
  //               Noisy masking:           Bit 11(0), Bit 12(0)
  //               No Connection masking:   Bit 11(1), Bit 12(0)
  //               Bridged Left masking:    Bit 11(0), Bit 12(1)
  //               Bridged Right masking:   Bit 11(1), Bit 12(1)
  // 
  // Adapted from code of the class AliTRDdataArrayDigits
  //

  Short_t signal = GetData(row,col,time);

  // Only set the Pad Status if the signal is > 0
  if(signal > 0)
    {
      switch(status)
	{
	case AliTRDCalPadStatus::kMasked:
	  SETBIT(signal, 10);
	  CLRBIT(signal, 11);
	  CLRBIT(signal, 12);
	  break;
	case AliTRDCalPadStatus::kNotConnected:
	  SETBIT(signal, 10);
	  SETBIT(signal, 11);
	  CLRBIT(signal, 12);
	  break;
	case AliTRDCalPadStatus::kPadBridgedLeft:
	  SETBIT(signal, 10);
	  CLRBIT(signal, 11);
	  SETBIT(signal, 12);
	  break;
	case AliTRDCalPadStatus::kPadBridgedRight:
	  SETBIT(signal, 10);
	  SETBIT(signal, 11);
	  SETBIT(signal, 12);
          break;
	default:
	  CLRBIT(signal, 10);
	  CLRBIT(signal, 11);
	  CLRBIT(signal, 12);
	}
      SetData(row, col, time, signal);
    }

}

//____________________________________________________________________________________
Bool_t AliTRDarrayADC::IsPadCorrupted(Int_t row, Int_t col, Int_t time)
{
  // 
  // Checks if the pad has any masking as corrupted (Bit 10 in signal set)
  // 
  // Adapted from code of the class AliTRDdataArrayDigits
  //

  Short_t signal = GetData(row,col,time);
  return (signal > 0 && TESTBIT(signal, 10)) ? kTRUE : kFALSE;

}

//____________________________________________________________________________________
void AliTRDarrayADC::Compress()
{
  //
  // Compress the array
  //

  if(fNAdim!=fNrow*fNumberOfChannels*fNtime)
    {
      AliDebug(1,"The ADC array is already compressed");
      return;
    }

  Int_t counter=0;
  Int_t newDim=0;
  Int_t j;                  
  Int_t l;                  
  Int_t r=0;                
  Int_t s=0;                
  Int_t k=0;

  Int_t *longm = new Int_t[fNAdim];  
  Int_t *longz = new Int_t[fNAdim];

  if(longz && longm && fADC)
    {

      memset(longz,0,sizeof(Int_t)*fNAdim);
      memset(longm,0,sizeof(Int_t)*fNAdim);

      for(Int_t i=0;i<fNAdim; i++)
        {
          j=0;
          if(fADC[i]==-1)
	    {
	      for(k=i;k<fNAdim;k++)
	        {
	          if((fADC[k]==-1)&&(j<16000))   
		    {
		      j=j+1;
		      longm[r]=j;                
		    }
	          else
		    {
		      break;
		    }
	        }
	      r=r+1;            
	    }
          l=16001;
          if(fADC[i]==0)
	    {
	      for(k=i;k<fNAdim;k++)
	        {
	          if((fADC[k]==0)&&(l<32767))     
		    {                             
		      l=l+1;
		      longz[s]=l;                
		    }
	          else
		    {
		      break;
		    }
	        }
	      s=s+1;         
	    }
          if(fADC[i]>0)
	    {
	      i=i+1;
	    }
          i=i+j+(l-16001-1); 
        }

      //Calculate the size of the compressed array
      for(Int_t i=0; i<fNAdim;i++)
        {
          if(longm[i]!=0)   
	    {
	      counter=counter+longm[i]-1;
	    }
          if(longz[i]!=0)  
	    {
	      counter=counter+(longz[i]-16001)-1;
	    }
        }

      Int_t counterTwo=0;
      newDim = fNAdim-counter;   //Dimension of the compressed array
      Short_t* buffer = new Short_t[newDim];

      if(buffer)
        {

          //Fill the buffer of the compressed array
          Int_t g=0;
          Int_t h=0; 
          for(Int_t i=0; i<newDim; i++)
            {
              if(counterTwo<fNAdim)
	        {
	          if(fADC[counterTwo]>0)
	            {
	              buffer[i]=fADC[counterTwo];
	            }
	          if(fADC[counterTwo]==-1)
	            {
	              buffer[i]=-(longm[g]);
	              counterTwo=counterTwo+longm[g]-1;
	              g++;
	            }  
	          if(fADC[counterTwo]==0)
	            {
	              buffer[i]=-(longz[h]); 
	              counterTwo=counterTwo+(longz[h]-16001)-1;
	              h++;
	            }  
	          counterTwo++;
	        }
            }

          //Copy the buffer
          delete [] fADC;
          fADC=0;
          fADC = new Short_t[newDim];
          fNAdim = newDim;
          for(Int_t i=0; i<newDim; i++)
            {
              fADC[i] = buffer[i]; 
            }

          //Delete auxiliary arrays
          delete [] buffer;
          buffer=0;
        } 

    }

  if (longz)
    {
      delete [] longz;
      longz=0;
    }
  if (longm)
    {
      delete [] longm;
      longm=0;

    }

}

//____________________________________________________________________________________
void AliTRDarrayADC::Expand()
{
  //
  // Expand the array
  //

  if (fADC)
    {

      //Check if the array has not been already expanded
      Int_t verif=0;
      for(Int_t i=0; i<fNAdim; i++)
        {
          if(fADC[i]<-1)
 	    {
	      verif++;
	    }
        }
  
      if(verif==0)
        {
          AliDebug(1,"Nothing to expand");
          return;
        }

      Int_t dimexp=0;
      Int_t *longz = new Int_t[fNAdim];
      Int_t *longm = new Int_t[fNAdim];

      if (longz && longm)
	{

          //Initialize arrays
          memset(longz,0,sizeof(Int_t)*fNAdim);
          memset(longm,0,sizeof(Int_t)*fNAdim);
          Int_t r2=0; 
          Int_t r3=0; 
          for(Int_t i=0; i<fNAdim;i++)
            {
              if((fADC[i]<0)&&(fADC[i]>=-16000))      
	        {
	          longm[r2]=-fADC[i];
	          r2++;
	        }
              if(fADC[i]<-16000)  
	        {
	          longz[r3]=-fADC[i]-16001;  
	          r3++;
	        }
            }

          //Calculate the new dimensions of the array
          for(Int_t i=0; i<fNAdim;i++)
            {
              if(longm[i]!=0)       
	        {
	          dimexp=dimexp+longm[i]-1;
	        }
              if(longz[i]!=0)      
	        {
	          dimexp=dimexp+longz[i]-1;
	        }
            }
          dimexp=dimexp+fNAdim;   

          //Write in the buffer the new array
          Int_t contaexp =0;     
          Int_t h=0;
          Int_t l=0;  
          Short_t* bufferE = new Short_t[dimexp];
          if(bufferE)
	    {
              for(Int_t i=0; i<dimexp; i++)
                {
                  if(fADC[contaexp]>0)  
	            {
	              bufferE[i]=fADC[contaexp];
	            }
                  if((fADC[contaexp]<0)&&(fADC[contaexp]>=-16000))  
	            {
	              for(Int_t j=0; j<longm[h];j++)
	                {
	                  bufferE[i+j]=-1;
	                }
	              i=i+longm[h]-1;
	              h++;
	            }
                  if(fADC[contaexp]<-16000)  
	            {
	              for(Int_t j=0; j<longz[l];j++)
	                {
	                  bufferE[i+j]=0;  
	                }
	              i=i+longz[l]-1;
	              l++;
	            }
                  contaexp++;
                }
              //Copy the buffer
              delete [] fADC;
              fADC = new Short_t[dimexp];
              fNAdim = dimexp;
              for(Int_t i=0; i<dimexp; i++)
                {
                  fADC[i] = bufferE[i]; 
                }

              delete [] bufferE;

	    }

          //Delete auxiliary arrays
          delete [] longm;
          delete [] longz;

	}

    }

}
//____________________________________________________________________________________
void AliTRDarrayADC::DeleteNegatives()
{

  //
  //This method modifies the digits array, changing the negative values (-1)
  //Produced during digitization into zero.
  //

  for(Int_t a=0; a<fNAdim; a++)
    {
      if(fADC[a]==-1)
	{
	  fADC[a]=0;
	}
    }
}
//________________________________________________________________________________
void AliTRDarrayADC::Reset()
{
  //
  // Reset the array, the old contents are deleted
  // The array keeps the same dimensions as before
  //
 
  memset(fADC,0,sizeof(Short_t)*fNAdim);
}
//________________________________________________________________________________
void AliTRDarrayADC::ConditionalReset(AliTRDSignalIndex* idx)
{
  //
  // Reset the array, the old contents are deleted
  // The array keeps the same dimensions as before
  //
 
  if(idx->GetNoOfIndexes()>25)
    memset(fADC,0,sizeof(Short_t)*fNAdim);
  else
    {
      Int_t row, col;
      while(idx->NextRCIndex(row, col)){
	Int_t colnumb = fgLutPadNumbering[col];
	memset(&fADC[(row*fNumberOfChannels+colnumb)*fNtime],0,fNtime);
      }
    }

}

//________________________________________________________________________________
void AliTRDarrayADC::CreateLut()
{
  //
  // Initializes the Look Up Table to relate
  // pad numbering and mcm channel numbering
  //

  if(fgLutPadNumbering)  return;
  
   fgLutPadNumbering = new Short_t[AliTRDfeeParam::GetNcol()];
   memset(fgLutPadNumbering,0,sizeof(Short_t)*AliTRDfeeParam::GetNcol());

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