ITS/AliITSRawCluster.h

   1 #ifndef ALIITSRAWCLUSTER_H
   2 #define ALIITSRAWCLUSTER_H
   3
   4 ////////////////////////////////////////////////////
   5 //  Cluster classes for set:ITS                   //
   6 ////////////////////////////////////////////////////
   7
   8 #include <TObject.h>
   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 !!!
  28 class AliITSRawClusterSPD : public AliITSRawCluster {
  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;
  80   };
  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
 105
 106   ClassDef(AliITSRawClusterSPD,2)  // AliITSRawCluster class for SPD
 107 };
 108 //----------------------------------------------------------------------
 109 class AliITSRawClusterSDD : public AliITSRawCluster {
 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 //----------------------------------------------------------------------
 208 class AliITSRawClusterSSD : public AliITSRawCluster {
 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
 237 };
 238 #endif