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

#ifndef ALIITSRAWCLUSTER_H
#define ALIITSRAWCLUSTER_H

////////////////////////////////////////////////////
//  Cluster classes for set:ITS                   //
////////////////////////////////////////////////////

#include <TObject.h>
// this class is subject to changes !!! - info used for declustering
// and  eventual debugging

class AliITSRawCluster : public TObject {  
 public:
    AliITSRawCluster() { // default constructor
	fMultiplicity=0;}
    virtual ~AliITSRawCluster() {// destructor
    }
    virtual Bool_t IsSortable() const {// is sortable
	return kTRUE;}
 public:
    Int_t       fMultiplicity;        // cluster multiplicity
  
    ClassDef(AliITSRawCluster,1)  // AliITSRawCluster class
};
//----------------------------------------------------------------------
// these classes are subject to changes - keep them temporarily for
// compatibility !!!
class AliITSRawClusterSPD : public AliITSRawCluster {
 public:
    AliITSRawClusterSPD() {// constructor
	fX=fZ=fQ=0.0;
	fZStart=fZStop=0.0;
	fNClZ=fNClX=fXStart=fXStop=fZend=fNTracks=0;
	fTracks[0]=fTracks[1]=fTracks[2]=-3,fModule=0;
    }
    AliITSRawClusterSPD(Float_t clz,Float_t clx,Float_t Charge,
			Int_t ClusterSizeZ,Int_t ClusterSizeX,
			Int_t xstart,Int_t xstop,Float_t zstart,
			Float_t zstop,Int_t zend,Int_t module);
    virtual ~AliITSRawClusterSPD() {// destructor
    }
    void Add(AliITSRawClusterSPD* clJ); 
    Bool_t Brother(AliITSRawClusterSPD* cluster,Float_t dz,Float_t dx);
    void PrintInfo();
    // Getters
    Float_t Q() const {// Q
	return fQ ;}
    Float_t Z() const {// Z
	return fZ ;}
    Float_t X() const {// X
	return fX ;}
    Int_t NclZ() const {// NclZ
	return fNClZ ;}
    Int_t NclX() const {// NclX
	return fNClX ;}
    Int_t   XStart() const {//XStart
	return fXStart;}
    Int_t   XStop() const {//XStop
	return fXStop;}
    Int_t   XStartf() const {//XStartf
	return fXStart;}
    Int_t   XStopf() const {//XStopf
	return fXStop;}
    Float_t ZStart() const {//ZStart
	return fZStart;}
    Float_t ZStop() const {//ZStop
	return fZStop;}
    Int_t   Zend() const {//Zend
	return fZend;}
    Int_t   NTracks() const {//NTracks
	return fNTracks;}
    Int_t Module() const {//Returns module where this cluster came from
	return fModule;}
    void GetTracks(Int_t &track0,Int_t &track1,Int_t &track2) const {
	// returns tracks created a cluster
	track0=fTracks[0];
	track1=fTracks[1];
	track2=fTracks[2];
	return;
  };
    void   SetTracks(Int_t track0, Int_t track1, Int_t track2) {
	// set tracks in cluster (not more than three ones)
	fTracks[0]=track0;
	fTracks[1]=track1;
	fTracks[2]=track2;
    }
    void   SetNTracks(Int_t ntracks) {
	// set ntracks
	fNTracks=ntracks;
    }
 protected:
    Float_t   fX;           // X of cluster
    Float_t   fZ;           // Z of cluster
    Float_t   fQ;           // Q of cluster
    Int_t     fNClZ;        // Cluster size in Z direction
    Int_t     fNClX;        // Cluster size in X direction
    Int_t     fXStart;      // number of first pixel in cluster
    Int_t     fXStop;       // number of last pixel in cluster
    Float_t   fZStart;      // number of first pixel in cluster
    Float_t   fZStop;       // number of last pixel in cluster
    Int_t     fZend;        // Zend
    Int_t     fNTracks;     // number of tracks created a cluster
    Int_t     fTracks[3];   // tracks created a cluster
    Int_t     fModule;      // Module number for this culuster
  
  ClassDef(AliITSRawClusterSPD,2)  // AliITSRawCluster class for SPD
};
//----------------------------------------------------------------------
class AliITSRawClusterSDD : public AliITSRawCluster {
 public:
    AliITSRawClusterSDD() {
	// constructor
	fX=fZ=fQ=0;
	fWing=0;
	fNanodes=1;
	fAnode=fTime=fPeakAmplitude=0;
	fPeakPosition=-1;
	fMultiplicity=0;
	fTstart=fTstop=fTstartf=fTstopf=0;
	fAstart=fAstop=0;
  }
    AliITSRawClusterSDD(Int_t wing,Float_t Anode,Float_t Time,Float_t Charge, 
			Float_t PeakAmplitude,Int_t PeakPosition,
			Float_t Asigma,Float_t Tsigma,Float_t DriftPath,
			Float_t AnodeOffset,  Int_t Samples, 
			Int_t Tstart, Int_t Tstop,Int_t Tstartf,Int_t Tstopf,
			Int_t Anodes, Int_t Astart, Int_t Astop);
    AliITSRawClusterSDD( const AliITSRawClusterSDD & source);
    virtual ~AliITSRawClusterSDD() {// destructor
    }
    void Add(AliITSRawClusterSDD* clJ); 
    Bool_t Brother(AliITSRawClusterSDD* cluster,Float_t dz,Float_t dx);
    void PrintInfo();
    // Setters
    void SetX(Float_t x) {fX=x;}
    void SetZ(Float_t z) {fZ=z;}
    void SetQ(Float_t q) {fQ=q;}
    void SetAnode(Float_t anode) {fAnode=anode;}
    void SetTime(Float_t time) {fTime=time;}
    void SetAsigma(Float_t asigma) {fAsigma=asigma;}
    void SetTsigma(Float_t tsigma) {fTsigma=tsigma;}
    void SetWing(Int_t wing) {fWing=wing;}
    void SetNanodes(Int_t na) {fNanodes=na;}
    void SetNsamples(Int_t ns) {fMultiplicity=ns;}
    void SetPeakAmpl(Float_t ampl) {fPeakAmplitude=ampl;}
    void SetPeakPos(Int_t pos) {fPeakPosition=pos;}
    // Getters
    Float_t X() const {//X
	return fX ;}
    Float_t Z() const {//Z
	return fZ ;}
    Float_t Q() const {//Q
	return fQ ;}
    Float_t A() const {//A
	return fAnode ;}
    Float_t T() const {//T
	return fTime ;}
    Float_t Asigma() const {//Asigma
	return fAsigma ;}
    Float_t Tsigma() const {//Tsigma
	return fTsigma ;}
    Float_t W() const {//W
	return fWing ;}
    Int_t Anodes() const {//Anodes
	return fNanodes ;}
    Int_t Samples() const {//Samples
	return fMultiplicity;}
    Float_t PeakAmpl() const {//PeakAmpl
	return fPeakAmplitude ;}
    Float_t SumAmpl() const {//PeakAmpl
	return fSumAmplitude ;}
    Int_t PeakPos() {return fPeakPosition;}
    Int_t Tstart() const {//Tstart
	return fTstart ;}
    Int_t Tstartf() const {//Tstartf
	return fTstartf ;}
    Int_t Tstop() const {//Tstop
	return fTstop;}
    Int_t Tstopf() const {//Tstopf
	return fTstopf ;}
    Int_t Astart() const {//Astart
	return fAstart ;}
    Int_t Astop() const {//Astop
	return fAstop ;}
 public:
    Float_t   fX;                 // X of cluster
    Float_t   fZ;                 // Z of cluster
    Float_t   fQ;                 // Q of cluster
    Int_t     fWing;              // Wing number
    Float_t   fAnode;             // Anode number
    Float_t   fTime;              // Drift Time
    Float_t   fAsigma;            //
    Float_t   fTsigma;            //
    Float_t   fPeakAmplitude;     // Peak Amplitude
    Float_t   fSumAmplitude;      // Total Amplitude (for weighting)  
    Int_t     fPeakPosition;      // index of digit corresponding to peak
    Int_t     fNanodes;           // N of anodes used for the cluster
    Int_t     fTstart;            // First sample in 1D cluster   
    Int_t     fTstop;             // Last sample in 1D cluster 
    Int_t     fTstartf;           // First sample in the full 2D cluster
    Int_t     fTstopf;            // Last sample in the full 2D cluster  
    Int_t     fAstart;            // First anode in the 2D cluster
    Int_t     fAstop;             // last anode in the 2D cluster
  
    ClassDef(AliITSRawClusterSDD,1)  // AliITSRawCluster class for SDD
};
//----------------------------------------------------------------------
class AliITSRawClusterSSD : public AliITSRawCluster {
 public:
    AliITSRawClusterSSD() {
	fMultiplicityN=0;
	fQErr=0; 
	fSignalP=0;
	fSignalN=0;
	fStatus=-1;
	fNtracks=0;
    }
    AliITSRawClusterSSD(Float_t Prob,Int_t Sp,Int_t Sn);
    virtual ~AliITSRawClusterSSD() {// destructor
    }
    Int_t  GetStatus() const {// get status
	return fStatus;}
    void   SetStatus(Int_t status) {// set status
	fStatus=status;}
 public:
    Int_t   fMultiplicityN;  // The number of N side strips involved 
                             // in this point calculations
    Float_t fQErr;           // Total charge error
    Float_t fSignalP;        // Signal of P side cluster
    Float_t fSignalN;        // Signal of N side cluster
    Int_t   fStatus;         // Flag status : 0 - real point
                             //               1 - ghost 
                             //               2 - EIC ? 
                             //               3 - single side 
    Int_t fNtracks;          // Number of tracks created the cluster
    ClassDef(AliITSRawClusterSSD,1)  // AliITSRawCluster class for SSD
};
#endif
Commit	Line	Data
b0f5e3fc	1	#ifndef ALIITSRAWCLUSTER_H
9e1e0cd7	2	#define ALIITSRAWCLUSTER_H
b0f5e3fc	3
	4	////////////////////////////////////////////////////
	5	// Cluster classes for set:ITS //
	6	////////////////////////////////////////////////////
	7
	8	#include <TObject.h>
9e1e0cd7	9	// this class is subject to changes !!! - info used for declustering
	10	// and eventual debugging
	11
	12	class AliITSRawCluster : public TObject {
	13	public:
	14	AliITSRawCluster() { // default constructor
	15	fMultiplicity=0;}
	16	virtual ~AliITSRawCluster() {// destructor
	17	}
	18	virtual Bool_t IsSortable() const {// is sortable
	19	return kTRUE;}
	20	public:
	21	Int_t fMultiplicity; // cluster multiplicity
	22
	23	ClassDef(AliITSRawCluster,1) // AliITSRawCluster class
	24	};
	25	//----------------------------------------------------------------------
	26	// these classes are subject to changes - keep them temporarily for
	27	// compatibility !!!
b0f5e3fc	28	class AliITSRawClusterSPD : public AliITSRawCluster {
9e1e0cd7	29	public:
	30	AliITSRawClusterSPD() {// constructor
	31	fX=fZ=fQ=0.0;
	32	fZStart=fZStop=0.0;
	33	fNClZ=fNClX=fXStart=fXStop=fZend=fNTracks=0;
	34	fTracks[0]=fTracks[1]=fTracks[2]=-3,fModule=0;
	35	}
	36	AliITSRawClusterSPD(Float_t clz,Float_t clx,Float_t Charge,
	37	Int_t ClusterSizeZ,Int_t ClusterSizeX,
	38	Int_t xstart,Int_t xstop,Float_t zstart,
	39	Float_t zstop,Int_t zend,Int_t module);
	40	virtual ~AliITSRawClusterSPD() {// destructor
	41	}
	42	void Add(AliITSRawClusterSPD* clJ);
	43	Bool_t Brother(AliITSRawClusterSPD* cluster,Float_t dz,Float_t dx);
	44	void PrintInfo();
	45	// Getters
	46	Float_t Q() const {// Q
	47	return fQ ;}
	48	Float_t Z() const {// Z
	49	return fZ ;}
	50	Float_t X() const {// X
	51	return fX ;}
	52	Int_t NclZ() const {// NclZ
	53	return fNClZ ;}
	54	Int_t NclX() const {// NclX
	55	return fNClX ;}
	56	Int_t XStart() const {//XStart
	57	return fXStart;}
	58	Int_t XStop() const {//XStop
	59	return fXStop;}
	60	Int_t XStartf() const {//XStartf
	61	return fXStart;}
	62	Int_t XStopf() const {//XStopf
	63	return fXStop;}
	64	Float_t ZStart() const {//ZStart
	65	return fZStart;}
	66	Float_t ZStop() const {//ZStop
	67	return fZStop;}
	68	Int_t Zend() const {//Zend
	69	return fZend;}
	70	Int_t NTracks() const {//NTracks
	71	return fNTracks;}
	72	Int_t Module() const {//Returns module where this cluster came from
	73	return fModule;}
	74	void GetTracks(Int_t &track0,Int_t &track1,Int_t &track2) const {
	75	// returns tracks created a cluster
	76	track0=fTracks[0];
	77	track1=fTracks[1];
	78	track2=fTracks[2];
	79	return;
a3e16987	80	};
9e1e0cd7	81	void SetTracks(Int_t track0, Int_t track1, Int_t track2) {
	82	// set tracks in cluster (not more than three ones)
	83	fTracks[0]=track0;
	84	fTracks[1]=track1;
	85	fTracks[2]=track2;
	86	}
	87	void SetNTracks(Int_t ntracks) {
	88	// set ntracks
	89	fNTracks=ntracks;
	90	}
	91	protected:
	92	Float_t fX; // X of cluster
	93	Float_t fZ; // Z of cluster
	94	Float_t fQ; // Q of cluster
	95	Int_t fNClZ; // Cluster size in Z direction
	96	Int_t fNClX; // Cluster size in X direction
	97	Int_t fXStart; // number of first pixel in cluster
	98	Int_t fXStop; // number of last pixel in cluster
	99	Float_t fZStart; // number of first pixel in cluster
	100	Float_t fZStop; // number of last pixel in cluster
	101	Int_t fZend; // Zend
	102	Int_t fNTracks; // number of tracks created a cluster
	103	Int_t fTracks[3]; // tracks created a cluster
	104	Int_t fModule; // Module number for this culuster
b0f5e3fc	105
77867ec5	106	ClassDef(AliITSRawClusterSPD,2) // AliITSRawCluster class for SPD
9e1e0cd7	107	};
9e1e0cd7	108	//----------------------------------------------------------------------
b0f5e3fc	109	class AliITSRawClusterSDD : public AliITSRawCluster {
9e1e0cd7	110	public:
	111	AliITSRawClusterSDD() {
	112	// constructor
	113	fX=fZ=fQ=0;
	114	fWing=0;
	115	fNanodes=1;
	116	fAnode=fTime=fPeakAmplitude=0;
	117	fPeakPosition=-1;
	118	fMultiplicity=0;
	119	fTstart=fTstop=fTstartf=fTstopf=0;
	120	fAstart=fAstop=0;
	121	}
	122	AliITSRawClusterSDD(Int_t wing,Float_t Anode,Float_t Time,Float_t Charge,
	123	Float_t PeakAmplitude,Int_t PeakPosition,
	124	Float_t Asigma,Float_t Tsigma,Float_t DriftPath,
	125	Float_t AnodeOffset, Int_t Samples,
	126	Int_t Tstart, Int_t Tstop,Int_t Tstartf,Int_t Tstopf,
	127	Int_t Anodes, Int_t Astart, Int_t Astop);
	128	AliITSRawClusterSDD( const AliITSRawClusterSDD & source);
	129	virtual ~AliITSRawClusterSDD() {// destructor
	130	}
	131	void Add(AliITSRawClusterSDD* clJ);
	132	Bool_t Brother(AliITSRawClusterSDD* cluster,Float_t dz,Float_t dx);
	133	void PrintInfo();
	134	// Setters
	135	void SetX(Float_t x) {fX=x;}
	136	void SetZ(Float_t z) {fZ=z;}
	137	void SetQ(Float_t q) {fQ=q;}
	138	void SetAnode(Float_t anode) {fAnode=anode;}
	139	void SetTime(Float_t time) {fTime=time;}
	140	void SetAsigma(Float_t asigma) {fAsigma=asigma;}
	141	void SetTsigma(Float_t tsigma) {fTsigma=tsigma;}
	142	void SetWing(Int_t wing) {fWing=wing;}
	143	void SetNanodes(Int_t na) {fNanodes=na;}
	144	void SetNsamples(Int_t ns) {fMultiplicity=ns;}
	145	void SetPeakAmpl(Float_t ampl) {fPeakAmplitude=ampl;}
	146	void SetPeakPos(Int_t pos) {fPeakPosition=pos;}
	147	// Getters
	148	Float_t X() const {//X
	149	return fX ;}
	150	Float_t Z() const {//Z
	151	return fZ ;}
	152	Float_t Q() const {//Q
	153	return fQ ;}
	154	Float_t A() const {//A
	155	return fAnode ;}
	156	Float_t T() const {//T
	157	return fTime ;}
	158	Float_t Asigma() const {//Asigma
	159	return fAsigma ;}
	160	Float_t Tsigma() const {//Tsigma
	161	return fTsigma ;}
	162	Float_t W() const {//W
	163	return fWing ;}
	164	Int_t Anodes() const {//Anodes
	165	return fNanodes ;}
	166	Int_t Samples() const {//Samples
	167	return fMultiplicity;}
	168	Float_t PeakAmpl() const {//PeakAmpl
	169	return fPeakAmplitude ;}
	170	Float_t SumAmpl() const {//PeakAmpl
	171	return fSumAmplitude ;}
	172	Int_t PeakPos() {return fPeakPosition;}
	173	Int_t Tstart() const {//Tstart
174	return fTstart ;}
175	Int_t Tstartf() const {//Tstartf
176	return fTstartf ;}
177	Int_t Tstop() const {//Tstop
178	return fTstop;}
179	Int_t Tstopf() const {//Tstopf
180	return fTstopf ;}
181	Int_t Astart() const {//Astart
182	return fAstart ;}
183	Int_t Astop() const {//Astop
184	return fAstop ;}
185	public:
186	Float_t fX; // X of cluster
187	Float_t fZ; // Z of cluster
188	Float_t fQ; // Q of cluster
189	Int_t fWing; // Wing number
190	Float_t fAnode; // Anode number
191	Float_t fTime; // Drift Time
192	Float_t fAsigma; //
193	Float_t fTsigma; //
194	Float_t fPeakAmplitude; // Peak Amplitude
195	Float_t fSumAmplitude; // Total Amplitude (for weighting)
196	Int_t fPeakPosition; // index of digit corresponding to peak
197	Int_t fNanodes; // N of anodes used for the cluster
198	Int_t fTstart; // First sample in 1D cluster
199	Int_t fTstop; // Last sample in 1D cluster
200	Int_t fTstartf; // First sample in the full 2D cluster
201	Int_t fTstopf; // Last sample in the full 2D cluster
202	Int_t fAstart; // First anode in the 2D cluster
203	Int_t fAstop; // last anode in the 2D cluster
204
205	ClassDef(AliITSRawClusterSDD,1) // AliITSRawCluster class for SDD
206	};
207	//----------------------------------------------------------------------
b0f5e3fc	208	class AliITSRawClusterSSD : public AliITSRawCluster {
9e1e0cd7	209	public:
	210	AliITSRawClusterSSD() {
	211	fMultiplicityN=0;
	212	fQErr=0;
	213	fSignalP=0;
	214	fSignalN=0;
	215	fStatus=-1;
	216	fNtracks=0;
	217	}
	218	AliITSRawClusterSSD(Float_t Prob,Int_t Sp,Int_t Sn);
	219	virtual ~AliITSRawClusterSSD() {// destructor
	220	}
	221	Int_t GetStatus() const {// get status
	222	return fStatus;}
	223	void SetStatus(Int_t status) {// set status
	224	fStatus=status;}
	225	public:
	226	Int_t fMultiplicityN; // The number of N side strips involved
	227	// in this point calculations
	228	Float_t fQErr; // Total charge error
	229	Float_t fSignalP; // Signal of P side cluster
	230	Float_t fSignalN; // Signal of N side cluster
	231	Int_t fStatus; // Flag status : 0 - real point
	232	// 1 - ghost
	233	// 2 - EIC ?
	234	// 3 - single side
	235	Int_t fNtracks; // Number of tracks created the cluster
	236	ClassDef(AliITSRawClusterSSD,1) // AliITSRawCluster class for SSD
b0f5e3fc	237	};
b0f5e3fc	238	#endif