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

// @(#) $Id$
// Original: AliHLTClustFinderNew.h,v 1.13 2004/06/18 10:55:26 loizides 

#ifndef AliHLTTPC_CLUSTERFINDER
#define AliHLTTPC_CLUSTERFINDER
/* 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   AliHLTTPCClusterFinder.h
    @author Anders Vestbo, Constantin Loizides, Jochen Thaeder
	    Kenneth Aamodt kenneth.aamodt@student.uib.no
    @date   
    @brief  Cluster Finder for the TPC
*/

// see below for class documentation
// or
// refer to README to build package
// or
// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt

#include "AliHLTLogging.h"
#include "AliHLTTPCPadArray.h"
class AliHLTTPCSpacePointData;
class AliHLTTPCDigitReader;

class AliHLTTPCClusterFinder : public AliHLTLogging {

 public:
  struct AliClusterData
  {
    UInt_t fTotalCharge;   //tot charge of cluster
    UInt_t fPad;           //pad value
    UInt_t fTime;          //time value
    ULong64_t fPad2;       //for error in XY direction
    ULong64_t fTime2;      //for error in Z  direction
    UInt_t fMean;          //mean in time
    UInt_t fFlags;         //different flags
    UInt_t fChargeFalling; //for deconvolution
    UInt_t fLastCharge;    //for deconvolution
    UInt_t fLastMergedPad; //dont merge twice per pad
  };
  typedef struct AliClusterData AliClusterData; //!

 private: 
  AliHLTTPCSpacePointData *fSpacePointData; //! array of space points
  AliHLTTPCDigitReader *fDigitReader;       //! reader instance

  UChar_t* fPtr;   //! pointer to packed block
  unsigned long fSize; //packed block size
  Bool_t fDeconvTime; //deconv in time direction
  Bool_t fDeconvPad;  //deconv in pad direction
  Bool_t fStdout;     //have print out in write clusters
  Bool_t fCalcerr;    //calculate centroid sigmas
  Bool_t fRawSP;      //store centroids in raw system


  Int_t fFirstRow;       //first row
  Int_t fLastRow;        //last row
  Int_t fCurrentRow;     //current active row
  Int_t fCurrentSlice;   //current slice
  Int_t fCurrentPatch;   //current patch
  Int_t fMatch;          //size of match
  UInt_t fThreshold;     //threshold for clusters
  /** threshold for zero suppression (applied per bin) */
  Int_t fSignalThreshold;
  Int_t fNClusters;      //number of found clusters
  Int_t fMaxNClusters;   //max. number of clusters
  Float_t fXYErr;        //fixed error in XY
  Float_t fZErr;         //fixed error in Z
  
  Float_t fOccupancyLimit; // Occupancy Limit

  AliHLTTPCPadArray * fPadArray; //! transient


#ifdef do_mc
  void GetTrackID(Int_t pad,Int_t time,Int_t *trackID);
#endif
  
 public:
  /** standard constructor */
  AliHLTTPCClusterFinder();
  /** not a valid copy constructor, defined according to effective C++ style */
  AliHLTTPCClusterFinder(const AliHLTTPCClusterFinder&);
  /** not a valid assignment op, but defined according to effective C++ style */
  AliHLTTPCClusterFinder& operator=(const AliHLTTPCClusterFinder&);
  /** destructor */
  virtual ~AliHLTTPCClusterFinder();

  void Read(void* ptr,unsigned long size);

  void InitSlice(Int_t slice,Int_t patch,Int_t firstrow, Int_t lastrow,Int_t maxpoints);
  void InitSlice(Int_t slice,Int_t patch,Int_t maxpoints);
  void ProcessDigits();

  void SetOutputArray(AliHLTTPCSpacePointData *pt);
  void WriteClusters(Int_t n_clusters,AliClusterData *list);

  void SetXYError(Float_t f) {fXYErr=f;}
  void SetZError(Float_t f) {fZErr=f;}
  void SetDeconv(Bool_t f) {fDeconvPad=f; fDeconvTime=f;}
  void SetThreshold(UInt_t i) {fThreshold=i;}
  void SetOccupancyLimit(Float_t f) {fOccupancyLimit=f;}
  void SetSignalThreshold(Int_t i) {fSignalThreshold=i;}
  void SetMatchWidth(UInt_t i) {fMatch=i;}
  void SetSTDOutput(Bool_t f=kFALSE) {fStdout=f;}  
  void SetCalcErr(Bool_t f=kTRUE) {fCalcerr=f;}
  void SetRawSP(Bool_t f=kFALSE) {fRawSP=f;}
  void SetReader(AliHLTTPCDigitReader* f){fDigitReader = f;}
  Int_t GetNumberOfClusters() const {return fNClusters;}

  //----------------------------------Methods for the new unsorted way of reading data ----------
  void SetPadArray(AliHLTTPCPadArray *padArray);
  void ReadDataUnsorted(void* ptr,unsigned long size);
  void FindClusters();
  void WriteClusters(Int_t nclusters,AliHLTTPCClusters *list);
  
  ClassDef(AliHLTTPCClusterFinder,1) //Fast cluster finder
};
#endif
Commit	Line	Data
a38a7850	1	// @(#) $Id$
4aa41877	2	// Original: AliHLTClustFinderNew.h,v 1.13 2004/06/18 10:55:26 loizides
a38a7850	3
01f43166	4	#ifndef AliHLTTPC_CLUSTERFINDER
	5	#define AliHLTTPC_CLUSTERFINDER
	6	/* This file is property of and copyright by the ALICE HLT Project *
	7	* ALICE Experiment at CERN, All rights reserved. *
	8	* See cxx source for full Copyright notice */
a38a7850	9
01f43166	10	/** @file AliHLTTPCClusterFinder.h
	11	@author Anders Vestbo, Constantin Loizides, Jochen Thaeder
	12	Kenneth Aamodt kenneth.aamodt@student.uib.no
	13	@date
	14	@brief Cluster Finder for the TPC
	15	*/
	16
	17	// see below for class documentation
	18	// or
	19	// refer to README to build package
	20	// or
	21	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
46b33a24	22
01f43166	23	#include "AliHLTLogging.h"
01f43166	24	#include "AliHLTTPCPadArray.h"
a38a7850	25	class AliHLTTPCSpacePointData;
	26	class AliHLTTPCDigitReader;
	27
46b33a24	28	class AliHLTTPCClusterFinder : public AliHLTLogging {
a38a7850	29
	30	public:
	31	struct AliClusterData
	32	{
	33	UInt_t fTotalCharge; //tot charge of cluster
	34	UInt_t fPad; //pad value
	35	UInt_t fTime; //time value
	36	ULong64_t fPad2; //for error in XY direction
	37	ULong64_t fTime2; //for error in Z direction
	38	UInt_t fMean; //mean in time
	39	UInt_t fFlags; //different flags
	40	UInt_t fChargeFalling; //for deconvolution
	41	UInt_t fLastCharge; //for deconvolution
	42	UInt_t fLastMergedPad; //dont merge twice per pad
	43	};
	44	typedef struct AliClusterData AliClusterData; //!
	45
	46	private:
2a083ac4	47	AliHLTTPCSpacePointData *fSpacePointData; //! array of space points
2a083ac4	48	AliHLTTPCDigitReader *fDigitReader; //! reader instance
a38a7850	49
2a083ac4	50	UChar_t* fPtr; //! pointer to packed block
a38a7850	51	unsigned long fSize; //packed block size
	52	Bool_t fDeconvTime; //deconv in time direction
	53	Bool_t fDeconvPad; //deconv in pad direction
	54	Bool_t fStdout; //have print out in write clusters
	55	Bool_t fCalcerr; //calculate centroid sigmas
	56	Bool_t fRawSP; //store centroids in raw system
	57
	58
	59	Int_t fFirstRow; //first row
	60	Int_t fLastRow; //last row
	61	Int_t fCurrentRow; //current active row
	62	Int_t fCurrentSlice; //current slice
	63	Int_t fCurrentPatch; //current patch
	64	Int_t fMatch; //size of match
	65	UInt_t fThreshold; //threshold for clusters
84645eb0	66	/** threshold for zero suppression (applied per bin) */
84645eb0	67	Int_t fSignalThreshold;
a38a7850	68	Int_t fNClusters; //number of found clusters
	69	Int_t fMaxNClusters; //max. number of clusters
	70	Float_t fXYErr; //fixed error in XY
	71	Float_t fZErr; //fixed error in Z
5235c3e9	72
	73	Float_t fOccupancyLimit; // Occupancy Limit
	74
01f43166	75	AliHLTTPCPadArray * fPadArray; //! transient
01f43166	76
a38a7850	77
	78	#ifdef do_mc
	79	void GetTrackID(Int_t pad,Int_t time,Int_t *trackID);
	80	#endif
	81
	82	public:
46b33a24	83	/** standard constructor */
a38a7850	84	AliHLTTPCClusterFinder();
46b33a24	85	/** not a valid copy constructor, defined according to effective C++ style */
	86	AliHLTTPCClusterFinder(const AliHLTTPCClusterFinder&);
	87	/** not a valid assignment op, but defined according to effective C++ style */
	88	AliHLTTPCClusterFinder& operator=(const AliHLTTPCClusterFinder&);
	89	/** destructor */
a38a7850	90	virtual ~AliHLTTPCClusterFinder();
	91
	92	void Read(void* ptr,unsigned long size);
	93
	94	void InitSlice(Int_t slice,Int_t patch,Int_t firstrow, Int_t lastrow,Int_t maxpoints);
	95	void InitSlice(Int_t slice,Int_t patch,Int_t maxpoints);
	96	void ProcessDigits();
	97
	98	void SetOutputArray(AliHLTTPCSpacePointData *pt);
	99	void WriteClusters(Int_t n_clusters,AliClusterData *list);
	100
	101	void SetXYError(Float_t f) {fXYErr=f;}
	102	void SetZError(Float_t f) {fZErr=f;}
	103	void SetDeconv(Bool_t f) {fDeconvPad=f; fDeconvTime=f;}
	104	void SetThreshold(UInt_t i) {fThreshold=i;}
5235c3e9	105	void SetOccupancyLimit(Float_t f) {fOccupancyLimit=f;}
84645eb0	106	void SetSignalThreshold(Int_t i) {fSignalThreshold=i;}
a38a7850	107	void SetMatchWidth(UInt_t i) {fMatch=i;}
	108	void SetSTDOutput(Bool_t f=kFALSE) {fStdout=f;}
	109	void SetCalcErr(Bool_t f=kTRUE) {fCalcerr=f;}
	110	void SetRawSP(Bool_t f=kFALSE) {fRawSP=f;}
	111	void SetReader(AliHLTTPCDigitReader* f){fDigitReader = f;}
	112	Int_t GetNumberOfClusters() const {return fNClusters;}
01f43166	113
	114	//----------------------------------Methods for the new unsorted way of reading data ----------
	115	void SetPadArray(AliHLTTPCPadArray *padArray);
	116	void ReadDataUnsorted(void* ptr,unsigned long size);
	117	void FindClusters();
	118	void WriteClusters(Int_t nclusters,AliHLTTPCClusters *list);
a38a7850	119
01f43166	120	ClassDef(AliHLTTPCClusterFinder,1) //Fast cluster finder
a38a7850	121	};
a38a7850	122	#endif