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

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:     MdcFastTrkAlg
// Module:      FTFinder
// 
// Description:  fast track finder class for MdcFastTrkAlg
//
//

#ifndef FTFinder_FLAG_
#define FTFinder_FLAG_


#include <iostream>

#include "MdcFastTrkAlg/FTList.h"
#include "MdcFastTrkAlg/FTTrack.h"
#include "MdcFastTrkAlg/FTWire.h"
#include "MdcFastTrkAlg/FTLayer.h"
#include "MdcFastTrkAlg/FTSuperLayer.h"
#include "MdcFastTrkAlg/MdcParameter.h"
#include "MdcFastTrkAlg/MdcFastTrkAlg.h"
#include "HepPDT/ParticleDataTable.hh"
#include "CLHEP/Vector/ThreeVector.h"
#include "RawDataProviderSvc/IRawDataProviderSvc.h"
#include "MagneticField/IMagneticFieldSvc.h"
#include "MagneticField/MagneticFieldSvc.h"

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

using namespace CLHEP;

class CLHEP::Hep3Vector;
//class MdcParameter;
class FTSegment;
class BesEvent;
class StatusCode;

class FTFinder{

public:
  //static FTFinder * GetPointer(void);

  void setAlgorithmPointer(Algorithm*);
public:
  FTFinder();

  void init();

  void term();

  void begin_run();

  void event();

public: // Selectors

  FTSuperLayer * superLayer(int id) const;

  FTList<FTTrack *> & tracks(void) const;

  CLHEP::Hep3Vector vertex(void) const;

  int getWireId(FTWire *) const;

  float t2x(const FTLayer& l, const float t) const;

  float x2t(const FTLayer& l, const float x) const;

        void  setBunchtime(double bunchtime){_bunchtime=bunchtime;};
        void  setT0cal(double t0cal) {_t0cal=t0cal;};

private: // private member functions
Algorithm * m_algorithm;

  void clear(void);

  int updateMdc(void);

  int  getTestime(void);

  void mkTrackList(void);

  void mkTrack3D(void);

  int VertexFit(int z_flag);

  int VertexFit2D();

  int findBestVertex(void);

  int CorrectEvtTiming(void);

  FTTrack * linkAxialSegments(FTSegment ** inner, FTSegment ** outer);

  // link 2,3,4 axial segments
  void  linkAxialSuperLayer234(FTList<FTSegment *> & inner_segments);

  // link 9,10 axial segments
  void  linkAxialSuperLayer910(FTList<FTSegment *> & outer_segments);

  void  linkAxialSegments_step(FTList<FTSegment *>& InnerSegments,
                                 FTList<FTSegment *>& OuterSegments,
                                 FTList<FTSegment *>& Connected,
                                 float maxDphi, float maxChi2);

#ifndef OnlineMode
  void makeMdst(void);
#endif

  //   by wangdy
  StatusCode makeTds(void);

  //register T0 into TDS by max
  StatusCode registT0(void);

  public:  // public data menbers
  /* int findEventVertex;
  int evtTimeCorr;
  double minPt;
  double minDr;
  float tOffSet;
  float xtCoEff;
  int doIt;
#ifndef OnlineMode
  bool mkMdst;
#endif
  bool mkTds;
  */ 
  int   eventNo;
  int   runNo;
  int   expflag;        
  float t0Estime;
  float tOffSet;
  float evtTiming;
  const HepPoint3D pivot;
  float Testime;
  int   i_rPhiFit; 
  int   tEstFlag;
  FTList<float> tEstime[10];

private: // private data members
  //static FTFinder * _tFinder;
  FTWire * _wire;
  FTLayer * _layer;
  FTSuperLayer * _superLayer;
  FTList<FTTrack *> & _tracks;
  FTList<FTSegment *> * _linkedSegments;
  FTList<FTSegment *> _axialSegCollect;
  double _vx;
  double _vy;
  double _vz;
  int _ExpNo;
  int _RunNo;
        double  _bunchtime;
        double  _t0cal;
  int m_total_trk;
  HepPDT::ParticleDataTable* m_particleTable;
  IRawDataProviderSvc* m_rawDataProviderSvc;
  IMagneticFieldSvc* m_pmgnIMF;

  static MdcParameter* param;
  int _widbase[43];
};

inline
FTSuperLayer *
FTFinder::superLayer(int id) const{
  return _superLayer + id;
}

inline
FTList<FTTrack *> & 
FTFinder::tracks(void) const{
  return _tracks;
}

inline
int
FTFinder::getWireId(FTWire * w) const {
  return ((long)w - (long)_wire)/sizeof(FTWire);
}

inline
float
FTFinder::x2t(const FTLayer & l, const float x) const
{
  return (x*x) / (param->_xtCoEff * param->_xtCoEff *l.csize());
}

inline
float
FTFinder::t2x(const FTLayer & l, const float t) const
{
  float x = (t>0.0f) ?((param->_xtCoEff))*sqrt(t*l.csize()) : 0.0f;
  if ( x > 0.47f*l.csize() ){
    x = 0.0004f*t + 0.47f*l.csize()*(1.0f-0.0004f*0.47f/((param->_xtCoEff)*(param->_xtCoEff)));
  }

  return x;
}

inline
void 
FTFinder::setAlgorithmPointer(Algorithm* alg){
  m_algorithm = alg;
}
#endif /* FTFinder_FLAG_ */

---