[u/mrichter/AliRoot.git] / ITS / AliITSClusterFinder.h

#ifndef ALIITSCLUSTERFINDER_H
#define ALIITSCLUSTERFINDER_H


////////////////////////////////////////////////
//  ITS Cluster Finder Class                 //
////////////////////////////////////////////////

#include "AliITSMap.h"

//---------------------------------------------------------------
class AliITSClusterFinder :public TObject
{
public:
  TClonesArray           *fDigits;      // digits
  Int_t                   fNdigits;     // num of digits
  
  AliITSClusterFinder(AliITSsegmentation *seg, AliITSresponse *resp, TClonesArray *digits);
  AliITSClusterFinder();
  virtual ~AliITSClusterFinder(){
    // destructor
  }
  AliITSClusterFinder(const AliITSClusterFinder &source); // copy constructor
  AliITSClusterFinder& operator=(const AliITSClusterFinder &source); // assignment operator

  virtual void SetResponse(AliITSresponse *response) {
    // set response
    fResponse=response;
  }
  virtual void SetSegmentation(AliITSsegmentation *segmentation) {
    // set segmentation
    fSegmentation=segmentation;
  }
  
  virtual void SetDigits(TClonesArray *ITSdigits) {
    // set digits
    fDigits=ITSdigits;
    fNdigits = fDigits->GetEntriesFast();
  }
  virtual Int_t   NDigits() {
    // Get Number of Digits
    return fNdigits;
  }
  
  virtual void SetMap() {
    // set map
  }
  AliITSMap   *Map()  {
    // map
    return fMap;
  }
  //
  virtual void AddCluster(Int_t branch, AliITSRawCluster *c);
  
  virtual void FindRawClusters() {
    // Search for raw clusters
  }
  virtual void FindCluster(Int_t i, Int_t j, AliITSRawCluster *c) {
    // find cluster
  }
  
  virtual void Decluster(AliITSRawCluster *cluster) {
    // Decluster
  }
  virtual void SetNperMax(Int_t npermax=3) {
    // Set max. Number of cells per local cluster
    fNperMax = npermax;
  }
  virtual void SetDeclusterFlag(Int_t flag=1) {
    // Decluster ?
    fDeclusterFlag =flag;
  }
  virtual void SetClusterSize(Int_t clsize=3) {
    // Set max. cluster size ; bigger clusters will be rejected
    fClusterSize = clsize;
  }
  virtual void CalibrateCOG() {
    // Self Calibration of COG 
  }
  virtual void CorrectCOG(){
    // correct COG
  }
  
  virtual Bool_t Centered(AliITSRawCluster *cluster) {
    // cluster
    return kTRUE;
  }
  virtual void   SplitByLocalMaxima(AliITSRawCluster *cluster) {
    // split by local maxima
  }
  virtual void   FillCluster(AliITSRawCluster *cluster, Int_t) {
    // fiil cluster
  }
  virtual void   FillCluster(AliITSRawCluster *cluster) {
    // fill cluster
    FillCluster(cluster,1);
  }
  
  // set the fitting methods in the derived classes 
  
protected:
  AliITSresponse         *fResponse;      // response
  AliITSsegmentation     *fSegmentation;  //segmentation
  
  Int_t                   fNRawClusters;  // in case we split the cluster
                                          // and want to keep track of 
                                          // the cluster which was splitted
  AliITSMap              *fMap;           // map
  
  Int_t                   fNperMax;       // NperMax
  Int_t                   fDeclusterFlag; // DeclusterFlag
  Int_t                   fClusterSize;   // ClusterSize
  Int_t                   fNPeaks;        // NPeaks
  
  
  ClassDef(AliITSClusterFinder,1) //Class for clustering and reconstruction of space points
    };
#endif
Commit	Line	Data
b0f5e3fc	1	#ifndef ALIITSCLUSTERFINDER_H
	2	#define ALIITSCLUSTERFINDER_H
	3
	4
	5	////////////////////////////////////////////////
	6	// ITS Cluster Finder Class //
	7	////////////////////////////////////////////////
	8
	9	#include "AliITSMap.h"
	10
	11	//---------------------------------------------------------------
	12	class AliITSClusterFinder :public TObject
	13	{
	14	public:
	15	TClonesArray *fDigits; // digits
	16	Int_t fNdigits; // num of digits
	17
	18	AliITSClusterFinder(AliITSsegmentation seg, AliITSresponse resp, TClonesArray *digits);
	19	AliITSClusterFinder();
	20	virtual ~AliITSClusterFinder(){
	21	// destructor
	22	}
	23	AliITSClusterFinder(const AliITSClusterFinder &source); // copy constructor
	24	AliITSClusterFinder& operator=(const AliITSClusterFinder &source); // assignment operator
	25
	26	virtual void SetResponse(AliITSresponse *response) {
	27	// set response
	28	fResponse=response;
	29	}
	30	virtual void SetSegmentation(AliITSsegmentation *segmentation) {
	31	// set segmentation
	32	fSegmentation=segmentation;
	33	}
	34
	35	virtual void SetDigits(TClonesArray *ITSdigits) {
	36	// set digits
	37	fDigits=ITSdigits;
	38	fNdigits = fDigits->GetEntriesFast();
	39	}
	40	virtual Int_t NDigits() {
	41	// Get Number of Digits
	42	return fNdigits;
	43	}
	44
	45	virtual void SetMap() {
	46	// set map
	47	}
	48	AliITSMap *Map() {
	49	// map
	50	return fMap;
	51	}
	52	//
	53	virtual void AddCluster(Int_t branch, AliITSRawCluster *c);
	54
	55	virtual void FindRawClusters() {
	56	// Search for raw clusters
	57	}
	58	virtual void FindCluster(Int_t i, Int_t j, AliITSRawCluster *c) {
	59	// find cluster
	60	}
	61
	62	virtual void Decluster(AliITSRawCluster *cluster) {
	63	// Decluster
	64	}
65	virtual void SetNperMax(Int_t npermax=3) {
66	// Set max. Number of cells per local cluster
67	fNperMax = npermax;
68	}
69	virtual void SetDeclusterFlag(Int_t flag=1) {
70	// Decluster ?
71	fDeclusterFlag =flag;
72	}
73	virtual void SetClusterSize(Int_t clsize=3) {
74	// Set max. cluster size ; bigger clusters will be rejected
75	fClusterSize = clsize;
76	}
77	virtual void CalibrateCOG() {
78	// Self Calibration of COG
79	}
80	virtual void CorrectCOG(){
81	// correct COG
82	}
83
84	virtual Bool_t Centered(AliITSRawCluster *cluster) {
85	// cluster
86	return kTRUE;
87	}
88	virtual void SplitByLocalMaxima(AliITSRawCluster *cluster) {
89	// split by local maxima
90	}
91	virtual void FillCluster(AliITSRawCluster *cluster, Int_t) {
92	// fiil cluster
93	}
94	virtual void FillCluster(AliITSRawCluster *cluster) {
95	// fill cluster
96	FillCluster(cluster,1);
97	}
98
99	// set the fitting methods in the derived classes
100
101	protected:
102	AliITSresponse *fResponse; // response
103	AliITSsegmentation *fSegmentation; //segmentation
104
105	Int_t fNRawClusters; // in case we split the cluster
106	// and want to keep track of
107	// the cluster which was splitted
108	AliITSMap *fMap; // map
109
110	Int_t fNperMax; // NperMax
111	Int_t fDeclusterFlag; // DeclusterFlag
112	Int_t fClusterSize; // ClusterSize
113	Int_t fNPeaks; // NPeaks
114
115
116	ClassDef(AliITSClusterFinder,1) //Class for clustering and reconstruction of space points
117	};
118	#endif
119
120
121
122
123
124
125