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=0;
 168     fNanodes=1;
 169     fAnode=fTime=fPeakAmplitude=0;
 170     fPeakPosition=-1;
 171     fMultiplicity=0;
 172     fTstart=fTstop=fTstartf=fTstopf=0;
 173     fAstart=fAstop=0;
 174   }
 175
 176   AliITSRawClusterSDD(Int_t wing, Float_t Anode,Float_t Time, Float_t Charge,
 177               Float_t PeakAmplitude,Int_t PeakPosition,  Float_t Asigma, Float_t Tsigma, Float_t DriftPath, Float_t AnodeOffset,  Int_t Samples,
 178                            Int_t Tstart, Int_t Tstop, Int_t Tstartf, Int_t Tstopf, Int_t Anodes, Int_t Astart, Int_t Astop);
 179   AliITSRawClusterSDD( const AliITSRawClusterSDD & source);
 180 //  AliITSRawClusterSDD(Int_t wing, Float_t Anode,Float_t Time,Float_t Charge,
 181 //                    Float_t PeakAmplitude,Int_t PeakPosition,Float_t Asigma, Float_t Tsigma,Float_t DriftPath, Float_t AnodeOffset,Int_t Samples);
 182   virtual ~AliITSRawClusterSDD() {
 183     // destructor
 184   }
 185
 186   void Add(AliITSRawClusterSDD* clJ);
 187   Bool_t Brother(AliITSRawClusterSDD* cluster,Float_t dz,Float_t dx);
 188 //  Bool_t Brother(AliITSRawClusterSDD* cluster);
 189   void PrintInfo();
 190   // Setters
 191   void SetX(Float_t x) {fX=x;}
 192   void SetZ(Float_t z) {fZ=z;}
 193   void SetQ(Float_t q) {fQ=q;}
 194   void SetAnode(Float_t anode) {fAnode=anode;}
 195   void SetTime(Float_t time) {fTime=time;}
 196   void SetAsigma(Float_t asigma) {fAsigma=asigma;}
 197   void SetTsigma(Float_t tsigma) {fTsigma=tsigma;}
 198  void SetWing(Int_t wing) {fWing=wing;}
 199   void SetNanodes(Int_t na) {fNanodes=na;}
 200   void SetNsamples(Int_t ns) {fMultiplicity=ns;}
 201   void SetPeakAmpl(Float_t ampl) {fPeakAmplitude=ampl;}
 202   void SetPeakPos(Int_t pos) {fPeakPosition=pos;}
 203   // Getters
 204   Float_t X() const {
 205     //X
 206     return fX ;
 207   }
 208   Float_t Z() const {
 209     //Z
 210     return fZ ;
 211   }
 212   Float_t Q() const {
 213     //Q
 214     return fQ ;
 215   }
 216   Float_t A() const {
 217     //A
 218     return fAnode ;
 219   }
 220   Float_t T() const {
 221     //T
 222     return fTime ;
 223   }
 224   Float_t Asigma() const {
 225     //Asigma
 226     return fAsigma ;
 227   }
 228   Float_t Tsigma() const {
 229     //Tsigma
 230     return fTsigma ;
 231   }
 232   Float_t W() const {
 233     //W
 234     return fWing ;
 235   }
 236   Int_t Anodes() const {
 237     //Anodes
 238     return fNanodes ;
 239   }
 240   Int_t Samples() const {
 241     //Samples
 242     return fMultiplicity;
 243   }
 244   Float_t PeakAmpl() const {
 245     //PeakAmpl
 246     return fPeakAmplitude ;
 247   }
 248   Float_t SumAmpl() const {
 249     //PeakAmpl
 250     return fSumAmplitude ;
 251   }
 252   Int_t PeakPos() {return fPeakPosition;}
 253
 254   Int_t Tstart() const {
 255     //Tstart
 256     return fTstart ;
 257   }
 258   Int_t Tstartf() const {
 259     //Tstartf
 260     return fTstartf ;
 261   }
 262   Int_t Tstop() const {
 263     //Tstop
 264     return fTstop ;
 265   }
 266   Int_t Tstopf() const {
 267     //Tstopf
 268     return fTstopf ;
 269   }
 270   Int_t Astart() const {
 271     //Astart
 272     return fAstart ;
 273   }
 274   Int_t Astop() const {
 275     //Astop
 276     return fAstop ;
 277   }
 278 public:
 279
 280   Float_t   fX;                 // X of cluster
 281   Float_t   fZ;                 // Z of cluster
 282   Float_t   fQ;                 // Q of cluster
 283   Int_t     fWing;              // Wing number
 284   Float_t   fAnode;             // Anode number
 285   Float_t   fTime;              // Drift Time
 286   Float_t   fAsigma;            //
 287   Float_t   fTsigma;            //
 288   Float_t   fPeakAmplitude;     // Peak Amplitude
 289   Float_t   fSumAmplitude;      // Total Amplitude (for weighting)
 290   Int_t     fPeakPosition;      // index of digit corresponding to peak
 291   Int_t     fNanodes;           // N of anodes used for the cluster
 292   Int_t     fTstart;            // First sample in 1D cluster
 293   Int_t     fTstop;             // Last sample in 1D cluster
 294   Int_t     fTstartf;           // First sample in the full 2D cluster
 295   Int_t     fTstopf;            // Last sample in the full 2D cluster
 296   Int_t     fAstart;            // First anode in the 2D cluster
 297   Int_t     fAstop;             // last anode in the 2D cluster
 298
 299   ClassDef(AliITSRawClusterSDD,1)  // AliITSRawCluster class for SDD
 300     };
 301
 302 //-----------------------------------------
 303 class AliITSRawClusterSSD : public AliITSRawCluster {
 304
 305 public:
 306
 307   AliITSRawClusterSSD() {
 308     fMultiplicityN=0;
 309     fQErr=0;
 310     fSignalP=0;
 311     fSignalN=0;
 312     fStatus=-1;
 313     fNtracks=0;
 314   }
 315   AliITSRawClusterSSD(Float_t Prob,Int_t Sp,Int_t Sn);
 316   virtual ~AliITSRawClusterSSD() {
 317     // destructor
 318   }
 319
 320   Int_t  GetStatus() const {
 321     // get status
 322     return fStatus;
 323   }
 324   void   SetStatus(Int_t status) {
 325     // set status
 326     fStatus=status;
 327   }
 328
 329
 330 public:
 331   Int_t   fMultiplicityN;  // The number of N side strips involved
 332                            // in this point calculations
 333   Float_t fQErr;           // Total charge error
 334   Float_t fSignalP;        // Signal of P side cluster
 335   Float_t fSignalN;        // Signal of N side cluster
 336   Int_t   fStatus;         // Flag status : 0 - real point
 337                            //               1 - ghost
 338                            //               2 - EIC ?
 339                            //               3 - single side
 340   Int_t fNtracks;          // Number of tracks created the cluster
 341
 342
 343   // Float_t fProbability;    // The probability that this is a "real" point
 344   // Int_t  fIndexMapN[100];  // indices of digits for Nside - the corresponding
 345                                 // info for P side is carried in the base class
 346   // Float_t fChi2N;
 347   ClassDef(AliITSRawClusterSSD,1)  // AliITSRawCluster class for SSD
 348
 349 };
 350
 351
 352 #endif