ITS/AliITSRawCluster.h

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