VertexTrack.h

Go to the documentation of this file.

#ifndef VertexTrack_H
#define VertexTrack_H

#include "RecoVertex/VertexPrimitives/interface/LinearizedTrackState.h"
#include "RecoVertex/VertexPrimitives/interface/VertexState.h"
#include "RecoVertex/VertexPrimitives/interface/RefittedTrackState.h"
#include "RecoVertex/VertexPrimitives/interface/VertexException.h"

#define SMATRIX_USE_CONSTEXPR
#include "Math/SMatrix.h"

template <unsigned int N>
class VertexTrack final : public ReferenceCounted {
public:
  typedef ROOT::Math::SVector<double, N> AlgebraicVectorN;
  typedef ROOT::Math::SMatrix<double, N - 2, N - 2, ROOT::Math::MatRepStd<double, N - 2, N - 2> > AlgebraicMatrixMM;
  typedef ROOT::Math::SMatrix<double, 3, N - 2, ROOT::Math::MatRepStd<double, 3, N - 2> > AlgebraicMatrix3M;
  typedef ROOT::Math::SMatrix<double, N + 1, N + 1, ROOT::Math::MatRepSym<double, N + 1> > AlgebraicSymMatrixOO;

  //typedef ReferenceCountingPointer<VertexTrack<N> > RefCountedVertexTrack;
  typedef ReferenceCountingPointer<LinearizedTrackState<N> > RefCountedLinearizedTrackState;
  typedef ReferenceCountingPointer<RefittedTrackState<N> > RefCountedRefittedTrackState;

  VertexTrack(RefCountedLinearizedTrackState lt, VertexState v, float weight);

  VertexTrack(RefCountedLinearizedTrackState lt,
              VertexState v,
              float weight,
              const RefCountedRefittedTrackState& refittedState,
              float smoothedChi2);

  VertexTrack(RefCountedLinearizedTrackState lt,
              VertexState v,
              float weight,
              const RefCountedRefittedTrackState& refittedState,
              float smoothedChi2,
              const AlgebraicSymMatrixOO& fullCov);

  RefCountedLinearizedTrackState linearizedTrack() const { return theLinTrack; }
  VertexState vertexState() const { return theVertexState; }
  float weight() const { return theWeight; }
  bool refittedStateAvailable() const { return stAvailable; }
  bool tkToVertexCovarianceAvailable() const { return covAvailable; }
  bool fullCovarianceAvailable() const { return covAvailable; }

  float smoothedChi2() const { return smoothedChi2_; }

  RefCountedRefittedTrackState refittedState() const {
    if (!refittedStateAvailable()) {
      throw VertexException("VertexTrack::refitted state not available");
    }
    return theRefittedState;
  }

  //   /** Track to vertex covariance
  //    */
  //   AlgebraicMatrix3M tkToVtxCovariance() const;

  AlgebraicSymMatrixOO fullCovariance() const {
    if (!tkToVertexCovarianceAvailable()) {
      throw VertexException("VertexTrack::track to vertex covariance not available");
    }
    return fullCovariance_;
  }

  bool operator==(const VertexTrack<N>& data) const { return ((*data.linearizedTrack()) == (*linearizedTrack())); }

  AlgebraicVectorN refittedParamFromEquation() const;

private:
  RefCountedLinearizedTrackState theLinTrack;
  VertexState theVertexState;
  float theWeight;
  bool stAvailable;
  bool covAvailable;
  RefCountedRefittedTrackState theRefittedState;
  AlgebraicSymMatrixOO fullCovariance_;
  ROOT::Math::SMatrix<double, 6, 6, ROOT::Math::MatRepSym<double, 6> > b6;
  ROOT::Math::SMatrix<double, 7, 7, ROOT::Math::MatRepSym<double, 7> > b7;
  float smoothedChi2_;
};

template <unsigned int N>
class VertexTrackEqual {
public:
  typedef ReferenceCountingPointer<VertexTrack<N> > RefCountedVertexTrack;
  VertexTrackEqual(const RefCountedVertexTrack& t) : track_(t) {}
  bool operator()(const RefCountedVertexTrack& t) const { return t->operator==(*track_); }

private:
  const RefCountedVertexTrack& track_;
};

#endif