TrackKinematicStatePropagator.cc

Go to the documentation of this file.

#include "RecoVertex/KinematicFitPrimitives/interface/TrackKinematicStatePropagator.h"
#include "TrackingTools/AnalyticalJacobians/interface/JacobianCartesianToCurvilinear.h"
#include "TrackingTools/AnalyticalJacobians/interface/JacobianCurvilinearToCartesian.h"
#include "TrackingTools/AnalyticalJacobians/interface/AnalyticalCurvilinearJacobian.h"
#include "DataFormats/GeometrySurface/interface/BoundPlane.h"
#include "DataFormats/GeometrySurface/interface/OpenBounds.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
 
using namespace std;
 
KinematicState TrackKinematicStatePropagator::propagateToTheTransversePCA(const KinematicState& state,
                                                                          const GlobalPoint& referencePoint) const {
  if (state.particleCharge() == 0.) {
    return propagateToTheTransversePCANeutral(state, referencePoint);
  } else {
    return propagateToTheTransversePCACharged(state, referencePoint);
  }
}
 
namespace {
  inline pair<HelixBarrelPlaneCrossingByCircle, BoundPlane::BoundPlanePointer> planeCrossing(
      const FreeTrajectoryState& state, const GlobalPoint& point) {
    typedef Point3DBase<double, GlobalTag> GlobalPointDouble;
    typedef Vector3DBase<double, GlobalTag> GlobalVectorDouble;
 
    GlobalPoint inPos = state.position();
    GlobalVector inMom = state.momentum();
    double kappa = state.transverseCurvature();
    double fac = state.charge() / state.parameters().magneticFieldInInverseGeV(point).z();
 
    GlobalVectorDouble xOrig2Centre(fac * inMom.y(), -fac * inMom.x(), 0.);
    GlobalVectorDouble xOrigProj(inPos.x(), inPos.y(), 0.);
    GlobalVectorDouble xRefProj(point.x(), point.y(), 0.);
    GlobalVectorDouble deltax = xRefProj - xOrigProj - xOrig2Centre;
    GlobalVectorDouble ndeltax = deltax.unit();
 
    PropagationDirection direction = anyDirection;
    Surface::PositionType pos(point);
 
    // Need to define plane with orientation as the ImpactPointSurface
    GlobalVector X(ndeltax.x(), ndeltax.y(), ndeltax.z());
    GlobalVector Y(0., 0., 1.);
    Surface::RotationType rot(X, Y);
    Plane::PlanePointer plane = Plane::build(pos, rot);
    HelixBarrelPlaneCrossingByCircle planeCrossing(HelixPlaneCrossing::PositionType(inPos.x(), inPos.y(), inPos.z()),
                                                   HelixPlaneCrossing::DirectionType(inMom.x(), inMom.y(), inMom.z()),
                                                   kappa,
                                                   direction);
    return std::pair<HelixBarrelPlaneCrossingByCircle, Plane::PlanePointer>(planeCrossing, plane);
  }
}  // namespace
 
bool TrackKinematicStatePropagator::willPropagateToTheTransversePCA(const KinematicState& state,
                                                                    const GlobalPoint& point) const {
  if (state.particleCharge() == 0.)
    return true;
 
  // copied from below...
  FreeTrajectoryState const& fState = state.freeTrajectoryState();
  std::pair<HelixBarrelPlaneCrossingByCircle, BoundPlane::BoundPlanePointer> cros = planeCrossing(fState, point);
 
  HelixBarrelPlaneCrossingByCircle planeCrossing = cros.first;
  BoundPlane::BoundPlanePointer plane = cros.second;
  std::pair<bool, double> propResult = planeCrossing.pathLength(*plane);
  return propResult.first;
}
 
KinematicState TrackKinematicStatePropagator::propagateToTheTransversePCACharged(
    const KinematicState& state, const GlobalPoint& referencePoint) const {
  //first use the existing FTS propagator to obtain parameters at PCA
  //in transverse plane to the given point
 
  //final parameters and covariance
 
  //initial parameters as class and vectors:
  //making a free trajectory state and looking
  //for helix barrel plane crossing
  FreeTrajectoryState const& fState = state.freeTrajectoryState();
  const GlobalPoint& iP = referencePoint;
  std::pair<HelixBarrelPlaneCrossingByCircle, BoundPlane::BoundPlanePointer> cros = planeCrossing(fState, iP);
 
  HelixBarrelPlaneCrossingByCircle planeCrossing = cros.first;
  BoundPlane::BoundPlanePointer plane = cros.second;
  std::pair<bool, double> propResult = planeCrossing.pathLength(*plane);
  if (!propResult.first) {
    LogDebug("RecoVertex/TrackKinematicStatePropagator") << "Propagation failed! State is invalid\n";
    return KinematicState();
  }
  double s = propResult.second;
 
  GlobalTrajectoryParameters const& inPar = state.trajectoryParameters();
  ParticleMass mass = state.mass();
  GlobalVector inMom = state.globalMomentum();
 
  HelixPlaneCrossing::PositionType xGen = planeCrossing.position(s);
  GlobalPoint nPosition(xGen.x(), xGen.y(), xGen.z());
  HelixPlaneCrossing::DirectionType pGen = planeCrossing.direction(s);
  pGen *= inMom.mag() / pGen.mag();
  GlobalVector nMomentum(pGen.x(), pGen.y(), pGen.z());
  AlgebraicVector7 par;
  AlgebraicSymMatrix77 cov;
  par(0) = nPosition.x();
  par(1) = nPosition.y();
  par(2) = nPosition.z();
  par(3) = nMomentum.x();
  par(4) = nMomentum.y();
  par(5) = nMomentum.z();
  par(6) = mass;
 
  //covariance matrix business
  //elements of 7x7 covariance matrix responcible for the mass and
  //mass - momentum projections corellations do change under such a transformation:
  //special Jacobian needed
  GlobalTrajectoryParameters fPar(nPosition, nMomentum, state.particleCharge(), state.magneticField());
 
  // check if correlation are present between mass and others
  bool thereIsNoCorr = true;
 
  for (auto i = 0; i < 6; ++i)
    thereIsNoCorr &= (0 == state.kinematicParametersError().matrix()(i, 6));
 
  if (thereIsNoCorr) {
    //  easy life
    AnalyticalCurvilinearJacobian prop(inPar, nPosition, nMomentum, s);
    AlgebraicSymMatrix55 cov2 = ROOT::Math::Similarity(prop.jacobian(), fState.curvilinearError().matrix());
    FreeTrajectoryState fts(fPar, CurvilinearTrajectoryError(cov2));
 
    return KinematicState(fts, state.mass(), std::sqrt(state.kinematicParametersError().matrix()(6, 6)));
 
    //KinematicState kRes(fts, state.mass(), std::sqrt(state.kinematicParametersError().matrix()(6,6)));
    //std::cout << "\n\ncart from final Kstate\n" << kRes.kinematicParametersError().matrix() << std::endl;
    // std::cout << "curv from final K\n" << kRes.freeTrajectoryState().curvilinearError().matrix() << std::endl;
 
  } else {
    JacobianCartesianToCurvilinear cart2curv(inPar);
    JacobianCurvilinearToCartesian curv2cart(fPar);
 
    AlgebraicMatrix67 ca2cu;
    AlgebraicMatrix76 cu2ca;
    ca2cu.Place_at(cart2curv.jacobian(), 0, 0);
    cu2ca.Place_at(curv2cart.jacobian(), 0, 0);
    ca2cu(5, 6) = 1;
    cu2ca(6, 5) = 1;
 
    //now both transformation jacobians: cartesian to curvilinear and back are done
    //We transform matrix to curv frame, then propagate it and translate it back to
    //cartesian frame.
    AlgebraicSymMatrix66 cov1 = ROOT::Math::Similarity(ca2cu, state.kinematicParametersError().matrix());
 
    /*
      std::cout << "\n\ncurv from Kstate\n" << cov1 << std::endl;
      std::cout << "curv from fts\n" << fState.curvilinearError().matrix() << std::endl;
    */
 
    //propagation jacobian
    AnalyticalCurvilinearJacobian prop(inPar, nPosition, nMomentum, s);
    AlgebraicMatrix66 pr;
    pr(5, 5) = 1;
    pr.Place_at(prop.jacobian(), 0, 0);
 
    //transportation
    AlgebraicSymMatrix66 cov2 = ROOT::Math::Similarity(pr, cov1);
 
    //now geting back to 7-parametrization from curvilinear
    cov = ROOT::Math::Similarity(cu2ca, cov2);
 
    /*
      std::cout << "curv prop \n" << cov2 << std::endl;
   std::cout << "cart prop\n" << cov << std::endl;
    */
 
    //return parameters as a kiematic state
    KinematicParameters resPar(par);
    KinematicParametersError resEr(cov);
 
    return KinematicState(resPar, resEr, state.particleCharge(), state.magneticField());
 
    /*
    KinematicState resK(resPar,resEr,state.particleCharge(), state.magneticField());
    std::cout << "\ncurv from K prop\n" << resK.freeTrajectoryState().curvilinearError().matrix() << std::endl;
    return resK;
  */
  }
}
 
KinematicState TrackKinematicStatePropagator::propagateToTheTransversePCANeutral(
    const KinematicState& state, const GlobalPoint& referencePoint) const {
  //new parameters vector and covariance:
  AlgebraicVector7 par;
  AlgebraicSymMatrix77 cov;
 
  //AlgebraicVector7 inStatePar = state.kinematicParameters().vector();
  GlobalTrajectoryParameters const& inPar = state.trajectoryParameters();
 
  //first making a free trajectory state and propagating it according
  //to the algorithm provided by Thomas Speer and Wolfgang Adam
  FreeTrajectoryState const& fState = state.freeTrajectoryState();
 
  GlobalPoint xvecOrig = fState.position();
  double phi = fState.momentum().phi();
  double theta = fState.momentum().theta();
  double xOrig = xvecOrig.x();
  double yOrig = xvecOrig.y();
  double zOrig = xvecOrig.z();
  double xR = referencePoint.x();
  double yR = referencePoint.y();
 
  double s2D = (xR - xOrig) * cos(phi) + (yR - yOrig) * sin(phi);
  double s = s2D / sin(theta);
  double xGen = xOrig + s2D * cos(phi);
  double yGen = yOrig + s2D * sin(phi);
  double zGen = zOrig + s2D / tan(theta);
  GlobalPoint xPerigee = GlobalPoint(xGen, yGen, zGen);
 
  //new parameters
  GlobalVector pPerigee = fState.momentum();
  par(0) = xPerigee.x();
  par(1) = xPerigee.y();
  par(2) = xPerigee.z();
  par(3) = pPerigee.x();
  par(4) = pPerigee.y();
  par(5) = pPerigee.z();
  // par(6) = inStatePar(7);
  par(6) = state.mass();
 
  //covariance matrix business:
  //everything lake it was before: jacobains are smart enouhg to
  //distinguish between neutral and charged states themselves
 
  GlobalTrajectoryParameters fPar(xPerigee, pPerigee, state.particleCharge(), state.magneticField());
 
  JacobianCartesianToCurvilinear cart2curv(inPar);
  JacobianCurvilinearToCartesian curv2cart(fPar);
 
  AlgebraicMatrix67 ca2cu;
  AlgebraicMatrix76 cu2ca;
  ca2cu.Place_at(cart2curv.jacobian(), 0, 0);
  cu2ca.Place_at(curv2cart.jacobian(), 0, 0);
  ca2cu(5, 6) = 1;
  cu2ca(6, 5) = 1;
 
  //now both transformation jacobians: cartesian to curvilinear and back are done
  //We transform matrix to curv frame, then propagate it and translate it back to
  //cartesian frame.
  AlgebraicSymMatrix66 cov1 = ROOT::Math::Similarity(ca2cu, state.kinematicParametersError().matrix());
 
  //propagation jacobian
  AnalyticalCurvilinearJacobian prop(inPar, xPerigee, pPerigee, s);
  AlgebraicMatrix66 pr;
  pr(5, 5) = 1;
  pr.Place_at(prop.jacobian(), 0, 0);
 
  //transportation
  AlgebraicSymMatrix66 cov2 = ROOT::Math::Similarity(pr, cov1);
 
  //now geting back to 7-parametrization from curvilinear
  cov = ROOT::Math::Similarity(cu2ca, cov2);
 
  // FreeTrajectoryState fts(fPar);
 
  //return parameters as a kiematic state
  KinematicParameters resPar(par);
  KinematicParametersError resEr(cov);
  return KinematicState(resPar, resEr, state.particleCharge(), state.magneticField());
 
  //return  KinematicState(fts,state.mass(), cov(6,6));
}