KalTrackingTemplate.h

#ifndef KALTRACKINGTEMPLATE_H
#define KALTRACKINGTEMPLATE_H

#include <map>
#include <list>
#include <EVENT/TrackerHit.h>
#include <IMPL/TrackImpl.h>
#include "TPCHitMap.h"
#include "TPCHitDomain.h"
#include <gear/TPCParameters.h>
#include <kaldet/GearTPCKalDetector.h>
#include <kaldet/GearTPCHit.h>
#include <gear/GearMgr.h>
#include <TMatrixD.h>
#include "TVector3.h"

#include "KalTrackingBase.h"

namespace marlintpc
{

  template <class ContainerT> class KalTrackingTemplate : public KalTrackingBase
{
    public:
        KalTrackingTemplate(const gear::GearMgr &gearMgr, 
                        unsigned int minTrackHits, 
                        unsigned int maxSkipRows, 
                        double maxDeltaChi2,
                        int hitDistanceFactor,
                        int startingHitMode,
                        double vDrift,
                        std::string modulesNotUsed);

        virtual ~KalTrackingTemplate();

        virtual std::list<EVENT::Track*>  findTracks(EVENT::LCCollection const * hitCollection);


        void setMaxDeltaChi2 (double max){_maxDeltaChi2 = max;}

        void setMinTrackHits(unsigned int min)
        {
            _minTrackHits = min;
        }

        void setMaxSkipRows(unsigned int max)
        {
            _maxSkipRows = max;
        }

    protected:
        virtual void printStateVector() = 0;

        virtual IMPL::TrackImpl* getTrack(ModuleRowHit firstHit);

        virtual void searchTrackHit();

        virtual bool searchTrack(ModuleRowHit hit) = 0;

        virtual bool doAddAndFilter(ContainerT * track, ModuleRowHit hit) = 0;

                virtual double getTrackTangentAndLayerAngle(ContainerT * trackCandidate) = 0;


        //      virtual ContainerT * createTrackCandidate( ModuleRowHit hit ) = 0;

        virtual double calculateDeltaChi2(ContainerT * trackCandidate) = 0;

        virtual void reset();

        //std::list<ModuleRowHit> _hitsOnTrack;
        std::vector<ModuleRowHit> _hitsOnTrack;
    
        gear::GearMgr const & _gearMgr;

        TPCHitDomain* _domain;


        const gear::TPCParameters&    _tpcParameters;

        //        ModuleRowHit _lastBestHit;

        unsigned int _minTrackHits;

        //FIXME:use enum
        int _direction;//+1: index increaing; -1: index decreasing
        static const int INWARDS=-1;
        static const int OUTWARDS=1;

        unsigned int _maxSkipRows;

        double _maxDeltaChi2;

                int _hitDistanceFactor;

                int _startingHitMode;
  
            double _vDrift; //< The drift velocity
        
        kaldet::GearTPCKalDetector _kalDetector;
    
        TKalDetCradle _detectorCradle;

        TPCHitMap _tpcHitMap;

        virtual void setLCIOTrackParameters(IMPL::TrackImpl* trk) = 0;

        ContainerT * _containerTrack;

        virtual kaldet::GearTPCHit * createGearHit( ModuleRowHit const & mhr ) const;

        struct Intersection
        {
          TVector3 coordinates;
          enum Status{IntersectionOK, OutOfDetector, NoIntersection, 
                      NoIntersectionInActiveRegion} status;

          Intersection(TVector3 _coordinates_, Status _status_) 
          :  coordinates(_coordinates_), status(_status_)
          {}
        };

        virtual Intersection extrapolateIntoNextLayer(int targetDistance,
                                                      bool useFarHit) = 0;

        virtual const kaldet::GearTPCMeasLayer* extrapolateIntoNextLayer(int targetDistance) = 0;

    private:
        KalTrackingTemplate(const KalTrackingTemplate& orig);
      
        KalTrackingTemplate& operator = (const KalTrackingTemplate& orig);
};

}
#endif  //KALTRACKINGTEMPLATE_H