trkf::BezierTrack Class Reference

#include "BezierTrack.h"

Public Member Functions
	BezierTrack (int id, const recob::Trajectory &traj)
	BezierTrack (const recob::Track &track)
	BezierTrack (std::vector< TVector3 > const &Pos, std::vector< TVector3 > const &Dir, std::vector< std::vector< double > > const &dQdx, int id)
	BezierTrack (std::vector< recob::Seed > const &)
int	NSegments () const
double	GetLength () const
double	GetRMSCurvature () const
double	GetTotalCharge (unsigned int View) const
double	GetViewdQdx (unsigned int View) const
TVector3	GetTrackPointV (double s) const
TVector3	GetTrackDirectionV (double s) const
void	GetTrackPoint (double s, double *xyz) const
void	GetTrackDirection (double s, double *xyz) const
void	FillTrackVectors (std::vector< TVector3 > &xyzVector, std::vector< TVector3 > &dirVector, double const ds=0.1) const
double	GetCurvature (double s) const
double	GetdQdx (double s, unsigned int View) const
void	GetProjectedPointUVWX (double s, double *uvw, double *x, int c, int t) const
void	GetProjectedPointUVWT (double s, double *uvw, double *ticks, int c, int t) const
void	GetClosestApproach (recob::Hit const &hit, double &s, double &Distance) const
void	GetClosestApproach (art::Ptr< recob::Hit > const &hit, double &s, double &Distance) const
void	GetClosestApproach (recob::SpacePoint *sp, double &s, double &Distance) const
void	GetClosestApproach (recob::Seed const &seed, double &s, double &Distance) const
void	GetClosestApproach (TVector3 vec, double &s, double &Distance) const
void	GetClosestApproach (uint32_t w, int p, int t, int c, float x, double &s, double &Distance) const
double	GetTrackPitch (geo::View_t view, double s, double WirePitch, unsigned int c=0, unsigned int t=0)
void	GetClosestApproaches (art::PtrVector< recob::Hit > const &hits, std::vector< double > &s, std::vector< double > &Distances) const
void	GetClosestApproaches (std::vector< art::Ptr< recob::Hit > > const &hits, std::vector< double > &s, std::vector< double > &Distances) const
void	CalculatedQdx (art::PtrVector< recob::Hit >const &)
void	CalculatedQdx (art::PtrVector< recob::Hit >const &, std::vector< double > const &SValues)
anab::Calorimetry	GetCalorimetryObject (std::vector< art::Ptr< recob::Hit > > const &Hits, geo::SigType_t sigtype, calo::CalorimetryAlg const &)
anab::Calorimetry	GetCalorimetryObject (art::PtrVector< recob::Hit > const &Hits, geo::SigType_t sigtype, calo::CalorimetryAlg const &)
anab::Calorimetry	GetCalorimetryObject (art::PtrVector< recob::Hit > const &Hits, geo::View_t view, calo::CalorimetryAlg const &calalg)
BezierTrack	Reverse ()
std::vector< recob::SpacePoint >	GetSpacePointTrajectory (int N)
BezierTrack	GetPartialTrack (double LowS, double HighS)
std::vector< recob::Seed >	GetSeedVector ()
int	WhichSegment (double S) const
recob::Trajectory const &	GetTrajectory () const
	Returns the current trajectory. More...

Private Member Functions
void	CalculateSegments ()
void	FillTrajectoryVectors ()
void	FillSeedVector ()

Private Attributes
recob::Trajectory	fTraj
	Internal trajectory representation. More...
std::vector< std::vector< double > >	fdQdx
std::vector< double >	fSegmentLength
std::vector< double >	fCumulativeLength
std::vector< recob::Seed >	fSeedCollection
double	fTrackLength
int	fBezierResolution

Detailed Description

Definition at line 29 of file BezierTrack.h.

Constructor & Destructor Documentation

trkf::BezierTrack::BezierTrack	(	int	id,
		const recob::Trajectory &	traj
	)

Definition at line 29 of file BezierTrack.cxx.

References CalculateSegments(), and fBezierResolution.

Referenced by Reverse().

    : fTraj(traj)
    // Clang: private field 'fID' is not used
  //  , fID(id)
  {
    fBezierResolution=1000;
    CalculateSegments();
  }

trkf::BezierTrack::BezierTrack

(

const recob::Track &

track

)

Definition at line 40 of file BezierTrack.cxx.

    : BezierTrack(track.ID(), track.Trajectory().Trajectory()) {}

trkf::BezierTrack::BezierTrack	(	std::vector< TVector3 > const &	Pos,
		std::vector< TVector3 > const &	Dir,
		std::vector< std::vector< double > > const &	dQdx,
		int	id
	)

Definition at line 91 of file BezierTrack.cxx.

References CalculateSegments(), and fBezierResolution.

    : fTraj(geo::vect::convertCollToPoint(Pos), geo::vect::convertCollToVector(Dir), false)
    // Clang: private field 'fID' is not used
  //  , fID(id)
    , fdQdx(dQdx)
  {
    fBezierResolution=1000;
    CalculateSegments();
  }

trkf::BezierTrack::BezierTrack

(

std::vector< recob::Seed > const &

SeedCol

)

Definition at line 46 of file BezierTrack.cxx.

References CalculateSegments(), fBezierResolution, and fSeedCollection.

    : fTraj()
  {
    if(SeedCol.size()>0)
      {
        double Pt[3], Dir[3], PtErr[3], DirErr[3];
        double FirstPt[3];
        double FirstDir[3];
        SeedCol.at(0).GetPoint(     Pt,  PtErr  );
        SeedCol.at(0).GetDirection( Dir, DirErr );
        for(int i=0; i!=3; ++i)
          {
            double BigN=1000;
            FirstPt[i]=Pt[i]-((1.+1./BigN) * Dir[i]);
            FirstDir[i]=Dir[i]/BigN;
          }
        fSeedCollection.push_back(recob::Seed(FirstPt, FirstDir, PtErr, DirErr));
      }
    for(size_t i=0; i!=SeedCol.size(); ++i)
      {
        fSeedCollection.push_back(SeedCol.at(i));
      }
    if(SeedCol.size()>0)
      {
        double Pt[3], Dir[3], PtErr[3], DirErr[3];
        double LastPt[3], LastDir[3];
        SeedCol.at(SeedCol.size()-1).GetPoint(     Pt,  PtErr  );
        SeedCol.at(SeedCol.size()-1).GetDirection( Dir, DirErr );
        for(int i=0; i!=3; ++i)
          {
            double BigN=1000;
            LastPt[i]=Pt[i]+((1.+1./BigN) * Dir[i]);
            LastDir[i]=Dir[i]/BigN;
          }
        fSeedCollection.push_back(recob::Seed(LastPt, LastDir, PtErr, DirErr));
      }
   
    CalculateSegments();
    fBezierResolution=1000;
  }

Member Function Documentation

void trkf::BezierTrack::CalculatedQdx

(

art::PtrVector< recob::Hit >const &

Hits

)

Definition at line 978 of file BezierTrack.cxx.

References art::PtrVector< T >::at(), fdQdx, fSegmentLength, GetClosestApproach(), NSegments(), art::PtrVector< T >::size(), and WhichSegment().

  {
    fdQdx.clear();

    std::map<int, std::map<int, double> > hitmap;
    //        ^              ^       ^
    //       view            seg    charge

    for(size_t i=0; i!=Hits.size(); ++i)
      {
        double Distance, S;
        GetClosestApproach(Hits.at(i), S, Distance);

        (hitmap[Hits.at(i)->View()])[WhichSegment(S)] += Hits.at(i)->Integral();
      }

    int NSeg = NSegments();

    for(std::map<int,std::map<int,double> >::const_iterator itview=hitmap.begin();
        itview!=hitmap.end(); ++itview)
      {
        std::vector<double> ThisViewdQdx;
        ThisViewdQdx.resize(NSeg);
        for(std::map<int,double>::const_iterator itseg=itview->second.begin();
            itseg!=itview->second.end(); ++itseg)
          {
            int seg = itseg->first;

            // need to nudge hits which fell outside the track

            if((seg>-1) && (seg<NSeg))
              ThisViewdQdx[seg] = (itseg->second / fSegmentLength[seg]);
          }
        fdQdx.push_back(ThisViewdQdx);
      }

  }

void trkf::BezierTrack::CalculatedQdx	(	art::PtrVector< recob::Hit >const &	Hits,
		std::vector< double > const &	SValues
	)

Definition at line 1022 of file BezierTrack.cxx.

References art::PtrVector< T >::at(), fdQdx, fSegmentLength, NSegments(), art::PtrVector< T >::size(), and WhichSegment().

  {
    fdQdx.clear();

    std::map<int, std::map<int, double> > hitmap;
    //        ^              ^       ^
    //       view            seg    charge

    for(size_t i=0; i!=Hits.size(); ++i)
      {

        (hitmap[Hits.at(i)->View()])[WhichSegment(SValues.at(i))] += Hits.at(i)->Integral();
      }

    int NSeg = NSegments();

    for(std::map<int,std::map<int,double> >::const_iterator itview=hitmap.begin();
        itview!=hitmap.end(); ++itview)
      {
        std::vector<double> ThisViewdQdx;
        ThisViewdQdx.resize(NSeg);
        for(std::map<int,double>::const_iterator itseg=itview->second.begin();
            itseg!=itview->second.end(); ++itseg)
          {
          
            int seg = itseg->first;

            // need to nudge hits which fell outside the track

            if((seg>-1) && (seg<NSeg))
              ThisViewdQdx[seg] = (itseg->second / fSegmentLength[seg]);
          }
        fdQdx.push_back(ThisViewdQdx);
      }
   

  }

void trkf::BezierTrack::CalculateSegments ( )

private

Definition at line 363 of file BezierTrack.cxx.

References fCumulativeLength, FillSeedVector(), FillTrajectoryVectors(), fSeedCollection, fSegmentLength, fTrackLength, trkf::BezierCurveHelper::GetSegmentLength(), and NSegments().

Referenced by BezierTrack().

  {

    if(fSeedCollection.size()==0)
      {
        if(NSegments()!=0) FillSeedVector();
        else
          {
            throw cet::exception("no points in track")
              <<"CalculateSegments method of Bezier track called with no"
              <<" track information loaded.  You must fill track with "
              <<"poisition and direction data before calling this method."
              <<"\n";
          }
      }
    if(NSegments()==0)
      {
        if(fSeedCollection.size()!=0)  FillTrajectoryVectors();
      }

    BezierCurveHelper bhlp(100);

    int Segments = NSegments();

    fTrackLength=0;
    bool FirstSeg=true;
    for(int i=0; i!=Segments; ++i)
      {
        if(!FirstSeg)
          {
            float SegmentLength=bhlp.GetSegmentLength(fSeedCollection.at(i-1),fSeedCollection.at(i));

            fTrackLength+=SegmentLength;
            fSegmentLength.push_back(SegmentLength);
          }
        FirstSeg=false;
        fCumulativeLength.push_back(fTrackLength);
      }
  }

void trkf::BezierTrack::FillSeedVector ( )

private

Definition at line 299 of file BezierTrack.cxx.

References dir, recob::Trajectory::DirectionAtPoint(), fSeedCollection, fTraj, recob::Trajectory::LocationAtPoint(), and NSegments().

Referenced by CalculateSegments().

  {
    int NSeg=NSegments();



    double Pt[3], Dir[3];
    for(int i=0; i!=NSeg; i++)
      {

        auto const& pos = fTraj.LocationAtPoint(i);
        Pt[0]=pos.X();
        Pt[1]=pos.Y();
        Pt[2]=pos.Z();

        auto const& dir = fTraj.DirectionAtPoint(i);
        Dir[0]=dir.X();
        Dir[1]=dir.Y();
        Dir[2]=dir.Z();

        fSeedCollection.push_back(recob::Seed(Pt,Dir));
      }

  }

void trkf::BezierTrack::FillTrackVectors	(	std::vector< TVector3 > &	xyzVector,
		std::vector< TVector3 > &	dirVector,
		double const	ds = 0.1
	)		const

Definition at line 1199 of file BezierTrack.cxx.

References GetLength(), GetTrackDirectionV(), GetTrackPointV(), and s.

  {
    const double s = ds / GetLength();
    const size_t n_traj_pts = (size_t)(GetLength()/ds);

    //+2: evenly space points, plus one for start and one for end
    xyzVector.resize(n_traj_pts+2);
    dirVector.resize(n_traj_pts+2);

    for(size_t i_traj=0; i_traj<=n_traj_pts; i_traj++){
      xyzVector[i_traj] = this->GetTrackPointV(i_traj*s);
      dirVector[i_traj] = this->GetTrackDirectionV(i_traj*s);
    }

    xyzVector[n_traj_pts+1] = this->GetTrackPointV(1.);
    dirVector[n_traj_pts+1] = this->GetTrackDirectionV(1.);


  }

void trkf::BezierTrack::FillTrajectoryVectors ( )

private

Definition at line 328 of file BezierTrack.cxx.

References fdQdx, fSeedCollection, fTraj, and geo::GeometryCore::Nplanes().

Referenced by CalculateSegments().

  {
    art::ServiceHandle<geo::Geometry> geom;
    int NPlanes = geom->Nplanes();
    fdQdx.resize(NPlanes) ;
    double Pt[3], Dir[3], ErrPt[3], ErrDir[3];
    recob::Trajectory::Positions_t positions;
    recob::Trajectory::Momenta_t directions;
    for(std::vector<recob::Seed>::const_iterator it=fSeedCollection.begin();
        it!=fSeedCollection.end(); ++it)
      {

        it->GetPoint(Pt,ErrPt);
        it->GetDirection(Dir, ErrDir);
        recob::Track::Point_t Point(Pt[0],Pt[1],Pt[2]);
        recob::Track::Vector_t Direction(Dir[0],Dir[1],Dir[2]);

        for(int i=0; i!=NPlanes; ++i)
          fdQdx.at(i).push_back(0);

        positions.push_back(Point);
        directions.push_back(Direction);
      }
    
    fTraj
      = recob::Trajectory(std::move(positions), std::move(directions), false);
    
  }

anab::Calorimetry trkf::BezierTrack::GetCalorimetryObject	(	std::vector< art::Ptr< recob::Hit > > const &	Hits,
		geo::SigType_t	sigtype,
		calo::CalorimetryAlg const &	calalg
	)

Definition at line 168 of file BezierTrack.cxx.

References art::PtrVector< T >::at(), art::PtrVector< T >::clear(), art::PtrVector< T >::push_back(), and art::PtrVector< T >::size().

Referenced by evd::AnalysisBaseDrawer::CalorInteractive(), calo::BezierCalorimetry::produce(), and evd::HitSelector::SaveSeedLines().

  {
    art::PtrVector<recob::Hit> Hitv;
    for(size_t i=0; i!=Hitv.size(); ++i)
      {
        Hitv.push_back(Hits.at(i));
      }
    Hitv.clear();
    
    return GetCalorimetryObject(Hitv, sigtype, calalg);
  }

anab::Calorimetry trkf::BezierTrack::GetCalorimetryObject	(	art::PtrVector< recob::Hit > const &	Hits,
		geo::SigType_t	sigtype,
		calo::CalorimetryAlg const &	calalg
	)

Definition at line 183 of file BezierTrack.cxx.

References art::PtrVector< T >::at(), d, calo::CalorimetryAlg::dEdx_AMP(), GetClosestApproach(), GetLength(), GetTrackPitch(), s, art::PtrVector< T >::size(), and geo::GeometryCore::WirePitch().

  {

    
    art::ServiceHandle<geo::Geometry> geom;

    std::vector<double>  dEdx;
    std::vector<double>  dQdx;
    std::vector<double>  resRange;
    std::vector<double>  deadwire;
    double Range = GetLength();
    std::vector<double>  TrkPitch;



    double s, d;

    bool do_now=true;
    geo::PlaneID planeID;

    if(Hits.size()>0)
      {
        for(size_t i=0; i!=Hits.size(); ++i)
          {
            if(Hits.at(i)->SignalType()==sigtype)
              {
                geo::View_t view = Hits.at(i)->View();
                double WirePitch = geom->WirePitch(view);
                GetClosestApproach(Hits.at(i),s,d);
                double ThisPitch = GetTrackPitch( view, s, WirePitch );
                TrkPitch.push_back(ThisPitch);
                resRange.push_back(Range - s*Range);
                dQdx.push_back(Hits.at(i)->Integral()/ThisPitch);
                dEdx.push_back( calalg.dEdx_AMP(Hits.at(i), ThisPitch) );

                if(do_now) {
                  planeID = Hits.at(i)->WireID().planeID();
                  do_now=false;
                }
              }
            
          }
      }


    double KineticEnergy = 0.;

    for(size_t i=0; i!=dEdx.size(); ++i)
      KineticEnergy+=dEdx.at(i)*TrkPitch.at(i);

    return anab::Calorimetry(KineticEnergy, dEdx, dQdx, resRange, deadwire, Range, TrkPitch,planeID);


  }

anab::Calorimetry trkf::BezierTrack::GetCalorimetryObject	(	art::PtrVector< recob::Hit > const &	Hits,
		geo::View_t	view,
		calo::CalorimetryAlg const &	calalg
	)

Definition at line 242 of file BezierTrack.cxx.

References art::PtrVector< T >::at(), d, calo::CalorimetryAlg::dEdx_AMP(), GetClosestApproach(), GetLength(), GetTrackPitch(), s, art::PtrVector< T >::size(), and geo::GeometryCore::WirePitch().

  {

   
    art::ServiceHandle<geo::Geometry> geom;

    std::vector<double>  dEdx;
    std::vector<double>  dQdx;
    std::vector<double>  resRange;
    std::vector<double>  deadwire;
    double Range = GetLength();
    std::vector<double>  TrkPitch;

    double WirePitch = geom->WirePitch(view);

    double KineticEnergy = 0;                
 
    double s, d;

    bool do_now=true;
    geo::PlaneID planeID;

    if(Hits.size()>0)
      {
        for(size_t i=0; i!=Hits.size(); ++i)
          {
            if(Hits.at(i)->View()==view)
              {
                GetClosestApproach(Hits.at(i),s,d);
                double ThisPitch = GetTrackPitch( view, s, WirePitch );
                TrkPitch.push_back(ThisPitch);
                resRange.push_back( (1.-s) * Range);
                dQdx.push_back(Hits.at(i)->Integral()/ThisPitch);
                double ThisdEdx = calalg.dEdx_AMP(Hits.at(i), ThisPitch);
                dEdx.push_back( ThisdEdx);
                KineticEnergy+=ThisdEdx*ThisPitch;
                                
                if(do_now) {
                  planeID = Hits.at(i)->WireID().planeID();
                  do_now=false;
                }

              }
            
          }
      }


    return anab::Calorimetry(KineticEnergy, dEdx, dQdx, resRange, deadwire, Range, TrkPitch, planeID);

  }

void trkf::BezierTrack::GetClosestApproach	(	recob::Hit const &	hit,
		double &	s,
		double &	Distance
	)		const

Definition at line 602 of file BezierTrack.cxx.

References detinfo::DetectorProperties::ConvertTicksToX(), geo::CryostatID::Cryostat, d, fBezierResolution, GetTrackPoint(), recob::Hit::PeakTime(), geo::PlaneID::Plane, geo::TPCID::TPC, geo::WireID::Wire, geo::GeometryCore::WireEndPoints(), and recob::Hit::WireID().

Referenced by CalculatedQdx(), GetCalorimetryObject(), GetClosestApproach(), and trkf::FeatureTracker::GetConnectionMap().

  {
    const detinfo::DetectorProperties* det = art::ServiceHandle<detinfo::DetectorPropertiesService>()->provider();
    
    art::ServiceHandle<geo::Geometry>            geo;

    //unsigned int c1, t1, p1, w1;

    double xyzend1[3], xyzend2[3];

    geo::WireID hitWireID = hit.WireID();
    geo->WireEndPoints(hitWireID.Cryostat,hitWireID.TPC,hitWireID.Plane,hitWireID.Wire,xyzend1,xyzend2);
    
    xyzend1[0] = xyzend2[0] = det->ConvertTicksToX(hit.PeakTime(),hitWireID.Plane,hitWireID.TPC,hitWireID.Cryostat);
    
    double iS, xyz[3], MinDistanceToPoint=10000, MinS=0;

    for(int i=0; i<=fBezierResolution; ++i)
      {
        iS=float(i)/fBezierResolution;
        GetTrackPoint(iS, xyz);
        // calculate line to point distance in 3D
        TVector3 end1(xyzend1[0],xyzend1[1],xyzend1[2]);
        TVector3 end2(xyzend2[0],xyzend2[1],xyzend2[2]);
        TVector3 trackpt(xyz[0],xyz[1],xyz[2]);

        float d = ((trackpt-end1).Cross(trackpt-end2)).Mag()/(end2-end1).Mag();

        if(d<MinDistanceToPoint)
          {
            MinDistanceToPoint=d;
            MinS=iS;
          }
      }

    s = MinS;
    Distance = MinDistanceToPoint;

  }

void trkf::BezierTrack::GetClosestApproach	(	art::Ptr< recob::Hit > const &	hit,
		double &	s,
		double &	Distance
	)		const

Definition at line 650 of file BezierTrack.cxx.

References detinfo::DetectorProperties::ConvertTicksToX(), geo::CryostatID::Cryostat, d, fBezierResolution, GetTrackPoint(), recob::Hit::PeakTime(), geo::PlaneID::Plane, geo::TPCID::TPC, geo::WireID::Wire, geo::GeometryCore::WireEndPoints(), and recob::Hit::WireID().

  {
    const detinfo::DetectorProperties* det = art::ServiceHandle<detinfo::DetectorPropertiesService>()->provider();
    art::ServiceHandle<geo::Geometry>            geo;

    //unsigned int c1, t1, p1, w1;

    double xyzend1[3], xyzend2[3];

    geo::WireID hitWireID = hit->WireID();
    geo->WireEndPoints(hitWireID.Cryostat,hitWireID.TPC,hitWireID.Plane,hitWireID.Wire,xyzend1,xyzend2);

    xyzend1[0] = xyzend2[0] = det->ConvertTicksToX(hit->PeakTime(),hitWireID.Plane,hitWireID.TPC,hitWireID.Cryostat);

    double iS, xyz[3], MinDistanceToPoint=10000, MinS=0;

    for(int i=0; i<=fBezierResolution; ++i)
      {
        iS=float(i)/fBezierResolution;
        GetTrackPoint(iS, xyz);
        // calculate line to point distance in 3D
        TVector3 end1(xyzend1[0],xyzend1[1],xyzend1[2]);
        TVector3 end2(xyzend2[0],xyzend2[1],xyzend2[2]);
        TVector3 trackpt(xyz[0],xyz[1],xyz[2]);

        float d = ((trackpt-end1).Cross(trackpt-end2)).Mag()/(end2-end1).Mag();

        if(d<MinDistanceToPoint)
          {
            MinDistanceToPoint=d;
            MinS=iS;
          }
      }

    s = MinS;
    Distance = MinDistanceToPoint;

  }

void trkf::BezierTrack::GetClosestApproach	(	recob::SpacePoint *	sp,
		double &	s,
		double &	Distance
	)		const

Definition at line 739 of file BezierTrack.cxx.

References GetClosestApproach(), and recob::SpacePoint::XYZ().

  {
    const double* xyz = sp->XYZ();
    TVector3 Vec(xyz[0],xyz[1],xyz[2]);
    GetClosestApproach(Vec, s, Distance);
  }

void trkf::BezierTrack::GetClosestApproach	(	recob::Seed const &	seed,
		double &	s,
		double &	Distance
	)		const

Definition at line 750 of file BezierTrack.cxx.

References GetClosestApproach(), and recob::Seed::GetPoint().

  {
    double SeedPt[3], SeedErr[3];
    seed.GetPoint(SeedPt,SeedErr);
    TVector3 Vec(SeedPt[0],SeedPt[1],SeedPt[2]);
    GetClosestApproach(Vec, s, Distance);
  }

void trkf::BezierTrack::GetClosestApproach	(	TVector3	vec,
		double &	s,
		double &	Distance
	)		const

Definition at line 764 of file BezierTrack.cxx.

References d, fBezierResolution, and GetTrackPoint().

  {
    //    const detinfo::DetectorProperties* det = art::ServiceHandle<detinfo::DetectorPropertiesService>()->provider();
    art::ServiceHandle<geo::Geometry>            geo;

    double iS, xyz[3], MinDistanceToPoint=10000, MinS=0;

    for(int i=0; i<=fBezierResolution; ++i)
      {
        iS=float(i)/fBezierResolution;
        GetTrackPoint(iS, xyz);
        TVector3 trackpt(xyz[0],xyz[1],xyz[2]);

        float d = (vec-trackpt).Mag();

        if(d<MinDistanceToPoint)
          {
            MinDistanceToPoint=d;
            MinS=iS;
          }
      }

    s = MinS;
    Distance = MinDistanceToPoint;


  }

void trkf::BezierTrack::GetClosestApproach	(	uint32_t	w,
		int	p,
		int	t,
		int	c,
		float	x,
		double &	s,
		double &	Distance
	)		const

Definition at line 696 of file BezierTrack.cxx.

References d, fBezierResolution, GetTrackPoint(), geo::GeometryCore::WireEndPoints(), and x.

  {
    //    const detinfo::DetectorProperties* det = art::ServiceHandle<detinfo::DetectorPropertiesService>()->provider();
    art::ServiceHandle<geo::Geometry>            geo;
    
    
    double xyzend1[3], xyzend2[3];

    geo->WireEndPoints(c,t,p,w,xyzend1,xyzend2);

    xyzend1[0] = xyzend2[0] = x;

    double iS, xyz[3], MinDistanceToPoint=10000, MinS=0;

    for(int i=0; i<=fBezierResolution; ++i)
      {
        iS=float(i)/fBezierResolution;
        GetTrackPoint(iS, xyz);
        // calculate line to point distance in 3D
        TVector3 end1(xyzend1[0],xyzend1[1],xyzend1[2]);
        TVector3 end2(xyzend2[0],xyzend2[1],xyzend2[2]);
        TVector3 trackpt(xyz[0],xyz[1],xyz[2]);

        float d = ((trackpt-end1).Cross(trackpt-end2)).Mag()/(end2-end1).Mag();

        if(d<MinDistanceToPoint)
          {
            MinDistanceToPoint=d;
            MinS=iS;
          }
      }

    s = MinS;
    Distance = MinDistanceToPoint;

  }

void trkf::BezierTrack::GetClosestApproaches	(	art::PtrVector< recob::Hit > const &	hits,
		std::vector< double > &	s,
		std::vector< double > &	Distances
	)		const

Definition at line 519 of file BezierTrack.cxx.

References art::PtrVector< T >::at(), detinfo::DetectorProperties::ConvertTicksToX(), geo::CryostatID::Cryostat, d, fBezierResolution, GetTrackPointV(), geo::PlaneID::Plane, art::PtrVector< T >::size(), geo::TPCID::TPC, geo::WireID::Wire, and geo::GeometryCore::WireEndPoints().

Referenced by GetClosestApproaches(), and evd::HitSelector::SaveSeedLines().

  {

    const detinfo::DetectorProperties* det = art::ServiceHandle<detinfo::DetectorPropertiesService>()->provider();
    art::ServiceHandle<geo::Geometry>            geo;

    s.clear();
    Distances.clear();


    // Pull all the relevant information out of hits and into simple vectors

    std::vector<TVector3> HitEnd1s, HitEnd2s;
    std::vector<double> WireLengths;

    HitEnd1s.resize(hits.size());
    HitEnd2s.resize(hits.size());
    WireLengths.resize(hits.size());

    //unsigned int c1, t1, p1, w1;
    double End1[3], End2[3];

    size_t NHits = hits.size();

    for(size_t i=0; i!=NHits; i++)
      {
        Distances.push_back(10000);
        s.push_back(-1);

        geo::WireID hitWireID = hits.at(i)->WireID();

        geo->WireEndPoints(hitWireID.Cryostat,hitWireID.TPC,hitWireID.Plane,hitWireID.Wire,End1,End2);

        HitEnd1s.at(i)[0]= HitEnd2s.at(i)[0]= det->ConvertTicksToX(hits.at(i)->PeakTime(),hitWireID.Plane,hitWireID.TPC,hitWireID.Cryostat);
        HitEnd1s.at(i)[1]= End1[1];
        HitEnd2s.at(i)[1]= End2[1];
        HitEnd1s.at(i)[2]= End1[2];
        HitEnd2s.at(i)[2]= End2[2];

        WireLengths.at(i)=((HitEnd1s.at(i)-HitEnd2s.at(i)).Mag());
      }


    double iS;

    for(int ipt=0; ipt<=fBezierResolution; ++ipt)
      {
        iS=float(ipt)/fBezierResolution;
        TVector3 trackpt = GetTrackPointV(iS);

        for(size_t ihit=0; ihit!=NHits; ++ihit)
          {
            float d = ((trackpt-HitEnd1s.at(ihit)).Cross(trackpt-HitEnd2s.at(ihit))).Mag()/WireLengths.at(ihit);

            if(d<Distances.at(ihit))
              {
                Distances.at(ihit)=d;
                s.at(ihit)=iS;
              }
          }
      }


  }

void trkf::BezierTrack::GetClosestApproaches	(	std::vector< art::Ptr< recob::Hit > > const &	hits,
		std::vector< double > &	s,
		std::vector< double > &	Distances
	)		const

Definition at line 586 of file BezierTrack.cxx.

References art::PtrVector< T >::clear(), GetClosestApproaches(), hits(), and art::PtrVector< T >::push_back().

  {
    art::PtrVector<recob::Hit> hitv;
    for(size_t h = 0; h < hits.size(); ++h) hitv.push_back(hits[h]);
    this->GetClosestApproaches(hitv, s, Distances);
    hitv.clear();
  }

double trkf::BezierTrack::GetCurvature

(

double

s

)

const

Definition at line 858 of file BezierTrack.cxx.

References fBezierResolution, fTrackLength, and GetTrackPointV().

Referenced by GetRMSCurvature().

  {
    if((s<1./fBezierResolution)||(s>(1.-1./fBezierResolution)))
      {
        throw cet::exception("BezierTrack error: s out of range")<<
          " cannot query curvature within "<< 1./fBezierResolution<<
          " of track end.  You asked for s = "<<s <<
          ", which is out of range \n";
      }

    TVector3 Pos1 = GetTrackPointV(s - 0.5/fBezierResolution);
    TVector3 Pos2 = GetTrackPointV(s );
    TVector3 Pos3 = GetTrackPointV(s + 0.5/fBezierResolution);

    double dx     = (1./fBezierResolution)*fTrackLength;
    double dtheta = (Pos3-Pos2).Angle(Pos2-Pos1);

    return (dtheta/dx);
  }

double trkf::BezierTrack::GetdQdx	(	double	s,
		unsigned int	View
	)		const

Definition at line 1065 of file BezierTrack.cxx.

References fdQdx, and WhichSegment().

  {
    view++;
    if((s<0.)||(s>1.))
      {
        throw cet::exception("Bezier dQdx: S out of range")
          <<"Bezier track S value of " << s <<" is not in the range 0<S<1"
          <<"\n";
      }
    if( /* (view<0)|| */ view>(fdQdx.size()-1))
      {
        throw cet::exception("Bezier dQdx: view out of range")
          <<"Bezier track view value of " << view <<" is not in the range "
          <<"of stored views, 0 < view < " << fdQdx.size()
          <<"\n";
      }
    int Segment = WhichSegment(s);
    //    if((Segment>=fdQdx[view].size())||(Segment<0))
    //      {
    //  throw cet::exception("Bezier dQdx: segment of range")
    //    <<"Bezier track segment value of " << Segment <<" is not in the range "
    //    <<"of stored segments, 0 < seg < " << fdQdx[view].size()
    //    <<"\n";
    //     }
    if( ( Segment < (int)fdQdx[view].size() ) && (Segment>1))
      return fdQdx[view][Segment];
    else
      {
        mf::LogVerbatim("BezierTrack")<<"GetdQdx : Bad s  " <<s<<", " <<Segment<<std::endl;
        return 0;
      }
  }

double trkf::BezierTrack::GetLength

(

)

const

Definition at line 899 of file BezierTrack.cxx.

References fTrackLength.

Referenced by FillTrackVectors(), GetCalorimetryObject(), trkf::FeatureTracker::GetConnectionMap(), opdet::TrackTimeAssoc::GetMIPHypotheses(), opdet::BeamFlashCompatabilityCheck::GetMIPHypotheses(), GetPartialTrack(), and evd::TWireProjPad::UpdateSeedCurve().

  {
    return fTrackLength;
  }

BezierTrack trkf::BezierTrack::GetPartialTrack	(	double	LowS,
		double	HighS
	)

Definition at line 906 of file BezierTrack.cxx.

References fSeedCollection, GetLength(), GetTrackPointV(), n, and WhichSegment().

  {
    if(!((LowS>=0)&&(HighS<=1.0)&&(LowS<HighS)))
      {
        mf::LogError("BezierTrack")<<"Error in partial track calc - S out of range";
      }
   
    int LowSegment  = WhichSegment(LowS);
    int HighSegment = WhichSegment(HighS);
  
    TVector3 HighEnd = GetTrackPointV(HighS);
    TVector3 LowEnd  = GetTrackPointV(LowS);
    
    if(LowSegment!=HighSegment)
      {
        
        std::vector<recob::Seed> NewSeedCollection;
        for(int seg=LowSegment+1; seg<=HighSegment; ++seg)
          {
            NewSeedCollection.push_back(fSeedCollection.at(seg));
          }
        
        double PtLow[3],  DirLow[3], Err[3];
        double PtHigh[3], DirHigh[3];
        double LengthLow, LengthHigh;
        
        NewSeedCollection.at(0).GetPoint(PtLow,Err);
        NewSeedCollection.at(0).GetDirection(DirLow,Err);
        LengthLow = NewSeedCollection.at(0).GetLength();
        
        NewSeedCollection.at(NewSeedCollection.size()-1).GetPoint(PtHigh,Err);
        NewSeedCollection.at(NewSeedCollection.size()-1).GetDirection(DirHigh,Err);
        LengthHigh = NewSeedCollection.at(NewSeedCollection.size()-1).GetLength();
        
        double LowScale = fabs((TVector3(PtLow[0],PtLow[1],PtLow[2]) - LowEnd).Dot(TVector3(DirLow[0],DirLow[1],DirLow[2]).Unit()));
        
        double HighScale = fabs((TVector3(PtHigh[0],PtHigh[1],PtHigh[2]) - HighEnd).Dot(TVector3(DirHigh[0],DirHigh[1],DirHigh[2]).Unit()));
        

        for(size_t n=0; n!=3; ++n)
          {
            DirLow[n]  *= LowScale  / LengthLow;
            DirHigh[n] *= HighScale / LengthHigh;
            Err[n]      = 0;
          } 
        
        NewSeedCollection.at(0).SetDirection(DirLow, Err);
        NewSeedCollection.at(NewSeedCollection.size()-1).SetDirection(DirHigh, Err);
        return trkf::BezierTrack(NewSeedCollection);
      }
    else
      {
        double Pt[3], Dir[3], Err[3];
        for(size_t n=0; n!=3; ++n)
          {
            Pt[n]  = 0.5*(HighEnd[n] + LowEnd[n]);
            Dir[n] = 0.5*(HighEnd[n] - LowEnd[n]);
            Err[n] = 0;
          }
        recob::Seed OneSeed(Pt, Dir, Err, Err);
        std::vector<recob::Seed> NewSeedCollection;
        NewSeedCollection.push_back(OneSeed);
        
        return trkf::BezierTrack(NewSeedCollection);
      }
   
  }

void trkf::BezierTrack::GetProjectedPointUVWT	(	double	s,
		double *	uvw,
		double *	ticks,
		int	c = 0,
		int	t = 0
	)		const

Definition at line 492 of file BezierTrack.cxx.

References detinfo::DetectorProperties::ConvertXToTicks(), geo::GeometryCore::Cryostat(), GetTrackPoint(), geo::GeometryCore::NearestWire(), geo::TPCGeo::Nplanes(), and geo::CryostatGeo::TPC().

Referenced by corner::CornerFinderAlg::line_integrals(), and evd::TWireProjPad::UpdateSeedCurve().

  {
    const detinfo::DetectorProperties* det = art::ServiceHandle<detinfo::DetectorPropertiesService>()->provider();
    art::ServiceHandle<geo::Geometry>            geo;

    double  xyz[3];

    // Get point in 3D space
    GetTrackPoint(s , xyz);
    
    int NPlanes=geo->Cryostat(c).TPC(t).Nplanes();

    for(int p=0; p!=NPlanes; p++)
      {
        uvw[p]= geo->NearestWire(xyz,p,t,c);
        ticks[p]=det->ConvertXToTicks(xyz[0],p,t,c);
      }
  }

void trkf::BezierTrack::GetProjectedPointUVWX	(	double	s,
		double *	uvw,
		double *	x,
		int	c = 0,
		int	t = 0
	)		const

Definition at line 463 of file BezierTrack.cxx.

References geo::GeometryCore::Cryostat(), GetTrackPoint(), geo::GeometryCore::NearestWire(), geo::TPCGeo::Nplanes(), and geo::CryostatGeo::TPC().

  {

    art::ServiceHandle<geo::Geometry>   geo;

    double  xyz[3];

    // Get point in 3D space
    GetTrackPoint(s , xyz);

    int NPlanes=geo->Cryostat(c).TPC(t).Nplanes();

    for(int p=0; p!=NPlanes; p++)
      {        
        uvw[p]= geo->NearestWire(xyz,p,t,c);
      }
    x[0]=xyz[0];
  }

double trkf::BezierTrack::GetRMSCurvature

(

)

const

Definition at line 883 of file BezierTrack.cxx.

References fBezierResolution, and GetCurvature().

  {
    double RMS =0.;
    for(int i=1; i!=(fBezierResolution-1); ++i)
      {
        RMS += pow(GetCurvature( float(i)/fBezierResolution),2);
      }
    return (pow(RMS/(fBezierResolution-2),0.5));
  }

std::vector< recob::Seed > trkf::BezierTrack::GetSeedVector

(

)

Definition at line 108 of file BezierTrack.cxx.

References fSeedCollection.

Referenced by trkf::BezierTrackerAlgorithm::JoinTracks(), and Reverse().

  {
    std::vector<recob::Seed> ReturnVector=fSeedCollection;
    if(fSeedCollection.size()>2)
      {
        ReturnVector.erase(ReturnVector.begin());
        ReturnVector.pop_back();
        return ReturnVector;
      }
    else
      return std::vector<recob::Seed>();
    
  }

std::vector< recob::SpacePoint > trkf::BezierTrack::GetSpacePointTrajectory

(

int

N

)

Definition at line 1168 of file BezierTrack.cxx.

References GetTrackPoint(), and util::kBogusD.

  {
    std::vector<recob::SpacePoint> spts(N);
    for(int i=0; i!=N; ++i)
      {
        double xyz[3];
        double ErrXYZ[3]={0.1,0.1,0.1};
        GetTrackPoint(float(i)/N,xyz);
        recob::SpacePoint TheSP(xyz, ErrXYZ, util::kBogusD, i);

        spts[i] = TheSP;

      }

    return spts;
  }

double trkf::BezierTrack::GetTotalCharge

(

unsigned int

View

)

const

Definition at line 1131 of file BezierTrack.cxx.

References fTrackLength, and GetViewdQdx().

  {
    View++;
    return GetViewdQdx(View) * fTrackLength;
  }

void trkf::BezierTrack::GetTrackDirection	(	double	s,
		double *	xyz
	)		const

Definition at line 799 of file BezierTrack.cxx.

References fBezierResolution, and GetTrackPoint().

Referenced by GetTrackDirectionV().

  {

    if((s<0.5/fBezierResolution)||(s>(1.-0.5/fBezierResolution)))
      {
        if     (( s < 0.5 / fBezierResolution ) && ( s > -0.00001 ) )
          s = 0.5 / fBezierResolution;
        else if((s>(1.-0.5/fBezierResolution)) && ( s < 1.00001)) s = 1.-0.5/fBezierResolution;
        else
          throw cet::exception("BezierTrack error: s out of range")<<
            " cannot query gradient within "<< 0.5/fBezierResolution<<
            " of track end.  You asked for s = "<<s <<
            ", which is out of range \n";
      }
    double xyz1[3], xyz2[3];
    GetTrackPoint(s - 0.5/fBezierResolution, xyz1);
    GetTrackPoint(s + 0.5/fBezierResolution, xyz2);

    double dx = pow(pow(xyz1[0]-xyz2[0],2)+
                    pow(xyz1[1]-xyz2[1],2)+
                    pow(xyz1[2]-xyz2[2],2),0.5);

    for(int i=0; i!=3; ++i)
      {
        xyz[i] = (xyz2[i]-xyz1[i])/dx;
      }

  }

TVector3 trkf::BezierTrack::GetTrackDirectionV

(

double

s

)

const

Definition at line 844 of file BezierTrack.cxx.

References GetTrackDirection().

Referenced by FillTrackVectors(), and GetTrackPitch().

  {
    double xyz[3];
    GetTrackDirection(s,xyz);
    TVector3 ReturnVec(xyz[0],xyz[1],xyz[2]);
    return ReturnVec;
  }

double trkf::BezierTrack::GetTrackPitch	(	geo::View_t	view,
		double	s,
		double	WirePitch,
		unsigned int	c = 0,
		unsigned int	t = 0
	)

Definition at line 128 of file BezierTrack.cxx.

References geo::GeometryCore::Cryostat(), GetTrackDirectionV(), geo::TPCGeo::Nplanes(), geo::TPCGeo::Plane(), geo::CryostatGeo::TPC(), geo::PlaneGeo::View(), geo::GeometryCore::WireEndPoints(), and geo::GeometryCore::WirePitch().

Referenced by GetCalorimetryObject().

  {
    static std::map<geo::View_t, bool>          DoneCalc;
    static std::map<geo::View_t, TVector3>      PitchVecs;

    if(!(DoneCalc[view]))
      {
        unsigned int p;
        unsigned int pTop;

        art::ServiceHandle<geo::Geometry> geom;

        pTop=geom->Cryostat(c).TPC(t).Nplanes();
        for(p=0; p!=pTop; ++p)
          if(geom->Cryostat(c).TPC(t).Plane(p).View() == view) break;

        double WireEnd1[3], WireEnd2[3];

        geom->WireEndPoints(c, t, p, 0, WireEnd1, WireEnd2);

        double WirePitch = geom->WirePitch(view);

        TVector3 WireVec;
        for(size_t i=0; i!=3; ++i)
          WireVec[i]= WireEnd2[i] -WireEnd1[i];
        PitchVecs[view] = (1.0 / WirePitch) * WireVec.Cross(TVector3(1,0,0)).Unit();

        DoneCalc[view]=true;
      }

    TVector3 TrackDir = GetTrackDirectionV(s).Unit();

    return 1. / (PitchVecs[view].Dot(TrackDir));
  }

void trkf::BezierTrack::GetTrackPoint	(	double	s,
		double *	xyz
	)		const

Definition at line 408 of file BezierTrack.cxx.

References recob::Trajectory::End(), fCumulativeLength, fSeedCollection, fSegmentLength, fTrackLength, fTraj, trkf::BezierCurveHelper::GetBezierPointXYZ(), and recob::Trajectory::Start().

Referenced by GetClosestApproach(), opdet::TrackTimeAssoc::GetMIPHypotheses(), opdet::BeamFlashCompatabilityCheck::GetMIPHypotheses(), GetProjectedPointUVWT(), GetProjectedPointUVWX(), GetSpacePointTrajectory(), GetTrackDirection(), GetTrackPointV(), opdet::TrackTimeAssoc::ScanMIPHypotheses(), and evd::Display3DPad::UpdateSeedCurve().

  {
    if((s>=1.)||(s<=0.))
      {
        // catch these easy floating point errors
        if((s>0.9999)&&(s<1.00001))
          {
            auto End1 = fTraj.End();
            xyz[0]=End1.X();
            xyz[1]=End1.Y();
            xyz[2]=End1.Z();

            return;
          }
        else if((s<0.0001)&&(s>-0.00001))
          {
            auto End0 = fTraj.Start();
            xyz[0]=End0.X();
            xyz[1]=End0.Y();
            xyz[2]=End0.Z();

            return;
          }

        // otherwise complain about the mistake
        else
          throw cet::exception("track point out of range")<<" s = "<<s <<" out of range \n";
      }
    else
      {
        BezierCurveHelper bhlp;
        for(unsigned int i=1; i!=fCumulativeLength.size(); i++)
          {
            if(  (   (fCumulativeLength.at(i-1) / fTrackLength) <=  s)
                 &&( (fCumulativeLength.at(i)   / fTrackLength) > s))
              {
                double locals = (s * fTrackLength - fCumulativeLength[i-1])/fSegmentLength[i-1];


                bhlp.GetBezierPointXYZ(fSeedCollection.at(i-1),fSeedCollection.at(i),locals, xyz);
              }

          }
      }
  }

TVector3 trkf::BezierTrack::GetTrackPointV

(

double

s

)

const

Definition at line 835 of file BezierTrack.cxx.

References GetTrackPoint().

Referenced by FillTrackVectors(), GetClosestApproaches(), GetCurvature(), and GetPartialTrack().

  {
    double xyz[3];
    GetTrackPoint(s,xyz);
    TVector3 ReturnVec(xyz[0],xyz[1],xyz[2]);
    return ReturnVec;
  }

recob::Trajectory const& trkf::BezierTrack::GetTrajectory ( ) const

inline

Returns the current trajectory.

Definition at line 96 of file BezierTrack.h.

Referenced by opdet::TrackTimeAssoc::ScanMIPHypotheses().

{ return fTraj; }

double trkf::BezierTrack::GetViewdQdx

(

unsigned int

View

)

const

Definition at line 1105 of file BezierTrack.cxx.

References fdQdx, fSegmentLength, fTrackLength, and NSegments().

Referenced by GetTotalCharge().

  {
    view++;
    if(/* (view<0)|| */ view>fdQdx.size()-1)
      {
        throw cet::exception("view out of range")
          <<"Bezier track view value of " << view <<" is not in the range "
          <<"of stored views, 0 < view < " << fdQdx.size()
          <<"\n";
      }

    size_t NSeg = NSegments();
    double TotaldQdx = 0.;
    for(size_t i=0; i!=NSeg; ++i)
      {
        TotaldQdx+=fdQdx.at(view).at(i)*fSegmentLength[i];
      }
    return TotaldQdx / fTrackLength;
  }

int trkf::BezierTrack::NSegments

(

)

const

Definition at line 1160 of file BezierTrack.cxx.

References fTraj, and recob::Trajectory::NumberTrajectoryPoints().

Referenced by CalculatedQdx(), CalculateSegments(), FillSeedVector(), and GetViewdQdx().

  {
    return fTraj.NumberTrajectoryPoints();
  }

trkf::BezierTrack trkf::BezierTrack::Reverse

(

)

Definition at line 1187 of file BezierTrack.cxx.

References BezierTrack(), and GetSeedVector().

  {
    std::vector<recob::Seed> SeedCol = GetSeedVector();
    std::reverse(SeedCol.begin(), SeedCol.end());
    for(size_t i=0; i!=SeedCol.size(); ++i)
      {
        SeedCol.at(i)=SeedCol.at(i).Reverse();
      }
    return BezierTrack(SeedCol);
  }

int trkf::BezierTrack::WhichSegment

(

double

S

)

const

Definition at line 1142 of file BezierTrack.cxx.

References fCumulativeLength, fTrackLength, and s.

Referenced by CalculatedQdx(), GetdQdx(), and GetPartialTrack().

  {
    int ReturnVal=-1;
    for(size_t i=0; i!=fCumulativeLength.size()-1; i++)
      {
        if( (fCumulativeLength.at(i)/fTrackLength <= s)
            &&(fCumulativeLength.at(i+1)/fTrackLength >= s))
          ReturnVal=i;
      }
    if( ( s<(fCumulativeLength.at(0)/fTrackLength)) && (s>-0.0001)) ReturnVal=0;
    return ReturnVal;
  }

Member Data Documentation

int trkf::BezierTrack::fBezierResolution

private

Definition at line 118 of file BezierTrack.h.

Referenced by BezierTrack(), GetClosestApproach(), GetClosestApproaches(), GetCurvature(), GetRMSCurvature(), and GetTrackDirection().

std::vector<double> trkf::BezierTrack::fCumulativeLength

private

Definition at line 113 of file BezierTrack.h.

Referenced by CalculateSegments(), GetTrackPoint(), and WhichSegment().

std::vector<std::vector<double> > trkf::BezierTrack::fdQdx

private

Charge deposition per unit length at points along track outer vector index is, per plane.

Definition at line 109 of file BezierTrack.h.

Referenced by CalculatedQdx(), FillTrajectoryVectors(), GetdQdx(), and GetViewdQdx().

std::vector<recob::Seed> trkf::BezierTrack::fSeedCollection

private

Definition at line 115 of file BezierTrack.h.

Referenced by BezierTrack(), CalculateSegments(), FillSeedVector(), FillTrajectoryVectors(), GetPartialTrack(), GetSeedVector(), and GetTrackPoint().

std::vector<double> trkf::BezierTrack::fSegmentLength

private

Definition at line 112 of file BezierTrack.h.

Referenced by CalculatedQdx(), CalculateSegments(), GetTrackPoint(), and GetViewdQdx().

double trkf::BezierTrack::fTrackLength

private

Definition at line 117 of file BezierTrack.h.

Referenced by CalculateSegments(), GetCurvature(), GetLength(), GetTotalCharge(), GetTrackPoint(), GetViewdQdx(), and WhichSegment().

recob::Trajectory trkf::BezierTrack::fTraj

private

Internal trajectory representation.

Definition at line 105 of file BezierTrack.h.

Referenced by FillSeedVector(), FillTrajectoryVectors(), GetTrackPoint(), and NSegments().

---

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

• larreco/v06_64_02/source/larreco/Deprecated/BezierTrack.h
• larreco/v06_64_02/source/larreco/Deprecated/BezierTrack.cxx