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_() {
      for (index i = 0; i < covarianceSize; ++i) {
        outerCovariance_[i] = 0;
        innerCovariance_[i] = 0;
      }
    }

    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
    const PropagationDirection &seedDirection() const { return seedDir_; }

    const edm::RefToBase<TrajectorySeed> &seedRef() const { return seedRef_; }
    void setSeedRef(const 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_;
  };

}  // namespace reco

#endif