#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.

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

recob::TrackTrajectory::Trajectory

Trajectory_t const & Trajectory() const

Returns the plain trajectory of this object.

Definition: TrackTrajectory.h:144

recob::Track::Trajectory

const recob::TrackTrajectory & Trajectory() const

Access to the stored recob::TrackTrajectory.

Definition: Track.h:101

trkf::BezierTrack::BezierTrack

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

Definition: BezierTrack.cxx:29

recob::Track::ID

int ID() const

Definition: Track.h:201

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<float>  dEdx;
     std::vector<float>  dQdx;
     std::vector<float>  resRange;
     std::vector<float>  deadwire;
     float Range = GetLength();
     std::vector<float>  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<float>  dEdx;
     std::vector<float>  dQdx;
     std::vector<float>  resRange;
     std::vector<float>  deadwire;
     float Range = GetLength();
     std::vector<float>  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().

96 { return fTraj; }

trkf::BezierTrack::fTraj

recob::Trajectory fTraj

Internal trajectory representation.

Definition: BezierTrack.h:105

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:

/cvmfs/larsoft.opensciencegrid.org/products/larreco/v07_10_02/source/larreco/Deprecated/BezierTrack.h
/cvmfs/larsoft.opensciencegrid.org/products/larreco/v07_10_02/source/larreco/Deprecated/BezierTrack.cxx

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation