ITS/AliITSClusterFinder.h

   1 #ifndef ALIITSCLUSTERFINDER_H
   2 #define ALIITSCLUSTERFINDER_H
   3
   4 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   5  * See cxx source for full Copyright notice                               */
   6
   7 /* $Id$ */
   8
   9 ////////////////////////////////////////////////
  10 //  ITS Cluster Finder Class                  //
  11 //                                            //
  12 //                                            //
  13 ////////////////////////////////////////////////
  14
  15 #include <TObject.h>
  16 #include <TClonesArray.h>
  17 #include "AliLog.h"
  18
  19 class AliITSMap;
  20 class AliITSresponse;
  21 class AliITSsegmentation;
  22 class AliITSdigit;
  23 class AliITSRecPoint;
  24 class AliITSDetTypeRec;
  25 class AliRawReader;
  26 class TArrayI;
  27
  28 //----------------------------------------------------------------------
  29 class AliITSClusterFinder :public TObject{
  30   public:
  31     AliITSClusterFinder(); // Default constructor
  32     // Standard Constructor
  33     AliITSClusterFinder(AliITSDetTypeRec* dettyp);
  34     AliITSClusterFinder(AliITSDetTypeRec* dettyp,TClonesArray *digits);// Standard+ Constructor
  35     virtual ~AliITSClusterFinder(); // Destructor
  36     //
  37     // Do the Reconstruction.
  38     virtual void FindRawClusters(Int_t /*mod*/)=0; // Finds cluster of digits.
  39     virtual void RawdataToClusters(AliRawReader* /*rawReader*/) {
  40       AliError("Method not implemented in this class ");
  41     }
  42
  43     // Digit
  44     virtual void SetDigits(TClonesArray *itsDigits) {// set digits
  45         fDigits=itsDigits;fNdigits = fDigits->GetEntriesFast();}
  46     virtual AliITSdigit* GetDigit(Int_t i){ // Returns ith digit
  47         return (AliITSdigit*) fDigits->UncheckedAt(i);}
  48     virtual TClonesArray* Digits(){return fDigits;}// Gets fDigits
  49     virtual Int_t   NDigits() const {return fNdigits;}// Get Number of Digits
  50
  51     // Set fClusters up
  52     virtual void SetClusters(TClonesArray *itsClusters){// set clusters
  53         fClusters = itsClusters;}
  54     // Get fCluters
  55     virtual TClonesArray* Clusters(){return fClusters;}
  56     // Returns the present number of enteries
  57     virtual Int_t NClusters()const {return fClusters->GetEntriesFast();}
  58
  59     virtual void SetModule(Int_t module){fModule = module;}// Set module number
  60     virtual Int_t GetModule()const {return fModule;}// Returns module number
  61
  62     void SetEvent(Int_t event) { fEvent=event; }
  63
  64     // Others
  65     virtual void  SetMap(AliITSMap *m) {fMap=m;}// map
  66     AliITSMap* Map(){return fMap;}// map
  67     virtual Int_t GetNPeaks() const {return fNPeaks;}// returns fNPeaks
  68     //
  69     virtual Bool_t IsNeighbor(TObjArray *digs,Int_t i,Int_t j[]) const;
  70         // Set max. cluster size ; bigger clusters will be rejected
  71
  72     // IO functions
  73     void Print(ostream *os) const; // Class ascii print function
  74     void Read(istream *os);  // Class ascii read function
  75     virtual void Print(Option_t *option="") const {TObject::Print(option);}
  76     virtual Int_t Read(const char *name) {return TObject::Read(name);}
  77
  78     virtual void SetDetTypeRec(AliITSDetTypeRec* dtr) {fDetTypeRec=dtr;}
  79     AliITSDetTypeRec* GetDetTypeRec() const {return fDetTypeRec;}
  80
  81     void InitGeometry();
  82     //
  83     Int_t    GetNClusters()                               const {return fNClusters;}
  84     void     SetRawID2ClusID(TArrayI *arr)                      {fRawID2ClusID = arr;}
  85     TArrayI* GetRawID2ClusID()                            const {return fRawID2ClusID;}
  86     //
  87   protected:
  88   class Ali1Dcluster {
  89   public:
  90     void SetY(Float_t y) {fY=y;}
  91     void SetQ(Float_t q) {fQ=q;}
  92     void SetNd(Int_t n)  {fNd=n;}
  93     void SetLabels(Int_t *lab) {fLab[0]=lab[0];fLab[1]=lab[1];fLab[2]=lab[2];}
  94     Float_t GetY() const {return fY;}
  95     Float_t GetQ() const {return fQ;}
  96     Int_t GetNd()const {return fNd;}
  97     Int_t GetLabel(Int_t lab) const { return fLab[lab]; }
  98   protected:
  99     Float_t fY; //cluster position
 100     Float_t fQ; //cluster charge
 101     Int_t fNd;  //number of digits
 102     Int_t fLab[3]; //track label
 103   };
 104   class AliBin {
 105   public:
 106   AliBin():fIndex(0),fMask(0xFFFFFFFE),fRawID(-1),fQ(0){}
 107     void SetIndex(UInt_t idx) {fIndex=idx;}
 108     void SetQ(UShort_t q)  {fQ=q;}
 109     void SetMask(UInt_t m) {fMask=m;}
 110     void SetRawID(Int_t id) {fRawID=id;}
 111     void Reset() {fIndex=0; fMask=0xFFFFFFFE; fQ=0; fRawID=-1;}
 112
 113     void Use() {fMask&=0xFFFFFFFE;}
 114     Bool_t IsNotUsed() const {return (fMask&1);}
 115     Bool_t IsUsed() const {return !(IsNotUsed());}
 116
 117     UInt_t   GetIndex() const {return fIndex;}
 118     UShort_t GetQ()     const {return fQ;}
 119     UInt_t   GetMask()  const {return fMask;}
 120     Int_t    GetRawID() const {return fRawID;}
 121   protected:
 122     UInt_t fIndex; //digit index
 123     UInt_t fMask; //peak mask
 124     Int_t  fRawID; // ID of raw word (used for embedding)
 125     UShort_t fQ;  //signal
 126   };
 127   void MakeCluster(Int_t k,Int_t max,AliBin *bins,UInt_t m,AliITSRecPoint &c);
 128   static Bool_t IsMaximum(Int_t k, Int_t max, const AliBin *bins);
 129   static void FindPeaks(Int_t k,Int_t m,AliBin*b,Int_t*idx,UInt_t*msk,Int_t&n);
 130   static void MarkPeak(Int_t k, Int_t max, AliBin *bins, UInt_t m);
 131   static void FindCluster(Int_t k,Int_t maxz,AliBin *bins,Int_t &n,Int_t *idx);
 132
 133   static void CheckLabels2(Int_t lab[10]);
 134   static void AddLabel(Int_t lab[10], Int_t label);
 135
 136   // data members
 137
 138   Int_t              fModule;        //! Module number to be reconstuctted
 139   TClonesArray       *fDigits;       //! digits
 140   Int_t              fNdigits;       //! num of digits
 141
 142   AliITSDetTypeRec* fDetTypeRec; //ITS object for reconstruction
 143   TClonesArray       *fClusters;     //! Array of clusters
 144   AliITSMap          *fMap;          //! map
 145   Int_t              fNPeaks;        //! NPeaks
 146   // Data members needed to fill AliCluster objects
 147   Int_t fNdet[2200];           // detector index
 148   Int_t fNlayer[2200];         // detector layer
 149
 150   Int_t fNModules;             // total number of modules
 151   Int_t fEvent;                //event number
 152   Int_t fZmin;   // minimum channel in Zloc
 153   Int_t fZmax;   // maximum channel in Zloc
 154   Int_t fXmin;   // minimum channel in Xloc
 155   Int_t fXmax;   // maximum channel in Xloc
 156   //
 157   UInt_t fNClusters; // total number of clusters found
 158   //
 159   TArrayI* fRawID2ClusID;        //! optional array to store raw word ID -> ClusID for embedding (not owned)
 160
 161   AliITSClusterFinder(const AliITSClusterFinder &source); // copy constructor
 162   // assignment operator
 163   AliITSClusterFinder& operator=(const AliITSClusterFinder &source);
 164
 165
 166   ClassDef(AliITSClusterFinder,11) //Class for clustering and reconstruction of space points
 167 };
 168 // Input and output functions for standard C++ input/output.
 169 ostream &operator<<(ostream &os,AliITSClusterFinder &source);
 170 istream &operator>>(istream &os,AliITSClusterFinder &source);
 171 #endif