/data/refman/pasoursint/CMSSW_6_1_2_SLHC2/src/RecoVertex/GhostTrackFitter/interface/GhostTrackPrediction.h

Go to the documentation of this file.

#ifndef RecoBTag_GhostTrackPrediction_h
#define RecoBTag_GhostTrackPrediction_h

#include <cmath>

#include <Math/SVector.h>
#include <Math/SMatrix.h>

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

class MagneticField;
class GlobalTrajectoryParameters;
class CurvilinearTrajectoryError;
class FreeTrajectoryState;

namespace reco {

class GhostTrackPrediction {
    public:
        // z0, tIP, dz/dr, phi

        typedef ROOT::Math::SVector<double, 4> Vector;
        typedef ROOT::Math::SMatrix<double, 4, 4,
                        ROOT::Math::MatRepSym<double, 4> > Error;
        typedef ROOT::Math::SMatrix<double, 6, 6,
                        ROOT::Math::MatRepSym<double, 6> > CartesianError;

        GhostTrackPrediction() {}
        GhostTrackPrediction(const Vector &prediction, const Error &error) :
                prediction_(prediction), covariance_(error)
        {}

        GhostTrackPrediction(const GlobalPoint &priorPosition, 
                             const GlobalError &priorError,
                             const GlobalVector &direction,
                             double coneRadius);

        GhostTrackPrediction(const GlobalPoint &priorPosition, 
                             const GlobalError &priorError,
                             const GlobalVector &direction,
                             const GlobalError &directionError)
        { init(priorPosition, priorError, direction, directionError); }

        GhostTrackPrediction(const GlobalTrajectoryParameters &trajectory,
                             const CurvilinearTrajectoryError &error);

        GhostTrackPrediction(const Track &track);

        double z() const { return prediction_[0]; }
        double ip() const { return prediction_[1]; }
        double cotTheta() const { return prediction_[2]; }
        double phi() const { return prediction_[3]; }

        double rho2() const { return cotTheta() * cotTheta() + 1.; }
        double rho() const { return std::sqrt(rho2()); }
        double sz() const { return z() / rho(); }
        double theta() const { return M_PI_2 - std::atan(cotTheta()); }
        double eta() const { return -std::log(rho() - cotTheta()); }

        const Vector &prediction() const { return prediction_; }
        const Error &covariance() const { return covariance_; }

        const GlobalPoint origin() const
        { return GlobalPoint(-std::sin(phi()) * ip(), std::cos(phi()) * ip(), z()); }
        const GlobalVector direction() const
        { return GlobalVector(std::cos(phi()), std::sin(phi()), cotTheta()); }

        double lambda(const GlobalPoint &point) const
        { return (point - origin()) * direction() / rho2(); }

        GlobalPoint position(double lambda = 0.) const
        { return origin() + lambda * direction(); }
        GlobalError positionError(double lambda = 0.) const;

        CartesianError cartesianError(double lambda = 0.) const;

        GlobalTrajectoryParameters globalTrajectory(
                                const MagneticField *fieldProvider) const;
        CurvilinearTrajectoryError curvilinearError() const;

        FreeTrajectoryState fts(const MagneticField *fieldProvider) const;

        Track track(double ndof = 0., double chi2 = 0.) const;

    private:
        void init(const GlobalPoint &priorPosition, 
                  const GlobalError &priorError,
                  const GlobalVector &direction,
                  const GlobalError &directionError);

        Vector  prediction_;
        Error   covariance_;
};

}
#endif // RecoBTag_GhostTrackPrediction_h