trkf::TrackStatePropagator Class Reference

Class for propagation of a trkf::TrackState to a recob::tracking::Plane. More...

#include "TrackStatePropagator.h"

Classes
struct	Config

Public Types
enum	PropDirection { FORWARD =0, BACKWARD =1, UNKNOWN =2 }
	Propagation direction enum. More...
using	Plane = recob::tracking::Plane
using	Point_t = recob::tracking::Point_t
using	Vector_t = recob::tracking::Vector_t
using	SVector6 = recob::tracking::SVector6
using	Parameters = fhicl::Table< Config >

Public Member Functions
	TrackStatePropagator (double minStep, double maxElossFrac, int maxNit, double tcut, double wrongDirDistTolerance, bool propPinvErr)
	Constructor from parameter values. More...
	TrackStatePropagator (Parameters const &p)
	Constructor from Parameters (fhicl::Table<Config>). More...
virtual	~TrackStatePropagator ()
	Destructor. More...
TrackState	propagateToPlane (bool &success, const TrackState &origin, const Plane &target, bool dodedx, bool domcs, PropDirection dir=FORWARD) const
	Main function for propagation of a TrackState to a Plane. More...
TrackState	rotateToPlane (bool &success, const TrackState &origin, const Plane &target) const
	Rotation of a TrackState to a Plane (zero distance propagation) More...
Point_t	propagatedPosByDistance (const Point_t &origpos, const Vector_t &origdir, double distance) const
	Quick accesss to the propagated position given a distance. More...
void	apply_dedx (double &pinv, double dedx, double e1, double mass, double s, double &deriv) const
	Apply energy loss. More...
bool	apply_mcs (double dudw, double dvdw, double pinv, double mass, double s, double range, double p, double e2, bool flipSign, SMatrixSym55 &noise_matrix) const
	Apply multiple coulomb scattering. More...
double	getTcut () const
	get Tcut parameter used in DetectorPropertiesService Eloss method More...
double	distanceToPlane (bool &success, const Point_t &origpos, const Vector_t &origdir, const Plane &target) const
	Distance of a TrackState (Point and Vector) to a Plane, along the TrackState direction. More...
double	distanceToPlane (bool &success, const TrackState &origin, const Plane &target) const
	Distance of a TrackState (Point and Vector) to a Plane, along the TrackState direction. More...
double	perpDistanceToPlane (bool &success, const Point_t &origpos, const Plane &target) const
	Distance of a TrackState (Point) to a Plane along the direction orthogonal to the Plane. More...
double	perpDistanceToPlane (bool &success, const TrackState &origin, const Plane &target) const
	Distance of a TrackState (Point) to a Plane along the direction orthogonal to the Plane. More...
std::pair< double, double >	distancePairToPlane (bool &success, const Point_t &origpos, const Vector_t &origdir, const Plane &target) const
	Return both direction types in one go. More...
std::pair< double, double >	distancePairToPlane (bool &success, const TrackState &origin, const Plane &target) const
	Return both direction types in one go. More...

Private Member Functions
TrackState	rotateToPlane (bool &success, const TrackState &origin, const Plane &target, double &dw2dw1) const
	Rotation of a TrackState to a Plane (zero distance propagation), keeping track of dw2dw1 (needed by mcs) More...

Private Attributes
double	fMinStep
	Minimum propagation step length guaranteed. More...
double	fMaxElossFrac
	Maximum propagation step length based on fraction of energy loss. More...
int	fMaxNit
	Maximum number of iterations. More...
double	fTcut
	Maximum delta ray energy for dE/dx. More...
double	fWrongDirDistTolerance
	Allowed propagation distance in the wrong direction. More...
bool	fPropPinvErr
	Propagate error on 1/p or not (in order to avoid infs, it should be set to false when 1/p not updated) More...
const detinfo::DetectorProperties *	detprop
const detinfo::LArProperties *	larprop

Detailed Description

Class for propagation of a trkf::TrackState to a recob::tracking::Plane.

Author

G. Cerati (FNAL, MicroBooNE)

Date

2017

Version

1.0

This class holds the functionalities needed to propagate a trkf::TrackState to a recob::tracking::Plane. While the core physics is mainly duplicated from trkf::Propagator and its derived classes (kudos to H. Greenlee), the code and the interface are optimized for usage with classes based on SMatrix (e.g. TrackState) and for the needs of TrackKalmanFitter.

While the propagated position can be directly computed, accounting for the material effects in the covariance matrix requires an iterative procedure in case of long propagations distances.

For configuration options see TrackStatePropagator::Config

Definition at line 37 of file TrackStatePropagator.h.

Member Typedef Documentation

using trkf::TrackStatePropagator::Parameters = fhicl::Table<Config>

Definition at line 80 of file TrackStatePropagator.h.

using trkf::TrackStatePropagator::Plane = recob::tracking::Plane

Definition at line 41 of file TrackStatePropagator.h.

using trkf::TrackStatePropagator::Point_t = recob::tracking::Point_t

Definition at line 42 of file TrackStatePropagator.h.

using trkf::TrackStatePropagator::SVector6 = recob::tracking::SVector6

Definition at line 44 of file TrackStatePropagator.h.

using trkf::TrackStatePropagator::Vector_t = recob::tracking::Vector_t

Definition at line 43 of file TrackStatePropagator.h.

Member Enumeration Documentation

enum trkf::TrackStatePropagator::PropDirection

Propagation direction enum.

Enumerator
FORWARD
BACKWARD
UNKNOWN

Definition at line 83 of file TrackStatePropagator.h.

{FORWARD=0, BACKWARD=1, UNKNOWN=2};

Constructor & Destructor Documentation

trkf::TrackStatePropagator::TrackStatePropagator	(	double	minStep,
		double	maxElossFrac,
		int	maxNit,
		double	tcut,
		double	wrongDirDistTolerance,
		bool	propPinvErr
	)

Constructor from parameter values.

Definition at line 11 of file TrackStatePropagator.cxx.

References detprop, and larprop.

                                                                                                                                                         :
    fMinStep(minStep),
    fMaxElossFrac(maxElossFrac),
    fMaxNit(maxNit),
    fTcut(tcut),
    fWrongDirDistTolerance(wrongDirDistTolerance),
    fPropPinvErr(propPinvErr)
  {
    detprop = art::ServiceHandle<detinfo::DetectorPropertiesService>()->provider();
    larprop = lar::providerFrom<detinfo::LArPropertiesService>();
  }

trkf::TrackStatePropagator::TrackStatePropagator ( Parameters const &  p )

inlineexplicit

Constructor from Parameters (fhicl::Table<Config>).

Definition at line 89 of file TrackStatePropagator.h.

References dir, geo::origin(), and target.

: TrackStatePropagator(p().minStep(),p().maxElossFrac(),p().maxNit(),p().tcut(),p().wrongDirDistTolerance(),p().propPinvErr()) {}

trkf::TrackStatePropagator::~TrackStatePropagator ( )

virtual

Destructor.

Definition at line 23 of file TrackStatePropagator.cxx.

{}

Member Function Documentation

void trkf::TrackStatePropagator::apply_dedx	(	double &	pinv,
		double	dedx,
		double	e1,
		double	mass,
		double	s,
		double &	deriv
	)		const

Apply energy loss.

Definition at line 217 of file TrackStatePropagator.cxx.

References detprop, detinfo::DetectorProperties::Eloss(), and fTcut.

Referenced by propagateToPlane().

  {
    // For infinite initial momentum, return with infinite momentum.
    if (pinv == 0.) return;
    //
    const double emid = e1 - 0.5 * s * dedx;
    if(emid > mass) {
      const double pmid = std::sqrt(emid*emid - mass*mass);
      const double e2 = e1 - 0.001 * s * detprop->Eloss(pmid, mass, fTcut);
      if(e2 > mass) {
        const double p2 = std::sqrt(e2*e2 - mass*mass);
        double pinv2 = 1./p2;
        if(pinv < 0.) pinv2 = -pinv2;
        // derivative
        deriv = pinv2*pinv2*pinv2 * e2 / (pinv*pinv*pinv * e1);
        // update result.
        pinv = pinv2;
      }
    }
    return;
  }

bool trkf::TrackStatePropagator::apply_mcs	(	double	dudw,
		double	dvdw,
		double	pinv,
		double	mass,
		double	s,
		double	range,
		double	p,
		double	e2,
		bool	flipSign,
		SMatrixSym55 &	noise_matrix
	)		const

Apply multiple coulomb scattering.

Definition at line 239 of file TrackStatePropagator.cxx.

References detinfo::DetectorProperties::Density(), detprop, detinfo::DetectorProperties::ElossVar(), fPropPinvErr, larprop, and detinfo::LArProperties::RadiationLength().

Referenced by propagateToPlane().

                                                                                                                                                                                       {
    // If distance is zero, or momentum is infinite, return zero noise.

    if(pinv == 0. || s == 0.)
      return true;

    // Use crude estimate of the range of the track.
    if(range > 100.) range = 100.;
    const double p2 = p*p;

    // Calculate the radiation length in cm.
    const double x0 = larprop->RadiationLength() / detprop->Density();

    // Calculate projected rms scattering angle.
    // Use the estimted range in the logarithm factor.
    // Use the incremental propagation distance in the square root factor.
    const double betainv = std::sqrt(1. + pinv*pinv * mass*mass);
    const double theta_fact = (0.0136 * pinv * betainv) * (1. + 0.038 * std::log(range/x0));
    const double theta02 = theta_fact*theta_fact * std::abs(s/x0);

    // Calculate some common factors needed for multiple scattering.
    const double ufact2 = 1. + dudw*dudw;
    const double vfact2 = 1. + dvdw*dvdw;
    const double uvfact2 = 1. + dudw*dudw + dvdw*dvdw;
    const double uvfact = std::sqrt(uvfact2);
    const double uv = dudw * dvdw;
    const double dist2_3 = s*s / 3.;
    double dist_2 = std::abs(s) / 2.;
    if(flipSign) dist_2 = -dist_2;

    // Calculate energy loss fluctuations.

    const double evar = 1.e-6 * detprop->ElossVar(p, mass) * std::abs(s); // E variance (GeV^2).
    const double pinvvar = evar * e2 / (p2*p2*p2);                        // Inv. p variance (1/GeV^2)

    // Update elements of noise matrix.

    // Position submatrix.
    noise_matrix(0,0) += dist2_3 * theta02 * ufact2;           // sigma^2(u,u)
    noise_matrix(1,0) += dist2_3 * theta02 * uv;               // sigma^2(u,v)
    noise_matrix(1,1) += dist2_3 * theta02 * vfact2;           // sigma^2(v,v)

    // Slope submatrix.
    noise_matrix(2,2) += theta02 * uvfact2 * ufact2;           // sigma^2(u', u')
    noise_matrix(3,2) += theta02 * uvfact2 * uv;               // sigma^2(v', u')
    noise_matrix(3,3) += theta02 * uvfact2 * vfact2;           // sigma^2(v', v')

    // Same-view position-slope correlations.
    noise_matrix(2,0) += dist_2 * theta02 * uvfact * ufact2;   // sigma^2(u', u)
    noise_matrix(3,1) += dist_2 * theta02 * uvfact * vfact2;   // sigma^2(v', v)

    // Opposite-view position-slope correlations.
    noise_matrix(2,1) += dist_2 * theta02 * uvfact * uv;       // sigma^2(u', v)
    noise_matrix(3,0) += dist_2 * theta02 * uvfact * uv;       // sigma^2(v', u)

    // Momentum correlations (zero).
    // noise_matrix(4,0) += 0.;                                   // sigma^2(pinv, u)
    // noise_matrix(4,1) += 0.;                                   // sigma^2(pinv, v)
    // noise_matrix(4,2) += 0.;                                   // sigma^2(pinv, u')
    // noise_matrix(4,3) += 0.;                                   // sigma^2(pinv, v')

    // Energy loss fluctuations.
    if (fPropPinvErr) noise_matrix(4,4) += pinvvar;               // sigma^2(pinv, pinv)

    // Done (success).
    return true;
  }

std::pair< double, double > trkf::TrackStatePropagator::distancePairToPlane	(	bool &	success,
		const Point_t &	origpos,
		const Vector_t &	origdir,
		const Plane &	target
	)		const

Return both direction types in one go.

Definition at line 201 of file TrackStatePropagator.cxx.

References recob::tracking::Plane::direction(), recob::tracking::Plane::position(), and s.

Referenced by propagateToPlane().

                                                                                                                                                            {
    const Point_t& targpos = target.position();
    const Vector_t& targdir = target.direction();
    //check that origmom is not along the plane, i.e. targdir.Dot(origmom.Unit())=0
    if (targdir.Dot(origmom.Unit())==0) {
      success = false;
      return std::pair<double, double>(DBL_MAX,DBL_MAX);
    }
    //point-plane distance projected along direction orthogonal to the plane
    double sperp = targdir.Dot(targpos-origpos);
    //distance along track direction
    double s = sperp/targdir.Dot(origmom.Unit());
    success = true;
    return std::pair<double, double>(s,sperp);
  }

std::pair<double, double> trkf::TrackStatePropagator::distancePairToPlane ( bool &  success, const TrackState &  origin, const Plane &  target  ) const

inline

Return both direction types in one go.

Definition at line 122 of file TrackStatePropagator.h.

References trkf::TrackState::momentum(), trkf::TrackState::position(), s, and target.

                                                                                                                           {
      return distancePairToPlane(success, origin.position(), origin.momentum().Unit(), target);
    }

double trkf::TrackStatePropagator::distanceToPlane	(	bool &	success,
		const Point_t &	origpos,
		const Vector_t &	origdir,
		const Plane &	target
	)		const

Distance of a TrackState (Point and Vector) to a Plane, along the TrackState direction.

Definition at line 178 of file TrackStatePropagator.cxx.

References recob::tracking::Plane::direction(), recob::tracking::Plane::position(), and s.

Referenced by trkf::TrackKalmanFitter::doFitWork(), and trkf::TrackKalmanFitter::setupInputStates().

                                                                                                                                        {
    const Point_t& targpos = target.position();
    const Vector_t& targdir = target.direction();
    //check that origmom is not along the plane, i.e. targdir.Dot(origmom.Unit())=0
    if (targdir.Dot(origmom.Unit())==0) {
      success = false;
      return DBL_MAX;
    }
    //distance along track direction
    double s = targdir.Dot(targpos-origpos)/targdir.Dot(origmom.Unit());
    success = true;
    return s;
  }

double trkf::TrackStatePropagator::distanceToPlane ( bool &  success, const TrackState &  origin, const Plane &  target  ) const

inline

Distance of a TrackState (Point and Vector) to a Plane, along the TrackState direction.

Definition at line 106 of file TrackStatePropagator.h.

References trkf::TrackState::momentum(), trkf::TrackState::position(), and target.

                                                                                                      {
      return distanceToPlane(success, origin.position(), origin.momentum().Unit(), target);
    }

double trkf::TrackStatePropagator::getTcut ( ) const

inline

get Tcut parameter used in DetectorPropertiesService Eloss method

Definition at line 134 of file TrackStatePropagator.h.

{return fTcut;}

double trkf::TrackStatePropagator::perpDistanceToPlane	(	bool &	success,
		const Point_t &	origpos,
		const Plane &	target
	)		const

Distance of a TrackState (Point) to a Plane along the direction orthogonal to the Plane.

Definition at line 192 of file TrackStatePropagator.cxx.

References recob::tracking::Plane::direction(), and recob::tracking::Plane::position().

                                                                                                                   {
    const Point_t& targpos = target.position();
    const Vector_t& targdir = target.direction();
    //point-plane distance projected along direction orthogonal to the plane
    double sperp = targdir.Dot(targpos-origpos);
    success = true;
    return sperp;
  }

double trkf::TrackStatePropagator::perpDistanceToPlane ( bool &  success, const TrackState &  origin, const Plane &  target  ) const

inline

Distance of a TrackState (Point) to a Plane along the direction orthogonal to the Plane.

Definition at line 114 of file TrackStatePropagator.h.

References trkf::TrackState::position(), and target.

                                                                                                          {
      return perpDistanceToPlane(success, origin.position(), target);
    }

Point_t trkf::TrackStatePropagator::propagatedPosByDistance ( const Point_t &  origpos, const Vector_t &  origdir, double  distance  ) const

inline

Quick accesss to the propagated position given a distance.

Definition at line 101 of file TrackStatePropagator.h.

Referenced by propagateToPlane().

{ return origpos+distance*origdir; }

TrackState trkf::TrackStatePropagator::propagateToPlane	(	bool &	success,
		const TrackState &	origin,
		const Plane &	target,
		bool	dodedx,
		bool	domcs,
		PropDirection	dir = FORWARD
	)		const

Main function for propagation of a TrackState to a Plane.

Definition at line 27 of file TrackStatePropagator.cxx.

References apply_dedx(), apply_mcs(), BACKWARD, trkf::TrackState::covariance(), detprop, recob::tracking::Plane::direction(), distancePairToPlane(), e, detinfo::DetectorProperties::Eloss(), fMaxElossFrac, fMaxNit, fMinStep, FORWARD, fPropPinvErr, fTcut, fWrongDirDistTolerance, trkf::TrackState::isTrackAlongPlaneDir(), trkf::TrackState::mass(), max, trkf::TrackState::momentum(), geo::origin(), trkf::TrackState::parameters(), trkf::TrackState::pID(), trkf::TrackState::plane(), trkf::TrackState::position(), propagatedPosByDistance(), rotateToPlane(), and s.

Referenced by trkf::TrackKalmanFitter::doFitWork().

                                                                                                                                                                  {
    //
    // 1- find distance to target plane
    std::pair<double, double> distpair = distancePairToPlane(success, origin, target);
    double distance = distpair.first;
    double sperp    = distpair.second;
    //
    if ((distance<-fWrongDirDistTolerance && dir==FORWARD) || (distance>fWrongDirDistTolerance && dir==BACKWARD)) {
      success = false;
      return origin;
    }
    //
    // 2- propagate 3d position by distance, form propagated state on plane parallel to origin plane
    Point_t p = propagatedPosByDistance(origin.position(), origin.momentum()*origin.parameters()[4], distance);
    TrackState tmpState(SVector5(0.,0.,origin.parameters()[2],origin.parameters()[3],origin.parameters()[4]), origin.covariance(),
                        Plane(p,origin.plane().direction()), origin.isTrackAlongPlaneDir(), origin.pID());
    //
    // 3- rotate state to target plane
    double dw2dw1 = 0;
    tmpState = rotateToPlane(success, tmpState, target, dw2dw1);
    SVector5 par5d = tmpState.parameters();
    SMatrixSym55 cov5d = tmpState.covariance();
    //
    // 4- compute jacobian to propagate uncertainties
    SMatrix55 pm = ROOT::Math::SMatrixIdentity();//diagonal elements are 1
    pm(0,2) = sperp;   // du2/d(dudw1);
    pm(1,3) = sperp;   // dv2/d(dvdw1);
    //
    // 5- apply material effects, performing more iterations if the distance is long
    bool arrived = false;
    int nit = 0;         // Iteration count.
    double deriv = 1.;
    SMatrixSym55 noise_matrix;
    while (!arrived) {
      ++nit;
      if(nit > fMaxNit) {
        success = false;
        return origin;
      }
      // Estimate maximum step distance, such that fMaxElossFrac of initial energy is lost by dedx
      const double mass = origin.mass();
      const double p = 1./par5d[4];
      const double e = std::hypot(p, mass);
      const double t = e - mass;
      const double dedx = 0.001 * detprop->Eloss(std::abs(p), mass, fTcut);
      const double range = t / dedx;
      const double smax = std::max(fMinStep,fMaxElossFrac*range);
      double s = distance;
      if (domcs && smax>0 && std::abs(s)>smax) {
        if (fMaxNit==1) {
          success = false;
          return origin;
        }
        s = (s>0 ? smax : -smax);
        distance-=s;
      } else arrived = true;
      // now apply material effects
      if(domcs) {
        bool flip = false;
        if (origin.isTrackAlongPlaneDir()==true && dw2dw1<0.) flip = true;
        if (origin.isTrackAlongPlaneDir()==false && dw2dw1>0.) flip = true;
        bool ok = apply_mcs(par5d[2], par5d[3], par5d[4], origin.mass(), s, range, p, e*e, flip, noise_matrix);
        if(!ok) {
          success = false;
          return origin;
        }
      }
      if(dodedx) {
        apply_dedx(par5d(4), dedx, e, origin.mass(), s, deriv);
      }
    }
    if (fPropPinvErr) pm(4,4)*=deriv;
    //
    // 6- create final track state
    cov5d = ROOT::Math::Similarity(pm,cov5d);//*rj
    cov5d = cov5d+noise_matrix;
    TrackState trackState(par5d, cov5d, target, origin.momentum().Dot(target.direction())>0, origin.pID());
    return trackState;
  }

TrackState trkf::TrackStatePropagator::rotateToPlane ( bool &  success, const TrackState &  origin, const Plane &  target  ) const

inline

Rotation of a TrackState to a Plane (zero distance propagation)

Definition at line 98 of file TrackStatePropagator.h.

References rotateToPlane().

Referenced by trkf::TrackKalmanFitter::fillResult(), propagateToPlane(), and rotateToPlane().

{ double dw2dw1 = 0.; return rotateToPlane(success, origin, target, dw2dw1);}

TrackState trkf::TrackStatePropagator::rotateToPlane ( bool &  success, const TrackState &  origin, const Plane &  target, double &  dw2dw1  ) const

private

Rotation of a TrackState to a Plane (zero distance propagation), keeping track of dw2dw1 (needed by mcs)

Definition at line 107 of file TrackStatePropagator.cxx.

References recob::tracking::Plane::cosAlpha(), recob::tracking::Plane::cosBeta(), trkf::TrackState::covariance(), recob::tracking::Plane::direction(), trkf::TrackState::momentum(), geo::origin(), trkf::TrackState::parameters(), trkf::TrackState::pID(), trkf::TrackState::plane(), recob::tracking::Plane::position(), trkf::TrackState::position(), recob::tracking::Plane::sinAlpha(), and recob::tracking::Plane::sinBeta().

                                                                                                                                   {
    const bool isTrackAlongPlaneDir = origin.momentum().Dot(target.direction())>0;
    //
    SVector5 par5 = origin.parameters();
    const double sinA1 = origin.plane().sinAlpha();
    const double cosA1 = origin.plane().cosAlpha();
    const double sinA2 = target.sinAlpha();
    const double cosA2 = target.cosAlpha();
    const double sinB1 = origin.plane().sinBeta();
    const double cosB1 = origin.plane().cosBeta();
    const double sinB2 = target.sinBeta();
    const double cosB2 = target.cosBeta();
    const double sindB = -sinB1*cosB2 + cosB1*sinB2;
    const double cosdB = cosB1*cosB2 + sinB1*sinB2;
    const double ruu = cosA1*cosA2 + sinA1*sinA2*cosdB;
    const double ruv = sinA2*sindB;
    const double ruw = sinA1*cosA2 - cosA1*sinA2*cosdB;
    const double rvu = -sinA1*sindB;
    const double rvv = cosdB;
    const double rvw = cosA1*sindB;
    const double rwu = cosA1*sinA2 - sinA1*cosA2*cosdB;
    const double rwv = -cosA2*sindB;
    const double rww = sinA1*sinA2 + cosA1*cosA2*cosdB;
    dw2dw1 = par5[2]*rwu + par5[3]*rwv + rww;
    if(dw2dw1 == 0.) {
      success = false;
      return origin;
    }
    const double dudw2 = (par5[2]*ruu + par5[3]*ruv + ruw) / dw2dw1;
    const double dvdw2 = (par5[2]*rvu + par5[3]*rvv + rvw) / dw2dw1;
    SMatrix55 pm;
    //
    pm(0,0) = ruu - dudw2*rwu;    // du2/du1
    pm(1,0) = rvu - dvdw2*rwu;    // dv2/du1
    pm(2,0) = 0.;                 // d(dudw2)/du1
    pm(3,0) = 0.;                 // d(dvdw2)/du1
    pm(4,0) = 0.;                 // d(pinv2)/du1
    //
    pm(0,1) = ruv - dudw2*rwv;    // du2/dv1
    pm(1,1) = rvv - dvdw2*rwv;    // dv2/dv1
    pm(2,1) = 0.;                 // d(dudw2)/dv1
    pm(3,1) = 0.;                 // d(dvdw2)/dv1
    pm(4,1) = 0.;                 // d(pinv2)/dv1
    //
    pm(0,2) = 0.;                            // du2/d(dudw1);
    pm(1,2) = 0.;                            // dv2/d(dudw1);
    pm(2,2) = (ruu - dudw2*rwu) / dw2dw1;    // d(dudw2)/d(dudw1);
    pm(3,2) = (rvu - dvdw2*rwu) / dw2dw1;    // d(dvdw2)/d(dudw1);
    pm(4,2) = 0.;                            // d(pinv2)/d(dudw1);
    //
    pm(0,3) = 0.;                            // du2/d(dvdw1);
    pm(1,3) = 0.;                            // dv2/d(dvdw1);
    pm(2,3) = (ruv - dudw2*rwv) / dw2dw1;    // d(dudw2)/d(dvdw1);
    pm(3,3) = (rvv - dvdw2*rwv) / dw2dw1;    // d(dvdw2)/d(dvdw1);
    pm(4,3) = 0.;                            // d(pinv2)/d(dvdw1);
    //
    pm(0,4) = 0.;      // du2/d(pinv1);
    pm(1,4) = 0.;      // dv2/d(pinv1);
    pm(2,4) = 0.;      // d(dudw2)/d(pinv1);
    pm(3,4) = 0.;      // d(dvdw2)/d(pinv1);
    pm(4,4) = 1.;      // d(pinv2)/d(pinv1);
    //
    par5[0] = (origin.position().X() - target.position().X()) * cosA2 + (origin.position().Y() - target.position().Y())*sinA2*sinB2 - (origin.position().Z() - target.position().Z())*sinA2*cosB2;
    par5[1] = (origin.position().Y() - target.position().Y()) * cosB2 + (origin.position().Z() - target.position().Z()) * sinB2;
    par5[2] = dudw2;
    par5[3] = dvdw2;
    //
    success = true;
    return TrackState(par5,ROOT::Math::Similarity(pm,origin.covariance()),Plane(origin.position(),target.direction()),isTrackAlongPlaneDir,origin.pID());
  }

Member Data Documentation

const detinfo::DetectorProperties* trkf::TrackStatePropagator::detprop

private

Definition at line 147 of file TrackStatePropagator.h.

Referenced by apply_dedx(), apply_mcs(), propagateToPlane(), and TrackStatePropagator().

double trkf::TrackStatePropagator::fMaxElossFrac

private

Maximum propagation step length based on fraction of energy loss.

Definition at line 142 of file TrackStatePropagator.h.

Referenced by propagateToPlane().

int trkf::TrackStatePropagator::fMaxNit

private

Maximum number of iterations.

Definition at line 143 of file TrackStatePropagator.h.

Referenced by propagateToPlane().

double trkf::TrackStatePropagator::fMinStep

private

Minimum propagation step length guaranteed.

Definition at line 141 of file TrackStatePropagator.h.

Referenced by propagateToPlane().

bool trkf::TrackStatePropagator::fPropPinvErr

private

Propagate error on 1/p or not (in order to avoid infs, it should be set to false when 1/p not updated)

Definition at line 146 of file TrackStatePropagator.h.

Referenced by apply_mcs(), and propagateToPlane().

double trkf::TrackStatePropagator::fTcut

private

Maximum delta ray energy for dE/dx.

Definition at line 144 of file TrackStatePropagator.h.

Referenced by apply_dedx(), and propagateToPlane().

double trkf::TrackStatePropagator::fWrongDirDistTolerance

private

Allowed propagation distance in the wrong direction.

Definition at line 145 of file TrackStatePropagator.h.

Referenced by propagateToPlane().

const detinfo::LArProperties* trkf::TrackStatePropagator::larprop

private

Definition at line 148 of file TrackStatePropagator.h.

Referenced by apply_mcs(), and TrackStatePropagator().

---

The documentation for this class was generated from the following files:

• lardata/v06_47_03/source/lardata/RecoObjects/TrackStatePropagator.h
• lardata/v06_47_03/source/lardata/RecoObjects/TrackStatePropagator.cxx