[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"
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
  //

  Int_t counter=0;
  Int_t newDim=0;
  Int_t j;                  
  Int_t l;                  
  Int_t r=0;                
  Int_t s=0;                
  Int_t *longm;            
  longm = new Int_t[fNAdim];  
  Int_t *longz;            
  longz = new Int_t[fNAdim];
  Int_t k=0;
  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;
	}
    }
  newDim = fNAdim-counter;   //Dimension of the compressed array
  Short_t* buffer;
  buffer = new Short_t[newDim];
  Int_t counterTwo=0;

  //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
  if(fADC)
    {
      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
  if(buffer)
    {
      delete [] buffer;
      buffer=0;
    } 
  if(longz) 
    {
      delete [] longz;
      longz=0;
    }
  if(longm) 
    {
      delete [] longm;
      longm=0;
    }

}

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

  //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 *longz;
  longz = new Int_t[fNAdim];
  Int_t *longm;
  longm = new Int_t[fNAdim];
  Int_t dimexp=0;
  //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
  Short_t* bufferE;
  bufferE = new Short_t[dimexp];
  Int_t contaexp =0;     
  Int_t h=0;
  Int_t l=0;  
  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
  if(fADC)
    {
      delete [] fADC;
      fADC=0;
    }

  fADC = new Short_t[dimexp];
  fNAdim = dimexp;
  for(Int_t i=0; i<dimexp; i++)
    {
      fADC[i] = bufferE[i]; 
    }

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