vertex_lcfi/inc/trackstate.h

#ifndef TRACKSTATE_H
#define TRACKSTATE_H

#include "../util/inc/vector3.h"
#include "../util/inc/matrix.h"
#include "../util/inc/helixrep.h"
#include "../inc/track.h"
#include <ostream>

namespace vertex_lcfi
{
        using namespace util;
        //Forward Declarations
        class Track;    


        class TrackState
        {
        public:
                ~TrackState()
                {}
                        

                TrackState(Track* Track);
                

                TrackState(const HelixRep & init,const double & cha, const SymMatrix5x5 & cov, Track* tra);
                
                void resetToRef();
                
                void swimDistance(const double s);
                
                void swimToStateNearest(const Vector3 & Point);
                
                void swimToStateNearest(TrackState* const TrackToSwimTo);

                void swimToStateNearestXY(const Vector3 & Point);

                //Comparison methods I haven't used operator= as I think thats confusing
                //it could mean either same state(position) or same track.
                inline bool sameTrack(TrackState* const Track) const
                {return (this->parentTrack() == Track->parentTrack());}

                inline bool sameTrack(Track* const Track) const
                {return (this->parentTrack() == Track);}

                inline double distanceTo(const Vector3 & Point) const
                {return this->position().distanceTo(Point);}

                inline double distanceTo2(const Vector3 & Point) const
                {return this->position().distanceTo2(Point);}
                
                inline double xyDistanceTo(const Vector3 &Point) const
                {return this->position().subtract(Point).mag(RPhi);}
                
                double chi2(const Vector3 &Point);
                
                double chi2_nomove(const Vector3 &Point);
                
                //const Vector3 &       momentum() const;
                
                const Vector3 &         position() const;
                
                inline double phi() const
                {return std::fmod(_Init.phi()+(_DistanceSwum*(_Init.invR())), 2.0*3.141592654);}
                
                inline double charge() const
                {return _Charge;}
                
                inline bool isNeutral() const
                {return (fabs(_Charge)<0.000001);} //Floating point, hence no comparison to zero
                
                inline bool isCharged() const
                {return !this->isNeutral();}
                
                const SymMatrix2x2&     positionCovarMatrix() const;
                
                const SymMatrix2x2&     inversePositionCovarMatrix() const;
                
                const Matrix3x3         vertexErrorContribution(Vector3 point) const;
                
                const SymMatrix3x3&     positionCovarMatrixXYZ() const;
                
                const SymMatrix3x3&     inversePositionCovarMatrixXYZ() const;
                
                inline Track*                   parentTrack() const
                {return _ParentTrack;}

                void                    debugOut();
                
                
        private:
                //Private to prevent usauge of default constructor
                TrackState()
                {}
                
                double                  _Charge;
        
                HelixRep                _Init;
                //Order tsi,eta,theta,phi,invr
                SymMatrix5x5            _InitCovarMatrix;
                
                mutable Vector3         _Position;
                mutable bool            _PosValid;
                
                mutable Vector3         _Momentum;
                mutable bool            _MomValid;
                                
                mutable SymMatrix2x2    _PositionCovarMatrix;
                mutable bool            _PositionCovarValid;
                                
                mutable SymMatrix2x2    _InversePositionCovarMatrix;
                mutable bool            _InversePositionCovarValid;
                
                mutable SymMatrix3x3    _PositionCovarMatrixXYZ;
                mutable bool            _PositionCovarValidXYZ;
                                
                mutable SymMatrix3x3    _InversePositionCovarMatrixXYZ;
                mutable bool            _InversePositionCovarValidXYZ;
                                
                double                  _DistanceSwum;
                
                //Pointer to Track that created this state
                Track*                  _ParentTrack;

                //Swimmer to use if none specified
                static const double     _swimprecision; //Set in CPP file
        };

        template <class charT, class traits> inline
        std::basic_ostream<charT,traits>& operator<<(std::basic_ostream<charT,traits>&os,const TrackState& ts) 
        {
                os << "TrackState: " << ts.parentTrack()->trackingNum() << " @ " << ts.position() << " C" << ts.isCharged() <<" H:" << ts.parentTrack()->helixRep() << " err" << ts.parentTrack()->covarianceMatrix()<< std::endl;
                return os;
        } 
}
#endif //TRACKSTATE_H