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

#ifndef ALIITSCLUSTERFINDERSDD_H
#define ALIITSCLUSTERFINDERSDD_H

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


#include "AliITSClusterFinder.h"

class AliITSMapA2;
class TFile;

class AliITSClusterFinderSDD :
 public AliITSClusterFinder

{
public:
  AliITSClusterFinderSDD
  (AliITSsegmentation *seg, 
   AliITSresponse *response, TClonesArray *digits,TClonesArray *recpoints);
  AliITSClusterFinderSDD();
  virtual ~AliITSClusterFinderSDD();
  AliITSClusterFinderSDD(const AliITSClusterFinderSDD &source); // copy constructor
  AliITSClusterFinderSDD& operator=(const AliITSClusterFinderSDD &source); // assignment operator
  
  virtual void SetCutAmplitude(Int_t thres=0) {
    // set cut amplitude
    fCutAmplitude=thres;
  }
  virtual Int_t CutAmplitude() {
    // get cut amplitude
    return fCutAmplitude;
  }
  virtual void SetDAnode(Float_t danode=4.2) {
    // setDAnode
    fDAnode=danode;
  }
  virtual Float_t DAnode() {
    // get DAnode
    return fDAnode;
  }
  virtual void SetDTime(Float_t dtime=75) {
    // SetDTime
    fDTime=dtime;
  }
  virtual Float_t DTime() {
    // get DTime
    return fDTime;
  }
  virtual void SetMinPeak(Int_t minpeak=10) {
    // SetMinPeak
    fMinPeak=minpeak;
  }
  virtual Int_t MinPeak() {
    // get MinPeak
    return fMinPeak;
  }
  virtual void SetMinCharge(Int_t mincharge=30) {
    // SetMinCharge
    fMinCharge=mincharge;
  }
  virtual Int_t MinCharge() {
    // get MinCharge
    return fMinCharge;
  }
  virtual void SetMinNCells(Int_t minc=3) {
    // setNCells
    fMinNCells=minc;
  }
  virtual Int_t MinNCells() {
    // get MinNCells
    return fMinNCells;
  }
   virtual void SetMaxNCells(Int_t maxc=10) {
    // setNCells
    fMaxNCells=maxc;
  }
  virtual Int_t MaxNCells() {
    // get MaxNCells
    return fMaxNCells;
  }
   virtual void SetTimeCorr(Float_t timec=23.) {
    // setNCells
    fTimeCorr=timec;
  }
  virtual Float_t TimeCorr() {
    // get Time Correction (ns)
    return fTimeCorr;
  }
  
  // Search for clusters
  virtual void FindRawClusters();
  void  Find1DClusters();
  void  Find1DClustersE();
  void  GroupClusters();
  void  SelectClusters();
  void  GetRecPoints();
  void ResolveClusters(); // Boris........ 
  void ResolveClustersE(); // Ernesto 
  Int_t SearchPeak( Float_t *spect, Int_t xdim, Int_t zdim, Int_t *peakX, Int_t
                    *peakZ, Float_t *peakAmp, Float_t minpeak ); // Ernesto
  Int_t noLinearFit( Int_t xdim, Int_t zdim, Float_t *param, Float_t *spe, Int_t
                     *niter, Float_t *chir );
  void minim( Int_t xdim, Int_t zdim, Float_t *param, Float_t *prm0, Float_t *steprm, Float_t *chisqr, 
		      Float_t *spe, Float_t *speFit );
  Float_t chisq( Int_t xdim, Int_t zdim, Float_t *spe, Float_t *speFit );
  void PeakFunc( Int_t xdim, Int_t zdim, Float_t *par, Float_t *spe, Float_t
                 *Integral=0 ); 

  virtual void Print();

private:
  
  TClonesArray       *fClusters;      // clusters
  Int_t               fNclusters;     // num of clusters
  Float_t             fDAnode;        // fDanode
  Float_t             fDTime;         // fDtime
  Float_t             fTimeCorr;      // Correction factor along time coord
  
  Int_t               fCutAmplitude;  // cut amplitude
  Int_t               fMinPeak;       // min peak
  Int_t               fMinCharge;     // min charge
  Int_t               fMinNCells;     // min num of cells
  Int_t               fMaxNCells;     // max num of cells
  ClassDef(AliITSClusterFinderSDD,1) // SDD clustering - Piergiorgio C. algo
    };
#endif
Commit	Line	Data
b0f5e3fc	1	#ifndef ALIITSCLUSTERFINDERSDD_H
	2	#define ALIITSCLUSTERFINDERSDD_H
	3
	4	////////////////////////////////////////////////
	5	// ITS Cluster Finder Class //
	6	////////////////////////////////////////////////
	7
78a228db	8
b0f5e3fc	9	#include "AliITSClusterFinder.h"
b0f5e3fc	10
e8189707	11	class AliITSMapA2;
78a228db	12	class TFile;
e8189707	13
b0f5e3fc	14	class AliITSClusterFinderSDD :
	15	public AliITSClusterFinder
	16
	17	{
	18	public:
	19	AliITSClusterFinderSDD
	20	(AliITSsegmentation *seg,
	21	AliITSresponse response, TClonesArray digits,TClonesArray *recpoints);
	22	AliITSClusterFinderSDD();
e8189707	23	virtual ~AliITSClusterFinderSDD();
b0f5e3fc	24	AliITSClusterFinderSDD(const AliITSClusterFinderSDD &source); // copy constructor
	25	AliITSClusterFinderSDD& operator=(const AliITSClusterFinderSDD &source); // assignment operator
	26
78a228db	27	virtual void SetCutAmplitude(Int_t thres=0) {
b0f5e3fc	28	// set cut amplitude
	29	fCutAmplitude=thres;
	30	}
a1f090e0	31	virtual Int_t CutAmplitude() {
	32	// get cut amplitude
	33	return fCutAmplitude;
	34	}
b0f5e3fc	35	virtual void SetDAnode(Float_t danode=4.2) {
	36	// setDAnode
	37	fDAnode=danode;
	38	}
a1f090e0	39	virtual Float_t DAnode() {
	40	// get DAnode
	41	return fDAnode;
	42	}
b0f5e3fc	43	virtual void SetDTime(Float_t dtime=75) {
	44	// SetDTime
	45	fDTime=dtime;
	46	}
a1f090e0	47	virtual Float_t DTime() {
	48	// get DTime
	49	return fDTime;
	50	}
	51	virtual void SetMinPeak(Int_t minpeak=10) {
b0f5e3fc	52	// SetMinPeak
	53	fMinPeak=minpeak;
	54	}
a1f090e0	55	virtual Int_t MinPeak() {
	56	// get MinPeak
	57	return fMinPeak;
	58	}
	59	virtual void SetMinCharge(Int_t mincharge=30) {
	60	// SetMinCharge
	61	fMinCharge=mincharge;
	62	}
	63	virtual Int_t MinCharge() {
	64	// get MinCharge
	65	return fMinCharge;
	66	}
	67	virtual void SetMinNCells(Int_t minc=3) {
b0f5e3fc	68	// setNCells
b0f5e3fc	69	fMinNCells=minc;
a1f090e0	70	}
	71	virtual Int_t MinNCells() {
	72	// get MinNCells
	73	return fMinNCells;
b0f5e3fc	74	}
78a228db	75	virtual void SetMaxNCells(Int_t maxc=10) {
	76	// setNCells
	77	fMaxNCells=maxc;
	78	}
a1f090e0	79	virtual Int_t MaxNCells() {
	80	// get MaxNCells
	81	return fMaxNCells;
	82	}
	83	virtual void SetTimeCorr(Float_t timec=23.) {
78a228db	84	// setNCells
	85	fTimeCorr=timec;
	86	}
a1f090e0	87	virtual Float_t TimeCorr() {
	88	// get Time Correction (ns)
	89	return fTimeCorr;
	90	}
b0f5e3fc	91
b0f5e3fc	92	// Search for clusters
	93	virtual void FindRawClusters();
	94	void Find1DClusters();
a1f090e0	95	void Find1DClustersE();
b0f5e3fc	96	void GroupClusters();
	97	void SelectClusters();
	98	void GetRecPoints();
a1f090e0	99	void ResolveClusters(); // Boris........
	100	void ResolveClustersE(); // Ernesto
	101	Int_t SearchPeak( Float_t spect, Int_t xdim, Int_t zdim, Int_t peakX, Int_t
	102	peakZ, Float_t peakAmp, Float_t minpeak ); // Ernesto
	103	Int_t noLinearFit( Int_t xdim, Int_t zdim, Float_t param, Float_t spe, Int_t
	104	niter, Float_t chir );
	105	void minim( Int_t xdim, Int_t zdim, Float_t param, Float_t prm0, Float_t steprm, Float_t chisqr,
	106	Float_t spe, Float_t speFit );
	107	Float_t chisq( Int_t xdim, Int_t zdim, Float_t spe, Float_t speFit );
	108	void PeakFunc( Int_t xdim, Int_t zdim, Float_t par, Float_t spe, Float_t
	109	*Integral=0 );
	110
	111	virtual void Print();
	112
b0f5e3fc	113	private:
	114
	115	TClonesArray *fClusters; // clusters
	116	Int_t fNclusters; // num of clusters
b0f5e3fc	117	Float_t fDAnode; // fDanode
b0f5e3fc	118	Float_t fDTime; // fDtime
78a228db	119	Float_t fTimeCorr; // Correction factor along time coord
b0f5e3fc	120
78a228db	121	Int_t fCutAmplitude; // cut amplitude
b0f5e3fc	122	Int_t fMinPeak; // min peak
a1f090e0	123	Int_t fMinCharge; // min charge
b0f5e3fc	124	Int_t fMinNCells; // min num of cells
78a228db	125	Int_t fMaxNCells; // max num of cells
b0f5e3fc	126	ClassDef(AliITSClusterFinderSDD,1) // SDD clustering - Piergiorgio C. algo
	127	};
	128	#endif
	129
	130
	131
	132
	133
	134
	135