PerigeeLinearizedTrackState.h

Go to the documentation of this file.

#ifndef PerigeeLinearizedTrackState_H
#define PerigeeLinearizedTrackState_H

#include "RecoVertex/VertexPrimitives/interface/LinearizedTrackState.h"
#include "TrackingTools/PatternTools/interface/TSCPBuilderNoMaterial.h"
#include "DataFormats/GeometrySurface/interface/ReferenceCounted.h"
#include "RecoVertex/VertexPrimitives/interface/LinearizedTrackState.h"
#include "Math/SMatrix.h"
#include "DataFormats/CLHEP/interface/Migration.h"
#include "FWCore/Utilities/interface/Likely.h"

class PerigeeLinearizedTrackState final : public LinearizedTrackState<5> {
public:
  friend class LinearizedTrackStateFactory;
  typedef ReferenceCountingPointer<LinearizedTrackState<5> > RefCountedLinearizedTrackState;

  RefCountedLinearizedTrackState stateWithNewLinearizationPoint(const GlobalPoint& newLP) const override;

  const GlobalPoint& linearizationPoint() const override { return theLinPoint; }

  reco::TransientTrack track() const override { return theTrack; }

  const TrajectoryStateOnSurface state() const { return theTSOS; }

  const AlgebraicVector5& constantTerm() const override;

  const AlgebraicMatrix53& positionJacobian() const override;

  const AlgebraicMatrix53& momentumJacobian() const override;

  const AlgebraicVector5& parametersFromExpansion() const override;

  const TrajectoryStateClosestToPoint& predictedState() const;

  AlgebraicVector5 predictedStateParameters() const override;

  AlgebraicVector3 predictedStateMomentumParameters() const override;

  AlgebraicSymMatrix55 predictedStateWeight(int& error) const override;

  AlgebraicSymMatrix55 predictedStateError() const override;

  AlgebraicSymMatrix33 predictedStateMomentumError() const override;

  //   /** Method returning the impact point measurement
  //    */
  //   ImpactPointMeasurement impactPointMeasurement() const;

  TrackCharge charge() const override { return theCharge; }

  bool hasError() const override;

  bool operator==(LinearizedTrackState<5>& other) const override;

  bool operator==(ReferenceCountingPointer<LinearizedTrackState<5> >& other) const;

  RefCountedRefittedTrackState createRefittedTrackState(const GlobalPoint& vertexPosition,
                                                        const AlgebraicVector3& vectorParameters,
                                                        const AlgebraicSymMatrix66& covarianceMatrix) const override;

  AlgebraicVector5 refittedParamFromEquation(const RefCountedRefittedTrackState& theRefittedState) const override;

  double weightInMixture() const override { return theTSOS.weight(); }

  void inline checkParameters(AlgebraicVector5& parameters) const override;

  std::vector<ReferenceCountingPointer<LinearizedTrackState<5> > > components() const override;

  bool isValid() const override;

private:
  PerigeeLinearizedTrackState(const GlobalPoint& linP,
                              const reco::TransientTrack& track,
                              const TrajectoryStateOnSurface& tsos)
      : theLinPoint(linP), theTrack(track), theTSOS(tsos), theCharge(theTrack.charge()), jacobiansAvailable(false) {}

  void computeJacobians() const;
  void computeChargedJacobians() const;
  void computeNeutralJacobians() const;
  void compute3DImpactPoint() const;

  GlobalPoint theLinPoint;
  reco::TransientTrack theTrack;
  const TrajectoryStateOnSurface theTSOS;

  mutable AlgebraicMatrix53 thePositionJacobian, theMomentumJacobian;
  mutable TrajectoryStateClosestToPoint thePredState;
  mutable AlgebraicVector5 theConstantTerm;
  mutable AlgebraicVector5 theExpandedParams;

  TSCPBuilderNoMaterial builder;

  TrackCharge theCharge;
  mutable bool jacobiansAvailable;
};

inline const AlgebraicVector5& PerigeeLinearizedTrackState::constantTerm() const {
  if UNLIKELY (!jacobiansAvailable)
    computeJacobians();
  return theConstantTerm;
}

inline const AlgebraicMatrix53& PerigeeLinearizedTrackState::positionJacobian() const {
  if UNLIKELY (!jacobiansAvailable)
    computeJacobians();
  return thePositionJacobian;
}

inline const AlgebraicMatrix53& PerigeeLinearizedTrackState::momentumJacobian() const {
  if UNLIKELY (!jacobiansAvailable)
    computeJacobians();
  return theMomentumJacobian;
}

inline const AlgebraicVector5& PerigeeLinearizedTrackState::parametersFromExpansion() const {
  if UNLIKELY (!jacobiansAvailable)
    computeJacobians();
  return theExpandedParams;
}

inline const TrajectoryStateClosestToPoint& PerigeeLinearizedTrackState::predictedState() const {
  if UNLIKELY (!jacobiansAvailable)
    computeJacobians();
  return thePredState;
}

inline bool PerigeeLinearizedTrackState::hasError() const {
  if UNLIKELY (!jacobiansAvailable)
    computeJacobians();
  return thePredState.hasError();
}

inline AlgebraicVector5 PerigeeLinearizedTrackState::predictedStateParameters() const {
  if (!jacobiansAvailable)
    computeJacobians();
  return thePredState.perigeeParameters().vector();
}

inline AlgebraicVector3 PerigeeLinearizedTrackState::predictedStateMomentumParameters() const {
  if UNLIKELY (!jacobiansAvailable)
    computeJacobians();
  auto v = thePredState.perigeeParameters().vector();
  return AlgebraicVector3(v[0], v[1], v[2]);
}

inline AlgebraicSymMatrix55 PerigeeLinearizedTrackState::predictedStateWeight(int& error) const {
  if UNLIKELY (!jacobiansAvailable)
    computeJacobians();
  if (!thePredState.isValid()) {
    error = 1;
    return AlgebraicSymMatrix55();
  }
  return thePredState.perigeeError().weightMatrix(error);
}

inline AlgebraicSymMatrix55 PerigeeLinearizedTrackState::predictedStateError() const {
  if UNLIKELY (!jacobiansAvailable)
    computeJacobians();
  return thePredState.perigeeError().covarianceMatrix();
}

inline AlgebraicSymMatrix33 PerigeeLinearizedTrackState::predictedStateMomentumError() const {
  if UNLIKELY (!jacobiansAvailable)
    computeJacobians();
  return thePredState.perigeeError().covarianceMatrix().Sub<AlgebraicSymMatrix33>(0, 2);
}

inline bool PerigeeLinearizedTrackState::isValid() const {
  if UNLIKELY (!theTSOS.isValid())
    return false;
  if UNLIKELY (!jacobiansAvailable)
    computeJacobians();
  return jacobiansAvailable;
}

#endif