TrackExtra.h

Go to the documentation of this file.

#ifndef TrackReco_TrackExtra_h
#define TrackReco_TrackExtra_h

#include <Rtypes.h>
#include "DataFormats/Common/interface/RefToBase.h"
#include "DataFormats/Math/interface/Vector3D.h"
#include "DataFormats/Math/interface/Point3D.h"
#include "DataFormats/Math/interface/Error.h"
#include "DataFormats/TrackReco/interface/TrackExtraBase.h"
#include "DataFormats/TrackReco/interface/TrackResiduals.h"
#include "DataFormats/TrajectorySeed/interface/PropagationDirection.h"
#include "DataFormats/TrajectorySeed/interface/TrajectorySeed.h"
#include "FWCore/Utilities/interface/thread_safety_macros.h"

namespace reco
{
class TrackExtra : public TrackExtraBase
{
public:
    enum { dimension = 5 };
    enum { covarianceSize = dimension * (dimension + 1) / 2 };
    typedef math::XYZPoint Point;
    typedef math::XYZVector Vector;
    typedef math::Error<5>::type CovarianceMatrix;
    typedef unsigned int index;

    TrackExtra():
        outerMomentum_(),
        outerOk_(false),
        outerDetId_(0),
        innerPosition_(),
        innerMomentum_(),
        innerOk_(false),
        innerDetId_(0),
        seedDir_(anyDirection),
        seedRef_(),
        trackResiduals_() {
        index idx = 0;
        for (index i = 0; i < dimension; ++ i) {
            for (index j = 0; j <= i; ++ j) {
                outerCovariance_[idx] = 0;
                innerCovariance_[idx] = 0;
                ++idx;
            }
        }
    }

    TrackExtra(const Point & outerPosition, const Vector & outerMomentum, bool ok ,
               const Point & innerPosition, const Vector & innerMomentum, bool iok,
               const CovarianceMatrix& outerState, unsigned int outerId,
               const CovarianceMatrix& innerState, unsigned int innerId,
               PropagationDirection seedDir,
               edm::RefToBase<TrajectorySeed> seedRef = edm::RefToBase<TrajectorySeed>());

    const Point &outerPosition() const {
        return outerPosition_;
    }
    const Vector &outerMomentum() const {
        return outerMomentum_;
    }
    bool outerOk() const {
        return outerOk_;
    }
    const Point &innerPosition() const {
        return innerPosition_;
    }
    const Vector &innerMomentum() const {
        return innerMomentum_;
    }
    bool innerOk() const {
        return innerOk_;
    }
    double outerPx() const {
        return outerMomentum_.X();
    }
    double outerPy() const {
        return outerMomentum_.Y();
    }
    double outerPz() const {
        return outerMomentum_.Z();
    }
    double outerX() const {
        return outerPosition_.X();
    }
    double outerY() const {
        return outerPosition_.Y();
    }
    double outerZ() const {
        return outerPosition_.Z();
    }
    double outerP() const {
        return outerMomentum().R();
    }
    double outerPt() const {
        return outerMomentum().Rho();
    }
    double outerPhi() const {
        return outerMomentum().Phi();
    }
    double outerEta() const {
        return outerMomentum().Eta();
    }
    double outerTheta() const {
        return outerMomentum().Theta();
    }
    double outerRadius() const {
        return outerPosition().Rho();
    }

    CovarianceMatrix outerStateCovariance() const;
    CovarianceMatrix innerStateCovariance() const;
    CovarianceMatrix & fillOuter CMS_THREAD_SAFE (CovarianceMatrix &v) const;
    CovarianceMatrix & fillInner CMS_THREAD_SAFE (CovarianceMatrix &v) const;
    unsigned int outerDetId() const {
        return outerDetId_;
    }
    unsigned int innerDetId() const {
        return innerDetId_;
    }
    // direction how the hits were sorted in the original seed
    PropagationDirection seedDirection() const {
        return seedDir_;
    }

    edm::RefToBase<TrajectorySeed> seedRef() const {
        return seedRef_;
    }
    void setSeedRef(edm::RefToBase<TrajectorySeed> &r) {
        seedRef_ = r;
    }
    void setResiduals(const TrackResiduals &r) {
        trackResiduals_ = r;
    }

    const TrackResiduals &residuals() const {
        return trackResiduals_;
    }

private:

    Point outerPosition_;
    Vector outerMomentum_;
    bool outerOk_;
    float outerCovariance_[covarianceSize];
    unsigned int outerDetId_;


    Point innerPosition_;
    Vector innerMomentum_;
    bool innerOk_;
    float innerCovariance_[covarianceSize];
    unsigned int innerDetId_;

    PropagationDirection seedDir_;
    edm::RefToBase<TrajectorySeed> seedRef_;

    TrackResiduals trackResiduals_;
};

}

#endif