IMarlinTrack.h

Go to the documentation of this file.

#ifndef IMarlinTrack_h
#define IMarlinTrack_h

#include <cfloat>

#include "lcio.h"

#include "EVENT/TrackerHit.h"
#include "IMPL/TrackStateImpl.h"

#include "DDRec/Vector3D.h"

#include <exception>
#include <string>


#ifdef MARLINTRK_BACKWARD_GEAR_WRAPPERS
#include "gearimpl/Vector3D.h"
#endif



namespace MarlinTrk{
  
  typedef dd4hep::rec::Vector3D Vector3D ;
  
  class IMarlinTrack {
    
  public:
    
    static const bool backward ;
    
    static const bool forward ;
    
    
    
    static const int modeBackward ;
    static const int modeClosest  ;
    static const int modeForward  ;
    
    
    static const int success ;  // no error
    static const int error ;
    static const int bad_intputs ;
    static const int no_intersection ; // no intersection found
    static const int site_discarded ;  // measurement discarded by the fitter
    static const int site_fails_chi2_cut ;  // measurement discarded by the fitter due to chi2 cut
    static const int all_sites_fail_fit ;   // no single measurement added to the fit
    
    
    virtual ~IMarlinTrack() {};
    
    virtual void setMass(double mass) = 0 ;

    virtual double getMass() = 0 ;

    virtual int addHit(EVENT::TrackerHit* hit) = 0 ;
    
    virtual int initialise( bool fitDirection ) = 0 ; 
    
    virtual int initialise(  const EVENT::TrackState& ts, double bfield_z, bool fitDirection ) = 0 ;
    
    
    virtual int fit( double maxChi2Increment=DBL_MAX ) = 0 ;
    
    
    virtual int addAndFit( EVENT::TrackerHit* hit, double& chi2increment, double maxChi2Increment=DBL_MAX ) = 0 ;

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

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

    virtual int getOutliers( std::vector<std::pair<EVENT::TrackerHit*, double> >& hits ) = 0 ;
    
    virtual int getNDF( int& ndf ) = 0 ;
    
    virtual int getTrackerHitAtPositiveNDF( EVENT::TrackerHit*& trkhit ) = 0 ;
    
    // PROPAGATORS 
    
    virtual int propagate( const Vector3D& point, IMPL::TrackStateImpl& ts, double& chi2, int& ndf ) = 0 ;

    
    virtual int propagate( const Vector3D& point, EVENT::TrackerHit* hit, IMPL::TrackStateImpl& ts, double& chi2, int& ndf ) = 0 ;


    virtual int propagateToLayer( int layerID, IMPL::TrackStateImpl& ts, double& chi2, int& ndf, int& detElementID, int mode=modeClosest ) = 0  ;
    
    virtual int propagateToLayer( int layerID, EVENT::TrackerHit* hit, IMPL::TrackStateImpl& ts, double& chi2, int& ndf, int& detElementID, int mode=modeClosest ) = 0  ;
    
    virtual int propagateToDetElement( int detElementID, IMPL::TrackStateImpl& ts, double& chi2, int& ndf, int mode=modeClosest ) = 0  ;
    
    virtual int propagateToDetElement( int detEementID, EVENT::TrackerHit* hit, IMPL::TrackStateImpl& ts, double& chi2, int& ndf, int mode=modeClosest ) = 0  ;
    
    
    
    // EXTRAPOLATORS
    
    virtual int extrapolate( const Vector3D& point, IMPL::TrackStateImpl& ts, double& chi2, int& ndf ) = 0 ;
    
    virtual int extrapolate( const Vector3D& point, EVENT::TrackerHit* hit, IMPL::TrackStateImpl& ts, double& chi2, int& ndf ) = 0 ;
    
    virtual int extrapolateToLayer( int layerID, IMPL::TrackStateImpl& ts, double& chi2, int& ndf, int& detElementID, int mode=modeClosest ) = 0  ;
    
    virtual int extrapolateToLayer( int layerID, EVENT::TrackerHit* hit, IMPL::TrackStateImpl& ts, double& chi2, int& ndf, int& detElementID, int mode=modeClosest ) = 0  ;
    
    virtual int extrapolateToDetElement( int detElementID, IMPL::TrackStateImpl& ts, double& chi2, int& ndf, int mode=modeClosest ) = 0  ;
    
    virtual int extrapolateToDetElement( int detEementID, EVENT::TrackerHit* hit, IMPL::TrackStateImpl& ts, double& chi2, int& ndf, int mode=modeClosest ) = 0  ;
    
    
    // INTERSECTORS
    
    virtual int intersectionWithLayer( int layerID, Vector3D& point, int& detElementID, int mode=modeClosest ) = 0  ;
    
    virtual int intersectionWithLayer( int layerID, EVENT::TrackerHit* hit, Vector3D& point, int& detElementID, int mode=modeClosest ) = 0  ;

    
    virtual int intersectionWithDetElement( int detElementID, Vector3D& point, int mode=modeClosest ) = 0  ;


    virtual int intersectionWithDetElement( int detEementID, EVENT::TrackerHit* hit, Vector3D& point, int mode=modeClosest ) = 0  ;
    
    virtual std::string toString() ;


    //-------------------------------------------------------------------------------------------------------------------------------

#ifdef MARLINTRK_BACKWARD_GEAR_WRAPPERS

    int propagate( const gear::Vector3D& point, IMPL::TrackStateImpl& ts, double& chi2, int& ndf ){
      Vector3D v( point.x(), point.y(), point.z() ) ;
      return propagate( v, ts, chi2, ndf ) ;
    }
    int propagate( const gear::Vector3D& point, EVENT::TrackerHit* hit, IMPL::TrackStateImpl& ts, double& chi2, int& ndf ){
      Vector3D v( point.x(), point.y(), point.z() ) ;
      return propagate( v, hit, ts, chi2, ndf ) ;
    }
    int extrapolate( const gear::Vector3D& point, IMPL::TrackStateImpl& ts, double& chi2, int& ndf ){
      Vector3D v( point.x(), point.y(), point.z() ) ;
      return extrapolate( v, ts, chi2, ndf ) ;
    }
    int extrapolate( const gear::Vector3D& point, EVENT::TrackerHit* hit, IMPL::TrackStateImpl& ts, double& chi2, int& ndf ){
      Vector3D v( point.x(), point.y(), point.z() ) ;
      return extrapolate( v, hit, ts, chi2, ndf ) ;
    }
    int intersectionWithLayer( int layerID, gear::Vector3D& point, int& detElementID, int mode=modeClosest ){
      Vector3D v( point.x(), point.y(), point.z() ) ;
      int ret =  intersectionWithLayer( layerID, v, detElementID, mode ) ;
      point = v ;
      return ret ;
    }
    int intersectionWithLayer( int layerID, EVENT::TrackerHit* hit, gear::Vector3D& point, int& detElementID, int mode=modeClosest ){
      Vector3D v( point.x(), point.y(), point.z() ) ;
      int ret = intersectionWithLayer( layerID, hit, v, detElementID, mode ) ;
      point = v ;
      return ret ;
    }
    int intersectionWithDetElement( int detElementID, gear::Vector3D& point, int mode=modeClosest ){
      Vector3D v( point.x(), point.y(), point.z() ) ;
      int ret = intersectionWithDetElement( detElementID, v, mode ) ;
      point = v ;
      return ret ;
    }   
    int intersectionWithDetElement( int detElementID, EVENT::TrackerHit* hit, gear::Vector3D& point, int mode=modeClosest ){
      Vector3D v( point.x(), point.y(), point.z() ) ;
      int ret = intersectionWithDetElement( detElementID, hit, v, mode ) ;
      point = v ;
      return ret ;
    }

#endif

    //-------------------------------------------------------------------------------------------------------------------------------

    
  protected:
    
  private:
    
    IMarlinTrack& operator=( const IMarlinTrack&) ; // disallow assignment operator 
                
  } ;
  
  std::string errorCode( int error );
  
  
  
  
} // end of MarlinTrk namespace 

#endif