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