TrackBase.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
//-----------------------------------------------------------------------------
// Description : A class to represent a track object in TRGCDC.
//-----------------------------------------------------------------------------
 
#ifndef TRGCDCTrackBase_FLAG_
#define TRGCDCTrackBase_FLAG_
 
#include <vector>
#include "CLHEP/Vector/LorentzVector.h"
 
#ifdef TRGCDC_SHORT_NAMES
#define TCTBase TRGCDCTrackBase
#endif
 
#define TRGCDCTrackBaseType            1
#define TRGCDCCircleType               2
#define TRGCDCLineType                 4
#define TRGCDCTrackType                8
#define TRGCDCSegmentType             16
 
namespace Belle2 {
  class TRGCDCLink;
  class TRGCDCFitter;
  class TRGCDCRelation;
 
  class TRGCDCTrackBase {
 
  public:
 
    TRGCDCTrackBase(const TRGCDCTrackBase&);
 
    TRGCDCTrackBase(const std::string& name, double charge);
 
    virtual ~TRGCDCTrackBase();
 
    TRGCDCTrackBase& operator=(TRGCDCTrackBase&) = delete;
 
  public:
 
    std::string name(void) const;
 
    int status(void) const;
 
    double charge(void) const;
 
    virtual const CLHEP::Hep3Vector& p(void) const;
 
    virtual double pt(void) const;
 
    virtual const CLHEP::Hep3Vector& x(void) const;
 
    virtual void dump(const std::string& message = std::string(""),
                      const std::string& prefix = std::string("")) const;
 
    const std::vector<TRGCDCLink*>& links(void) const;
 
    const std::vector<TRGCDCLink*>& links(unsigned layerId) const;
 
    bool fitted(void) const;
 
    void setFitted(bool fitted);
 
    void setTrackID(int trackID);
 
    int getTrackID();
 
    virtual unsigned objectType(void) const;
 
    const TRGCDCFitter* fitter(void) const;
 
    const TRGCDCRelation relation(void) const;
 
    const TRGCDCRelation relation2D(void) const;
 
    const TRGCDCRelation relation3D(void) const;
 
  public: // Modifiers
 
    std::string name(const std::string& newName);
 
    void append(TRGCDCLink*);
 
    void append(const std::vector<TRGCDCLink*>& links);
 
    double charge(double c);
 
    virtual int fit(void);
 
    const TRGCDCFitter* fitter(const TRGCDCFitter*);
 
  public: // Utility functions
 
    virtual int approach2D(TRGCDCLink&) const;
 
  private:
 
    std::string _name;
 
    int _status;
 
    double _charge;
 
    CLHEP::Hep3Vector _p;
 
    CLHEP::Hep3Vector _x;
 
    std::vector<TRGCDCLink*>* _ts;
 
    std::vector<TRGCDCLink*> _tsAll;
 
    const unsigned _nTs;
 
    const TRGCDCFitter* _fitter;
 
    mutable bool _fitted;
 
    int m_trackID;
 
    friend class TRGCDCFitter;
    friend class TRGCDCCircleFitter;
    friend class TRGCDCHelixFitter;
    friend class TRGCDCCircle;
    friend class TRGCDCTrack;
  };
 
//-----------------------------------------------------------------------------
 
  inline
  std::string
  TRGCDCTrackBase::name(void) const
  {
    return _name;
  }
 
  inline
  std::string
  TRGCDCTrackBase::name(const std::string& a)
  {
    return _name = a;
  }
 
  inline
  int
  TRGCDCTrackBase::status(void) const
  {
    return _status;
  }
 
  inline
  const CLHEP::Hep3Vector&
  TRGCDCTrackBase::p(void) const
  {
    return _p;
  }
 
  inline
  const CLHEP::Hep3Vector&
  TRGCDCTrackBase::x(void) const
  {
    return _x;
  }
 
  inline
  double
  TRGCDCTrackBase::pt(void) const
  {
    return _p.perp();
  }
 
  inline
  bool
  TRGCDCTrackBase::fitted(void) const
  {
    return _fitted;
  }
 
  inline
  void
  TRGCDCTrackBase::setFitted(bool fitted)
  {
    _fitted = fitted;
  }
 
  inline
  unsigned
  TRGCDCTrackBase::objectType(void) const
  {
    return TRGCDCTrackBaseType;
  }
 
  inline
  double
  TRGCDCTrackBase::charge(void) const
  {
    return _charge;
  }
 
  inline
  double
  TRGCDCTrackBase::charge(double a)
  {
    return _charge = a;
  }
 
  inline
  const TRGCDCFitter*
  TRGCDCTrackBase::fitter(void) const
  {
    return _fitter;
  }
 
  inline
  const TRGCDCFitter*
  TRGCDCTrackBase::fitter(const TRGCDCFitter* a)
  {
    _fitted = false;
    return _fitter = a;
  }
 
  inline
  void
  TRGCDCTrackBase::setTrackID(int trackID)
  {
    m_trackID = trackID;
  }
 
  inline
  int
  TRGCDCTrackBase::getTrackID()
  {
    return m_trackID;
  }
 
} // namespace Belle2
 
#endif /* TRGCDCTrackBase_FLAG_ */