[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.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(AliTRDdataArrayF &a)
{
  //
  // Copy function
  //

  fElements->Copy(*a.fElements);

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