trkf::TrajectoryMCSFitter Class Reference

Class for Maximum Likelihood fit of Multiple Coulomb Scattering angles between segments within a Track or Trajectory. More...

#include "TrajectoryMCSFitter.h"

Classes
struct	Config
struct	ScanResult

Public Types
using	Parameters = fhicl::Table< Config >

Public Member Functions
	TrajectoryMCSFitter (int pIdHyp, int minNSegs, double segLen, int minHitsPerSegment, int nElossSteps, int eLossMode, double pMin, double pMax, double pStep, double angResol)
	TrajectoryMCSFitter (const Parameters &p)
recob::MCSFitResult	fitMcs (const recob::TrackTrajectory &traj, bool momDepConst=true) const
recob::MCSFitResult	fitMcs (const recob::Track &track, bool momDepConst=true) const
recob::MCSFitResult	fitMcs (const recob::Trajectory &traj, bool momDepConst=true) const
recob::MCSFitResult	fitMcs (const recob::TrackTrajectory &traj, int pid, bool momDepConst=true) const
recob::MCSFitResult	fitMcs (const recob::Track &track, int pid, bool momDepConst=true) const
recob::MCSFitResult	fitMcs (const recob::Trajectory &traj, int pid, bool momDepConst=true) const
void	breakTrajInSegments (const recob::TrackTrajectory &traj, std::vector< size_t > &breakpoints, std::vector< float > &segradlengths, std::vector< float > &cumseglens) const
void	linearRegression (const recob::TrackTrajectory &traj, const size_t firstPoint, const size_t lastPoint, recob::tracking::Vector_t &pcdir) const
double	mcsLikelihood (double p, double theta0x, std::vector< float > &dthetaij, std::vector< float > &seg_nradl, std::vector< float > &cumLen, bool fwd, bool momDepConst, int pid) const
const ScanResult	doLikelihoodScan (std::vector< float > &dtheta, std::vector< float > &seg_nradlengths, std::vector< float > &cumLen, bool fwdFit, bool momDepConst, int pid) const
double	MomentumDependentConstant (const double p) const
double	mass (int pid) const
double	energyLossBetheBloch (const double mass, const double e2) const
double	energyLossLandau (const double mass2, const double E2, const double x) const
double	GetE (const double initial_E, const double length_travelled, const double mass) const

Private Attributes
int	pIdHyp_
int	minNSegs_
double	segLen_
int	minHitsPerSegment_
int	nElossSteps_
int	eLossMode_
double	pMin_
double	pMax_
double	pStep_
double	angResol_

Detailed Description

Class for Maximum Likelihood fit of Multiple Coulomb Scattering angles between segments within a Track or Trajectory.

Class for Maximum Likelihood fit of Multiple Coulomb Scattering angles between segments within a Track or Trajectory.

Inputs are: a Track or Trajectory, and various fit parameters (pIdHypothesis, minNumSegments, segmentLength, pMin, pMax, pStep, angResol)

Outputs are: a recob::MCSFitResult, containing: resulting momentum, momentum uncertainty, and best likelihood value (both for fwd and bwd fit); vector of segment (radiation) lengths, vector of scattering angles, and PID hypothesis used in the fit.

For configuration options see TrajectoryMCSFitter::Config

Author

G. Cerati (FNAL, MicroBooNE)

Date

2017

Version

1.0

Definition at line 33 of file TrajectoryMCSFitter.h.

Member Typedef Documentation

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

Definition at line 91 of file TrajectoryMCSFitter.h.

Constructor & Destructor Documentation

trkf::TrajectoryMCSFitter::TrajectoryMCSFitter ( int  pIdHyp, int  minNSegs, double  segLen, int  minHitsPerSegment, int  nElossSteps, int  eLossMode, double  pMin, double  pMax, double  pStep, double  angResol  )

inline

Definition at line 93 of file TrajectoryMCSFitter.h.

References trkf::TrajectoryMCSFitter::Config::angResol, angResol_, trkf::TrajectoryMCSFitter::Config::eLossMode, eLossMode_, trkf::TrajectoryMCSFitter::Config::minHitsPerSegment, minHitsPerSegment_, minNSegs_, trkf::TrajectoryMCSFitter::Config::nElossSteps, nElossSteps_, pIdHyp_, trkf::TrajectoryMCSFitter::Config::pMax, pMax_, trkf::TrajectoryMCSFitter::Config::pMin, pMin_, trkf::TrajectoryMCSFitter::Config::pStep, pStep_, and segLen_.

                                                                                                                                                                                {
      pIdHyp_ = pIdHyp;
      minNSegs_ = minNSegs;
      segLen_ = segLen;
      minHitsPerSegment_ = minHitsPerSegment;
      nElossSteps_ = nElossSteps;
      eLossMode_ = eLossMode;
      pMin_ = pMin;
      pMax_ = pMax;
      pStep_ = pStep;
      angResol_ = angResol;
    }

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

inlineexplicit

Definition at line 105 of file TrajectoryMCSFitter.h.

      : TrajectoryMCSFitter(p().pIdHypothesis(),p().minNumSegments(),p().segmentLength(),p().minHitsPerSegment(),p().nElossSteps(),p().eLossMode(),p().pMin(),p().pMax(),p().pStep(),p().angResol()) {}

Member Function Documentation

void TrajectoryMCSFitter::breakTrajInSegments	(	const recob::TrackTrajectory &	traj,
		std::vector< size_t > &	breakpoints,
		std::vector< float > &	segradlengths,
		std::vector< float > &	cumseglens
	)		const

Definition at line 59 of file TrajectoryMCSFitter.cxx.

References recob::TrackTrajectory::FirstValidPoint(), recob::TrackTrajectory::InvalidIndex, recob::TrackTrajectory::LastValidPoint(), recob::TrackTrajectory::Length(), recob::TrackTrajectory::LocationAtPoint(), max, recob::TrackTrajectory::NextValidPoint(), and R.

Referenced by fitMcs().

                                                                                                                                                                          {
  //
  const double trajlen = traj.Length();
  const int nseg = std::max(minNSegs_,int(trajlen/segLen_));
  const double thisSegLen = trajlen/double(nseg);
  // std::cout << "track with length=" << trajlen << " broken in nseg=" << nseg << " of length=" << thisSegLen << " where segLen_=" << segLen_ << std::endl;
  //
  constexpr double lar_radl_inv = 1./14.0;
  cumseglens.push_back(0.);//first segment has zero cumulative length from previous segments
  double thislen = 0.;
  auto nextValid=traj.FirstValidPoint();
  breakpoints.push_back(nextValid);
  auto pos0 = traj.LocationAtPoint(nextValid);
  nextValid = traj.NextValidPoint(nextValid+1);
  int npoints = 0;
  while (nextValid!=recob::TrackTrajectory::InvalidIndex) {
    auto pos1 = traj.LocationAtPoint(nextValid);
    thislen += ( (pos1-pos0).R() );
    pos0=pos1;
    npoints++;
    if (thislen>=thisSegLen) {
      breakpoints.push_back(nextValid);
      if (npoints>=minHitsPerSegment_) segradlengths.push_back(thislen*lar_radl_inv);
      else segradlengths.push_back(-999.);
      cumseglens.push_back(cumseglens.back()+thislen);
      thislen = 0.;
      npoints = 0;
    }
    nextValid = traj.NextValidPoint(nextValid+1);
  }
  //then add last segment
  if (thislen>0.) {
    breakpoints.push_back(traj.LastValidPoint()+1);
    segradlengths.push_back(thislen*lar_radl_inv);
    cumseglens.push_back(cumseglens.back()+thislen);
  }
  return;
}

const TrajectoryMCSFitter::ScanResult TrajectoryMCSFitter::doLikelihoodScan	(	std::vector< float > &	dtheta,
		std::vector< float > &	seg_nradlengths,
		std::vector< float > &	cumLen,
		bool	fwdFit,
		bool	momDepConst,
		int	pid
	)		const

Definition at line 98 of file TrajectoryMCSFitter.cxx.

References max.

                                                                                                                                                                                                             {
  int    best_idx  = -1;
  double best_logL = std::numeric_limits<double>::max();
  double best_p    = -1.0;
  std::vector<float> vlogL;
  for (double p_test = pMin_; p_test <= pMax_; p_test+=pStep_) {
    double logL = mcsLikelihood(p_test, angResol_, dtheta, seg_nradlengths, cumLen, fwdFit, momDepConst, pid);
    if (logL < best_logL) {
      best_p    = p_test;
      best_logL = logL;
      best_idx  = vlogL.size();
    }
    vlogL.push_back(logL);
  }
  //
  //uncertainty from left side scan
  double lunc = -1.0;
  if (best_idx>0) {
    for (int j=best_idx-1;j>=0;j--) {
      double dLL = vlogL[j]-vlogL[best_idx];
      if ( dLL<0.5 ) {
        lunc = (best_idx-j)*pStep_;
      } else break;
    }
  }
  //uncertainty from right side scan
  double runc = -1.0;
  if (best_idx<int(vlogL.size()-1)) {  
    for (unsigned int j=best_idx+1;j<vlogL.size();j++) {
      double dLL = vlogL[j]-vlogL[best_idx];
      if ( dLL<0.5 ) {
        runc = (j-best_idx)*pStep_;
      } else break;
    }
  }
  return ScanResult(best_p, std::max(lunc,runc), best_logL);
}

double TrajectoryMCSFitter::energyLossBetheBloch	(	const double	mass,
		const double	e2
	)		const

Definition at line 259 of file TrajectoryMCSFitter.cxx.

References E.

Referenced by mass().

                                                                                        {
  // stolen, mostly, from GFMaterialEffects.
  constexpr double Iinv = 1./188.E-6;
  constexpr double matConst = 1.4*18./40.;//density*Z/A
  constexpr double me = 0.511;
  constexpr double kappa = 0.307075;
  //
  const double beta2 = (e2-mass*mass)/e2;
  const double gamma2 = 1./(1.0 - beta2);
  const double massRatio = me/mass;
  const double argument = (2.*me*gamma2*beta2*Iinv) * std::sqrt(1+2*std::sqrt(gamma2)*massRatio + massRatio*massRatio);
  //
  double dedx = kappa*matConst/beta2;
  //
  if (mass==0.0) return(0.0);
  if (argument <= exp(beta2)) {
      dedx = 0.;
  } else{
    dedx *= (log(argument)-beta2)*1.E-3; // Bethe-Bloch, converted to GeV/cm
    if (dedx<0.) dedx = 0.;
  }
  return dedx;
}

double TrajectoryMCSFitter::energyLossLandau	(	const double	mass2,
		const double	E2,
		const double	x
	)		const

Definition at line 241 of file TrajectoryMCSFitter.cxx.

Referenced by mass().

                                                                                                     {
  //
  // eq. (33.11) in http://pdg.lbl.gov/2016/reviews/rpp2016-rev-passage-particles-matter.pdf (except density correction is ignored)
  //
  if (x<=0.) return 0.;
  constexpr double Iinv2 = 1./(188.E-6*188.E-6);
  constexpr double matConst = 1.4*18./40.;//density*Z/A
  constexpr double me = 0.511;
  constexpr double kappa = 0.307075;
  constexpr double j = 0.200;
  //
  const double beta2 = (e2-mass2)/e2;
  const double gamma2 = 1./(1.0 - beta2);
  const double epsilon = 0.5*kappa*x*matConst/beta2;
  //
  return 0.001*epsilon*( log(2.*me*beta2*gamma2*epsilon*Iinv2) + j - beta2 );
}

recob::MCSFitResult trkf::TrajectoryMCSFitter::fitMcs ( const recob::TrackTrajectory &  traj, bool  momDepConst = true  ) const

inline

Definition at line 108 of file TrajectoryMCSFitter.h.

References fitMcs(), and pIdHyp_.

Referenced by fitMcs(), trkmkr::KalmanFilterFitTrackMaker::getMomentum(), and trkf::MCSFitProducer::produce().

{ return fitMcs(traj,pIdHyp_,momDepConst); }

recob::MCSFitResult trkf::TrajectoryMCSFitter::fitMcs ( const recob::Track &  track, bool  momDepConst = true  ) const

inline

Definition at line 109 of file TrajectoryMCSFitter.h.

References fitMcs(), and pIdHyp_.

Referenced by fitMcs().

{ return fitMcs(track,pIdHyp_,momDepConst); }

recob::MCSFitResult trkf::TrajectoryMCSFitter::fitMcs ( const recob::Trajectory &  traj, bool  momDepConst = true  ) const

inline

Definition at line 110 of file TrajectoryMCSFitter.h.

References fitMcs(), and pIdHyp_.

Referenced by fitMcs().

{ return fitMcs(traj,pIdHyp_,momDepConst); }

recob::MCSFitResult TrajectoryMCSFitter::fitMcs	(	const recob::TrackTrajectory &	traj,
		int	pid,
		bool	momDepConst = true
	)		const

Definition at line 11 of file TrajectoryMCSFitter.cxx.

References trkf::TrajectoryMCSFitter::ScanResult::logL, trkf::TrajectoryMCSFitter::ScanResult::p, and trkf::TrajectoryMCSFitter::ScanResult::pUnc.

                                                                                                               {
  //
  // Break the trajectory in segments of length approximately equal to segLen_
  //
  vector<size_t> breakpoints;
  vector<float> segradlengths;
  vector<float> cumseglens;
  breakTrajInSegments(traj, breakpoints, segradlengths, cumseglens);
  //
  // Fit segment directions, and get 3D angles between them
  //
  if (segradlengths.size()<2) return recob::MCSFitResult();
  vector<float> dtheta;
  Vector_t pcdir0;
  Vector_t pcdir1;
  for (unsigned int p = 0; p<segradlengths.size(); p++) {
    linearRegression(traj, breakpoints[p], breakpoints[p+1], pcdir1);
    if (p>0) {
      if (segradlengths[p]<-100. || segradlengths[p-1]<-100.) {
        dtheta.push_back(-999.);
      } else { 
        const double cosval = pcdir0.X()*pcdir1.X()+pcdir0.Y()*pcdir1.Y()+pcdir0.Z()*pcdir1.Z();
        //assert(std::abs(cosval)<=1);
        //units are mrad
        double dt = 1000.*acos(cosval);//should we try to use expansion for small angles?
        dtheta.push_back(dt);
      }
    }
    pcdir0 = pcdir1;
  }
  //
  // Perform likelihood scan in forward and backward directions
  //
  vector<float> cumLenFwd;
  vector<float> cumLenBwd;
  for (unsigned int i = 0; i<cumseglens.size()-2; i++) {
    cumLenFwd.push_back(cumseglens[i]);
    cumLenBwd.push_back(cumseglens.back()-cumseglens[i+2]);
  }
  const ScanResult fwdResult = doLikelihoodScan(dtheta, segradlengths, cumLenFwd, true,  momDepConst, pid);
  const ScanResult bwdResult = doLikelihoodScan(dtheta, segradlengths, cumLenBwd, false, momDepConst, pid);
  //
  return recob::MCSFitResult(pid,
                             fwdResult.p,fwdResult.pUnc,fwdResult.logL,
                             bwdResult.p,bwdResult.pUnc,bwdResult.logL,
                             segradlengths,dtheta);
}

recob::MCSFitResult trkf::TrajectoryMCSFitter::fitMcs ( const recob::Track &  track, int  pid, bool  momDepConst = true  ) const

inline

Definition at line 113 of file TrajectoryMCSFitter.h.

References fitMcs(), and recob::Track::Trajectory().

Referenced by fitMcs().

{ return fitMcs(track.Trajectory(),pid,momDepConst); }

recob::MCSFitResult trkf::TrajectoryMCSFitter::fitMcs ( const recob::Trajectory &  traj, int  pid, bool  momDepConst = true  ) const

inline

Definition at line 114 of file TrajectoryMCSFitter.h.

References breakTrajInSegments(), fitMcs(), linearRegression(), mcsLikelihood(), and recob::Trajectory::NPoints().

                                                                                                       {
      recob::TrackTrajectory::Flags_t flags(traj.NPoints());
      const recob::TrackTrajectory tt(traj,std::move(flags));
      return fitMcs(tt,pid,momDepConst);
    }

double TrajectoryMCSFitter::GetE	(	const double	initial_E,
		const double	length_travelled,
		const double	mass
	)		const

Definition at line 283 of file TrajectoryMCSFitter.cxx.

Referenced by mass().

                                                                                                            {
  //
  const double step_size = length_travelled / nElossSteps_;
  //
  double current_E = initial_E;
  const double m2 = m*m;
  //
  for (auto i = 0; i < nElossSteps_; ++i) {
    if (eLossMode_==2) {
      double dedx = energyLossBetheBloch(m,current_E);
      current_E -= (dedx * step_size);
    } else {
      // MPV of Landau energy loss distribution
      current_E -= energyLossLandau(m2,current_E*current_E,step_size);
    }
    if ( current_E <= m ) {
      // std::cout<<"WARNING: current_E less than mu mass. it is "<<current_E<<std::endl;
      return 0.;
    }
  }
  return current_E;
}

void TrajectoryMCSFitter::linearRegression	(	const recob::TrackTrajectory &	traj,
		const size_t	firstPoint,
		const size_t	lastPoint,
		recob::tracking::Vector_t &	pcdir
	)		const

Definition at line 136 of file TrajectoryMCSFitter.cxx.

References geo::vect::MiddlePointAccumulatorDim< N >::add(), recob::TrackTrajectory::DirectionAtPoint(), recob::TrackTrajectory::LocationAtPoint(), geo::vect::MiddlePointAccumulatorDim< N >::middlePoint(), recob::TrackTrajectory::NextValidPoint(), and norm.

Referenced by fitMcs().

                                                                                                                                                   {
  //
  int npoints = 0;
  geo::vect::MiddlePointAccumulator middlePointCalc;
  size_t nextValid = firstPoint;
  while (nextValid<lastPoint) {
    middlePointCalc.add(traj.LocationAtPoint(nextValid));
    nextValid = traj.NextValidPoint(nextValid+1);
    npoints++;
  }
  const auto avgpos = middlePointCalc.middlePoint();
  const double norm = 1./double(npoints);
  //
  //assert(npoints>0);
  //
  TMatrixDSym m(3);
  nextValid = firstPoint;
  while (nextValid<lastPoint) {
    const auto p = traj.LocationAtPoint(nextValid);
    const double xxw0 = p.X()-avgpos.X();
    const double yyw0 = p.Y()-avgpos.Y();
    const double zzw0 = p.Z()-avgpos.Z();
    m(0, 0) += xxw0*xxw0*norm;
    m(0, 1) += xxw0*yyw0*norm;
    m(0, 2) += xxw0*zzw0*norm;
    m(1, 0) += yyw0*xxw0*norm;
    m(1, 1) += yyw0*yyw0*norm;
    m(1, 2) += yyw0*zzw0*norm;
    m(2, 0) += zzw0*xxw0*norm;
    m(2, 1) += zzw0*yyw0*norm;
    m(2, 2) += zzw0*zzw0*norm;
    nextValid = traj.NextValidPoint(nextValid+1);
  }
  //
  const TMatrixDSymEigen me(m);
  const auto& eigenval = me.GetEigenValues();
  const auto& eigenvec = me.GetEigenVectors();
  //
  int maxevalidx = 0;
  double maxeval = eigenval(0);
  for (int i=1; i<3; ++i) {
    if (eigenval(i)>maxeval) {
      maxevalidx = i;
      maxeval = eigenval(i);
    }
  } 
  //
  pcdir = Vector_t(eigenvec(0, maxevalidx),eigenvec(1, maxevalidx),eigenvec(2, maxevalidx));
  if (traj.DirectionAtPoint(firstPoint).Dot(pcdir)<0.) pcdir*=-1.;
  //
}

double trkf::TrajectoryMCSFitter::mass ( int  pid ) const

inline

Definition at line 138 of file TrajectoryMCSFitter.h.

References energyLossBetheBloch(), energyLossLandau(), GetE(), util::kBogusD, and x.

                               {
      if (abs(pid)==13)   { return mumass; }
      if (abs(pid)==211)  { return pimass; }
      if (abs(pid)==321)  { return kmass;  }
      if (abs(pid)==2212) { return pmass;  }
      return util::kBogusD;
    }

double TrajectoryMCSFitter::mcsLikelihood	(	double	p,
		double	theta0x,
		std::vector< float > &	dthetaij,
		std::vector< float > &	seg_nradl,
		std::vector< float > &	cumLen,
		bool	fwd,
		bool	momDepConst,
		int	pid
	)		const

Definition at line 188 of file TrajectoryMCSFitter.cxx.

References beta, evd::details::end(), and max.

Referenced by fitMcs().

                                                                                                                                                                                                {
  //
  const int beg  = (fwd ? 0 : (dthetaij.size()-1));
  const int end  = (fwd ? dthetaij.size() : -1);
  const int incr = (fwd ? +1 : -1);
  //
  // bool print = false;//(p>1.999 && p<2.001);
  //
  const double m = mass(pid);
  const double m2 = m*m;
  const double Etot = sqrt(p*p + m2);//Initial energy
  double Eij2 = 0.;
  //
  double const fixedterm = 0.5 * std::log( 2.0 * M_PI );
  double result = 0;
  for (int i = beg; i != end; i+=incr ) {
    if (dthetaij[i]<0) {
      //cout << "skip segment with too few points" << endl;
      continue;
    }
    //
    if (eLossMode_==1) {
      // ELoss mode: MIP (constant)
      constexpr double kcal = 0.002105;
      const double Eij = Etot - kcal*cumLen[i];//energy at this segment
      Eij2 = Eij*Eij;
    } else {
      // Non constant energy loss distribution
      const double Eij = GetE(Etot,cumLen[i],m);
      Eij2 = Eij*Eij;
    }
    //
    if ( Eij2 <= m2 ) {
      result = std::numeric_limits<double>::max();
      break;
    }
    const double pij = sqrt(Eij2 - m2);//momentum at this segment
    const double beta = sqrt( 1. - ((m2)/(pij*pij + m2)) );
    constexpr double tuned_HL_term1 = 11.0038; // https://arxiv.org/abs/1703.06187
    constexpr double HL_term2 = 0.038;
    const double tH0 = ( (momDepConst ? MomentumDependentConstant(pij) : tuned_HL_term1) / (pij*beta) ) * ( 1.0 + HL_term2 * std::log( seg_nradl[i] ) ) * sqrt( seg_nradl[i] );
    const double rms = sqrt( 2.0*( tH0 * tH0 + theta0x * theta0x ) );
    if (rms==0.0) {
      std::cout << " Error : RMS cannot be zero ! " << std::endl;
      return std::numeric_limits<double>::max();
    } 
    const double arg = dthetaij[i]/rms;
    result += ( std::log( rms ) + 0.5 * arg * arg + fixedterm);
    // if (print && fwd==true) cout << "TrajectoryMCSFitter pij=" << pij << " dthetaij[i]=" << dthetaij[i] << " tH0=" << tH0 << " rms=" << rms << " prob=" << ( std::log( rms ) + 0.5 * arg * arg + fixedterm) << " const=" << (momDepConst ? MomentumDependentConstant(pij) : tuned_HL_term1) << " beta=" << beta << " red_length=" << seg_nradl[i] << endl;
  }
  return result;
}

double trkf::TrajectoryMCSFitter::MomentumDependentConstant ( const double  p ) const

inline

Definition at line 132 of file TrajectoryMCSFitter.h.

                                                                  {
      //these are from https://arxiv.org/abs/1703.06187
      constexpr double a = 0.1049;
      constexpr double c = 11.0038;
      return (a/(p*p)) + c;
    }

Member Data Documentation

double trkf::TrajectoryMCSFitter::angResol_

private

Definition at line 160 of file TrajectoryMCSFitter.h.

Referenced by TrajectoryMCSFitter().

int trkf::TrajectoryMCSFitter::eLossMode_

private

Definition at line 156 of file TrajectoryMCSFitter.h.

Referenced by TrajectoryMCSFitter().

int trkf::TrajectoryMCSFitter::minHitsPerSegment_

private

Definition at line 154 of file TrajectoryMCSFitter.h.

Referenced by TrajectoryMCSFitter().

int trkf::TrajectoryMCSFitter::minNSegs_

private

Definition at line 152 of file TrajectoryMCSFitter.h.

Referenced by TrajectoryMCSFitter().

int trkf::TrajectoryMCSFitter::nElossSteps_

private

Definition at line 155 of file TrajectoryMCSFitter.h.

Referenced by TrajectoryMCSFitter().

int trkf::TrajectoryMCSFitter::pIdHyp_

private

Definition at line 151 of file TrajectoryMCSFitter.h.

Referenced by fitMcs(), and TrajectoryMCSFitter().

double trkf::TrajectoryMCSFitter::pMax_

private

Definition at line 158 of file TrajectoryMCSFitter.h.

Referenced by TrajectoryMCSFitter().

double trkf::TrajectoryMCSFitter::pMin_

private

Definition at line 157 of file TrajectoryMCSFitter.h.

Referenced by TrajectoryMCSFitter().

double trkf::TrajectoryMCSFitter::pStep_

private

Definition at line 159 of file TrajectoryMCSFitter.h.

Referenced by TrajectoryMCSFitter().

double trkf::TrajectoryMCSFitter::segLen_

private

Definition at line 153 of file TrajectoryMCSFitter.h.

Referenced by TrajectoryMCSFitter().

---

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

• /cvmfs/larsoft.opensciencegrid.org/products/larreco/v07_10_02/source/larreco/RecoAlg/TrajectoryMCSFitter.h
• /cvmfs/larsoft.opensciencegrid.org/products/larreco/v07_10_02/source/larreco/RecoAlg/TrajectoryMCSFitter.cxx