MarlinAidaTTTrack.h

#ifndef MarlinAidaTTTrack_h
#define MarlinAidaTTTrack_h

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

#include "aidaTT/AidaTT.hh"

#include <cmath>

namespace MarlinTrk {
  class MarlinAidaTT;
}

namespace EVENT{
  class TrackerHit ;
}



namespace MarlinTrk{

class MarlinAidaTTTrack : public MarlinTrk::IMarlinTrack {
  
public:

    
  MarlinAidaTTTrack(MarlinAidaTT* aidaTT) ;
  
  ~MarlinAidaTTTrack() ;
  
protected:
  
private:
  
  MarlinAidaTTTrack(const MarlinAidaTTTrack&) ;                 // Prevent copy-construction
  MarlinAidaTTTrack& operator=(const MarlinAidaTTTrack&) ;      // Prevent assignment
  
  // make member functions private to force use through interface
  
  void setMass(double mass)  ;
  
  double getMass() ;

  int addHit(EVENT::TrackerHit* hit) ;
  
  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 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 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 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 ) ;
  
  
  
  // 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 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 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 ) ;
  
  
  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 intersectionWithDetElement( int detElementID, gear::Vector3D& point, int mode=modeClosest )  ;
  
  int intersectionWithDetElement( int detElementID, EVENT::TrackerHit* hit, gear::Vector3D& point, int mode=modeClosest )  ;
  
  
  //** end of memeber functions from IMarlinTrack interface
  
  inline double toBaseRange( double phi) const {
    while( phi <= -M_PI ){  phi += 2. * M_PI ; }
    while( phi >   M_PI ){  phi -= 2. * M_PI ; }
    return phi ;
  }
  
protected:
  
  aidaTT::trackParameters createPreFit(aidaTT::trackParameters& tp ) ;

  void getHitInfo( const EVENT::TrackerHit* hit, double* hitpos, std::vector<double>& precision, const aidaTT::ISurface* surf ) ;

  int getTrackState( const aidaTT::Vector3D& refPoint, int label, IMPL::TrackStateImpl& ts, double& chi2, int& ndf ) ;

  int myInit() ;

  // memeber variables 
  
  MarlinAidaTT* _aidaTT;
  
  bool _initialised ;
  
  bool _fitDirection ;
  
  bool _smoothed ;
  
  std::vector< EVENT::TrackerHit*> _lcioHits ;
 
  aidaTT::trackParameters _initialTrackParams ;

  aidaTT::trajectory* _fitTrajectory ;
  
  const std::vector<std::pair<double, const aidaTT::ISurface*> >* _intersections ;

  std::map< int, int > _indexMap ;

  double _mass ;
} ;

} // end of namespace MarlinTrk
  
#endif