Track.h

//-----------------------------------------------------------------------------
// $Id$
//-----------------------------------------------------------------------------
// Filename : Track.h
// Section  : TRG CDC
// Owner    : Yoshihito Iwasaki
// Email    : yoshihito.iwasaki@kek.jp
//-----------------------------------------------------------------------------
// Description : A class to represent a reconstructed charged track in TRGCDC.
//-----------------------------------------------------------------------------
// $Log$
//-----------------------------------------------------------------------------
 
#ifndef TRGCDCTrack_FLAG_
#define TRGCDCTrack_FLAG_
 
#include "trg/cdc/TrackBase.h"
#include "trg/cdc/Helix.h"
 
#ifdef TRGCDC_SHORT_NAMES
#define TCTrack TRGCDCTrack
#endif
 
//...Definition of status...
#define TCTrack_2DTrack       1
#define TCTrack_2DTrackFitted 2
#define TCTrack_3DTrack       4
#define TCTrack_3DTrackFitted 8
 
namespace Belle2 {
  class TRGCDCCircle;
 
  class TRGCDCTrack : public TRGCDCTrackBase {
 
  public:
    enum EDebugValueType { fit2D = 1 << 3,
                           find3D = 1 << 4,
                           fit3D = 1 << 5,
                           any = fit2D | find3D | fit3D
                         };
 
 
    static std::vector<const TRGCDCTrack*> list(void);
 
    TRGCDCTrack();
 
    explicit TRGCDCTrack(const TRGCDCCircle&);
 
    virtual ~TRGCDCTrack();
 
    const TRGCDCHelix& helix(void) const;
 
    void setHelix(TRGCDCHelix& helix);
 
    int approach(TRGCDCLink&, bool sagCorrection = false) const;
 
    virtual const CLHEP::Hep3Vector& p(void) const override;
 
    virtual double pt(void) const override;
 
    virtual const CLHEP::Hep3Vector& x(void) const override;
 
    void set2DFitChi2(double);
 
    double get2DFitChi2(void) const;
 
    void set3DFitChi2(double);
 
    double get3DFitChi2(void) const;
 
    void setDebugValue(EDebugValueType const& moduleName, bool flag);
 
    int getDebugValue(EDebugValueType const& moduleName) const;
 
  public:
 
    std::vector<HepGeom::Point3D<double> > perfectPosition(void) const;
 
  private:// static members
 
    static std::vector<const TRGCDCTrack*> _list;
 
  private:
 
    TRGCDCHelix _helix;
 
    mutable CLHEP::Hep3Vector _p;
 
    mutable CLHEP::Hep3Vector _x;
 
    double m_2DFitChi2;
 
    double m_3DFitChi2;
 
    int m_debugValue;
  };
 
//-----------------------------------------------------------------------------
 
// inline
// unsigned
// TRGCDCTrack::id(void) const{
//     if (_list.size()) {
//         for (unsigned i = 0; i < _list.size(); i++)
//             if (_list[i] == this)
//                 return unsigned(i);
//     }
//     return 999;
// }
 
  inline
  const TRGCDCHelix&
  TRGCDCTrack::helix(void) const
  {
    return _helix;
  }
 
  inline
  void
  TRGCDCTrack::setHelix(TRGCDCHelix& helix)
  {
    _helix = helix;
  }
 
  inline
  const CLHEP::Hep3Vector&
  TRGCDCTrack::p(void) const
  {
    _p = _helix.momentum();
    return _p;
  }
 
  inline
  double
  TRGCDCTrack::pt(void) const
  {
    _p = _helix.momentum();
    return _p.perp();
  }
 
  inline
  const CLHEP::Hep3Vector&
  TRGCDCTrack::x(void) const
  {
    _x = _helix.x();
    return _x;
  }
 
  inline
  void TRGCDCTrack::set2DFitChi2(double in2DFitChi2)
  {
    m_2DFitChi2 = in2DFitChi2;
  }
 
  inline
  double TRGCDCTrack::get2DFitChi2(void) const
  {
    return m_2DFitChi2;
  }
 
  inline
  void TRGCDCTrack::set3DFitChi2(double in3DFitChi2)
  {
    m_3DFitChi2 = in3DFitChi2;
  }
 
  inline
  double TRGCDCTrack::get3DFitChi2(void) const
  {
    return m_3DFitChi2;
  }
 
  inline
  void TRGCDCTrack::setDebugValue(EDebugValueType const& moduleName, bool flag)
  {
    if (flag) m_debugValue |= moduleName;
    else m_debugValue &= ~moduleName;
  }
 
  inline
  int TRGCDCTrack::getDebugValue(EDebugValueType const& moduleName) const
  {
    return m_debugValue & moduleName;
  }
 
 
 
} // namespace Belle2
 
#endif /* TRGCDCTrack_FLAG_ */