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

// XEmacs -*-C++-*-
// @(#) $Id$

#ifndef ALIHLTTPCDIGITREADERUNPACKED_H
#define ALIHLTTPCDIGITREADERUNPACKED_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   AliHLTTPCDigitReaderUnpacked.h
    @author Timm Steinbeck, Jochen Thaeder, Matthias Richter
    @date   
    @brief  A digit reader implementation for unpacked TPC data.
*/

#include "AliHLTTPCDigitReader.h"
#include "AliHLTTPCDigitData.h"
class AliHLTTPCMapping;
class AliHLTTPCDigitRowData;

/**
 * @class AliHLTTPCDigitReaderUnpacked
 * A digit reader implementation for unpacked TPC data.
 * @ingroup alihlt_tpc
 */
class AliHLTTPCDigitReaderUnpacked : public AliHLTTPCDigitReader{
public:
  /** standard constructor */
  AliHLTTPCDigitReaderUnpacked();
  /** destructor */
  virtual ~AliHLTTPCDigitReaderUnpacked();

  /**
   * Init the reader
   * @param ptr    pointer to input buffer
   * @param size   size of the input buffer
   * @param patch  readout partition
   * @param slice  sector no
   */  
  int InitBlock(void* ptr,unsigned long size, Int_t patch, Int_t slice);
  using AliHLTTPCDigitReader::InitBlock;

  /**
   * place the reader at the next signal
   * @return 1 if there was a nest signal, 0 if not
   */
  bool NextSignal();

  /**
   * Get row number of the current signal
   * @return row number of the current signal
   */
  int GetRow();

  /**
   * Get pad number of the current signal
   * @return pad number of the current signal
   */
  int GetPad();

  /**
   * Get signal
   * @return ADC signal
   */
  int GetSignal();

  /**
   * Get time of the current signal
   * @return time of the current signal
   */
  int GetTime();
  
  bool NextChannel();
  int NextBunch();
  AliHLTUInt32_t GetAltroBlockHWaddr() const;
  int GetBunchSize();
  const UInt_t* GetSignals();
  AliHLTTPCDigitData GetSortedDigit();
  Int_t GetSortedTime();    
  Int_t GetSortedSignal();
  Int_t GetSortedPad() const;
  Int_t GetSortedRow() const;
  int GetRowOffset() const;

  void SetUnsorted(bool unsorted){fUnsorted=unsorted;}

  void SortBunchBinVector(); // fills the vector fBinRowPositionSorted so that digits are read in the correct order

  const AliHLTTPCDigitData* GetBunchDigits();

protected:


private:
  /** copy constructor prohibited */
  AliHLTTPCDigitReaderUnpacked(const AliHLTTPCDigitReaderUnpacked&);
  /** assignment operator prohibited */
  AliHLTTPCDigitReaderUnpacked& operator=(const AliHLTTPCDigitReaderUnpacked&);

  /**
   * Increment to the next raw data pointer.
   * @param pRow        [IN] the current row data pointer
   *                    [OUT] the new pointer
   * @return -EBADF in case of format error 
   */
  int GetNextRowData(AliHLTTPCDigitRowData*& pRow) const;

  /** intermediate row data structure (pointer in fPtr buffer) */
  AliHLTTPCDigitRowData *fDigitRowData; //!
  /** current row data structure (pointer in fPtr buffer) */
  AliHLTTPCDigitRowData *fActRowData; //!
  /** the current digit data */
  AliHLTTPCDigitData *fData; //!

  /** input buffer */
  void* fPtr; //!
  /** size of the input buffer */
  unsigned long fSize;                                             // see above

  /** current bin */
  Int_t fBin;                                                      // see above
  /** current row */
  Int_t fRow;                                                      // see above
  /** first row */
  Int_t fFirstRow;                                                 // see above
  /** last row */
  Int_t fLastRow;                                                  // see above

  Bool_t fUnsorted; //!transient

  /** array to hold bunch data */
  vector<UInt_t> fDataBunch;                            //! transient

  vector<Int_t> fTrackIDs;                              //! transient
  vector<UInt_t> fTrackIDCounts;                        //! transient
  
  Bool_t fEndOfDataReached;                             //! transient

  Bool_t fEndOfChannelReached;                          //! transient

  Int_t fPrevTime;                                      //! transient

  Int_t fEndTimeBinOfBunch;                             //! transient

  Int_t fPrevSignal;                                    //! transient

  Int_t fPrevPad;                                       //! transient

  Int_t fPrevRow;                                       //! transient
  
  Bool_t fNextChannelIsAlreadyConfirmed;                //! transient 

  AliHLTTPCMapping *fMapping;                           //! transient

  vector<AliHLTTPCDigitData> fDigitsVector;             //! transient

  vector<Int_t>fBinRowPositionSorted;                      //! transient

  Int_t fPatch;

  ClassDef(AliHLTTPCDigitReaderUnpacked, 0)
};
#endif
Commit	Line	Data
	1	// XEmacs --C++--
	2	// @(#) $Id$
	3
	4	#ifndef ALIHLTTPCDIGITREADERUNPACKED_H
	5	#define ALIHLTTPCDIGITREADERUNPACKED_H
	6
	7	//* This file is property of and copyright by the ALICE HLT Project *
	8	//* ALICE Experiment at CERN, All rights reserved. *
	9	//* See cxx source for full Copyright notice *
	10
	11	/** @file AliHLTTPCDigitReaderUnpacked.h
	12	@author Timm Steinbeck, Jochen Thaeder, Matthias Richter
	13	@date
	14	@brief A digit reader implementation for unpacked TPC data.
	15	*/
	16
	17	#include "AliHLTTPCDigitReader.h"
	18	#include "AliHLTTPCDigitData.h"
	19	class AliHLTTPCMapping;
	20	class AliHLTTPCDigitRowData;
	21
	22	/**
	23	* @class AliHLTTPCDigitReaderUnpacked
	24	* A digit reader implementation for unpacked TPC data.
	25	* @ingroup alihlt_tpc
	26	*/
	27	class AliHLTTPCDigitReaderUnpacked : public AliHLTTPCDigitReader{
	28	public:
	29	/** standard constructor */
	30	AliHLTTPCDigitReaderUnpacked();
	31	/** destructor */
	32	virtual ~AliHLTTPCDigitReaderUnpacked();
	33
	34	/**
	35	* Init the reader
	36	* @param ptr pointer to input buffer
	37	* @param size size of the input buffer
	38	* @param patch readout partition
	39	* @param slice sector no
	40	*/
	41	int InitBlock(void* ptr,unsigned long size, Int_t patch, Int_t slice);
	42	using AliHLTTPCDigitReader::InitBlock;
	43
	44	/**
	45	* place the reader at the next signal
	46	* @return 1 if there was a nest signal, 0 if not
	47	*/
	48	bool NextSignal();
	49
	50	/**
	51	* Get row number of the current signal
	52	* @return row number of the current signal
	53	*/
	54	int GetRow();
	55
	56	/**
	57	* Get pad number of the current signal
	58	* @return pad number of the current signal
	59	*/
	60	int GetPad();
	61
	62	/**
	63	* Get signal
	64	* @return ADC signal
	65	*/
	66	int GetSignal();
	67
	68	/**
	69	* Get time of the current signal
	70	* @return time of the current signal
	71	*/
	72	int GetTime();
	73
	74	bool NextChannel();
	75	int NextBunch();
	76	AliHLTUInt32_t GetAltroBlockHWaddr() const;
	77	int GetBunchSize();
	78	const UInt_t* GetSignals();
	79	AliHLTTPCDigitData GetSortedDigit();
	80	Int_t GetSortedTime();
	81	Int_t GetSortedSignal();
	82	Int_t GetSortedPad() const;
	83	Int_t GetSortedRow() const;
	84	int GetRowOffset() const;
	85
	86	void SetUnsorted(bool unsorted){fUnsorted=unsorted;}
	87
	88	void SortBunchBinVector(); // fills the vector fBinRowPositionSorted so that digits are read in the correct order
	89
	90	const AliHLTTPCDigitData* GetBunchDigits();
	91
	92	protected:
	93
	94
	95	private:
	96	/** copy constructor prohibited */
	97	AliHLTTPCDigitReaderUnpacked(const AliHLTTPCDigitReaderUnpacked&);
	98	/** assignment operator prohibited */
	99	AliHLTTPCDigitReaderUnpacked& operator=(const AliHLTTPCDigitReaderUnpacked&);
	100
	101	/**
	102	* Increment to the next raw data pointer.
	103	* @param pRow [IN] the current row data pointer
	104	* [OUT] the new pointer
	105	* @return -EBADF in case of format error
	106	*/
	107	int GetNextRowData(AliHLTTPCDigitRowData*& pRow) const;
	108
	109	/** intermediate row data structure (pointer in fPtr buffer) */
	110	AliHLTTPCDigitRowData *fDigitRowData; //!
	111	/** current row data structure (pointer in fPtr buffer) */
	112	AliHLTTPCDigitRowData *fActRowData; //!
	113	/** the current digit data */
	114	AliHLTTPCDigitData *fData; //!
	115
	116	/** input buffer */
	117	void* fPtr; //!
	118	/** size of the input buffer */
	119	unsigned long fSize; // see above
	120
	121	/** current bin */
	122	Int_t fBin; // see above
	123	/** current row */
	124	Int_t fRow; // see above
	125	/** first row */
	126	Int_t fFirstRow; // see above
	127	/** last row */
	128	Int_t fLastRow; // see above
	129
	130	Bool_t fUnsorted; //!transient
	131
	132	/** array to hold bunch data */
	133	vector<UInt_t> fDataBunch; //! transient
	134
	135	vector<Int_t> fTrackIDs; //! transient
	136	vector<UInt_t> fTrackIDCounts; //! transient
	137
	138	Bool_t fEndOfDataReached; //! transient
	139
	140	Bool_t fEndOfChannelReached; //! transient
	141
	142	Int_t fPrevTime; //! transient
	143
	144	Int_t fEndTimeBinOfBunch; //! transient
	145
	146	Int_t fPrevSignal; //! transient
	147
	148	Int_t fPrevPad; //! transient
	149
	150	Int_t fPrevRow; //! transient
	151
	152	Bool_t fNextChannelIsAlreadyConfirmed; //! transient
	153
	154	AliHLTTPCMapping *fMapping; //! transient
	155
	156	vector<AliHLTTPCDigitData> fDigitsVector; //! transient
	157
	158	vector<Int_t>fBinRowPositionSorted; //! transient
	159
	160	Int_t fPatch;
	161
	162	ClassDef(AliHLTTPCDigitReaderUnpacked, 0)
	163	};
	164	#endif
	165
	166
	167