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

Go to the documentation of this file.

//-----------------------------------------------------------------------------
// $Id: TSegment0.h,v 1.7 2010/03/31 09:58:59 liucy Exp $
//-----------------------------------------------------------------------------
// Filename : TSegment0.h
// Section  : Tracking
// Owner    : Yoshi Iwasaki
// Email    : yoshihito.iwasaki@kek.jp
//-----------------------------------------------------------------------------
// Description : A class to manage a group of TMLink's.
//               See http://bsunsrv1.kek.jp/~yiwasaki/tracking/
//-----------------------------------------------------------------------------

#ifndef TSegment0_FLAG_
#define TSegment0_FLAG_

#ifdef TRKRECO_DEBUG_DETAIL
#ifndef TRKRECO_DEBUG
#define TRKRECO_DEBUG
#endif
#endif
#ifndef CLHEP_POINT3D_H
#include "CLHEP/Geometry/Point3D.h"
#endif
#ifndef ENABLE_BACKWARDS_COMPATIBILITY
    typedef HepGeom::Point3D<double> HepPoint3D;
#endif
#include "CLHEP/Geometry/Vector3D.h"
#ifndef ENABLE_BACKWARDS_COMPATIBILITY
    typedef HepGeom::Vector3D<double> HepVector3D;
#endif

#include "TrkReco/TTrackBase.h"
#include "TrkReco/TMDCUtil.h"
#include "TrkReco/TMLink.h"

class TTrack;
class Range;
template <class T> class CAList;

class TSegment0 : public TTrackBase {

  public:
    TSegment0();
    TSegment0(const AList<TMLink> &);

    virtual ~TSegment0();

  public:// Selectors
    virtual unsigned objectType(void) const;

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

    unsigned superLayerId() const;

    const HepPoint3D & position(void) const;

    const HepVector3D & direction(void) const;

    double distance(const TSegment0 &) const;
    double distance(const HepPoint3D &, const HepVector3D &) const;

    Range rangeX(double min, double max) const;

    unsigned innerWidth(void) const;

    unsigned outerWidth(void) const;

    unsigned innerMostLayer(void) const;

    unsigned outerMostLayer(void) const;

    unsigned clusterType(void) const;

    AList<TSegment0> split(void) const;

    int solveDualHits(void);
    double duality(void) const;

  public:// TTrack relations
    AList<TTrack> & tracks(void);

  public:// Segment links
    AList<TSegment0> & innerLinks(void);

  private:
    AList<TSegment0> splitAV(void) const;
    AList<TSegment0> splitParallel(void) const;
    AList<TSegment0> splitComplicated(void) const;
    AList<TSegment0> splitDual(void) const;

  private:
    void update(void) const;

    void updateType(void) const;

    void updateDuality(void) const;

  private:
    // always updated.
    AList<TTrack> _tracks;
    AList<TSegment0> _innerLinks;

  private:
    mutable HepPoint3D _position;
    mutable HepVector3D _direction;
    mutable unsigned _innerWidth;
    mutable unsigned _outerWidth;
    mutable unsigned _innerMostLayer;
    mutable unsigned _outerMostLayer;
    mutable AList<TMLink> _inners;
    mutable AList<TMLink> _outers;
    mutable unsigned _nLayer;
    mutable unsigned _clusterType;
    mutable double _duality;
    mutable unsigned _nDual;
    mutable double _angle;
};

// Utility functions
unsigned NCoreLinks(const CAList<TSegment0> & list);

AList<TMLink> Links(const TSegment0 &, const TTrack &);

/*
void
CheckSegments(const CAList<TSegment0> & segmentList);

void
CheckSegmentLink(const TSegment0 & base,
                 const TSegment0 & next,
                 float distance,
                 float dirAngle);
*/

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

#ifdef TSegment0_NO_INLINE
#define inline
#else
#undef inline
#define TSegment0_INLINE_DEFINE_HERE
#endif

#ifdef TSegment0_INLINE_DEFINE_HERE

inline
const HepPoint3D &
TSegment0::position(void) const {
    if (! _fitted) update();
    return _position;
}

inline
const HepVector3D &
TSegment0::direction(void) const {
    if (! _fitted) update();
    return _direction;
}

inline
unsigned
TSegment0::innerWidth(void) const {
    if (! _fitted) update();
    return _innerWidth;
}

inline
unsigned
TSegment0::outerWidth(void) const {
    if (! _fitted) update();
    return _outerWidth;
}

inline
unsigned
TSegment0::innerMostLayer(void) const {
    if (! _fitted) update();
    return _innerMostLayer;
}

inline
unsigned
TSegment0::outerMostLayer(void) const {
    if (! _fitted) update();
    return _outerMostLayer;
}

inline
unsigned
TSegment0::clusterType(void) const {
    if (! nLinks()) return 0;
    if (_clusterType == 0) updateType();
    return _clusterType;
}

inline
double
TSegment0::duality(void) const {
    return _duality;
}

inline
unsigned
TSegment0::objectType(void) const {
    return Segment;
}

inline
unsigned
TSegment0::superLayerId(void) const {
    unsigned id = (links())[0]->wire()->superLayerId();
#ifdef TRKRECO_DEBUG
    {
        const AList<TMLink> & list = links();
        unsigned n = list.length();
        for (unsigned i = 1; i < n; i++) {
            if (list[i]->hit()->wire()->superLayerId() != id) {
                std::cout << "TSegment0::superLayerId !!! strange segment found";
                std::cout << std::endl;
                dump();
                break;
            }
        }
    }
#endif
    return id;
}

inline
AList<TTrack> &
TSegment0::tracks(void) {
    return _tracks;
}

inline
AList<TSegment0> &
TSegment0::innerLinks(void) {
    return _innerLinks;
}

#endif

#undef inline

#endif /* TSegment0_FLAG_ */

---