/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Reconstruction/KalFitAlg/KalFitAlg-00-07-55-p03/KalFitAlg/KalFitTrack.h

Go to the documentation of this file.

#ifndef _DEFINE_KALFITTRACK_H_
#define _DEFINE_KALFITTRACK_H_
#ifndef DBL_MAX 
#define DBL_MAX 9999
#endif
#ifndef ENABLE_BACKWARDS_COMPATIBILITY
typedef HepGeom::Transform3D  HepTransform3D;
#endif

//#include "TrackUtil/Helix.h"
#include "KalFitAlg/helix/Helix.h"
#include "KalFitAlg/coil/Bfield.h"
#include "CLHEP/Geometry/Transform3D.h"
#include "CLHEP/Geometry/Point3D.h"
#include "CLHEP/Matrix/Vector.h"
#include "CLHEP/Matrix/Matrix.h"
#include "KalFitAlg/KalFitHitMdc.h"
#include "KalFitAlg/KalFitHelixSeg.h"
#include "MdcCalibFunSvc/MdcCalibFunSvc.h"
#include "MagneticField/IMagneticFieldSvc.h"
#include "MagneticField/MagneticFieldSvc.h"
#include "MdcRawEvent/MdcDigi.h"
#include "EventModel/Event.h"

//class HepTransform3D;
class KalFitMaterial;


using namespace KalmanFit;
using namespace CLHEP;


class KalFitTrack : public Helix                 
{
        int type_; // track with  hits in pattern recognition (=1)
        double mass_;
        int trasan_id_;
        int l_mass_;
        int insist_;
        double chiSq_; 
        unsigned int nchits_, nster_, ncath_, ndf_back_;
        double chiSq_back_, pathip_, path_rd_, 
               path_ab_, tof_, dchi2_max_, r_max_;
        double tof_kaon_, tof_proton_;
        double p_kaon_, p_proton_;
        double r0_;
        double PathL_[43];
        double pathSM_;
        double fiTerm_;
        double tof2_;

        CLHEP::Hep3Vector mom_[43];
        int pat1_, pat2_;
        int layer_prec_;
        int nhit_r_, nhit_z_;

        // Information at the last hit included :
        HepPoint3D pivot_last_;
        CLHEP::HepVector a_last_;
        CLHEP::HepSymMatrix Ea_last_;
        HepPoint3D point_last_;


        // Information at the inned hit of Mdc :
        HepPoint3D pivot_forMdc_;
        CLHEP::HepVector a_forMdc_;
        CLHEP::HepSymMatrix Ea_forMdc_;
        vector<KalFitHitMdc> HitsMdc_;
        //it is used to for record the intermediate info. of fwd-filter and bwd-filter 
        vector<KalFitHelixSeg> HelixSegs_;

        enum { NMASS = 5 };
        static const double MASS[NMASS];

        static int lead_, back_;
        // the used svcs for this track
        static const MdcCalibFunSvc* CalibFunSvc_;
        static const IMagneticFieldSvc* MFSvc_;
        static IMdcGeomSvc* iGeomSvc_;
        static double EventT0_;
        static HepSymMatrix initMatrix_;
        static MdcDigiCol* mdcDigiCol_ ;
public:
        KalFitTrack(const HepPoint3D& pivot,
                        const CLHEP::HepVector& a,
                        const CLHEP::HepSymMatrix& Ea,
                        unsigned int m,
                        double chiSq,
                        unsigned int nhits);

        ~KalFitTrack(void);

        double intersect_cylinder(double r) const;
        double intersect_yz_plane(const HepTransform3D& plane,
                        double x) const;
        double intersect_zx_plane(const HepTransform3D& plane,
                        double y) const;
        double intersect_xy_plane(double z) const;

        void msgasmdc(double path, int index);
        void ms(double path,
                        const KalFitMaterial& m, int index);

        void eloss(double path,
                        const KalFitMaterial& m, int index);

        double smoother_Mdc(KalFitHelixSeg& seg, CLHEP::Hep3Vector& meas, int& flg, int csmflag);
        double smoother_Mdc_csmalign(KalFitHelixSeg& seg, CLHEP::Hep3Vector& meas, int& flg, int csmflag );
        double smoother_Mdc(KalFitHitMdc& HitMdc, CLHEP::Hep3Vector& meas, KalFitHelixSeg& seg, double& dchi2, int csmflag);


        double update_hits(KalFitHitMdc& HitMdc, int inext, CLHEP::Hep3Vector& meas, int way, double& dchi2, double& dtrack, double& dtracknew, double& dtdc, int csmflag);

        double update_hits(KalFitHelixSeg& HelixSeg, int inext, CLHEP::Hep3Vector& meas, int way, double& dchi2, int csmflag);
        double update_hits_csmalign(KalFitHelixSeg& HelixSeg, int inext, CLHEP::Hep3Vector& meas, int way, double& dchi2,int csmflag );
        double chi2_next(Helix& H, KalFitHitMdc & HitMdc, int csmflag);
        double chi2_next(Helix& H, KalFitHitMdc & HitMdc);



        //double approach(KalFitHitMdc& hit, bool doSagCorrection) const;

        //double approach(HepPoint3D pfwd, HepPoint3D pbwd,  bool doSagCorrection) const;


        void update_last(void);
        void update_forMdc(void);

        void point_last(const HepPoint3D& point) { point_last_ = point;} 
        const HepPoint3D& point_last(void)   { return point_last_;} 


        const HepPoint3D & pivot_last(void)         const{ return pivot_last_;  }
        const CLHEP::HepVector & a_last(void)       const{ return a_last_;      }
        const CLHEP::HepSymMatrix & Ea_last(void)   const{ return Ea_last_;     }

        const HepPoint3D & pivot_forMdc(void)       const{ return pivot_forMdc_;}
        const CLHEP::HepVector & a_forMdc(void)     const{ return a_forMdc_;    }
        const CLHEP::HepSymMatrix & Ea_forMdc(void) const{ return Ea_forMdc_;   }

        void path_add(double path);

        void addPathSM(double path);
        double getPathSM(void) { return pathSM_;}

        void addTofSM(double time);
        double getTofSM(void) { return tof2_;}

        void fiTerm(double fi);
        double getFiTerm(void) { return fiTerm_;}

        void tof(double path);
        double filter(double v_m, const CLHEP::HepVector& m_H,
                        double v_d, double m_V);

        double cor_tanldep(double* p, double er);

        void update_bit(int i);

        int insist(void) const { return insist_; }
        int type(void) const { return type_; }
        int trasan_id(void) const { return trasan_id_; }
        double r0(void) const { return r0_; }
        double mass(void) const { return mass_; }
        double chiSq(void) const { return chiSq_; }
        double chiSq_back(void) const { return chiSq_back_; }
        int ndf_back(void) const { return ndf_back_; }
        double pathip(void) const { return pathip_; }
        double path_rd(void) const { return path_rd_; }
        double path_ab(void) const { return path_ab_; }
        double* pathl(void) { return PathL_; }
        CLHEP::Hep3Vector* mom(void) { return mom_; }
        double tof(void) const { return tof_; }
        double tof_kaon(void) const { return tof_kaon_; }
        double tof_proton(void) const { return tof_proton_; }
        double p_kaon(void) const { return p_kaon_; }
        double p_proton(void) const { return p_proton_; }
        double dchi2_max(void) const { return dchi2_max_; }
        double r_max(void) const { return r_max_; }
        unsigned int nchits(void) const { return nchits_; }
        unsigned int nster(void) const { return nster_; }
        unsigned int ncath(void) const { return ncath_; }
        int pat1(void) const { return pat1_;  }
        int pat2(void) const { return pat2_;  }
        int nhit_r(void) const { return nhit_r_;  }
        int nhit_z(void) const { return nhit_z_;  }

        void type(int t){ type_ = t;}
        void trasan_id(int t){ trasan_id_ = t;}
        void insist(int t){ insist_ = t;}

        void pathip(double pl){ pathip_ = pl;}
        void p_kaon(double pl){ p_kaon_ = pl;}
        void p_proton(double pl){ p_proton_ = pl;}
        void chiSq(double c){ chiSq_ = c; }
        void chiSq_back(double c){ chiSq_back_ = c; }
        void ndf_back(int n){ ndf_back_ = n; }
        void nchits(int n){ nchits_ = n; }
        void nster(int n){ nster_ = n; }

        void add_nhit_r(void) { nhit_r_++;}
        void add_nhit_z(void) { nhit_z_++;}

        double PathL(int layer);

        void appendHitsMdc(KalFitHitMdc h);
        void HitsMdc(vector<KalFitHitMdc>& lh);
        vector<KalFitHitMdc>& HitsMdc(void) { return HitsMdc_;}
        KalFitHitMdc& HitMdc(int i) { return HitsMdc_[i];}

        void appendHelixSegs(KalFitHelixSeg s);
        void HelixSegs(vector<KalFitHelixSeg>& vs);
        vector<KalFitHelixSeg>& HelixSegs(void) { return HelixSegs_;}
        KalFitHelixSeg& HelixSeg(int i) { return HelixSegs_[i];}

        void order_wirhit(int index);
        void order_hits(void);
        void number_wirhit(void);

        const HepPoint3D & pivot_numf(const HepPoint3D & newPivot);
        const HepPoint3D & pivot_numf(const HepPoint3D & newPivot, double & pathl);

        double radius_numf(void) const;

        //temporily for wire resolution, use service in future
        double getSigma(int layerId, double driftDist ) const;

        //  call from calibration service 
        double  getSigma(KalFitHitMdc& hitmdc, double tanlam, int lr, double dist) const;
        double  getDriftDist(KalFitHitMdc& hitmdc, double drifttime, int lr) const;

        double  getDriftTime(KalFitHitMdc& hitmdc , double toftime) const;

        // event start time
        static void  setT0(double t0);
        double getT0(void) const;

        static void setInitMatrix(HepSymMatrix m);
        HepSymMatrix getInitMatrix(void) const;

        double  getDigi() const;

        //for get service 
        static void setMdcCalibFunSvc(const MdcCalibFunSvc* calibsvc);
        static void setMagneticFieldSvc(IMagneticFieldSvc*);
        static void setIMdcGeomSvc( IMdcGeomSvc* igeomsvc);
        static void setMdcDigiCol(MdcDigiCol*  digicol);

        static double  mdcGasRadlen_;

        static int tprop_;

        static int debug_;  
        static double chi2_hitf_, chi2_hits_;  
        static int numf_;   
        static int inner_steps_;
        static int outer_steps_;

        static double dchi2cutf_anal[43];

        static double dchi2cuts_anal[43];

        static double dchi2cutf_calib[43];

        static double dchi2cuts_calib[43];

        static int numfcor_;   
        // Nominal mag field 
        static double Bznom_;
        static int steplev_;   

        static int Tof_correc_;  

        static int strag_;
        static double factor_strag_;
        static int nmdc_hit2_;
        static double chi2mdc_hit2_; 
        static int tofall_;
        static int resolflag_;

        static int LR_;
        static int drifttime_choice_;
        static int nmass(void);
        static double mass(int i);
        void chgmass(int i);
        static void LR(int x);
        static int lead(void);
        static void lead(int i);
        static int back(void);
        static void back(int i);
        static int resol(void);
        static void resol(int i);
        static int numf(void);
        static void numf(int i);

        int nLayerUsed() 
        {
                int n=0;
                for(int i=0; i<43; i++) n+=myLayerUsed[i];
                return n;
        }

        void resetLayerUsed() {
                for(int i=0; i<43; i++) myLayerUsed[i]=0;
        }

        void useLayer(int iLay) {
                if(iLay>=0 && iLay<=43) myLayerUsed[iLay]=1;
        }


private:
        int myLayerUsed[43];


};

#endif

---