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

// $Id$

#ifndef AliHLTTPC_KRYPTONCLUSTERFINDER
#define AliHLTTPC_KRYPTONCLUSTERFINDER
/* 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   AliHLTTPCKryptonClusterFinder.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 "AliHLTTPCPad.h"
class AliHLTTPCSpacePointData;
class AliHLTTPCDigitReader;

class AliHLTTPCKryptonClusterFinder : 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
    Int_t fRow;             //row value
  };
  typedef struct AliClusterData AliClusterData; //!

  /** standard constructor */
  AliHLTTPCKryptonClusterFinder();
  /** destructor */
  virtual ~AliHLTTPCKryptonClusterFinder();

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

  void SetReader(AliHLTTPCDigitReader* f){fDigitReader = f;}

  void PrintClusters();

  Int_t GetNumberOfClusters() const {return fNClusters;}

  void ReBunch(const UInt_t * bunchData,Int_t bunchSize);
  void ReadDataUnsorted(void* ptr,unsigned long size);
  void FindNormalClusters();
  void FindKryptonClusters();
  void CheckForCandidateOnPreviousPad(AliHLTTPCClusters* tmpCluster);
  void SetPatch(Int_t patch){fCurrentPatch=patch;}
  void InitializePadArray();
  Int_t DeInitializePadArray();
  Bool_t ComparePads(AliHLTTPCPad *nextPad,AliHLTTPCClusters* candidate,Int_t nextPadToRead);
 private: 
  /** copy constructor prohibited */
  AliHLTTPCKryptonClusterFinder(const AliHLTTPCKryptonClusterFinder&);
  /** assignment operator prohibited */
  AliHLTTPCKryptonClusterFinder& operator=(const AliHLTTPCKryptonClusterFinder&);

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

  UChar_t* fPtr;   //! pointer to packed block
  unsigned long fSize; //packed block size

  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 on total charge for krypton cluster

  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
  
  Bool_t fVectorInitialized;

  typedef vector<AliHLTTPCPad*> AliHLTTPCPadVector;

  vector<AliHLTTPCPadVector> fRowPadVector;                        //! transient

  vector<AliHLTTPCClusters> fClusters;                             //! transient
  
  vector<Int_t> fTimebinsInBunch;                                  //! transient

  vector<Int_t> fIndexOfBunchStart;                                //! transient

  UInt_t* fNumberOfPadsInRow;                                      //! transient
  
  UInt_t fNumberOfRows;                                            //! transient
  
  UInt_t fRowOfFirstCandidate;

  ClassDef(AliHLTTPCKryptonClusterFinder,0) //Fast cluster finder
};
#endif
Commit	Line	Data
187229ab	1	// $Id$
	2
	3	#ifndef AliHLTTPC_KRYPTONCLUSTERFINDER
	4	#define AliHLTTPC_KRYPTONCLUSTERFINDER
	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 AliHLTTPCKryptonClusterFinder.h
	10	@author Anders Vestbo, Constantin Loizides, Jochen Thaeder
	11	Kenneth Aamodt kenneth.aamodt@student.uib.no
	12	@date
	13	@brief Cluster Finder for the TPC
	14	*/
	15
	16	// see below for class documentation
	17	// or
	18	// refer to README to build package
	19	// or
	20	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	21
	22
	23	#include "AliHLTLogging.h"
	24	#include "AliHLTTPCPad.h"
	25	class AliHLTTPCSpacePointData;
	26	class AliHLTTPCDigitReader;
	27
	28	class AliHLTTPCKryptonClusterFinder : public AliHLTLogging {
	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	Int_t fRow; //row value
	44	};
	45	typedef struct AliClusterData AliClusterData; //!
	46
	47	/** standard constructor */
	48	AliHLTTPCKryptonClusterFinder();
	49	/** destructor */
	50	virtual ~AliHLTTPCKryptonClusterFinder();
	51
	52	void InitSlice(Int_t slice,Int_t patch,Int_t firstrow, Int_t lastrow,Int_t maxpoints);
	53
	54	void SetReader(AliHLTTPCDigitReader* f){fDigitReader = f;}
	55
	56	void PrintClusters();
	57
	58	Int_t GetNumberOfClusters() const {return fNClusters;}
	59
	60	void ReBunch(const UInt_t * bunchData,Int_t bunchSize);
	61	void ReadDataUnsorted(void* ptr,unsigned long size);
	62	void FindNormalClusters();
	63	void FindKryptonClusters();
	64	void CheckForCandidateOnPreviousPad(AliHLTTPCClusters* tmpCluster);
65	void SetPatch(Int_t patch){fCurrentPatch=patch;}
66	void InitializePadArray();
67	Int_t DeInitializePadArray();
68	Bool_t ComparePads(AliHLTTPCPad nextPad,AliHLTTPCClusters candidate,Int_t nextPadToRead);
69	private:
70	/** copy constructor prohibited */
71	AliHLTTPCKryptonClusterFinder(const AliHLTTPCKryptonClusterFinder&);
72	/** assignment operator prohibited */
73	AliHLTTPCKryptonClusterFinder& operator=(const AliHLTTPCKryptonClusterFinder&);
74
75	AliHLTTPCSpacePointData *fSpacePointData; //! array of space points
76	AliHLTTPCDigitReader *fDigitReader; //! reader instance
77
78	UChar_t* fPtr; //! pointer to packed block
79	unsigned long fSize; //packed block size
80
81	Int_t fFirstRow; //first row
82	Int_t fLastRow; //last row
83	Int_t fCurrentRow; //current active row
84	Int_t fCurrentSlice; //current slice
85	Int_t fCurrentPatch; //current patch
86	Int_t fMatch; //size of match
87	UInt_t fThreshold; //Threshold on total charge for krypton cluster
88
89	Int_t fNClusters; //number of found clusters
90	Int_t fMaxNClusters; //max. number of clusters
91	Float_t fXYErr; //fixed error in XY
92	Float_t fZErr; //fixed error in Z
93
94	Bool_t fVectorInitialized;
95
96	typedef vector<AliHLTTPCPad*> AliHLTTPCPadVector;
97
98	vector<AliHLTTPCPadVector> fRowPadVector; //! transient
99
100	vector<AliHLTTPCClusters> fClusters; //! transient
101
102	vector<Int_t> fTimebinsInBunch; //! transient
103
104	vector<Int_t> fIndexOfBunchStart; //! transient
105
106	UInt_t* fNumberOfPadsInRow; //! transient
107
108	UInt_t fNumberOfRows; //! transient
109
110	UInt_t fRowOfFirstCandidate;
111
112	ClassDef(AliHLTTPCKryptonClusterFinder,0) //Fast cluster finder
113	};
114	#endif