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     fMultiplicity=0;
  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
  33   Int_t       fMultiplicity;        // cluster multiplicity
  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
  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;
  52        }
  53
  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);
  55   virtual ~AliITSRawClusterSPD() {
  56     // destructor
  57   }
  58
  59   void Add(AliITSRawClusterSPD* clJ);
  60   Bool_t Brother(AliITSRawClusterSPD* cluster,Float_t dz,Float_t dx);
  61   void PrintInfo();
  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   }
  75   //  Float_t NclZ() const {
  76   Int_t NclZ() const {
  77     // NclZ
  78     return fNClZ ;
  79   }
  80   //  Float_t NclX() const {
  81   Int_t NclX() const {
  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   }
 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   }
 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
 152   Int_t     fNTracks;     // number of tracks created a cluster
 153   Int_t     fTracks[3];   // tracks created a cluster
 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
 166     fX=fZ=fQ=0;
 167     fWing=fNsamples=0;
 168     fNanodes=1;
 169     fAnode=fTime=fPeakAmplitude=0;
 170     fPeakPosition=-1;
 171     fMultiplicity=0;
 172   }
 173
 174   AliITSRawClusterSDD(Int_t wing, Float_t Anode,Float_t Time,Float_t Charge,
 175                       Float_t PeakAmplitude,Int_t PeakPosition,Float_t Asigma, Float_t Tsigma,Float_t DriftPath, Float_t AnodeOffset,Int_t Samples);
 176   virtual ~AliITSRawClusterSDD() {
 177     // destructor
 178   }
 179
 180   void Add(AliITSRawClusterSDD* clJ);
 181   Bool_t Brother(AliITSRawClusterSDD* cluster,Float_t dz,Float_t dx);
 182   void PrintInfo();
 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;}
 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   }
 231   Int_t PeakPos() {return fPeakPosition;}
 232
 233 public:
 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
 242   Int_t     fPeakPosition;      // index of digit corresponding to peak
 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() {
 255     fMultiplicityN=0;
 256     fQErr=0;
 257     fStatus=-1;
 258     /*
 259       for (int k=0;k<100;k++) {
 260          fIndexMapN[k]=-1;
 261       }
 262       fProbability=0;
 263       fChi2N=-1;
 264     */
 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:
 282   Int_t   fMultiplicityN;  // The number of N side strips involved
 283                            // in this point calculations
 284   Float_t fQErr;           // Total charge error
 285   Int_t   fStatus;         // Flag status : 0 - real point
 286                            //               1 - ghost
 287                            //               2 - EIC ?
 288                            //               3 - single side
 289
 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;
 294   ClassDef(AliITSRawClusterSSD,1)  // AliITSRawCluster class for SSD
 295
 296 };
 297
 298
 299 #endif