/data/refman/pasoursint/CMSSW_5_3_0/src/RecoVertex/GhostTrackFitter/interface/GhostTrackState.h

Go to the documentation of this file.

#ifndef RecoBTag_GhostTrackState_h
#define RecoBTag_GhostTrackState_h

#include <utility>

#include "DataFormats/GeometryVector/interface/GlobalPoint.h"
#include "DataFormats/GeometryVector/interface/GlobalVector.h"
#include "DataFormats/GeometryCommonDetAlgo/interface/GlobalError.h"

#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"

#include "RecoVertex/GhostTrackFitter/interface/BasicGhostTrackState.h"

class VertexState;

namespace reco {

class TransientTrack;
class GhostTrackPrediction;

class GhostTrackState : public BasicGhostTrackState::Proxy {
        typedef BasicGhostTrackState::Proxy Base;

    public:
        typedef BasicGhostTrackState::CovarianceMatrix CovarianceMatrix;
        typedef BasicGhostTrackState::Vertex Vertex;

        GhostTrackState(const TransientTrack &track);
        GhostTrackState(const GlobalPoint &pos, const CovarianceMatrix &cov);
        GhostTrackState(const GlobalPoint &pos, const GlobalError &error);
        GhostTrackState(const VertexState &state);

        const TransientTrack &track() const;
        const TrajectoryStateOnSurface &tsos() const;

        GlobalPoint globalPosition() const { return data().globalPosition(); }
        GlobalError cartesianError() const { return data().cartesianError(); }
        CovarianceMatrix cartesianCovariance() const { return data().cartesianCovariance(); }

        double lambda() const { return data().lambda(); }
        double lambdaError(const GhostTrackPrediction &pred,
                           const GlobalError &pvError = GlobalError()) const;
        bool isValid() const { return Base::isValid() && data().isValid(); }
        bool isTrack() const;
        bool isVertex() const;

        void reset() { unsharedData().reset(); }
        bool linearize(const GhostTrackPrediction &pred,
                       bool initial = false, double lambda = 0.)
        { return unsharedData().linearize(pred, initial, lambda); }
        bool linearize(const GhostTrackPrediction &pred, double lambda)
        { return unsharedData().linearize(pred, lambda); }

        double flightDistance(const GlobalPoint &point,
                              const GlobalVector &dir) const;
        double axisDistance(const GlobalPoint &point,
                            const GlobalVector &dir) const;
        double axisDistance(const GhostTrackPrediction &pred) const;

        Vertex vertexStateOnGhostTrack(
                                const GhostTrackPrediction &pred,
                                bool withMeasurementError = true) const
        { return data().vertexStateOnGhostTrack(pred, withMeasurementError); }
        Vertex vertexStateOnMeasurement(const GhostTrackPrediction &pred,
                                        bool withGhostTrackError = true) const
        { return data().vertexStateOnMeasurement(pred, withGhostTrackError); }

        double weight() const { return data().weight(); }
        void setWeight(double weight) { unsharedData().setWeight(weight); }
};

}

#endif // RecoBTag_GhostTrackState_h