StiHit.h

#ifndef StiHit_HH
#define StiHit_HH
#include "StiDetector.h"
#include "StiPlacement.h"
#include "StMeasuredPoint.h"
#include "StThreeVectorF.hh"
#include "StMatrixF.hh"
class StiHit 
{
public: 

  enum StiHitProperty { kR,
                        kZ,
                        kPseudoRapidity,
                        kPhi};
    StiHit();
    StiHit(const StiHit&);
    const StiHit& operator=(const StiHit& );
    ~StiHit();

    const Float_t &x() const {return mx;}
    const Float_t &y() const {return my;}
    const Float_t &z() const {return mz;}
    const Float_t  y(Float_t time) const {return my + _vy*time;}
    const Float_t  z(Float_t time) const {return mz + _vz*time;}
    Float_t x_g() const {return _xg;}
    Float_t y_g() const {return _yg;}
    Float_t z_g() const {return _zg;}
    float   rxy() const {return sqrt(_xg*_xg+_yg*_yg);}


    Float_t sxx() const {return msxx;}
    Float_t syy() const {return msyy;}
    Float_t szz() const {return mszz;}
    Float_t sxy() const {return msxy;}
    Float_t sxz() const {return msxz;}
    Float_t syz() const {return msyz;}
    const Float_t *errMtx() const               {return &msxx;}
    Float_t getEloss();
    Float_t refangle() const {return mrefangle;}
    Float_t position() const {return mposition;}
    const StiDetector* detector() const {return mdetector;}
    Int_t isDca() const;
    void makeDca();
    //const StHit* stHit() const 
    const StMeasuredPoint * stHit() const {return msthit;}


    UInt_t timesUsed() const { return mTimesUsed;}
    

    const StThreeVectorF globalPosition() const;

    void set(Float_t position,  Float_t angle, Float_t y, Float_t z);

    void set(const StiDetector * detector,
             const StMeasuredPoint * stHit,
             Float_t energy,
             Float_t x, Float_t y, Float_t z, 
             Float_t sxx=1, Float_t sxy=1, Float_t sxz=1, Float_t syy=1, Float_t syz=1, Float_t szz=1);
    void setGlobal(const StiDetector * detector,
                   const StMeasuredPoint * stHit,
                   Float_t x, Float_t y, Float_t z,
                   Float_t energy);
    
    void setError(const StMatrixF&);
    void setError(const Float_t errMx[6]);
    void setDetector(const StiDetector*det) {mdetector=det;};
    void setStHit(const StMeasuredPoint*hit){msthit=hit;}
    void setMaxTimes(int set)   {mMaxTimes = set;}
    void setTimesUsed(int set){mTimesUsed=set;}
    void addTimesUsed();
    void subTimesUsed();
    int  isUsed() const {return mTimesUsed>=mMaxTimes;}
    void setVz(Float_t vz) {_vz = vz;}
    void setVy(Float_t vy) {_vy = vy;}
    void reset();
    void unset(){;}
    void rotate(double angle);
    double getValue(Int_t key) const;
    double getPseudoRapidity() const;
    Float_t  vz() const {return _vz;}
    Float_t  vy() const {return _vy;}
    friend ostream& operator<<(ostream& os, const StiHit& h);
    int idTruth() const;
    int qaTruth() const;

protected:
    char  mBeg[1];
    char mMaxTimes;
    char mTimesUsed;
    Float_t mrefangle;
    Float_t mposition;
    Float_t mx;
    Float_t my;
    Float_t mz; 
    Float_t msxx;
    Float_t msxy;
    Float_t msyy;
    Float_t msxz;
    Float_t msyz;
    Float_t mszz;
    // global position
    Float_t _xg,_yg,_zg;
    const StiDetector* mdetector;
    const StMeasuredPoint * msthit;
    Float_t _energy;
    // drift velocities cm/mksec( 0 for non driting )
    Float_t _vy, _vz;
    char  mEnd[1];
public:
    Int_t mCount;
};

//Functors for ordering hits
struct StiHitRadiusLessThan
{
  bool operator() (const StiHit*h1, const StiHit*h2) const
  {
    double x1 = h1->x_g();
    double y1 = h1->y_g();
    double r1 = sqrt(x1*x1+y1*y1);
    double x2 = h2->x_g();
    double y2 = h2->y_g();
    double r2 = sqrt(x2*x2+y2*y2);
    return r1<r2;
  }
};

struct StidHitLessThan
{
  bool operator() (const StiHit*lhs, const StiHit*rhs) const
    {
      return (lhs->y() < rhs->y()) ? true : false;
    }
};

struct StizHitLessThan
{
  bool operator() (const StiHit*lhs, const StiHit*rhs) const
  {
    return (lhs->z() < rhs->z()) ? true : false;
  }
};

struct StiHitIsUsed
{
  bool operator() (const StiHit*hit) const
  {
    return (hit->isUsed()==0);
  }
};


#endif