[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCHWCFData.h

//-*- Mode: C++ -*-
// $Id$
#ifndef ALIHLTTPCHWCFDATA_H
#define ALIHLTTPCHWCFDATA_H
//* This file is property of and copyright by the ALICE HLT Project        * 
//* ALICE Experiment at CERN, All rights reserved.                         *
//* See cxx source for full Copyright notice                               *

/// @file   AliHLTTPCHWCFData.h
/// @author Matthias Richter
/// @date   2011-08-04
/// @brief  Decoder methods for the HWCF format
///

#include "AliHLTTPCRootTypes.h"
#include "AliHLTDataTypes.h"
#include "AliHLTLogging.h"
#include "AliHLTErrorGuard.h"

class TArrayC;

/**
 * @class AliHLTTPCHWCFData
 * The class provides decoding functionality for the output format of the
 * TPC HW ClusterFinder
 *
 * Two formats have been defined in the past and can be detected:
 * version 0: 5 32bit words 20 Byte
 * <pre>
 *   word 0: header (big endian 32bit unsigned)
 *           bit 31-30: 0x11 indicates cluster
 *           bit 29-24: row number in partition
 *           bit 23-0: Qtot, fixed point number with 6 bits after the point
 *   word 1: pad (float)
 *   word 2: time (float)
 *   word 3: pad variance (float)
 *   word 4: time variance (float)
 * </pre>
 *
 * version 1: 6 32bit words 24 Byte
 * <pre>
 *   word 0: header (big endian 32bit unsigned)
 *           bit 31-30: 0x11 indicates cluster
 *           bit 29-24: row number in partition
 *           bit 23-0: Qmax, fixed point number with 6 bits after the point
 *   word 1: total charge 32bit  big endian, fixed point number with 12 bits after the point
 *   word 2: pad (float)
 *   word 3: time (float)
 *   word 4: pad variance (float)
 *   word 5: time variance (float)
 * </pre>
 */
class AliHLTTPCHWCFData : public AliHLTLogging {
 public:
  AliHLTTPCHWCFData(int forceVersion=-1);
  virtual ~AliHLTTPCHWCFData();

  int Init(const AliHLTUInt8_t* pBuffer, int bufferSize);
  int Reset();

  Int_t    GetNumberOfClusters() const;

  Int_t    GetPadRow(int i)  const;
  Float_t  GetPad(int i)     const;
  Float_t  GetTime(int i)    const;
  Float_t  GetSigmaY2(int i) const;
  Float_t  GetSigmaZ2(int i) const;
  Int_t    GetCharge(int i)  const;
  Int_t    GetQMax(int i)    const;

  int CheckVersion();
  bool CheckAssumption(int format, const AliHLTUInt8_t* pData, int size) const;

  // check if index is within bounds
  bool CheckBounds(int i) const {
    if (fVersion<0) {
      ALIHLTERRORGUARD(1, "");
      return false;
    }
    int elementsize=GetElementSize(fVersion);
    if (elementsize<0) return false;
    return ((i+1)*elementsize+fRCUTrailerSize<=fBufferSize);
  }

  // get the size of one element
  int GetElementSize(int version) const {
    switch (version) {
    case 0: return sizeof(AliHLTTPCHWClusterV0);
    case 1: return sizeof(AliHLTTPCHWClusterV1);
    default:
      ALIHLTERRORGUARD(1, "invalid format version %d", fVersion);
    }
    return -1;
  }

  // pointer to RCU trailer
  const AliHLTUInt8_t*  GetRCUTrailer() const
  {
    if (fRCUTrailerSize<=0 || fpBuffer==NULL || fBufferSize<fRCUTrailerSize) return NULL;
    return fpBuffer+fRCUTrailerSize;
  }

  // size of RCU trailer
  int GetRCUTrailerSize() const { return fRCUTrailerSize; }

  // print info
  void Print(const char* option);

  // open a file and init
  int Open(const char* filename);

  enum {
    kHWCFDataV0 = 0,
    kHWCFDataV1 = 1,
  };

  struct AliHLTTPCHWClusterV0 {
    AliHLTUInt32_t fHeader;
    Float_t        fPad;
    Float_t        fTime;
    Float_t        fSigmaY2;
    Float_t        fSigmaZ2;

    Int_t    GetPadRow()  const;
    Float_t  GetPad()     const {return fPad+0.5;}
    Float_t  GetTime()    const {return fTime;}
    Float_t  GetSigmaY2() const {
      Float_t sy2 = fSigmaY2 - fPad*fPad;
      return (sy2>0) ?sy2 :0.;
    }
    Float_t  GetSigmaZ2() const {
      Float_t sz2 = fSigmaZ2 - fTime*fTime;
      return (sz2>0) ?sz2 :0.;
    }
    Int_t    GetCharge()  const;
    Int_t    GetQMax()    const {return -1;}
  };

  struct AliHLTTPCHWClusterV1 {
    AliHLTUInt32_t fHeader;
    AliHLTUInt32_t fCharge;
    Float_t        fPad;
    Float_t        fTime;
    Float_t        fSigmaY2;
    Float_t        fSigmaZ2;

    Int_t    GetPadRow()  const;
    Float_t  GetPad()     const {return fPad+0.5;}
    Float_t  GetTime()    const {return fTime;}
    Float_t  GetSigmaY2() const {
      Float_t sy2 = fSigmaY2 - fPad*fPad;
      return (sy2>0) ?sy2 :0.;
    }
    Float_t  GetSigmaZ2() const {
      Float_t sz2 = fSigmaZ2 - fTime*fTime;
      return (sz2>0) ?sz2 :0.;
    }
    Int_t    GetCharge()  const;
    Int_t    GetQMax()    const;
  };

  template<typename T>
  class AliHLTTPCHWClusterDecoder {
  public:
    AliHLTTPCHWClusterDecoder(const T* pClusterArray, int entries);
    ~AliHLTTPCHWClusterDecoder();

    // i'th element, no bounds check for performance reasons
    const T& operator[](unsigned i) {
      return fpClusterArray[i];
    }

    Int_t    GetPadRow(int i)  const {return fpClusterArray[i]->GetPadRow();}
    Float_t  GetPad(int i)     const {return fpClusterArray[i]->GetPad();}
    Float_t  GetTime(int i)    const {return fpClusterArray[i]->GetTime();}
    Float_t  GetSigmaY2(int i) const {return fpClusterArray[i]->GetSigmaY2();}
    Float_t  GetSigmaZ2(int i) const {return fpClusterArray[i]->GetSigmaZ2();}
    Int_t    GetCharge(int i)  const {return fpClusterArray[i]->GetCharge();}
    Int_t    GetQMax(int i)    const {return fpClusterArray[i]->GetQMax();}

  private:
    const T* fpClusterArray; //! array of clusters
    int fEntries;            //! number of entries
  };

  class iterator {
  public:
    iterator()
      : fData(NULL), fVersion(-1), fElementSize(0) {}
    iterator(const AliHLTUInt8_t* pData, int version, int elementSize)
      : fData(pData), fVersion(version), fElementSize(elementSize) {}
    iterator(const iterator& i)
      : fData(i.fData), fVersion(i.fVersion), fElementSize(i.fElementSize) {}
    iterator& operator=(const iterator& i)
      { fData=i.fData; fVersion=i.fVersion; fElementSize=i.fElementSize; return *this;}
    ~iterator() {fData=NULL;}

    bool operator==(const iterator& i) const  {return (fData!=NULL) && (fData==i.fData);}
    bool operator!=(const iterator& i) const  {return (fData!=NULL) && (fData!=i.fData);}
    // prefix operators
    iterator& operator++() {fData+=fElementSize; return *this;}
    iterator& operator--() {fData-=fElementSize; return *this;}
    // postfix operators
    iterator operator++(int) {iterator i(*this); fData+=fElementSize; return i;}
    iterator operator--(int) {iterator i(*this); fData-=fElementSize; return i;}

    iterator& operator+=(int step) {fData+=step*fElementSize; return *this;}

    Int_t    GetPadRow()  const {
      switch (fVersion) {
      case 0: return reinterpret_cast<const AliHLTTPCHWClusterV0*>(fData)->GetPadRow();
      case 1: return reinterpret_cast<const AliHLTTPCHWClusterV1*>(fData)->GetPadRow();
      } return -1;
    }
    Float_t  GetPad()     const {
      switch (fVersion) {
      case 0: return reinterpret_cast<const AliHLTTPCHWClusterV0*>(fData)->GetPad();
      case 1: return reinterpret_cast<const AliHLTTPCHWClusterV1*>(fData)->GetPad();
      } return -10000.;
    }
    Float_t  GetTime()    const {
      switch (fVersion) {
      case 0: return reinterpret_cast<const AliHLTTPCHWClusterV0*>(fData)->GetTime();
      case 1: return reinterpret_cast<const AliHLTTPCHWClusterV1*>(fData)->GetTime();
      } return -10000.;
    }
    Float_t  GetSigmaY2() const {
      switch (fVersion) {
      case 0: return reinterpret_cast<const AliHLTTPCHWClusterV0*>(fData)->GetSigmaY2();
      case 1: return reinterpret_cast<const AliHLTTPCHWClusterV1*>(fData)->GetSigmaY2();
      } return -10000.;
    }
    Float_t  GetSigmaZ2() const {
      switch (fVersion) {
      case 0: return reinterpret_cast<const AliHLTTPCHWClusterV0*>(fData)->GetSigmaZ2();
      case 1: return reinterpret_cast<const AliHLTTPCHWClusterV1*>(fData)->GetSigmaZ2();
      } return -10000.;
    }
    Int_t    GetCharge()  const {
      switch (fVersion) {
      case 0: return reinterpret_cast<const AliHLTTPCHWClusterV0*>(fData)->GetCharge();
      case 1: return reinterpret_cast<const AliHLTTPCHWClusterV1*>(fData)->GetCharge();
      } return -1;
    }
    Int_t    GetQMax()    const {
      switch (fVersion) {
      case 0: return reinterpret_cast<const AliHLTTPCHWClusterV0*>(fData)->GetQMax();
      case 1: return reinterpret_cast<const AliHLTTPCHWClusterV1*>(fData)->GetQMax();
      } return -1;
    }

  protected:
  private:
    const AliHLTUInt8_t* fData; //! data
    int fVersion; //! format version
    int fElementSize; //! element size
  };

  // prepare iterator and end marker
  iterator& begin() {
    fIterator.~iterator();
    new (&fIterator) iterator(fpBuffer, fVersion, GetElementSize(fVersion));
    fIteratorEnd=fIterator;
    fIteratorEnd+=GetNumberOfClusters();
    return fIterator;
  }

  // get loop end marker
  iterator& end() {
    return fIteratorEnd;
  }

  // find one single element
  iterator& find(int i) {
    fIterator.~iterator();
    fIteratorEnd.~iterator();
    if (i>=GetNumberOfClusters()) return fIterator;
    new (&fIterator) iterator(fpBuffer, fVersion, GetElementSize(fVersion));
    fIterator+=i;
    fIteratorEnd=fIterator;
    fIteratorEnd+=1;
    return fIterator;
  }

  static const unsigned  fgkAliHLTTPCHWClusterSize;
 protected:

 private:
  AliHLTTPCHWCFData(const AliHLTTPCHWCFData&);
  AliHLTTPCHWCFData& operator=(const AliHLTTPCHWCFData&);

  // get pointer to i'th element
  const AliHLTUInt8_t* Get(int i) const
  {
    if (!fpBuffer) return NULL;
    int elementsize=GetElementSize(fVersion);
    if (elementsize<0) return NULL;
    return fpBuffer+(i*elementsize);
  }


  const AliHLTUInt8_t* fpBuffer; //! pointer to data buffer
  int fBufferSize; //! size of data buffer

  int fVersion; //! format version
  int fForcedVersion; //! forced format version
  int fRCUTrailerSize; //! size of the RCU trailer in Byte

  TArrayC* fpFileBuffer; //! internal buffer for file content

  iterator fIterator; //! iterator
  iterator fIteratorEnd; //! end iterator

  ClassDef(AliHLTTPCHWCFData, 0)
};
#endif
Commit	Line	Data
73cc961a	1	//-- Mode: C++ --
3aa4d287	2	// $Id$
	3	#ifndef ALIHLTTPCHWCFDATA_H
	4	#define ALIHLTTPCHWCFDATA_H
	5	//* This file is property of and copyright by the ALICE HLT Project *
	6	//* ALICE Experiment at CERN, All rights reserved. *
	7	//* See cxx source for full Copyright notice *
	8
	9	/// @file AliHLTTPCHWCFData.h
	10	/// @author Matthias Richter
	11	/// @date 2011-08-04
	12	/// @brief Decoder methods for the HWCF format
	13	///
	14
	15	#include "AliHLTTPCRootTypes.h"
	16	#include "AliHLTDataTypes.h"
	17	#include "AliHLTLogging.h"
73cc961a	18	#include "AliHLTErrorGuard.h"
3aa4d287	19
	20	class TArrayC;
	21
	22	/**
	23	* @class AliHLTTPCHWCFData
	24	* The class provides decoding functionality for the output format of the
	25	* TPC HW ClusterFinder
	26	*
	27	* Two formats have been defined in the past and can be detected:
	28	* version 0: 5 32bit words 20 Byte
	29	* <pre>
	30	* word 0: header (big endian 32bit unsigned)
	31	* bit 31-30: 0x11 indicates cluster
	32	* bit 29-24: row number in partition
	33	* bit 23-0: Qtot, fixed point number with 6 bits after the point
	34	* word 1: pad (float)
	35	* word 2: time (float)
	36	* word 3: pad variance (float)
	37	* word 4: time variance (float)
	38	* </pre>
	39	*
	40	* version 1: 6 32bit words 24 Byte
	41	* <pre>
	42	* word 0: header (big endian 32bit unsigned)
	43	* bit 31-30: 0x11 indicates cluster
	44	* bit 29-24: row number in partition
	45	* bit 23-0: Qmax, fixed point number with 6 bits after the point
	46	* word 1: total charge 32bit big endian, fixed point number with 12 bits after the point
	47	* word 2: pad (float)
	48	* word 3: time (float)
	49	* word 4: pad variance (float)
	50	* word 5: time variance (float)
	51	* </pre>
	52	*/
	53	class AliHLTTPCHWCFData : public AliHLTLogging {
	54	public:
	55	AliHLTTPCHWCFData(int forceVersion=-1);
	56	virtual ~AliHLTTPCHWCFData();
	57
	58	int Init(const AliHLTUInt8_t* pBuffer, int bufferSize);
	59	int Reset();
	60
	61	Int_t GetNumberOfClusters() const;
	62
	63	Int_t GetPadRow(int i) const;
	64	Float_t GetPad(int i) const;
	65	Float_t GetTime(int i) const;
	66	Float_t GetSigmaY2(int i) const;
	67	Float_t GetSigmaZ2(int i) const;
	68	Int_t GetCharge(int i) const;
	69	Int_t GetQMax(int i) const;
	70
	71	int CheckVersion();
	72	bool CheckAssumption(int format, const AliHLTUInt8_t* pData, int size) const;
73cc961a	73
	74	// check if index is within bounds
	75	bool CheckBounds(int i) const {
	76	if (fVersion<0) {
	77	ALIHLTERRORGUARD(1, "");
	78	return false;
	79	}
	80	int elementsize=GetElementSize(fVersion);
	81	if (elementsize<0) return false;
	82	return ((i+1)*elementsize+fRCUTrailerSize<=fBufferSize);
	83	}
	84
	85	// get the size of one element
	86	int GetElementSize(int version) const {
	87	switch (version) {
	88	case 0: return sizeof(AliHLTTPCHWClusterV0);
	89	case 1: return sizeof(AliHLTTPCHWClusterV1);
	90	default:
	91	ALIHLTERRORGUARD(1, "invalid format version %d", fVersion);
	92	}
	93	return -1;
	94	}
3aa4d287	95
	96	// pointer to RCU trailer
	97	const AliHLTUInt8_t* GetRCUTrailer() const
	98	{
	99	if (fRCUTrailerSize<=0 \|\| fpBuffer==NULL \|\| fBufferSize<fRCUTrailerSize) return NULL;
	100	return fpBuffer+fRCUTrailerSize;
	101	}
	102
	103	// size of RCU trailer
	104	int GetRCUTrailerSize() const { return fRCUTrailerSize; }
	105
	106	// print info
	107	void Print(const char* option);
	108
	109	// open a file and init
	110	int Open(const char* filename);
	111
	112	enum {
	113	kHWCFDataV0 = 0,
	114	kHWCFDataV1 = 1,
	115	};
	116
	117	struct AliHLTTPCHWClusterV0 {
	118	AliHLTUInt32_t fHeader;
	119	Float_t fPad;
	120	Float_t fTime;
	121	Float_t fSigmaY2;
	122	Float_t fSigmaZ2;
	123
	124	Int_t GetPadRow() const;
1b9cc91a	125	Float_t GetPad() const {return fPad+0.5;}
3aa4d287	126	Float_t GetTime() const {return fTime;}
b83cf637	127	Float_t GetSigmaY2() const {
	128	Float_t sy2 = fSigmaY2 - fPad*fPad;
	129	return (sy2>0) ?sy2 :0.;
	130	}
	131	Float_t GetSigmaZ2() const {
	132	Float_t sz2 = fSigmaZ2 - fTime*fTime;
	133	return (sz2>0) ?sz2 :0.;
	134	}
3aa4d287	135	Int_t GetCharge() const;
	136	Int_t GetQMax() const {return -1;}
	137	};
	138
	139	struct AliHLTTPCHWClusterV1 {
	140	AliHLTUInt32_t fHeader;
	141	AliHLTUInt32_t fCharge;
	142	Float_t fPad;
	143	Float_t fTime;
	144	Float_t fSigmaY2;
	145	Float_t fSigmaZ2;
	146
	147	Int_t GetPadRow() const;
1b9cc91a	148	Float_t GetPad() const {return fPad+0.5;}
3aa4d287	149	Float_t GetTime() const {return fTime;}
b83cf637	150	Float_t GetSigmaY2() const {
	151	Float_t sy2 = fSigmaY2 - fPad*fPad;
	152	return (sy2>0) ?sy2 :0.;
	153	}
	154	Float_t GetSigmaZ2() const {
	155	Float_t sz2 = fSigmaZ2 - fTime*fTime;
	156	return (sz2>0) ?sz2 :0.;
	157	}
3aa4d287	158	Int_t GetCharge() const;
	159	Int_t GetQMax() const;
	160	};
	161
	162	template<typename T>
	163	class AliHLTTPCHWClusterDecoder {
	164	public:
	165	AliHLTTPCHWClusterDecoder(const T* pClusterArray, int entries);
	166	~AliHLTTPCHWClusterDecoder();
	167
	168	// i'th element, no bounds check for performance reasons
	169	const T& operator[](unsigned i) {
	170	return fpClusterArray[i];
	171	}
	172
	173	Int_t GetPadRow(int i) const {return fpClusterArray[i]->GetPadRow();}
	174	Float_t GetPad(int i) const {return fpClusterArray[i]->GetPad();}
	175	Float_t GetTime(int i) const {return fpClusterArray[i]->GetTime();}
	176	Float_t GetSigmaY2(int i) const {return fpClusterArray[i]->GetSigmaY2();}
	177	Float_t GetSigmaZ2(int i) const {return fpClusterArray[i]->GetSigmaZ2();}
	178	Int_t GetCharge(int i) const {return fpClusterArray[i]->GetCharge();}
	179	Int_t GetQMax(int i) const {return fpClusterArray[i]->GetQMax();}
	180
	181	private:
	182	const T* fpClusterArray; //! array of clusters
	183	int fEntries; //! number of entries
	184	};
	185
536e7d6d	186	class iterator {
	187	public:
	188	iterator()
	189	: fData(NULL), fVersion(-1), fElementSize(0) {}
	190	iterator(const AliHLTUInt8_t* pData, int version, int elementSize)
	191	: fData(pData), fVersion(version), fElementSize(elementSize) {}
	192	iterator(const iterator& i)
	193	: fData(i.fData), fVersion(i.fVersion), fElementSize(i.fElementSize) {}
	194	iterator& operator=(const iterator& i)
	195	{ fData=i.fData; fVersion=i.fVersion; fElementSize=i.fElementSize; return *this;}
73cc961a	196	~iterator() {fData=NULL;}
536e7d6d	197
	198	bool operator==(const iterator& i) const {return (fData!=NULL) && (fData==i.fData);}
	199	bool operator!=(const iterator& i) const {return (fData!=NULL) && (fData!=i.fData);}
	200	// prefix operators
	201	iterator& operator++() {fData+=fElementSize; return *this;}
	202	iterator& operator--() {fData-=fElementSize; return *this;}
	203	// postfix operators
	204	iterator operator++(int) {iterator i(*this); fData+=fElementSize; return i;}
	205	iterator operator--(int) {iterator i(*this); fData-=fElementSize; return i;}
	206
	207	iterator& operator+=(int step) {fData+=stepfElementSize; return this;}
	208
	209	Int_t GetPadRow() const {
	210	switch (fVersion) {
	211	case 0: return reinterpret_cast<const AliHLTTPCHWClusterV0*>(fData)->GetPadRow();
	212	case 1: return reinterpret_cast<const AliHLTTPCHWClusterV1*>(fData)->GetPadRow();
	213	} return -1;
	214	}
	215	Float_t GetPad() const {
	216	switch (fVersion) {
	217	case 0: return reinterpret_cast<const AliHLTTPCHWClusterV0*>(fData)->GetPad();
	218	case 1: return reinterpret_cast<const AliHLTTPCHWClusterV1*>(fData)->GetPad();
	219	} return -10000.;
	220	}
	221	Float_t GetTime() const {
	222	switch (fVersion) {
	223	case 0: return reinterpret_cast<const AliHLTTPCHWClusterV0*>(fData)->GetTime();
	224	case 1: return reinterpret_cast<const AliHLTTPCHWClusterV1*>(fData)->GetTime();
	225	} return -10000.;
	226	}
	227	Float_t GetSigmaY2() const {
	228	switch (fVersion) {
	229	case 0: return reinterpret_cast<const AliHLTTPCHWClusterV0*>(fData)->GetSigmaY2();
	230	case 1: return reinterpret_cast<const AliHLTTPCHWClusterV1*>(fData)->GetSigmaY2();
	231	} return -10000.;
	232	}
	233	Float_t GetSigmaZ2() const {
	234	switch (fVersion) {
	235	case 0: return reinterpret_cast<const AliHLTTPCHWClusterV0*>(fData)->GetSigmaZ2();
	236	case 1: return reinterpret_cast<const AliHLTTPCHWClusterV1*>(fData)->GetSigmaZ2();
	237	} return -10000.;
	238	}
	239	Int_t GetCharge() const {
	240	switch (fVersion) {
	241	case 0: return reinterpret_cast<const AliHLTTPCHWClusterV0*>(fData)->GetCharge();
	242	case 1: return reinterpret_cast<const AliHLTTPCHWClusterV1*>(fData)->GetCharge();
	243	} return -1;
	244	}
	245	Int_t GetQMax() const {
	246	switch (fVersion) {
	247	case 0: return reinterpret_cast<const AliHLTTPCHWClusterV0*>(fData)->GetQMax();
	248	case 1: return reinterpret_cast<const AliHLTTPCHWClusterV1*>(fData)->GetQMax();
	249	} return -1;
	250	}
	251
	252	protected:
	253	private:
	254	const AliHLTUInt8_t* fData; //! data
	255	int fVersion; //! format version
	256	int fElementSize; //! element size
	257	};
	258
	259	// prepare iterator and end marker
	260	iterator& begin() {
261	fIterator.~iterator();
262	new (&fIterator) iterator(fpBuffer, fVersion, GetElementSize(fVersion));
263	fIteratorEnd=fIterator;
264	fIteratorEnd+=GetNumberOfClusters();
265	return fIterator;
266	}
267
268	// get loop end marker
269	iterator& end() {
270	return fIteratorEnd;
271	}
272
73cc961a	273	// find one single element
	274	iterator& find(int i) {
	275	fIterator.~iterator();
	276	fIteratorEnd.~iterator();
	277	if (i>=GetNumberOfClusters()) return fIterator;
	278	new (&fIterator) iterator(fpBuffer, fVersion, GetElementSize(fVersion));
	279	fIterator+=i;
	280	fIteratorEnd=fIterator;
	281	fIteratorEnd+=1;
	282	return fIterator;
	283	}
	284
3aa4d287	285	static const unsigned fgkAliHLTTPCHWClusterSize;
	286	protected:
	287
	288	private:
	289	AliHLTTPCHWCFData(const AliHLTTPCHWCFData&);
	290	AliHLTTPCHWCFData& operator=(const AliHLTTPCHWCFData&);
	291
	292	// get pointer to i'th element
	293	const AliHLTUInt8_t* Get(int i) const
	294	{
	295	if (!fpBuffer) return NULL;
	296	int elementsize=GetElementSize(fVersion);
	297	if (elementsize<0) return NULL;
	298	return fpBuffer+(i*elementsize);
	299	}
	300
	301
	302	const AliHLTUInt8_t* fpBuffer; //! pointer to data buffer
	303	int fBufferSize; //! size of data buffer
	304
	305	int fVersion; //! format version
	306	int fForcedVersion; //! forced format version
	307	int fRCUTrailerSize; //! size of the RCU trailer in Byte
	308
	309	TArrayC* fpFileBuffer; //! internal buffer for file content
	310
536e7d6d	311	iterator fIterator; //! iterator
	312	iterator fIteratorEnd; //! end iterator
	313
3aa4d287	314	ClassDef(AliHLTTPCHWCFData, 0)
	315	};
	316	#endif