/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Reconstruction/MdcFastTrkAlg/MdcFastTrkAlg-00-04-09/MdcFastTrkAlg/FTTrack.h

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:     MdcFastTrkAlg
// Module:      FTTrack
// 
// Description:  track class for MdcFastTrkAlg
//

#ifndef FTTrack_FLAG_
#define FTTrack_FLAG_

#include"TrackUtil/Helix.h"
#include"TrackUtil/Lpav.h"
#include"TrackUtil/zav.h"

#include "MdcFastTrkAlg/FTList.h"
#include "MdcFastTrkAlg/FTSegment.h"
#include "MdcFastTrkAlg/MdcParameter.h"
#include "MagneticField/IMagneticFieldSvc.h"
#include "MagneticField/MagneticFieldSvc.h"

#ifndef ENABLE_BACKWARDS_COMPATIBILITY
typedef HepGeom::Point3D<double> HepPoint3D;
#endif

class FTWire;
class FTTrack{
public:
  FTTrack(FTList<FTSegment *> & axial_segments, float kappa, float chi2_kappa);

  ~FTTrack();

public: // public member functions
  int r_phiFit(void);

  int  r_phiReFit(float vx, float xy, int vtx_flag);
  
  // cut the largest residual hit when do r-phi fit 
  int  r_phi2Fit(float vx, float xy, int vtx_flag);
  int  r_phi3Fit(int l, float vx, float xy, int vtx_flag);
  int  r_phi4Fit(float vx, float xy, int vtx_flag);

  int s_zFit(void);

  void updateSZ(void);

  int linkStereoSegments(void);

public: // Selectors

  Helix * helix(void) const;

  const Lpav & lpav(void) const;

  const zav & Zav(void) const;

  FTList<FTSegment *>& axial_segments(void) const;

  FTList<FTSegment *>& stereo_segments(void) const;

  float kappa_tmp(void) const;

  float chi2_kappa_tmp(void) const;

  float d_z(float s, float z) const;

#ifndef OnlineMode
  void printout();
#endif

public: // Modifiers
  float SigmaZ(float z);

  float SigmaS(float s);

  float SigmaSS(float ss);

  float SigmaSZ(float sz);

  void append_stereo(FTSegment *, float s, float z);

  void append_stereo_cache(FTSegment *);

  int get_nhits(void);

public: // static data members
   float minPt;
   float minDr;
   //const HepPoint3D pivot;
  // int evtTiming;
   float xtCoEff;
   float Testime;

public: 
   void setFTFinder(FTFinder*);

private:
  FTFinder* m_ftFinder;
  IMagneticFieldSvc* m_pmgnIMF;
  
public: // private data members
  Lpav * _la;
  zav * _za;
  Helix * _helix;
  FTList<FTSegment *> & _axial_segments;
  FTList<FTSegment *> * _stereo_segments;
  FTList<FTSegment *> * _stereo_segments_cache;
  FTList<FTList<FTSegment *> *> * _stereo_segments_by_superLayer;
  static MdcParameter * param;

  union{
    float _kappa;
    float _SigmaS;
  };
  union{
    float _chi2_kappa;
    float _SigmaSS;
  };
  float _SigmaZ;
  float _SigmaSZ;
};


//----------------------------------------------
#ifdef FTTrack_NO_INLINE
#define inline
#else
#undef inline
#define FTTrack_INLINE_DEFINE_HERE
#endif

#ifdef FTTrack_INLINE_DEFINE_HERE

inline
FTTrack::FTTrack(FTList<FTSegment *> & axial_segments,
                 float kappa, float chi2_kappa)
  : _la(NULL),
    _za(NULL),
    _helix(NULL),
    _axial_segments(axial_segments),
    _stereo_segments(NULL),
    _stereo_segments_cache(NULL),
    _stereo_segments_by_superLayer(NULL),
    //_wireHits(*(new FTList<FTWire *>(50))),
    _kappa(kappa),
    _chi2_kappa(chi2_kappa)
{
  StatusCode scmgn = Gaudi::svcLocator()->service("MagneticFieldSvc",m_pmgnIMF);
  if(scmgn!=StatusCode::SUCCESS) {
    std::cout<< "Unable to open Magnetic field service"<<std::endl;
  }
}

inline
FTTrack::~FTTrack()
{
  delete &_axial_segments;
  delete _la;
  delete _za;
  delete _stereo_segments;
  delete _helix;
}

inline
FTList<FTSegment *>& 
FTTrack::axial_segments(void) const
{
  return _axial_segments;
}

inline
FTList<FTSegment *>& 
FTTrack::stereo_segments(void) const
{
  return *_stereo_segments;
}

inline
void
FTTrack::append_stereo_cache(FTSegment * src)
{
  _stereo_segments_cache->append(src);
}

inline
void
FTTrack::append_stereo(FTSegment * src, float s = 0, float z = 0)
{
  _stereo_segments->append(src);
  _SigmaS += s;
  _SigmaZ += z;
  _SigmaSZ += s*z;
  _SigmaSS += s*s;
}

inline
float
FTTrack::kappa_tmp(void) const
{
  return _kappa;
}

inline
float
FTTrack::chi2_kappa_tmp(void) const
{
  return _chi2_kappa;
}

inline
const Lpav &
FTTrack::lpav(void) const
{
  return *_la;
}

inline
const zav &
FTTrack::Zav(void) const
{
  return *_za;
}

inline
Helix *
FTTrack::helix(void) const
{
  return _helix;
}

inline 
float 
FTTrack::SigmaZ(float z)
{
  return _SigmaZ += z;
}

inline 
float
FTTrack::SigmaS(float s)
{
  return _SigmaS += s;
}

inline
float
FTTrack::SigmaSZ(float sz)
{
  return _SigmaSZ += sz;
}

inline 
float
FTTrack::SigmaSS(float ss)
{
  return _SigmaSS += ss;
}

inline 
float
FTTrack::d_z(float s, float z) const
{
  int n = _stereo_segments->length();
  if (!n) return 0;
  float Dz = (n==1)
    ? z - s*_SigmaZ/_SigmaS
    : z - (s*(_SigmaSZ-_SigmaS*_SigmaZ)+_SigmaSS*_SigmaZ-_SigmaS*_SigmaSZ)
      / (_SigmaSS - _SigmaS*_SigmaS);
  return (Dz < 10*(7-n)) ? Dz : 9999.;
}


inline
void
FTTrack::updateSZ(void)
{
  int n = _stereo_segments_cache->length();
  if (n==1){
    FTSegment * s = _stereo_segments_cache->first();
    float s_tmp = s->s();
    float z_tmp = s->z();
    if (d_z(s_tmp,z_tmp) < 9998.){
      _SigmaS += s_tmp;
      _SigmaZ += z_tmp;
      _SigmaSS += s_tmp*s_tmp;
      _SigmaSZ += s_tmp*z_tmp;
      _stereo_segments->append(s);
    }
    _stereo_segments_cache->clear();
  }else if(n){
    _stereo_segments_by_superLayer->append(_stereo_segments_cache);
    _stereo_segments_cache = new FTList<FTSegment *>(3);
  }
}

inline
void
FTTrack::setFTFinder(FTFinder * finder)
{
  m_ftFinder = finder;
}

#endif

#undef inline

#endif /* FTTrack_FLAG_ */

---