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

#ifndef ALIITSRAWCLUSTER_H
#define ALIITSRAWCLUSTER_H 


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

#include <TObject.h>


class AliITSRawCluster : public TObject {
  
  // this class is subject to changes !!! - info used for declustering 
  // and  eventual debugging
  
public:
  
  AliITSRawCluster() {
    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
    };

//---------------------------------------------
class AliITSRawClusterSPD : public AliITSRawCluster {
  
  // these classes are subject to changes - keep them temporarily for
  // compatibility !!!
  
public:
  
  AliITSRawClusterSPD() {
    // constructor
    fX=fZ=fQ=0;
    fZStart=fZStop=0;
    fNClZ=fNClX=fXStart=fXStop=fXStartf=fXStopf=fZend=fNTracks=0;
    fTracks[0]=fTracks[1]=fTracks[2]=-3;
       }
  
  AliITSRawClusterSPD(Float_t clz,Float_t clx,Float_t Charge,Int_t ClusterSizeZ,Int_t ClusterSizeX,Int_t xstart,Int_t xstop,Int_t xstartf,Int_t xstopf,Float_t zstart,Float_t zstop,Int_t zend);
  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 ;
  }
  //  Float_t NclZ() const {
  Int_t NclZ() const {
    // NclZ
    return fNClZ ;
  }
  //  Float_t NclX() const {
  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 fXStartf;
  }
  Int_t   XStopf() const {
    //XStopf
    return fXStopf;
  }
  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;
  }

  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
  Int_t     fXStartf;     // number of first pixel in full cluster
  Int_t     fXStopf;      // number of last pixel in full 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
  
  ClassDef(AliITSRawClusterSPD,1)  // AliITSRawCluster class for SPD

    };

//---------------------------------------------
class AliITSRawClusterSDD : public AliITSRawCluster {
  
public:
  
  AliITSRawClusterSDD() {
    // constructor
    fX=fZ=fQ=0;
    fWing=fNsamples=0;
    fNanodes=1;
    fAnode=fTime=fPeakAmplitude=0;
    fPeakPosition=-1;
    fMultiplicity=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);
  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 SetWing(Int_t wing) {fWing=wing;}
  void SetNanodes(Int_t na) {fNanodes=na;}
  void SetNsamples(Int_t ns) {fNsamples=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 W() const {
    //W
    return fWing ;
  }
  Int_t Anodes() const {
    //Anodes
    return fNanodes ;
  }
  Int_t Samples() const {
    //Samples
    return fNsamples ;
  }
  Float_t PeakAmpl() const {
    //PeakAmpl
    return fPeakAmplitude ;
  }
  Int_t PeakPos() {return fPeakPosition;}
  
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   fPeakAmplitude;     // Peak Amplitude
  Int_t     fPeakPosition;      // index of digit corresponding to peak
  Int_t     fNanodes;           // N of anodes used for the cluster
  Int_t     fNsamples;          // N of samples used for the cluster
  
  ClassDef(AliITSRawClusterSDD,1)  // AliITSRawCluster class for SDD
    };

//-----------------------------------------
class AliITSRawClusterSSD : public AliITSRawCluster {
    
public:
  
  AliITSRawClusterSSD() {
    fMultiplicityN=0;
    fQErr=0; 
    fStatus=-1;
    /*
      for (int k=0;k<100;k++) {
         fIndexMapN[k]=-1;
      }
      fProbability=0;
      fChi2N=-1;
    */
  }
  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
  Int_t   fStatus;         // Flag status : 0 - real point
                           //               1 - ghost 
                           //               2 - EIC ? 
                           //               3 - single side 
  
  // Float_t fProbability;    // The probability that this is a "real" point
  // Int_t  fIndexMapN[100];  // indices of digits for Nside - the corresponding
                                // info for P side is carried in the base class
  // Float_t fChi2N;
  ClassDef(AliITSRawClusterSSD,1)  // AliITSRawCluster class for SSD

};


#endif
Commit	Line	Data
b0f5e3fc	1	#ifndef ALIITSRAWCLUSTER_H
	2	#define ALIITSRAWCLUSTER_H
	3
	4
	5	////////////////////////////////////////////////////
	6	// Cluster classes for set:ITS //
	7	////////////////////////////////////////////////////
	8
	9	#include <TObject.h>
	10
	11
	12	class AliITSRawCluster : public TObject {
	13
313ba434	14	// this class is subject to changes !!! - info used for declustering
b0f5e3fc	15	// and eventual debugging
	16
	17	public:
	18
	19	AliITSRawCluster() {
e8189707	20	fMultiplicity=0;
b0f5e3fc	21	}
	22
	23	virtual ~AliITSRawCluster() {
	24	// destructor
	25	}
	26	virtual Bool_t IsSortable() const {
	27	// is sortable
	28	return kTRUE;
	29	}
	30
	31	public:
	32
e8189707	33	Int_t fMultiplicity; // cluster multiplicity
b0f5e3fc	34
	35	ClassDef(AliITSRawCluster,1) // AliITSRawCluster class
	36	};
	37
	38	//---------------------------------------------
	39	class AliITSRawClusterSPD : public AliITSRawCluster {
	40
	41	// these classes are subject to changes - keep them temporarily for
	42	// compatibility !!!
	43
	44	public:
	45
	46	AliITSRawClusterSPD() {
	47	// constructor
313ba434	48	fX=fZ=fQ=0;
	49	fZStart=fZStop=0;
	50	fNClZ=fNClX=fXStart=fXStop=fXStartf=fXStopf=fZend=fNTracks=0;
	51	fTracks[0]=fTracks[1]=fTracks[2]=-3;
b0f5e3fc	52	}
b0f5e3fc	53
a3e16987	54	AliITSRawClusterSPD(Float_t clz,Float_t clx,Float_t Charge,Int_t ClusterSizeZ,Int_t ClusterSizeX,Int_t xstart,Int_t xstop,Int_t xstartf,Int_t xstopf,Float_t zstart,Float_t zstop,Int_t zend);
b0f5e3fc	55	virtual ~AliITSRawClusterSPD() {
	56	// destructor
	57	}
	58
	59	void Add(AliITSRawClusterSPD* clJ);
	60	Bool_t Brother(AliITSRawClusterSPD* cluster,Float_t dz,Float_t dx);
e8189707	61	void PrintInfo();
b0f5e3fc	62	// Getters
	63	Float_t Q() const {
	64	// Q
	65	return fQ ;
	66	}
	67	Float_t Z() const {
	68	// Z
	69	return fZ ;
	70	}
	71	Float_t X() const {
	72	// X
	73	return fX ;
	74	}
a3e16987	75	// Float_t NclZ() const {
a3e16987	76	Int_t NclZ() const {
b0f5e3fc	77	// NclZ
	78	return fNClZ ;
	79	}
a3e16987	80	// Float_t NclX() const {
a3e16987	81	Int_t NclX() const {
b0f5e3fc	82	// NclX
	83	return fNClX ;
	84	}
	85	Int_t XStart() const {
	86	//XStart
	87	return fXStart;
	88	}
	89	Int_t XStop() const {
	90	//XStop
	91	return fXStop;
	92	}
	93	Int_t XStartf() const {
	94	//XStartf
	95	return fXStartf;
	96	}
	97	Int_t XStopf() const {
	98	//XStopf
	99	return fXStopf;
	100	}
	101	Float_t ZStart() const {
	102	//ZStart
	103	return fZStart;
	104	}
	105	Float_t ZStop() const {
	106	//ZStop
	107	return fZStop;
	108	}
	109	Int_t Zend() const {
	110	//Zend
	111	return fZend;
	112	}
a3e16987	113	Int_t NTracks() const {
	114	//NTracks
	115	return fNTracks;
	116	}
	117
	118	void GetTracks(Int_t &track0,Int_t &track1,Int_t &track2) const {
	119	// returns tracks created a cluster
	120
	121	track0=fTracks[0];
	122	track1=fTracks[1];
	123	track2=fTracks[2];
	124	return;
	125	};
	126
	127	void SetTracks(Int_t track0, Int_t track1, Int_t track2) {
	128	// set tracks in cluster (not more than three ones)
	129	fTracks[0]=track0;
	130	fTracks[1]=track1;
	131	fTracks[2]=track2;
	132	}
	133	void SetNTracks(Int_t ntracks) {
	134	// set ntracks
	135	fNTracks=ntracks;
	136	}
b0f5e3fc	137
	138	protected:
	139
	140	Float_t fX; // X of cluster
	141	Float_t fZ; // Z of cluster
	142	Float_t fQ; // Q of cluster
	143	Int_t fNClZ; // Cluster size in Z direction
	144	Int_t fNClX; // Cluster size in X direction
	145	Int_t fXStart; // number of first pixel in cluster
	146	Int_t fXStop; // number of last pixel in cluster
	147	Int_t fXStartf; // number of first pixel in full cluster
	148	Int_t fXStopf; // number of last pixel in full cluster
	149	Float_t fZStart; // number of first pixel in cluster
	150	Float_t fZStop; // number of last pixel in cluster
	151	Int_t fZend; // Zend
a3e16987	152	Int_t fNTracks; // number of tracks created a cluster
a3e16987	153	Int_t fTracks[3]; // tracks created a cluster
b0f5e3fc	154
	155	ClassDef(AliITSRawClusterSPD,1) // AliITSRawCluster class for SPD
	156
	157	};
	158
	159	//---------------------------------------------
	160	class AliITSRawClusterSDD : public AliITSRawCluster {
	161
	162	public:
	163
	164	AliITSRawClusterSDD() {
	165	// constructor
313ba434	166	fX=fZ=fQ=0;
b0f5e3fc	167	fWing=fNsamples=0;
	168	fNanodes=1;
	169	fAnode=fTime=fPeakAmplitude=0;
313ba434	170	fPeakPosition=-1;
313ba434	171	fMultiplicity=0;
b0f5e3fc	172	}
	173
	174	AliITSRawClusterSDD(Int_t wing, Float_t Anode,Float_t Time,Float_t Charge,
313ba434	175	Float_t PeakAmplitude,Int_t PeakPosition,Float_t Asigma, Float_t Tsigma,Float_t DriftPath, Float_t AnodeOffset,Int_t Samples);
b0f5e3fc	176	virtual ~AliITSRawClusterSDD() {
	177	// destructor
	178	}
	179
	180	void Add(AliITSRawClusterSDD* clJ);
	181	Bool_t Brother(AliITSRawClusterSDD* cluster,Float_t dz,Float_t dx);
e8189707	182	void PrintInfo();
313ba434	183	// Setters
	184	void SetX(Float_t x) {fX=x;}
	185	void SetZ(Float_t z) {fZ=z;}
	186	void SetQ(Float_t q) {fQ=q;}
	187	void SetAnode(Float_t anode) {fAnode=anode;}
	188	void SetTime(Float_t time) {fTime=time;}
	189	void SetWing(Int_t wing) {fWing=wing;}
	190	void SetNanodes(Int_t na) {fNanodes=na;}
	191	void SetNsamples(Int_t ns) {fNsamples=ns;}
	192	void SetPeakAmpl(Float_t ampl) {fPeakAmplitude=ampl;}
	193	void SetPeakPos(Int_t pos) {fPeakPosition=pos;}
b0f5e3fc	194	// Getters
	195	Float_t X() const {
	196	//X
	197	return fX ;
	198	}
	199	Float_t Z() const {
	200	//Z
	201	return fZ ;
	202	}
	203	Float_t Q() const {
	204	//Q
	205	return fQ ;
	206	}
	207	Float_t A() const {
	208	//A
	209	return fAnode ;
	210	}
	211	Float_t T() const {
	212	//T
	213	return fTime ;
	214	}
	215	Float_t W() const {
	216	//W
	217	return fWing ;
	218	}
	219	Int_t Anodes() const {
	220	//Anodes
	221	return fNanodes ;
	222	}
	223	Int_t Samples() const {
	224	//Samples
	225	return fNsamples ;
	226	}
	227	Float_t PeakAmpl() const {
	228	//PeakAmpl
	229	return fPeakAmplitude ;
	230	}
313ba434	231	Int_t PeakPos() {return fPeakPosition;}
b0f5e3fc	232
313ba434	233	public:
b0f5e3fc	234
	235	Float_t fX; // X of cluster
	236	Float_t fZ; // Z of cluster
	237	Float_t fQ; // Q of cluster
	238	Int_t fWing; // Wing number
	239	Float_t fAnode; // Anode number
	240	Float_t fTime; // Drift Time
	241	Float_t fPeakAmplitude; // Peak Amplitude
313ba434	242	Int_t fPeakPosition; // index of digit corresponding to peak
b0f5e3fc	243	Int_t fNanodes; // N of anodes used for the cluster
	244	Int_t fNsamples; // N of samples used for the cluster
	245
	246	ClassDef(AliITSRawClusterSDD,1) // AliITSRawCluster class for SDD
	247	};
	248
	249	//-----------------------------------------
	250	class AliITSRawClusterSSD : public AliITSRawCluster {
	251
	252	public:
	253
	254	AliITSRawClusterSSD() {
e8189707	255	fMultiplicityN=0;
	256	fQErr=0;
	257	fStatus=-1;
b0f5e3fc	258	/*
b0f5e3fc	259	for (int k=0;k<100;k++) {
e8189707	260	fIndexMapN[k]=-1;
b0f5e3fc	261	}
e8189707	262	fProbability=0;
e8189707	263	fChi2N=-1;
b0f5e3fc	264	*/
b0f5e3fc	265	}
	266	AliITSRawClusterSSD(Float_t Prob,Int_t Sp,Int_t Sn);
	267	virtual ~AliITSRawClusterSSD() {
	268	// destructor
	269	}
	270
	271	Int_t GetStatus() const {
	272	// get status
	273	return fStatus;
	274	}
	275	void SetStatus(Int_t status) {
	276	// set status
	277	fStatus=status;
	278	}
	279
	280
	281	public:
b0f5e3fc	282	Int_t fMultiplicityN; // The number of N side strips involved
e8189707	283	// in this point calculations
e8189707	284	Float_t fQErr; // Total charge error
b0f5e3fc	285	Int_t fStatus; // Flag status : 0 - real point
e8189707	286	// 1 - ghost
	287	// 2 - EIC ?
	288	// 3 - single side
b0f5e3fc	289
e8189707	290	// Float_t fProbability; // The probability that this is a "real" point
	291	// Int_t fIndexMapN[100]; // indices of digits for Nside - the corresponding
	292	// info for P side is carried in the base class
	293	// Float_t fChi2N;
b0f5e3fc	294	ClassDef(AliITSRawClusterSSD,1) // AliITSRawCluster class for SSD
	295
	296	};
	297
	298
	299	#endif