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

ClassImp(AliTRDarrayADC)

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

}

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

  Allocate(nrow,ncol,ntime);

}

//____________________________________________________________________________________
AliTRDarrayADC::AliTRDarrayADC(const AliTRDarrayADC &b)
               :TObject()
	       ,fNdet(b.fNdet)
               ,fNrow(b.fNrow)
               ,fNcol(b.fNcol)
               ,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;
  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*Col*Time
  //
  
  fNrow=nrow;
  fNcol=ncol;
  fNtime=ntime;
  fNAdim=nrow*ncol*ntime;  

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

}

//____________________________________________________________________________________
Short_t AliTRDarrayADC::GetDataB(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 = fADC[(row*fNcol+col)*fNtime+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);
	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);

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