/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Reconstruction/TrkReco/TrkReco-00-08-59-patch4-slc6tag/TrkReco/TTrack.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
// $Id: TTrack.h,v 1.21 2012/05/28 05:16:29 maoh Exp $
//-----------------------------------------------------------------------------
// Filename : TTrack.h
// Section  : Tracking
// Owner    : Yoshi Iwasaki
// Email    : yoshihito.iwasaki@kek.jp
//-----------------------------------------------------------------------------
// Description : A class to represent a track in tracking.
//               See http://bsunsrv1.kek.jp/~yiwasaki/tracking/
//-----------------------------------------------------------------------------

#ifndef TTrack_FLAG_
#define TTrack_FLAG_

#ifdef TRKRECO_DEBUG_DETAIL
#ifndef TRKRECO_DEBUG
#define TRKRECO_DEBUG
#endif
#endif

//...Definition of finder/manager...
#define TrackOldConformalFinder 1
#define TrackFastFinder         2
#define TrackSlowFinder         4
#define TrackCurlFinder         8
#define TrackTrackManager      16
#define TrackPMCurlFinder      32
#define TrackSVDAssociator     64
#define TrackFinderMask       255

//...Definition of type/kind...
#define TrackTypeUndefined        0
#define TrackTypeNormal           1
#define TrackTypeCurl             2
#define TrackTypeCircle           4
#define TrackTypeCosmic           8
#define TrackTypeIncomingCosmic   8
#define TrackTypeOutgoingCosmic  16
#define TrackTypeKink            32
#define TrackTypeSVDOnly        256

//...Definition of quality...
#define TrackQualityOutsideCurler   1
#define TrackQualityAfterKink       2
#define TrackQualityCosmic          4
#define TrackQuality2D              8
#define TrackQualityShift           8
#define TrackQualityMask          255

//...Definition of fitting status...
#define TrackFitGlobal         1
#define TrackFitCosmic         2
#define TrackFitCdcKalman      4
#define TrackFitSvdCdcKalman   8
#define TrackFitShift         16
#define TrackFitMask         255

//...Definition of relation...
#define TrackHasMother         1
#define TrackHasDaughter       2
#define TrackRelationShift    24
#define TrackRelationMask    255

#include <string>

#define HEP_SHORT_NAMES
#include "CLHEP/Vector/ThreeVector.h"
//#include "helix/Helix.h"
//#include "TrkReco/Helix.h"
#include "TrackUtil/Helix.h"
#include "TrkReco/TMDCUtil.h"
#include "TrkReco/TTrackBase.h"
#include "TrkReco/TMLink.h"
#include "TrkReco/TBuilder0.h"
#include "TrkReco/TBuilderCosmic.h"
#include "TrkReco/TBuilderCurl.h"
//#include "TrkReco/TMDCCatHit.h"
#include "TrkReco/TPoint2D.h"
//#include "TrkReco/TSvdHit.h"

#include "TrkReco/T3DLine.h"
#include "TrkReco/TRunge.h"
#include "GaudiKernel/IInterface.h"
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/Service.h"
#include "MagneticField/IMagneticFieldSvc.h"
#include "MagneticField/MagneticFieldSvc.h"

#include "CLHEP/Matrix/Vector.h"
#include "CLHEP/Matrix/SymMatrix.h"
#include "CLHEP/Vector/ThreeVector.h"
#include "CLHEP/Vector/LorentzVector.h"
#include "CLHEP/Geometry/Point3D.h"


using CLHEP::Hep3Vector;

#ifndef CLHEP_POINT3D_H
#include "CLHEP/Geometry/Point3D.h"
#endif
#ifndef ENABLE_BACKWARDS_COMPATIBILITY
    typedef HepGeom::Point3D<double> HepPoint3D;
#endif
using HepGeom::Point3D;

//class HepPoint3D;
class TrkReco;
class TTrackManager;
class TCircle;
class TCosmicFitter;
class Refit;
class THelixFitter;
class TBuilder;
//class TPMCurlFinder;
class TCurlFinder;
//struct reccdc_trk;
//struct reccdc_trk_add;
//struct rectrk_localz;
//struct gen_hepevt;
//struct mdst_trk_fit;
class MdcRec_trk;
class MdcRec_trk_add;
class MdcTrk_localz;
class Gen_hepevt;
class Mdst_trk_fit;

class TTrack : public TTrackBase {

  public:
    TTrack();

    TTrack(const TCircle &);

    TTrack(const TTrack &);

    TTrack(const T3DLine &);

    TTrack(const Helix &);

    TTrack(const TRunge &);
    virtual ~TTrack();

  public:// General information
    const std::string & name(void) const;
    const std::string & name(const std::string & newName);

    TTrack * mother(void) const;
    TTrack * mother(TTrack *);
    TTrack * daughter(void) const;
    TTrack * daughter(TTrack *);

    unsigned objectType(void) const;

    unsigned type(void) const;

    unsigned finder(void) const;
    unsigned finder(unsigned finderMask);
    void setFinderType(unsigned);
    unsigned getFinderType(void)const;

    unsigned quality(void) const;
    unsigned quality(unsigned qualityMask);

    unsigned fitting(void) const;
    unsigned fitting(unsigned fitMask);

    unsigned state(void) const;

    void assign(unsigned maskForWireHit);

    void dump(const std::string & message = std::string(""),
              const std::string & prefix = std::string("")) const;

  public:// Kinematics
    double charge(void) const;

    const Helix & helix(void) const;

    Hep3Vector p(void) const;

    double ptot(void) const;

    double pt(void) const;

    double pz(void) const;

    double impact(void) const;

    TPoint2D center(void) const;

    double radius(void) const;

    unsigned ndf(void) const;

    double chi2(void) const;

    double confidenceLevel(void) const;

  public:// Utilities for segment operations.
    AList<TSegment> & segments(void);
    const AList<TSegment> & segments(void) const;

  public:// Utilities
    int approach(TMLink &) const;
    int approach(TMLink &, bool sagCorrection) const;
    int approach2D(TMLink &) const;

    int szPosition(TMLink & link) const;

    int szPosition(const TSegment & segment, TMLink & link) const;
    
    int szPosition(const HepPoint3D & p, HepPoint3D & szPosition) const;

#define OLD_STEREO 1
#if OLD_STEREO
    int stereoHitForCurl(TMLink & link, AList<HepPoint3D> & arcZList) const;
    int stereoHitForCurl(TMLink & link, TMLink & link1) const;
    int stereoHitForCurl(TMLink & link, TMLink & link1, TMLink & link2) const;
    void deleteListForCurl(AList<HepPoint3D> &l1,
                           AList<HepPoint3D> &l2) const;
    void deleteListForCurl(AList<HepPoint3D> &l1,
                           AList<HepPoint3D> &l2,
                           AList<HepPoint3D> &l3) const;
#endif
    int stereoHitForCurl(AList<TMLink>&) const;

  public:// Modifiers
    double charge(double);

    // int fitx(void);

    int fit2D(unsigned = 0, double = 0.1, double = 0.015);

    //    int fitWithCathode( float windowSize = 0.6 , int SysCorr = 0 ); // mod by matsu ( 1999/07/05 )

    void refine2D(AList<TMLink> & list, float maxSigma);

    void movePivot(void);

  public:// temporary added
    //    const AList<TMDCCatHit> & catHits(void) const;

    int HelCyl(double rhole,
               double rcyl,
               double zb,
               double zf,
               double epsl,
               double & phi,
               HepPoint3D & xp) const;

    //    void findCatHit(unsigned trackid);

    //   void relationClusterWithWire();

    //   void relationClusterWithLayer(int SysCorr ); // by matsu ( 1999/07/05 )

    //   void svdHits(AList<TSvdHit> &);

    //   AList<TSvdHit> & svdHits(void);
    //   const AList<TSvdHit> & svdHits(void) const;

   const AList<TMLink> & finalHits(void) const;
   const AList<TMLink> & finalHits(const AList<TMLink> & hits);

   const AList<TMLink> & associateHits(void) const;
   const AList<TMLink> & associateHits(const AList<TMLink> & hits);

  private:
    int dxda(const TMLink & link,
             double dPhi,
             Vector & dxda,
             Vector & dyda,
             Vector & dzda) const;

    int dxda2D(const TMLink & link,
               double dPhi,
               Vector & dxda,
               Vector & dyda,
               Vector & dzda) const;

    int dxda2D(const TMLink & link,
               double dPhi,
               Vector & dxda,
               Vector & dyda) const;

    int dxda2D(double dPhi,
               Vector & dxda,
               Vector & dyda) const;

    unsigned defineType(void) const;

    unsigned _findertype;
  private:// Always updated
    unsigned _state;
    double _charge;
    AList<TSegment> _segments;
    TTrack * _mother;
    TTrack * _daughter;
    //    AList<TSvdHit> _svdHits;
    AList<TMLink> _finalHits;
    AList<TMLink> _associateHits;

  private:// Updated when fitted
    //static const THelixFitter _fitter;//yzhang delete 2012-05-04 
    static const THelixFitter _fitter;//yzhang add
    Helix *  _helix;
    unsigned _ndf;
    double _chi2;
    std::string _name;
    mutable unsigned _type;

  private:// temporary added
    //    AList<TMDCCatHit> _catHits;

    friend class TTrackManager;
    friend class TrkReco;
    friend class THelixFitter;
    friend class TCosmicFitter;
    friend class Refit;
    friend class TBuilder;
    friend class TBuilder0;
    friend class TBuilderCosmic;
    friend class TBuilderCurl;
    friend class TPMCurlFinder;
    friend class TCurlFinder;

  private:
    mutable IMagneticFieldSvc* m_pmgnIMF;


};

#if defined(__GNUG__)
int
SortByPt(const TTrack ** a, const TTrack ** b);
#else
extern "C" int
SortByPt(const void* a, const void* b);
#endif

inline std::string
TrackDump(const TTrack &);

inline std::string
TrackType(const TTrack &);

inline std::string
TrackType(unsigned type);

std::string
TrackStatus(const TTrack &);

std::string
TrackStatus(const MdcRec_trk &);

std::string
TrackStatus(const MdcRec_trk_add &);

std::string
TrackStatus(unsigned md,
            unsigned mk,
            unsigned mq,
            unsigned ms,
            unsigned mm,
            unsigned ma);

inline std::string
TrackKinematics(const TTrack &);

std::string
TrackKinematics(const Helix &);

std::string
TrackInformation(const TTrack &);

std::string
TrackInformation(const MdcRec_trk &);

std::string
TrackInformation(unsigned nA, unsigned nS, unsigned n, float chisq);

std::string
TrackLayerUsage(const TTrack &);

Helix
Track2Helix(const MdcRec_trk &);

Helix
Track2Helix(const MdcTrk_localz &);

Helix
Track2Helix(const Gen_hepevt &);

Helix
Track2Helix(const Mdst_trk_fit &);

bool
HelixHasNan(const Helix &);

bool
PositiveDefinite(const Helix &);

//-----------------------------------------------------------------------------

#ifdef TTrack_NO_INLINE
#define inline
#else
#undef inline
#define TTrack_INLINE_DEFINE_HERE
#endif

#ifdef TTrack_INLINE_DEFINE_HERE

inline
const Helix &
TTrack::helix(void) const {
#ifdef TRKRECO_DEBUG
    // if (! _fitted) std::cout << "TTrack::helix !!! helix not updated" << std::endl;
#endif
    return * _helix;
}

inline
unsigned
TTrack::ndf(void) const {
#ifdef TRKRECO_DEBUG
    if (! _fitted) std::cout << "TTrack::ndf !!! ndf not updated" << std::endl;
#endif
    return _ndf;
}

inline
double
TTrack::chi2(void) const {
#ifdef TRKRECO_DEBUG
    if (! _fitted) std::cout << "TTrack::chi2 !!! chi2 not updated" << std::endl;
#endif
    return _chi2;
}

inline
double
TTrack::charge(void) const {
    return _charge;
}

inline
double
TTrack::charge(double a) {
    return _charge = a;
}

inline
const std::string &
TTrack::name(void) const {
    return _name;
}

inline
const std::string &
TTrack::name(const std::string & a) {
    return _name = a;
}

inline
double
TTrack::pt(void) const {
    return 1. / fabs(_helix->a()[2]);
}

inline
double
TTrack::pz(void) const {
    return (1. / fabs(_helix->a()[2])) * _helix->a()[4];
}

inline
double
TTrack::ptot(void) const {
    return (1. / fabs(_helix->a()[2])) * 
        sqrt(1. + _helix->a()[4] * _helix->a()[4]);
}

inline
double
TTrack::confidenceLevel(void) const {
    return chisq2confLevel((int) _ndf, _chi2);
}

inline
Hep3Vector
TTrack::p(void) const {
    return _helix->momentum(0.);
}

inline
unsigned
TTrack::objectType(void) const {
    return Track;
}

inline
unsigned
TTrack::type(void) const {
    return defineType();
}

inline
double
TTrack::impact(void) const {
    return fabs(_helix->radius()) - _helix->center().mag();
}

inline
double
TTrack::radius(void) const {
    return _helix->radius();
}

inline
AList<TSegment> &
TTrack::segments(void) {
    return _segments;
}

inline
const AList<TSegment> &
TTrack::segments(void) const {
    return _segments;
}

inline
TPoint2D
TTrack::center(void) const {
    return TPoint2D(_helix->center());
}

inline
unsigned
TTrack::finder(void) const {
    return _state & TrackFinderMask;
}

inline
unsigned
TTrack::finder(unsigned a) {
    _state |= (a & TrackFinderMask);
    return finder();
}

inline
unsigned
TTrack::quality(void) const {
    return (_state >> TrackQualityShift) & TrackQualityMask;
}

inline
unsigned
TTrack::quality(unsigned a) {
//      _state = ((a << TrackQualityShift) & TrackQualityMask) |
//      (_state & (~ (TrackQualityMask << TrackQualityShift)));
    _state = ((a & TrackQualityMask) << TrackQualityShift) |
        (_state & (~ (TrackQualityMask << TrackQualityShift)));
    return quality();
}

inline
unsigned
TTrack::fitting(void) const {
    return (_state >> TrackFitShift) & TrackFitMask;
}

inline
unsigned
TTrack::fitting(unsigned a) {
    _state |= ((a << TrackFitShift) & TrackFitMask);
    return fitting();
}

inline
TTrack *
TTrack::mother(void) const {
    return _mother;
}

inline
TTrack *
TTrack::mother(TTrack * a) {
    if (a) _state |= (TrackHasMother << TrackRelationShift);
    else   _state &= (~(TrackHasMother << TrackRelationShift));
    return _mother = a;
}

inline
TTrack *
TTrack::daughter(void) const {
    return _daughter;
}

inline
TTrack *
TTrack::daughter(TTrack * a) {
    if (a) _state |= (TrackHasDaughter << TrackRelationShift);
    else   _state &= (~(TrackHasDaughter << TrackRelationShift));
    return _daughter = a;
}

inline
unsigned
TTrack::state(void) const {
    return _state;
}

inline
void TTrack::setFinderType(unsigned type){
        _findertype=type;
}
inline
unsigned TTrack::getFinderType(void)const{
        return _findertype;
}
inline
std::string
TrackType(const TTrack & t) {
    return TrackType(t.type());
}

inline
std::string
TrackKinematics(const TTrack & t) {
    return TrackKinematics(t.helix());
}

inline
std::string
TrackDump(const TTrack & t) {
    return t.name() + " " + TrackStatus(t) + " " + TrackKinematics(t) + " " +
        TrackInformation(t);
}

inline
const AList<TMLink> &
TTrack::finalHits(const AList<TMLink> & list) {
    _finalHits = list;
    return _finalHits;
}

inline
const AList<TMLink> &
TTrack::finalHits(void) const {
    return _finalHits;
}

inline
const AList<TMLink> &
TTrack::associateHits(const AList<TMLink> & list) {
    _associateHits = list;
    return _associateHits;
}

inline
const AList<TMLink> &
TTrack::associateHits(void) const {
    return _associateHits;
}


#endif

#undef inline

#endif /* TTrack_FLAG_ */

---