StRoot: StFtpcTrackMaker/StFtpcPoint.hh Source File

00001 // $Id: StFtpcPoint.hh,v 1.15 2004/05/07 14:19:25 oldi Exp $
00002 // $Log: StFtpcPoint.hh,v $
00003 // Revision 1.15  2004/05/07 14:19:25  oldi
00004 // const added to GedtDetectorId() and GetHardwarePosition().
00005 // Creation of StEvent/StFtpcHit removed. This is done in a new constructor of StFtpcit itself, now.
00006 //
00007 // Revision 1.14  2004/04/06 18:36:13  oldi
00008 // New data mebers for pad and time position and pad and time sigma added.
00009 // Reference to StFtpcHit added.
00010 // Possibility to update StFtpcHit coordinates directly included.
00011 //
00012 // Revision 1.13  2004/02/12 19:37:10  oldi
00013 // *** empty log message ***
00014 //
00015 // Revision 1.12  2003/09/16 15:27:02  jcs
00016 // removed inline as it would leave a few undefined reference
00017 //
00018 // Revision 1.11  2003/01/16 18:04:33  oldi
00019 // Bugs eliminated. Now it compiles on Solaris again.
00020 // Split residuals for global and primary fit.
00021 //
00022 // Revision 1.10  2002/11/06 13:45:42  oldi
00023 // Flag for clusters not to be used for tracking introduced.
00024 // Code clean ups.
00025 //
00026 // Revision 1.9  2002/06/04 13:34:59  oldi
00027 // Transformation of local FTPC coordinates in global coordinates introduced.
00028 // An additional flag keeps track in which coordinate system the point position
00029 // is measured.
00030 // 'Tracked' flag is set correctly, now.
00031 //
00032 // Revision 1.8  2002/04/05 16:50:40  oldi
00033 // Cleanup of MomentumFit (StFtpcMomentumFit is now part of StFtpcTrack).
00034 // Each Track inherits from StHelix, now.
00035 // Therefore it is possible to calculate, now:
00036 //  - residuals
00037 //  - vertex estimations obtained by back extrapolations of FTPC tracks
00038 // Chi2 was fixed.
00039 // Many additional minor (and major) changes.
00040 //
00041 // Revision 1.7  2002/01/29 11:08:03  oldi
00042 // Write() renamed to WriteCluster() resp. WriteTrack() to avoid compiler warnings.
00043 // As a result the functions TObject::Write() are available again (directly).
00044 //
00045 // Revision 1.6  2001/01/25 15:21:51  oldi
00046 // Review of the complete code.
00047 // Fix of several bugs which caused memory leaks:
00048 //  - Tracks were not allocated properly.
00049 //  - Tracks (especially split tracks) were not deleted properly.
00050 //  - TClonesArray seems to have a problem (it could be that I used it in a
00051 //    wrong way). I changed all occurences to TObjArray which makes the
00052 //    program slightly slower but much more save (in terms of memory usage).
00053 // Speed up of HandleSplitTracks() which is now 12.5 times faster than before.
00054 // Cleanup.
00055 //
00056 // Revision 1.5  2000/11/10 18:37:46  oldi
00057 // New constructor added.
00058 // StThreeVector replaced by TVector3 to be able to use ROOT output (e.g. Write()).
00059 // Cleanup.
00060 //
00061 // Revision 1.4  2000/08/01 12:24:04  hummler
00062 // add writing to table functionality (ToTable() function)
00063 //
00064 // Revision 1.3  2000/07/18 21:22:16  oldi
00065 // Changes due to be able to find laser tracks.
00066 // Cleanup: - new functions in StFtpcConfMapper, StFtpcTrack, and StFtpcPoint
00067 //            to bundle often called functions
00068 //          - short functions inlined
00069 //          - formulas of StFormulary made static
00070 //          - avoid streaming of objects of unknown size
00071 //            (removes the bunch of CINT warnings during compile time)
00072 //          - two or three minor bugs cured
00073 //
00074 // Revision 1.2  2000/06/13 14:49:25  oldi
00075 // Added SetTrackedFlag(Bool_t tracked) and GetTrackedFlag() to take care of the
00076 // bit 5 of mFlags.
00077 // Changed SetUsage(Bool_t f) to change the bit 5 of mFlags, too.
00078 //
00079 // Revision 1.1  2000/05/11 15:14:49  oldi
00080 // Changed class names *Hit.* due to already existing class StFtpcHit.cxx in StEvent
00081 //
00082 
00084 //                                                                               //
00085 // StFtpcPoint class - representation of one FTPC cluster for the FTPC trackers. //
00086 //                                                                               //
00088 
00089 #ifndef STAR_StFtpcPoint
00090 #define STAR_StFtpcPoint
00091 
00092 #include "TObject.h"
00093 #include "TObjArray.h"
00094 #include "TVector3.h"
00095 #include "TMath.h"
00096 
00097 #include "StDetectorId.h"
00098 #include "StFtpcTrack.hh"
00099 
00100 class StFtpcHitCollection;
00101 class StFtpcHit;
00102 class StFtpcTrack;
00103 
00104 class StFtpcPoint : public TObject {
00105   
00106 private:
00107 
00108   StFtpcHit *mStEventHit;    // pointer to the corresponding hit in StEvent
00109   
00110   TVector3   mCoord;         // vector of cluster coordinates
00111   TVector3   mError;         // vector of errors on cluster coordinates
00112   
00113   Bool_t     mGlobalCoord;   // flag that indicates if the hit is stored in global or local (FTPC) coordinates
00114   Bool_t     mUsed;          // flag that indicates if the hit is assigned to a track 
00115   Int_t      mHitNumber;     // number of this cluster in this event
00116   Int_t      mNextHitNumber; // number of next hit on same track
00117   Int_t      mTrackNumber;   // track number to which this cluster belongs to
00118 
00119   // additional input variables from cluster finder
00120   
00121   Float_t    mPadPos;        // pad position of hit
00122   Float_t    mTimePos;       // time position of hit
00123   Float_t    mPadPosSigma;   // sigma pad position of hit
00124   Float_t    mTimePosSigma;  // sigma time position of hit
00125   Long_t     mPadRow;        // FTPC row number
00126   Long_t     mSector;        // FTPC readout sector number
00127   Long_t     mNumberPads;    // number of pads in cluster
00128   Long_t     mNumberBins;    // number of consecutive timebins in cluster
00129   Long_t     mMaxADC;        // cluster peak height (adc channels)
00130   Long_t     mCharge;        // cluster charge (adc channels)
00131   Long_t     mFlags;         // bit0:unfolded, bit1:unfold failed,
00132                              // bit2:saturated, bit3:bad shape, 
00133                              // bit4:cut off, bit5:tracked, 
00134                              // bit6:global coords, bit7:don't use for tracking
00135   Double_t   mSigmaPhi;      // cluster sigma in pad direction
00136   Double_t   mSigmaR;        // cluster sigma in drift direction
00137 
00138 
00139   // Residuals
00140   Double_t   mXPrimResidual;     // x distance of measured point to primary momentum fit
00141   Double_t   mYPrimResidual;     // y distance of measured point to primary momentum fit
00142   Double_t   mRPrimResidual;     // r of measured point to r of primary momentum fit
00143   Double_t   mPhiPrimResidual;   // angle of measured point to angle of primary momentum fit
00144   Double_t   mXGlobResidual;     // x distance of measured point to global momentum fit
00145   Double_t   mYGlobResidual;     // y distance of measured point to global momentum fit
00146   Double_t   mRGlobResidual;     // r of measured point to r of global momentum fit
00147   Double_t   mPhiGlobResidual;   // angle of measured point to angle of global momentum fit
00148 
00149 public:
00150   
00151                  StFtpcPoint();                                 // default constructor
00152                  StFtpcPoint(Long_t   row, 
00153                              Long_t   sector, 
00154                              Long_t   n_pads, 
00155                              Long_t   n_bins, 
00156                              Long_t   max_adc, 
00157                              Long_t   charge, 
00158                              Float_t  padpos,
00159                              Float_t  timepos,
00160                              Float_t  padpossigma,
00161                              Float_t  timepossigma,
00162                              Double_t x, 
00163                              Double_t y, 
00164                              Double_t z, 
00165                              Double_t x_err, 
00166                              Double_t y_err, 
00167                              Double_t z_err, 
00168                              Double_t s_phi, 
00169                              Double_t s_r, 
00170                              Long_t   flags);                   // constructor to be filled directly from the cluster finder
00171                  StFtpcPoint(const StFtpcPoint &point);         // copy constructor
00172                  StFtpcPoint(Double_t *x, Int_t row);           // constructor which take an arbitrary point as input
00173   virtual       ~StFtpcPoint();                                 // destructor
00174 
00175   // coordinate transformations
00176   void TransformFtpc2Global();
00177   void TransformGlobal2Ftpc();
00178   void SetStFtpcHitCoord();
00179 
00180   virtual Int_t  ToStEvent(StFtpcHitCollection *ftpcHitColl);   // writes cluster to StFtpcHit class within StEvent
00181   
00182   // getter
00183   StFtpcHit* GetStFtpcHit() { return mStEventHit; }
00184 
00185   TVector3 GetCoord()  { return mCoord;    }
00186   TVector3 GetError()  { return mError;    }
00187   
00188   Double_t GetX()          const { return mCoord.X();   }
00189   Double_t GetY()          const { return mCoord.Y();   }
00190   Double_t GetZ()          const { return mCoord.Z();   }
00191   Double_t GetRadius()     const { return TMath::Sqrt(mCoord.X()*mCoord.X() + mCoord.Y()*mCoord.Y()); }
00192   Double_t GetXerr()       const { return mError.X();   }
00193   Double_t GetYerr()       const { return mError.Y();   }
00194   Double_t GetZerr()       const { return mError.Z();   }
00195   Double_t GetSigmaPhi()   const { return mSigmaPhi;    }
00196   Double_t GetSigmaR()     const { return mSigmaR;      }
00197   
00198   StFtpcTrack *GetTrack(TObjArray *tracks) const;
00199          void  SetTrackedFlag(Bool_t tracked);
00200        Bool_t  GetTrackedFlag();
00201          void  SetGlobalFlag(Bool_t global);
00202        Bool_t  GetGlobalFlag();
00203          void  SetUnusableForTrackingFlag(Bool_t global);
00204        Bool_t  GetUnusableForTrackingFlag();
00205 
00206   Bool_t   IsUsable();
00207   Bool_t   IsUnusable();
00208   Bool_t   IsInGlobalCoord()  { return GetGlobalFlag();  }
00209   Bool_t   GetUsage()         { return GetTrackedFlag(); }
00210   Int_t    GetHitNumber()     const { return mHitNumber;       }
00211   Int_t    GetNextHitNumber() const { return mNextHitNumber;   }
00212   Int_t    GetTrackNumber()   const { return mTrackNumber;     }
00213   Float_t  GetPadPos()        const { return mPadPos;          }
00214   Float_t  GetTimePos()       const { return mTimePos;         }
00215   Float_t  GetPadPosSigma()   const { return mPadPosSigma;     }
00216   Float_t  GetTimePosSigma()  const { return mTimePosSigma;    }
00217   Long_t   GetPadRow()        const { return mPadRow;          }
00218   Long_t   GetSector()        const { return mSector;          }
00219   Long_t   GetNumberPads()    const { return mNumberPads;      }
00220   Long_t   GetNumberBins()    const { return mNumberBins;      }
00221   Long_t   GetMaxADC()        const { return mMaxADC;          }
00222   Long_t   GetCharge()        const { return mCharge;          }
00223   Long_t   GetFlags()         const { return mFlags;           }
00224    Int_t   GetDetectorId() const;
00225   Long_t   GetHardwarePosition() const;
00226   
00227   Double_t GetXPrimResidual()     const { return mXPrimResidual;       }
00228   Double_t GetYPrimResidual()     const { return mYPrimResidual;       }
00229   Double_t GetRPrimResidual()     const { return mRPrimResidual;       }
00230   Double_t GetPhiPrimResidual()   const { return mPhiPrimResidual;     }
00231   Double_t GetXGlobResidual()     const { return mXGlobResidual;       }
00232   Double_t GetYGlobResidual()     const { return mYGlobResidual;       }
00233   Double_t GetRGlobResidual()     const { return mRGlobResidual;       }
00234   Double_t GetPhiGlobResidual()   const { return mPhiGlobResidual;     }
00235 
00236   // setter
00237   void    SetStFtpcHit(StFtpcHit* f) { mStEventHit = f; }
00238 
00239   void    SetX(Double_t f)        {     mCoord.SetX(f); }
00240   void    SetY(Double_t f)        {     mCoord.SetY(f); } 
00241   void    SetZ(Double_t f)        {     mCoord.SetZ(f); }
00242   void    SetXerr(Double_t f)     {     mError.SetX(f); }
00243   void    SetYerr(Double_t f)     {     mError.SetY(f); }
00244   void    SetZerr(Double_t f)     {     mError.SetZ(f); }
00245   
00246   void    SetGlobalCoord(Bool_t f)  {    SetGlobalFlag(f);  }
00247   void    SetUsage(Bool_t f)        {   SetTrackedFlag(f);  }
00248   void    SetHitNumber(Int_t f)     {     mHitNumber =  f;  }
00249   void    SetNextHitNumber(Int_t f) { mNextHitNumber =  f;  }
00250   void    SetTrackNumber(Int_t f)   {   mTrackNumber =  f;  }
00251   void    SetPadPos(Float_t f)      {        mPadPos =  f;  }
00252   void    SetTimePos(Float_t f)     {       mTimePos =  f;  }
00253   void    SetPadPosSigma(Float_t f) {   mPadPosSigma =  f;  }
00254   void    SetTimePosSigma(Float_t f){  mTimePosSigma =  f;  }
00255   void    SetPadRow(Long_t f)       {        mPadRow =  f;  }
00256   void    SetSector(Long_t f)       {        mSector =  f;  }
00257   void    SetNumberPads(Long_t f)   {    mNumberPads =  f;  }
00258   void    SetNumberBins(Long_t f)   {    mNumberBins =  f;  }
00259   void    SetMaxADC(Long_t f)       {        mMaxADC =  f;  }
00260   void    SetCharge(Long_t f)       {        mCharge =  f;  }
00261   void    SetFlags(Long_t f)        {         mFlags =  f;  }
00262   void    SetSigmaPhi(Double_t f)   {      mSigmaPhi =  f;  }
00263   void    SetSigmaR(Double_t f)     {        mSigmaR =  f;  }
00264   
00265   void    SetResidualsToZero();
00266   void    SetXPrimResidual(Double_t f)  {      mXPrimResidual = f;  }
00267   void    SetYPrimResidual(Double_t f)  {      mYPrimResidual = f;  }
00268   void    SetRPrimResidual(Double_t f)  {      mRPrimResidual = f;  }
00269   void    SetPhiPrimResidual(Double_t f){    mPhiPrimResidual = f;  }
00270   void    SetXGlobResidual(Double_t f)  {      mXGlobResidual = f;  }
00271   void    SetYGlobResidual(Double_t f)  {      mYGlobResidual = f;  }
00272   void    SetRGlobResidual(Double_t f)  {      mRGlobResidual = f;  }
00273   void    SetPhiGlobResidual(Double_t f){    mPhiGlobResidual = f;  }
00274   
00275   ClassDef(StFtpcPoint, 1)   //Ftpc point class
00276 };
00277 
00278 
00279 
00280 #endif