MarlinDDKalTestTrack.h

#ifndef MarlinDDKalTestTrack_h
#define MarlinDDKalTestTrack_h

#include "IMarlinTrack.h"
#include "IMarlinTrkSystem.h"

#include <TObjArray.h>

#include <cmath>

#include "TMatrixD.h"


class TKalTrack ;
class THelicalTrack ;
class TKalTrackSite ;
class DDVTrackHit ;
class DDVMeasLayer ;

namespace MarlinTrk {
  class MarlinDDKalTest;
}

namespace EVENT{
  class TrackerHit ;
}



namespace MarlinTrk{

class MarlinDDKalTestTrack : public MarlinTrk::IMarlinTrack {
  
public:

#ifdef MARLINTRK_DIAGNOSTICS_ON
  friend class DiagnosticsController;
#endif
    
  MarlinDDKalTestTrack(MarlinDDKalTest* ktest) ;
  
  ~MarlinDDKalTestTrack() ;
  
protected:
  
private:
  
  MarlinDDKalTestTrack(const MarlinDDKalTestTrack&) ;                 // Prevent copy-construction
  MarlinDDKalTestTrack& operator=(const MarlinDDKalTestTrack&) ;      // Prevent assignment
  
  // make member functions private to force use through interface
  
  void setMass(double mass)  ;
  
  double getMass() ;

  int addHit(EVENT::TrackerHit* hit) ;
  
  int addHit(EVENT::TrackerHit* trkhit, const DDVMeasLayer* ml) ;
  
  int addHit( EVENT::TrackerHit* trkhit, DDVTrackHit* kalhit, const DDVMeasLayer* ml) ;
  
  int initialise( bool fitDirection ); 
  
  int initialise( const EVENT::TrackState& ts, double /*bfield_z*/, bool fitDirection ) ;
  
  
  int fit( double maxChi2Increment=DBL_MAX ) ;
  
  
  int smooth() ;
  
  
  int smooth( EVENT::TrackerHit* hit )  ;
  
  
  int addAndFit( EVENT::TrackerHit* hit, double& chi2increment, double maxChi2Increment=DBL_MAX ) ;
  
  int addAndFit( DDVTrackHit* kalhit, double& chi2increment, TKalTrackSite*& site, double maxChi2Increment=DBL_MAX ) ;

  
  int testChi2Increment( EVENT::TrackerHit* hit, double& chi2increment ) ;

  
  // Track State Accessesors
  
  int getTrackState( IMPL::TrackStateImpl& ts, double& chi2, int& ndf ) ;
  
  
  int getTrackState( EVENT::TrackerHit* hit, IMPL::TrackStateImpl& ts, double& chi2, int& ndf ) ;
  
  
  int getHitsInFit( std::vector<std::pair<EVENT::TrackerHit*, double> >& hits ) ;
  
  int getOutliers( std::vector<std::pair<EVENT::TrackerHit*, double> >& hits ) ;


  int getNDF( int& ndf ) ;
  
  int getTrackerHitAtPositiveNDF( EVENT::TrackerHit*& trkhit ) ;
  
  // PROPAGATORS 
  
  int propagate( const gear::Vector3D& point, IMPL::TrackStateImpl& ts, double& chi2, int& ndf ) ;
  
  
  int propagate( const gear::Vector3D& point, EVENT::TrackerHit* hit, IMPL::TrackStateImpl& ts, double& chi2, int& ndf ) ;
  
  
  int propagate( const gear::Vector3D& point, const TKalTrackSite& site, IMPL::TrackStateImpl& ts, double& chi2, int& ndf, const DDVMeasLayer* ml = 0 ) ;
  
  
  int propagateToLayer( int layerID, IMPL::TrackStateImpl& ts, double& chi2, int& ndf, int& detElementID, int mode=modeClosest )  ;
  
  int propagateToLayer( int layerID, EVENT::TrackerHit* hit, IMPL::TrackStateImpl& ts, double& chi2, int& ndf, int& detElementID, int mode=modeClosest )  ;
  
  int propagateToLayer( int layerID, const TKalTrackSite& site, IMPL::TrackStateImpl& ts, double& chi2, int& ndf, int& detElementID, int mode=modeClosest ) ; 
  
  int propagateToDetElement( int detElementID, IMPL::TrackStateImpl& ts, double& chi2, int& ndf, int mode=modeClosest ) ;
  
  int propagateToDetElement( int detEementID, EVENT::TrackerHit* hit, IMPL::TrackStateImpl& ts, double& chi2, int& ndf, int mode=modeClosest ) ;
  
  int propagateToDetElement( int detEementID, const TKalTrackSite& site, IMPL::TrackStateImpl& ts, double& chi2, int& ndf, int mode=modeClosest ) ;
  
  
  
  // EXTRAPOLATORS
  
  int extrapolate( const gear::Vector3D& point, IMPL::TrackStateImpl& ts, double& chi2, int& ndf ) ;
  
  int extrapolate( const gear::Vector3D& point, EVENT::TrackerHit* hit, IMPL::TrackStateImpl& ts, double& chi2, int& ndf ) ;
  
  int extrapolate( const gear::Vector3D& point, const TKalTrackSite& site, IMPL::TrackStateImpl& ts, double& chi2, int& ndf ) ;
  
  int extrapolateToLayer( int layerID, IMPL::TrackStateImpl& ts, double& chi2, int& ndf, int& detElementID, int mode=modeClosest )  ;
  
  int extrapolateToLayer( int layerID, EVENT::TrackerHit* hit, IMPL::TrackStateImpl& ts, double& chi2, int& ndf, int& detElementID, int mode=modeClosest )  ;
  
  int extrapolateToLayer( int layerID, const TKalTrackSite& site, IMPL::TrackStateImpl& ts, double& chi2, int& ndf, int& detElementID, int mode=modeClosest )  ;
  
  int extrapolateToDetElement( int detElementID, IMPL::TrackStateImpl& ts, double& chi2, int& ndf, int mode=modeClosest ) ;
  
  int extrapolateToDetElement( int detEementID, EVENT::TrackerHit* hit, IMPL::TrackStateImpl& ts, double& chi2, int& ndf, int mode=modeClosest ) ;
  
  int extrapolateToDetElement( int detEementID, const TKalTrackSite& site, IMPL::TrackStateImpl& ts, double& chi2, int& ndf, int mode=modeClosest ) ;
  
  
  std::string toString() ;
 
  // INTERSECTORS
  
  
  int intersectionWithLayer( int layerID, gear::Vector3D& point, int& detElementID, int mode=modeClosest )  ;
  
  int intersectionWithLayer( int layerID, EVENT::TrackerHit* hit, gear::Vector3D& point, int& detElementID, int mode=modeClosest )  ;
  
  int intersectionWithLayer( int layerID, const TKalTrackSite& site, gear::Vector3D& point, int& detElementID, const DDVMeasLayer*& ml, int mode=modeClosest ) ;
  
  
  int intersectionWithDetElement( int detElementID, gear::Vector3D& point, int mode=modeClosest )  ;
  
  int intersectionWithDetElement( int detElementID, EVENT::TrackerHit* hit, gear::Vector3D& point, int mode=modeClosest )  ;
  
  int intersectionWithDetElement( int detElementID, const TKalTrackSite& site, gear::Vector3D& point, const DDVMeasLayer*& ml, int mode=modeClosest ) ;
  
  int findIntersection( std::vector<DDVMeasLayer const*>& meas_modules, const TKalTrackSite& site, gear::Vector3D& point, int& detElementID, const DDVMeasLayer*& ml, int mode=modeClosest ) ;
  
  int findIntersection( const DDVMeasLayer& meas_module, const TKalTrackSite& site, gear::Vector3D& point, double& dphi, int& detElementIDconst, int mode=modeClosest ) ;
  
  
  
  
  //** end of memeber functions from IMarlinTrack interface
  
  void ToLCIOTrackState( const TKalTrackSite& site,  IMPL::TrackStateImpl& ts, double& chi2, int& ndf ) const ;
  
  void ToLCIOTrackState( const THelicalTrack& helix, const TMatrixD& cov, IMPL::TrackStateImpl& ts, double& chi2, int& ndf ) const ;
  
  int getSiteFromLCIOHit( EVENT::TrackerHit* trkhit, TKalTrackSite*& site ) const ;

  
  
  inline double toBaseRange( double phi) const {
    while( phi <= -M_PI ){  phi += 2. * M_PI ; }
    while( phi >   M_PI ){  phi -= 2. * M_PI ; }
    return phi ;
  }
  


  // memeber variables 
  
  TKalTrack* _kaltrack;
  
  EVENT::TrackerHitVec _lcioHits ; 
  
  TObjArray* _kalhits;
  
  MarlinDDKalTest* _ktest;
  
  EVENT::TrackerHit* _trackHitAtPositiveNDF;
  int _hitIndexAtPositiveNDF;
  
  bool _initialised ;
  
  bool _fitDirection ;
  
  
  bool _smoothed ;
  
  std::map<EVENT::TrackerHit*,TKalTrackSite*> _hit_used_for_sites ;
  
  std::map<EVENT::TrackerHit*,DDVTrackHit*> _lcio_hits_to_kaltest_hits ;
   
  std::vector<EVENT::TrackerHit*> _hit_not_used_for_sites ;

  std::vector< std::pair<EVENT::TrackerHit*, double> > _hit_chi2_values ;
  
  std::vector< std::pair<EVENT::TrackerHit*, double> > _outlier_chi2_values ;

  
} ;

} // end of namespace MarlinTrk
  
#endif