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

/**************************************************************************
 * Copyright(c) 1998-1999, 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.                  *
 **************************************************************************/

/*
$Log$
Revision 1.4  2000/06/09 11:10:07  cblume
Compiler warnings and coding conventions, next round

Revision 1.3  2000/06/08 18:32:58  cblume
Make code compliant to coding conventions

Revision 1.2  2000/05/08 16:17:27  cblume
Merge TRD-develop

Revision 1.1.2.1  2000/05/08 15:14:34  cblume
Add new data array classes

*/

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  General container for integer data of a TRD detector segment.            //
//  Adapted from AliDigits (origin: M.Ivanov).                               //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include "AliTRDdataArrayF.h"

ClassImp(AliTRDdataArrayF)

//_____________________________________________________________________________
AliTRDdataArrayF::AliTRDdataArrayF():AliTRDdataArray()
{
  //
  // Default constructor
  //

  fElements = 0;

}

//_____________________________________________________________________________
AliTRDdataArrayF::AliTRDdataArrayF(Int_t nrow, Int_t ncol, Int_t ntime)
                 :AliTRDdataArray(nrow,ncol,ntime)
{
  //
  // Creates a AliTRDdataArrayF with the dimensions <nrow>, <ncol>, and <ntime>.
  // The row- and column dimensions are compressible.
  //

  Allocate(nrow,ncol,ntime);
  
}

//_____________________________________________________________________________
AliTRDdataArrayF::AliTRDdataArrayF(const AliTRDdataArrayF &a)
{
  //
  // AliTRDdataArrayF copy constructor
  //

  ((AliTRDdataArrayF &) a).Copy(*this);

}

//_____________________________________________________________________________
AliTRDdataArrayF::~AliTRDdataArrayF()
{
  //
  // Destructor
  //

  if (fElements) fElements->Delete();
  
}

//_____________________________________________________________________________
void AliTRDdataArrayF::Allocate(Int_t nrow, Int_t ncol, Int_t ntime)
{
  //
  // Allocates memory for a AliTRDdataArrayF with the dimensions 
  // <nrow>, <ncol>, and <ntime>.
  // The row- and column dimensions are compressible.
  //


  if (fNelems < 0) AliTRDdataArray::Allocate(nrow,ncol,ntime);

  if (fElements) delete fElements;
  fElements = new AliTRDarrayF;
  fElements->Set(fNelems);

}

//_____________________________________________________________________________
void AliTRDdataArrayF::Copy(TObject &a)
{
  //
  // Copy function
  //

  fElements->Copy(*((AliTRDdataArrayF &) a).fElements);

  ((AliTRDdataArrayF &) a).fThreshold = fThreshold;

  AliTRDdataArray::Copy(a);

}

//_____________________________________________________________________________
void AliTRDdataArrayF::Reset() 
{ 
  //
  // Reset the array (old content gets deleted)
  //
  
  if (fElements) delete fElements;
  fElements = new AliTRDarrayF;
  fElements->Set(0); 

  AliTRDdataArray::Reset();

}

//_____________________________________________________________________________
Int_t AliTRDdataArrayF::GetSize()
{
  //
  // Returns the size of the complete object
  //

  Int_t size = sizeof(this);

  if (fIndex)    size += sizeof(fIndex)    
                         + fIndex->GetSize()    * sizeof(Float_t);
  if (fElements) size += sizeof(fElements) 
                         + fElements->GetSize() * sizeof(Float_t);

  return size;

}

//_____________________________________________________________________________
Int_t AliTRDdataArrayF::GetDataSize()
{
  //
  // Returns the size of only the data part
  //

  if (fElements == 0) 
    return 0;
  else 
    return sizeof(fElements) + fElements->GetSize() * sizeof(Float_t);

}

//_____________________________________________________________________________
Int_t AliTRDdataArrayF::GetOverThreshold(Float_t threshold)
{
  //
  // Returns the number of entries over threshold
  //
 
  if ((fElements == 0) || (fElements->GetSize() <= 0))
    return 0;
 
  Int_t over = 0;

  for (Bool_t cont = First(); cont == kTRUE; cont = Next()) {
    if ((fCurrentIdx1 < 0) || (fCurrentIdx1 > fNdim1)) continue;
    if ((fCurrentIdx2 < 0) || (fCurrentIdx2 > fNdim2)) continue;
    if (fElements->At(fCurrentIndex) > threshold) over++;
  }

  return over;

}

//_____________________________________________________________________________
Float_t AliTRDdataArrayF::GetData(Int_t row, Int_t col, Int_t time)
{
  //
  // Returns the data value at a given position of the array
  // Includes boundary checking
  //

  if ((row >= 0) && (col >= 0) && (time >= 0)) {
    Int_t idx1 = GetIdx1(row,col);
    if ((idx1 >= 0) && (time < fNdim2)) {
      if (fBufType == 0) return GetDataFast(idx1,time);
      if (fBufType == 1) return GetData1(idx1,time);
    }
    else {
      if (idx1 >= 0) {
        TObject::Error("GetData"
                      ,"time %d out of bounds (size: %d, this: 0x%08x)"
                      ,time,fNdim2,this);
      }
    }
  }

  return -1;

}

//_____________________________________________________________________________
void AliTRDdataArrayF::Compress(Int_t bufferType, Float_t threshold)
{
  //
  // Compresses the buffer
  //

  fThreshold = threshold;
  Compress(bufferType);

}

//_____________________________________________________________________________
void AliTRDdataArrayF::Compress(Int_t bufferType)
{
  //
  // Compresses the buffer
  //

  if (fBufType  < 0) {
    Error("AliTRDdataArrayF::Compress","Buffer does not exist");
    return;
  }
  if (fBufType == bufferType) {
    return;
  }  
  if (fBufType > 0) {
    Expand();
  }
  if (fBufType !=0)  {
    Error("AliTRDdataArrayF::Compress","Buffer does not exist");
    return;
  }

  // Compress a buffer of type 1
  if (bufferType == 1) {
    Compress1();
  }

}

//_____________________________________________________________________________
void AliTRDdataArrayF::Expand()
{  
  //
  // Expands the compressed buffer
  //

  if (fBufType  < 0) {
    Error("AliTRDdataArrayF::Expand","Buffer does not exist");
    return;
  }
  if (fBufType == 0) {  
    return;
  } 
 
  // Expand a buffer of type 1
  if (fBufType == 1) Expand1();
  
  fBufType = 0;

}

//_____________________________________________________________________________
Bool_t AliTRDdataArrayF::First()
{
  //
  // Returns the position of the first valid data value
  //

  if (fBufType == 0) return First0();
  if (fBufType == 1) return First1();
  return kFALSE;

}

//_____________________________________________________________________________
Bool_t  AliTRDdataArrayF::Next()
{
  //
  // Returns the position of the next valid data value
  //

  if (fBufType == 0) return Next0();
  if (fBufType == 1) return Next1();
  return kFALSE;

}

//_____________________________________________________________________________
void AliTRDdataArrayF::Expand1()
{
  //
  // Expands a buffer of type 1
  //

  Int_t i, k;

  fNelems = fNdim1 * fNdim2;

  Float_t *buf = new Float_t[fNelems];

  fIndex->Set(fNdim2);

  for (i = 0, k = 0; i < fNdim2; i++, k += fNdim1) (*fIndex)[i] = k;

  Int_t idx1 = 0;
  Int_t idx2 = 0;
  Int_t n    = fElements->fN;

  for (i = 0; i < n; i++){

    // Negative sign counts the unwritten values (under threshold)
    if ((*fElements)[i] < 0) {
      idx1 -= (Int_t) fElements->At(i);
    } 
    else {
      buf[(*fIndex)[idx2] + idx1] = fElements->At(i);
      idx1++;
    }
    if (idx1 == fNdim1) {
      idx1 = 0;
      idx2++;
    }
    else { 
      if (idx1 > fNdim1){
	Reset();
	return;
      }      
    }
  }

  fElements->Adopt(fNelems,buf); 
   
}

//_____________________________________________________________________________
void AliTRDdataArrayF::Compress1()
{
  //
  // Compress a buffer of type 1
  //

  AliTRDarrayF buf;  
  buf.Set(fNelems);
  AliTRDarrayI index;
  index.Set(fNdim2);

  Int_t icurrent = -1;
  Int_t izero;
  for (Int_t idx2 = 0; idx2 < fNdim2; idx2++){      

    // Set the idx2 pointer
    index[idx2] = icurrent + 1;

    // Reset the zero counter 
    izero = 0;  

    for (Int_t idx1 = 0; idx1 < fNdim1; idx1++){
      // If below threshold
      if (GetDataFast(idx1,idx2) <= fThreshold) {
        izero++;
      }
      else {
	if (izero > 0) {
	  // If we have currently izero counts under threshold
	  icurrent++;	  
	  if (icurrent >= buf.fN) buf.Expand(icurrent*2);
          // Store the number of entries below zero
	  buf[icurrent] = -izero;  
	  izero = 0;
	} 
	icurrent++;
	if (icurrent >= buf.fN) buf.Expand(icurrent*2);
	buf[icurrent] = GetDataFast(idx1,idx2);	    
      } // If signal larger than threshold	  	
    } // End of loop over idx1

    if (izero > 0) {
      icurrent++;	  
      if (icurrent >= buf.fN) buf.Expand(icurrent*2);
      // Store the number of entries below zero
      buf[icurrent] = -izero; 
    }

  }

  buf.Expand(icurrent+1);
  (*fElements) = buf;
  fNelems   = fElements->fN;
  fBufType  = 1;
  (*fIndex) = index;

}

//_____________________________________________________________________________
void AliTRDdataArrayF::Expand2()
{
  //
  // Expands a buffer of type 2 
  //

  Int_t i, k;
  Float_t *buf = new Float_t[fNelems];

  fNelems = fNdim1 * fNdim2;
  fIndex->Set(fNdim2);

  for (i = 0, k = 0; i < fNdim2; i++, k += fNdim1) (*fIndex)[i] = k;

  Int_t idx1 = 0;
  Int_t idx2 = 0;
  Int_t n    = fElements->fN;
  for (i = 0; i < n; i++){
    // Negative sign counts the unwritten values (under threshold)
    if ((*fElements)[i] < 0) {
      idx1 -= (Int_t) fElements->At(i); 
    }
    else {
      buf[(*fIndex)[idx2]+idx1] = fElements->At(i);
      idx1++;
    }
    if (idx1 == fNdim1) {
      idx1 = 0;
      idx2++;
    }
    else { 
      if (idx1 > fNdim1){
	Reset();
	return;
      }      
    }
  }

  fElements->Adopt(fNelems,buf);    

}

//_____________________________________________________________________________
void AliTRDdataArrayF::Compress2()
{
  //
  // Compress a buffer of type 2 - not implemented!
  //

}

//_____________________________________________________________________________
Bool_t AliTRDdataArrayF::First0()
{
  //
  // Returns the first entry for a buffer of type 0
  //

  fCurrentIdx1  = -1;
  fCurrentIdx2  = -1;
  fCurrentIndex = -1;

  Int_t i;
  for (i = 0; ((i < fNelems) && (fElements->At(i) <= fThreshold)); i++)
  if (i == fNelems) return kFALSE;

  fCurrentIdx1  = i % fNdim1;
  fCurrentIdx2  = i / fNdim1;
  fCurrentIndex = i;
  return kTRUE;	

}

//_____________________________________________________________________________
Bool_t AliTRDdataArrayF::Next0()
{
  //
  // Returns the next entry for a buffer of type 0
  //

  if (fCurrentIndex < 0) return kFALSE; 

  Int_t i;
  for (i = fCurrentIndex + 1; 
       ((i < fNelems) && (fElements->At(i) <= fThreshold)); 
       i++);
  if (i >= fNelems)  {
    fCurrentIndex = -1;
    return kFALSE;
  }

  fCurrentIdx1  = i % fNdim1;
  fCurrentIdx2  = i / fNdim1;
  fCurrentIndex = i;
  return kTRUE;	

}

//_____________________________________________________________________________
Bool_t AliTRDdataArrayF::First1()
{
  //
  // Returns the first entry for a buffer of type 1
  //

  fCurrentIdx1  = -1;
  fCurrentIdx2  =  0;
  fCurrentIndex = -1;

  Int_t i;
  for (i = 0; i < fNelems; i++){
    if (fElements->At(i) < 0) {
      fCurrentIdx1 -= (Int_t) fElements->At(i);
    }
    else {     
      fCurrentIdx1++;
    }
    if (fCurrentIdx1 >= fNdim1) {
      fCurrentIdx2++;
      fCurrentIdx1 -= fNdim1;
    }
    if (fElements->At(i) > fThreshold) break;
  }

  fCurrentIndex = i;
  if (fCurrentIndex >= 0) return kTRUE;
  fCurrentIdx1  = -1;
  fCurrentIdx2  = -1;
  return kFALSE;	

}

//_____________________________________________________________________________
Bool_t AliTRDdataArrayF::Next1()
{
  //
  // Returns the next entry for a buffer of type 1
  //

  if (fCurrentIndex < 0) return kFALSE;

  Int_t i;
  for (i = fCurrentIndex + 1; i < fNelems; i++){
    if (fElements->At(i) < 0) {
      fCurrentIdx1 -= (Int_t) fElements->At(i);
    }
    else {      
      fCurrentIdx1++;
    }
    if (fCurrentIdx1 >= fNdim1) {
      fCurrentIdx2++;
      fCurrentIdx1 -= fNdim1;
    }
    if (fElements->At(i) > fThreshold) break;
  }

  fCurrentIndex =  i;
  if ((i >= 0) && (i < fNelems)) return kTRUE;
  fCurrentIdx1  = -1;
  fCurrentIdx2  = -1;
  return kFALSE;

}

//_____________________________________________________________________________
Float_t AliTRDdataArrayF::GetData1(Int_t idx1, Int_t idx2)
{
  //
  // Returns the value at a given position of the array
  //
  
  Int_t i, n2;

  if ((idx2 + 1) >= fNdim2) {
    n2 = fNelems;
  }
  else {
    n2 = fIndex->At(idx2 + 1);
  }

  // Current idx1    
  Int_t curidx1 = 0; 
 
  for (i = fIndex->At(idx2); ((i < n2) && (curidx1 < idx1)); i++){
    if (fElements->At(i) < 0) {
      curidx1 -= (Int_t) fElements->At(i);
    }
    else {      
      curidx1++;
    }
  }

  if ((curidx1 == idx1) && (fElements->At(i) > 0)) {
    return fElements->At(i);
  }
  else {
    return 0;
  }

}

//____________________________________________________________________________
Float_t AliTRDdataArrayF::GetDataFast(Int_t idx1, Int_t idx2)
{
  //
  // Returns the value at a given position in the array
  //

  return fElements->At(fIndex->At(idx2) + idx1); 

}

//_____________________________________________________________________________
void AliTRDdataArrayF::SetData(Int_t row, Int_t col, Int_t time, Float_t value)
{
  //
  // Sets the data value at a given position of the array
  // Includes boundary checking
  //

  if ((row >= 0) && (col >= 0) && (time >= 0)) {
    Int_t idx1 = GetIdx1(row,col);
    if ((idx1 >= 0) && (time < fNdim2)) {
      SetDataFast(idx1,time,value);
    }
    else {
      if (idx1 >= 0) {
        TObject::Error("SetData"
                      ,"time %d out of bounds (size: %d, this: 0x%08x)"
                      ,time,fNdim2,this);
      }
    }
  }

}

//_____________________________________________________________________________
void  AliTRDdataArrayF::SetDataFast(Int_t idx1, Int_t idx2, Float_t value)
{
  //
  // Set the value at a given position in the array
  //

  if ((idx1 < 0) || (idx1 >= fNdim1) || 
      (idx2 < 0) || (idx2 >= fNdim2)) { 
    TObject::Error("SetDataFast"
                  ,"idx1 %d  idx2 %d out of bounds (size: %d x %d, this: 0x%08x)"
                  ,idx1,idx2,fNdim1,fNdim2,this);
  }

  (*fElements)[fIndex->fArray[idx2] + idx1] = value; 

}

//_____________________________________________________________________________
AliTRDdataArrayF &AliTRDdataArrayF::operator=(const AliTRDdataArrayF &a)
{
  //
  // Assignment operator
  //

  if (this != &a) ((AliTRDdataArrayF &) a).Copy(*this);
  return *this;

}
Commit	Line	Data
6f1e466d	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, 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	/*
	17	$Log$
43da34c0	18	Revision 1.4 2000/06/09 11:10:07 cblume
	19	Compiler warnings and coding conventions, next round
	20
dd9a6ee3	21	Revision 1.3 2000/06/08 18:32:58 cblume
	22	Make code compliant to coding conventions
	23
8230f242	24	Revision 1.2 2000/05/08 16:17:27 cblume
	25	Merge TRD-develop
	26
6f1e466d	27	Revision 1.1.2.1 2000/05/08 15:14:34 cblume
	28	Add new data array classes
	29
	30	*/
	31
	32	///////////////////////////////////////////////////////////////////////////////
	33	// //
	34	// General container for integer data of a TRD detector segment. //
	35	// Adapted from AliDigits (origin: M.Ivanov). //
	36	// //
	37	///////////////////////////////////////////////////////////////////////////////
	38
	39	#include "AliTRDdataArrayF.h"
	40
	41	ClassImp(AliTRDdataArrayF)
	42
	43	//_____________________________________________________________________________
	44	AliTRDdataArrayF::AliTRDdataArrayF():AliTRDdataArray()
	45	{
	46	//
	47	// Default constructor
	48	//
	49
	50	fElements = 0;
	51
	52	}
	53
	54	//_____________________________________________________________________________
	55	AliTRDdataArrayF::AliTRDdataArrayF(Int_t nrow, Int_t ncol, Int_t ntime)
	56	:AliTRDdataArray(nrow,ncol,ntime)
	57	{
	58	//
	59	// Creates a AliTRDdataArrayF with the dimensions <nrow>, <ncol>, and <ntime>.
	60	// The row- and column dimensions are compressible.
	61	//
	62
	63	Allocate(nrow,ncol,ntime);
	64
	65	}
	66
8230f242	67	//_____________________________________________________________________________
dd9a6ee3	68	AliTRDdataArrayF::AliTRDdataArrayF(const AliTRDdataArrayF &a)
8230f242	69	{
	70	//
	71	// AliTRDdataArrayF copy constructor
	72	//
	73
dd9a6ee3	74	((AliTRDdataArrayF &) a).Copy(*this);
8230f242	75
	76	}
	77
6f1e466d	78	//_____________________________________________________________________________
	79	AliTRDdataArrayF::~AliTRDdataArrayF()
	80	{
	81	//
	82	// Destructor
	83	//
	84
	85	if (fElements) fElements->Delete();
	86
	87	}
	88
	89	//_____________________________________________________________________________
	90	void AliTRDdataArrayF::Allocate(Int_t nrow, Int_t ncol, Int_t ntime)
	91	{
	92	//
	93	// Allocates memory for a AliTRDdataArrayF with the dimensions
	94	// <nrow>, <ncol>, and <ntime>.
	95	// The row- and column dimensions are compressible.
	96	//
	97
	98
	99	if (fNelems < 0) AliTRDdataArray::Allocate(nrow,ncol,ntime);
	100
	101	if (fElements) delete fElements;
	102	fElements = new AliTRDarrayF;
	103	fElements->Set(fNelems);
	104
	105	}
	106
8230f242	107	//_____________________________________________________________________________
43da34c0	108	void AliTRDdataArrayF::Copy(TObject &a)
8230f242	109	{
	110	//
	111	// Copy function
	112	//
	113
43da34c0	114	fElements->Copy(*((AliTRDdataArrayF &) a).fElements);
8230f242	115
43da34c0	116	((AliTRDdataArrayF &) a).fThreshold = fThreshold;
8230f242	117
	118	AliTRDdataArray::Copy(a);
	119
	120	}
	121
6f1e466d	122	//_____________________________________________________________________________
	123	void AliTRDdataArrayF::Reset()
	124	{
	125	//
	126	// Reset the array (old content gets deleted)
	127	//
	128
	129	if (fElements) delete fElements;
	130	fElements = new AliTRDarrayF;
	131	fElements->Set(0);
	132
	133	AliTRDdataArray::Reset();
	134
	135	}
	136
	137	//_____________________________________________________________________________
	138	Int_t AliTRDdataArrayF::GetSize()
	139	{
	140	//
	141	// Returns the size of the complete object
	142	//
	143
	144	Int_t size = sizeof(this);
	145
	146	if (fIndex) size += sizeof(fIndex)
	147	+ fIndex->GetSize() * sizeof(Float_t);
	148	if (fElements) size += sizeof(fElements)
	149	+ fElements->GetSize() * sizeof(Float_t);
	150
	151	return size;
	152
	153	}
	154
	155	//_____________________________________________________________________________
	156	Int_t AliTRDdataArrayF::GetDataSize()
	157	{
	158	//
	159	// Returns the size of only the data part
	160	//
	161
	162	if (fElements == 0)
	163	return 0;
	164	else
	165	return sizeof(fElements) + fElements->GetSize() * sizeof(Float_t);
	166
	167	}
	168
	169	//_____________________________________________________________________________
	170	Int_t AliTRDdataArrayF::GetOverThreshold(Float_t threshold)
	171	{
	172	//
	173	// Returns the number of entries over threshold
	174	//
	175
	176	if ((fElements == 0) \|\| (fElements->GetSize() <= 0))
	177	return 0;
	178
	179	Int_t over = 0;
	180
	181	for (Bool_t cont = First(); cont == kTRUE; cont = Next()) {
	182	if ((fCurrentIdx1 < 0) \|\| (fCurrentIdx1 > fNdim1)) continue;
	183	if ((fCurrentIdx2 < 0) \|\| (fCurrentIdx2 > fNdim2)) continue;
	184	if (fElements->At(fCurrentIndex) > threshold) over++;
	185	}
186
187	return over;
188
189	}
190
191	//_____________________________________________________________________________
192	Float_t AliTRDdataArrayF::GetData(Int_t row, Int_t col, Int_t time)
193	{
194	//
195	// Returns the data value at a given position of the array
196	// Includes boundary checking
197	//
198
199	if ((row >= 0) && (col >= 0) && (time >= 0)) {
200	Int_t idx1 = GetIdx1(row,col);
201	if ((idx1 >= 0) && (time < fNdim2)) {
202	if (fBufType == 0) return GetDataFast(idx1,time);
203	if (fBufType == 1) return GetData1(idx1,time);
204	}
205	else {
206	if (idx1 >= 0) {
207	TObject::Error("GetData"
208	,"time %d out of bounds (size: %d, this: 0x%08x)"
209	,time,fNdim2,this);
210	}
211	}
212	}
213
214	return -1;
215
216	}
217
218	//_____________________________________________________________________________
219	void AliTRDdataArrayF::Compress(Int_t bufferType, Float_t threshold)
220	{
221	//
222	// Compresses the buffer
223	//
224
225	fThreshold = threshold;
226	Compress(bufferType);
227
228	}
229
230	//_____________________________________________________________________________
231	void AliTRDdataArrayF::Compress(Int_t bufferType)
232	{
233	//
234	// Compresses the buffer
235	//
236
237	if (fBufType < 0) {
238	Error("AliTRDdataArrayF::Compress","Buffer does not exist");
239	return;
240	}
241	if (fBufType == bufferType) {
242	return;
243	}
244	if (fBufType > 0) {
245	Expand();
246	}
247	if (fBufType !=0) {
248	Error("AliTRDdataArrayF::Compress","Buffer does not exist");
249	return;
250	}
251
252	// Compress a buffer of type 1
253	if (bufferType == 1) {
254	Compress1();
255	}
256
257	}
258
259	//_____________________________________________________________________________
260	void AliTRDdataArrayF::Expand()
261	{
262	//
263	// Expands the compressed buffer
264	//
265
266	if (fBufType < 0) {
267	Error("AliTRDdataArrayF::Expand","Buffer does not exist");
268	return;
269	}
270	if (fBufType == 0) {
271	return;
272	}
273
274	// Expand a buffer of type 1
275	if (fBufType == 1) Expand1();
276
277	fBufType = 0;
278
279	}
280
281	//_____________________________________________________________________________
282	Bool_t AliTRDdataArrayF::First()
283	{
284	//
285	// Returns the position of the first valid data value
286	//
287
288	if (fBufType == 0) return First0();
289	if (fBufType == 1) return First1();
290	return kFALSE;
291
292	}
293
294	//_____________________________________________________________________________
295	Bool_t AliTRDdataArrayF::Next()
296	{
297	//
298	// Returns the position of the next valid data value
299	//
300
301	if (fBufType == 0) return Next0();
302	if (fBufType == 1) return Next1();
303	return kFALSE;
304
305	}
306
307	//_____________________________________________________________________________
308	void AliTRDdataArrayF::Expand1()
309	{
310	//
311	// Expands a buffer of type 1
312	//
313
314	Int_t i, k;
315
316	fNelems = fNdim1 * fNdim2;
317
318	Float_t *buf = new Float_t[fNelems];
319
320	fIndex->Set(fNdim2);
321
322	for (i = 0, k = 0; i < fNdim2; i++, k += fNdim1) (*fIndex)[i] = k;
323
324	Int_t idx1 = 0;
325	Int_t idx2 = 0;
8230f242	326	Int_t n = fElements->fN;
6f1e466d	327
8230f242	328	for (i = 0; i < n; i++){
6f1e466d	329
	330	// Negative sign counts the unwritten values (under threshold)
	331	if ((*fElements)[i] < 0) {
	332	idx1 -= (Int_t) fElements->At(i);
	333	}
	334	else {
	335	buf[(*fIndex)[idx2] + idx1] = fElements->At(i);
	336	idx1++;
	337	}
	338	if (idx1 == fNdim1) {
	339	idx1 = 0;
	340	idx2++;
	341	}
	342	else {
	343	if (idx1 > fNdim1){
	344	Reset();
	345	return;
	346	}
	347	}
	348	}
	349
	350	fElements->Adopt(fNelems,buf);
	351
	352	}
	353
	354	//_____________________________________________________________________________
	355	void AliTRDdataArrayF::Compress1()
	356	{
	357	//
	358	// Compress a buffer of type 1
	359	//
	360
	361	AliTRDarrayF buf;
	362	buf.Set(fNelems);
	363	AliTRDarrayI index;
	364	index.Set(fNdim2);
	365
	366	Int_t icurrent = -1;
	367	Int_t izero;
	368	for (Int_t idx2 = 0; idx2 < fNdim2; idx2++){
	369
	370	// Set the idx2 pointer
	371	index[idx2] = icurrent + 1;
	372
	373	// Reset the zero counter
	374	izero = 0;
	375
	376	for (Int_t idx1 = 0; idx1 < fNdim1; idx1++){
	377	// If below threshold
	378	if (GetDataFast(idx1,idx2) <= fThreshold) {
	379	izero++;
	380	}
	381	else {
	382	if (izero > 0) {
	383	// If we have currently izero counts under threshold
	384	icurrent++;
	385	if (icurrent >= buf.fN) buf.Expand(icurrent*2);
	386	// Store the number of entries below zero
	387	buf[icurrent] = -izero;
	388	izero = 0;
	389	}
	390	icurrent++;
	391	if (icurrent >= buf.fN) buf.Expand(icurrent*2);
	392	buf[icurrent] = GetDataFast(idx1,idx2);
393	} // If signal larger than threshold
394	} // End of loop over idx1
395
396	if (izero > 0) {
397	icurrent++;
398	if (icurrent >= buf.fN) buf.Expand(icurrent*2);
399	// Store the number of entries below zero
400	buf[icurrent] = -izero;
401	}
402
403	}
404
405	buf.Expand(icurrent+1);
406	(*fElements) = buf;
407	fNelems = fElements->fN;
408	fBufType = 1;
409	(*fIndex) = index;
410
411	}
412
413	//_____________________________________________________________________________
414	void AliTRDdataArrayF::Expand2()
415	{
416	//
417	// Expands a buffer of type 2
418	//
419
420	Int_t i, k;
421	Float_t *buf = new Float_t[fNelems];
422
423	fNelems = fNdim1 * fNdim2;
424	fIndex->Set(fNdim2);
425
426	for (i = 0, k = 0; i < fNdim2; i++, k += fNdim1) (*fIndex)[i] = k;
427
428	Int_t idx1 = 0;
429	Int_t idx2 = 0;
8230f242	430	Int_t n = fElements->fN;
8230f242	431	for (i = 0; i < n; i++){
6f1e466d	432	// Negative sign counts the unwritten values (under threshold)
	433	if ((*fElements)[i] < 0) {
	434	idx1 -= (Int_t) fElements->At(i);
	435	}
	436	else {
	437	buf[(*fIndex)[idx2]+idx1] = fElements->At(i);
	438	idx1++;
	439	}
	440	if (idx1 == fNdim1) {
	441	idx1 = 0;
	442	idx2++;
	443	}
	444	else {
	445	if (idx1 > fNdim1){
	446	Reset();
	447	return;
	448	}
	449	}
	450	}
	451
	452	fElements->Adopt(fNelems,buf);
	453
	454	}
	455
	456	//_____________________________________________________________________________
	457	void AliTRDdataArrayF::Compress2()
	458	{
8230f242	459	//
	460	// Compress a buffer of type 2 - not implemented!
	461	//
6f1e466d	462
	463	}
	464
	465	//_____________________________________________________________________________
	466	Bool_t AliTRDdataArrayF::First0()
	467	{
	468	//
	469	// Returns the first entry for a buffer of type 0
	470	//
	471
	472	fCurrentIdx1 = -1;
	473	fCurrentIdx2 = -1;
	474	fCurrentIndex = -1;
	475
	476	Int_t i;
	477	for (i = 0; ((i < fNelems) && (fElements->At(i) <= fThreshold)); i++)
	478	if (i == fNelems) return kFALSE;
	479
	480	fCurrentIdx1 = i % fNdim1;
	481	fCurrentIdx2 = i / fNdim1;
	482	fCurrentIndex = i;
	483	return kTRUE;
	484
	485	}
	486
	487	//_____________________________________________________________________________
	488	Bool_t AliTRDdataArrayF::Next0()
	489	{
	490	//
	491	// Returns the next entry for a buffer of type 0
	492	//
	493
	494	if (fCurrentIndex < 0) return kFALSE;
	495
	496	Int_t i;
	497	for (i = fCurrentIndex + 1;
	498	((i < fNelems) && (fElements->At(i) <= fThreshold));
	499	i++);
	500	if (i >= fNelems) {
	501	fCurrentIndex = -1;
	502	return kFALSE;
	503	}
	504
	505	fCurrentIdx1 = i % fNdim1;
	506	fCurrentIdx2 = i / fNdim1;
	507	fCurrentIndex = i;
	508	return kTRUE;
	509
	510	}
	511
	512	//_____________________________________________________________________________
	513	Bool_t AliTRDdataArrayF::First1()
	514	{
	515	//
	516	// Returns the first entry for a buffer of type 1
	517	//
	518
	519	fCurrentIdx1 = -1;
	520	fCurrentIdx2 = 0;
	521	fCurrentIndex = -1;
	522
	523	Int_t i;
	524	for (i = 0; i < fNelems; i++){
	525	if (fElements->At(i) < 0) {
526	fCurrentIdx1 -= (Int_t) fElements->At(i);
527	}
528	else {
529	fCurrentIdx1++;
530	}
531	if (fCurrentIdx1 >= fNdim1) {
532	fCurrentIdx2++;
533	fCurrentIdx1 -= fNdim1;
534	}
535	if (fElements->At(i) > fThreshold) break;
536	}
537
538	fCurrentIndex = i;
539	if (fCurrentIndex >= 0) return kTRUE;
540	fCurrentIdx1 = -1;
541	fCurrentIdx2 = -1;
542	return kFALSE;
543
544	}
545
546	//_____________________________________________________________________________
547	Bool_t AliTRDdataArrayF::Next1()
548	{
549	//
550	// Returns the next entry for a buffer of type 1
551	//
552
553	if (fCurrentIndex < 0) return kFALSE;
554
555	Int_t i;
556	for (i = fCurrentIndex + 1; i < fNelems; i++){
557	if (fElements->At(i) < 0) {
558	fCurrentIdx1 -= (Int_t) fElements->At(i);
559	}
560	else {
561	fCurrentIdx1++;
562	}
563	if (fCurrentIdx1 >= fNdim1) {
564	fCurrentIdx2++;
565	fCurrentIdx1 -= fNdim1;
566	}
567	if (fElements->At(i) > fThreshold) break;
568	}
569
570	fCurrentIndex = i;
571	if ((i >= 0) && (i < fNelems)) return kTRUE;
572	fCurrentIdx1 = -1;
573	fCurrentIdx2 = -1;
574	return kFALSE;
575
576	}
577
578	//_____________________________________________________________________________
579	Float_t AliTRDdataArrayF::GetData1(Int_t idx1, Int_t idx2)
580	{
581	//
582	// Returns the value at a given position of the array
583	//
584
585	Int_t i, n2;
586
587	if ((idx2 + 1) >= fNdim2) {
588	n2 = fNelems;
589	}
590	else {
591	n2 = fIndex->At(idx2 + 1);
592	}
593
594	// Current idx1
595	Int_t curidx1 = 0;
596
597	for (i = fIndex->At(idx2); ((i < n2) && (curidx1 < idx1)); i++){
598	if (fElements->At(i) < 0) {
599	curidx1 -= (Int_t) fElements->At(i);
600	}
601	else {
602	curidx1++;
603	}
604	}
605
606	if ((curidx1 == idx1) && (fElements->At(i) > 0)) {
607	return fElements->At(i);
608	}
609	else {
610	return 0;
611	}
612
613	}
614
dd9a6ee3	615	//____________________________________________________________________________
	616	Float_t AliTRDdataArrayF::GetDataFast(Int_t idx1, Int_t idx2)
	617	{
	618	//
	619	// Returns the value at a given position in the array
	620	//
	621
	622	return fElements->At(fIndex->At(idx2) + idx1);
	623
	624	}
	625
	626	//_____________________________________________________________________________
	627	void AliTRDdataArrayF::SetData(Int_t row, Int_t col, Int_t time, Float_t value)
	628	{
	629	//
	630	// Sets the data value at a given position of the array
	631	// Includes boundary checking
	632	//
	633
	634	if ((row >= 0) && (col >= 0) && (time >= 0)) {
	635	Int_t idx1 = GetIdx1(row,col);
	636	if ((idx1 >= 0) && (time < fNdim2)) {
	637	SetDataFast(idx1,time,value);
	638	}
	639	else {
	640	if (idx1 >= 0) {
	641	TObject::Error("SetData"
	642	,"time %d out of bounds (size: %d, this: 0x%08x)"
	643	,time,fNdim2,this);
	644	}
	645	}
	646	}
	647
	648	}
	649
	650	//_____________________________________________________________________________
	651	void AliTRDdataArrayF::SetDataFast(Int_t idx1, Int_t idx2, Float_t value)
	652	{
	653	//
	654	// Set the value at a given position in the array
	655	//
	656
	657	if ((idx1 < 0) \|\| (idx1 >= fNdim1) \|\|
	658	(idx2 < 0) \|\| (idx2 >= fNdim2)) {
	659	TObject::Error("SetDataFast"
	660	,"idx1 %d idx2 %d out of bounds (size: %d x %d, this: 0x%08x)"
	661	,idx1,idx2,fNdim1,fNdim2,this);
	662	}
	663
	664	(*fElements)[fIndex->fArray[idx2] + idx1] = value;
	665
	666	}
	667
	668	//_____________________________________________________________________________
	669	AliTRDdataArrayF &AliTRDdataArrayF::operator=(const AliTRDdataArrayF &a)
	670	{
	671	//
	672	// Assignment operator
	673	//
	674
	675	if (this != &a) ((AliTRDdataArrayF &) a).Copy(*this);
	676	return *this;
	677
	678	}