geoalgo::GeoAlgo Class Reference

void line(double t, double *p, double &x, double &y, double &z)

Definition: PDSPAnalyzer_module.cc:4741

Point_t _ClosestPt_(const Point_t &pt, const LineSegment_t &line) const

Definition: GeoAlgo.cxx:388

Point_t geoalgo::GeoAlgo::_ClosestPt_	(	const Point_t &	pt,
		const HalfLine_t &	line
	)		const

protected

Definition at line 420 of file GeoAlgo.cxx.

   {
     auto const& ab = line.Dir();
     auto t = (pt - line.Start()) * ab;
     if( t <= 0. ) return line.Start();
     else {
       auto denom = ab.Length();
       return (line.Start() + ab * (t/denom));
     }
   }

Point_t geoalgo::GeoAlgo::_ClosestPt_	(	const HalfLine_t &	line,
		const Point_t &	pt
	)		const

inlineprotected

Definition at line 415 of file GeoAlgo.h.

416 { return _ClosestPt_(pt,line); }

void line(double t, double *p, double &x, double &y, double &z)

Definition: PDSPAnalyzer_module.cc:4741

Point_t _ClosestPt_(const Point_t &pt, const LineSegment_t &line) const

Definition: GeoAlgo.cxx:388

Point_t geoalgo::GeoAlgo::_ClosestPt_	(	const Line_t &	line,
		const Point_t &	pt
	)		const

protected

Definition at line 444 of file GeoAlgo.cxx.

   {
     auto const& ab = line.Pt2()-line.Pt1();
     auto t = (pt - line.Pt1()) * ab;
     auto denom = ab.Length();
     return (line.Pt1() + ab * (t/denom));
   }

Point_t geoalgo::GeoAlgo::_ClosestPt_	(	const Point_t &	pt,
		const Line_t &	line
	)		const

inlineprotected

Definition at line 421 of file GeoAlgo.h.

422 { return _ClosestPt_(line,pt); }

void line(double t, double *p, double &x, double &y, double &z)

Definition: PDSPAnalyzer_module.cc:4741

Point_t _ClosestPt_(const Point_t &pt, const LineSegment_t &line) const

Definition: GeoAlgo.cxx:388

Point_t geoalgo::GeoAlgo::_ClosestPt_	(	const Point_t &	pt,
		const AABox_t &	box
	)		const

protected

Point & AABox closest point w/o dimensionality check.

Definition at line 500 of file GeoAlgo.cxx.

   {
     // Result
     auto res = pt;
     // For each coordinate axis, if the point coordinate value is outside box,
     // clamp it to the box, else keep it as is
     for(size_t i=0; i<pt.size(); ++i) {
       auto const& v_pt  = pt[i];
       auto const& v_min = box.Min()[i];
       auto const& v_max = box.Max()[i];
       res[i] = v_pt;
       if( v_pt < v_min ) res[i] = v_min;
       if( v_pt > v_max ) res[i] = v_max;
     }
     return res;
   }

Point_t geoalgo::GeoAlgo::_ClosestPt_	(	const AABox_t &	box,
		const Point_t &	pt
	)		const

inlineprotected

Point & AABox closest point w/o dimensionality check.

Definition at line 438 of file GeoAlgo.h.

439 { return _ClosestPt_(pt,box); }

Point_t _ClosestPt_(const Point_t &pt, const LineSegment_t &line) const

Definition: GeoAlgo.cxx:388

double geoalgo::GeoAlgo::_commonOrigin_	(	const Line_t &	lin1,
		const Line_t &	lin2,
		Point_t &	origin
	)		const

protected

Common origin: Line & Line. Keep track of origin.

Common origin: Half Line & Half Line. Keep track of origin.

Definition at line 854 of file GeoAlgo.cxx.

   {
 
     // Function Description:
     // Given two HalfLine objects, project them backwards
     // and find the point of closest approach on both
     // lines.
     // The half-point between these two is considered the
     // candidate origin or vertex of the two lines
     // Then make segments uniting this vertex and
     // the start point of both half lines.
     // Take the dot product of the segment uniting
     // the vertex with the start of lin1, and the direction
     // of lin1. Similarly for lin2.
     // These dot-products will be close to 1 if the lines,
     // traced backwards, indeed point to the reconstructed
     // vertex.
     // return the sum of these dot products, which
     // is bound between -2 and +2.
     // other values of this return (1, 0, -1, -2)
     // will give insight on other possible topologies.
 
     // get directions of two lines
     Vector_t dir1(lin1.Pt2()-lin1.Pt1());
     Vector_t dir2(lin2.Pt2()-lin2.Pt1());
     dir1.Normalize();
     dir2.Normalize();
 
     // Closest approach points on the two lines
     Point_t pt1(lin1.Pt1().size());
     Point_t pt2(lin2.Pt1().size());
 
     //double IP = _SqDist_(lin1, lin2, pt1, pt2);
     origin = (pt1+pt2)/2.;
 
     // If origin coincides with lin1 start
     // -> vec1 should be in same direction of lin1
     Vector_t vec1(dir1);
     if (lin1.Pt1() != origin)
       vec1 = lin1.Pt1()-origin;
     vec1.Normalize();
     // similarly for vec1
     Vector_t vec2(dir2);
     if (lin2.Pt1() != origin)
       vec2 = lin2.Pt1()-origin;
     vec2.Normalize();
 
     return vec1.Dot(dir1) + vec2.Dot(dir2);
   }

double geoalgo::GeoAlgo::_commonOrigin_	(	const HalfLine_t &	lin1,
		const HalfLine_t &	lin2,
		Point_t &	origin,
		bool	backwards
	)		const

protected

Common origin: Half Line & Half Line. Keep track of origin.

Definition at line 906 of file GeoAlgo.cxx.

   {
 
     //If backwards is false, call infinite line function, otherwise proceed
     if (!backwards){
       Line_t l1(lin1.Start(),lin1.Start()+lin1.Dir());
       Line_t l2(lin2.Start(),lin2.Start()+lin2.Dir());
       return _commonOrigin_(l1,l2,origin);
     }
 
     // Function Description:
     // Given two HalfLine objects, project them backwards
     // and find the point of closest approach on both
     // lines.
     // The half-point between these two is considered the
     // candidate origin or vertex of the two lines
     // Then make segments uniting this vertex and
     // the start point of both half lines.
     // Take the dot product of the segment uniting
     // the vertex with the start of lin1, and the direction
     // of lin1. Similarly for lin2.
     // These dot-products will be close to 1 if the lines,
     // traced backwards, indeed point to the reconstructed
     // vertex.
     // return the sum of these dot products, which
     // is bound between -2 and +2.
     // other values of this return (1, 0, -1, -2)
     // will give insight on other possible topologies.
 
     // Flip the HalfLines: want to project backwards
     HalfLine_t lin1Back(lin1.Start(), lin1.Dir()*(-1));
     HalfLine_t lin2Back(lin2.Start(), lin2.Dir()*(-1));
     // Closest approach points on the two lines
     Point_t pt1(lin1.Start().size());
     Point_t pt2(lin2.Start().size());
 
     // double IP = _SqDist_(lin1Back, lin2Back, pt1, pt2); Unused variable
     origin = (pt1+pt2)/2.;
 
     // If origin coincides with lin1 start
     // -> vec1 should be in same direction of lin1
     Vector_t vec1(lin1.Dir());
     if (lin1.Start() != origin)
       vec1 = lin1.Start()-origin;
     vec1.Normalize();
     // similarly for vec1
     Vector_t vec2(lin2.Dir());
     if (lin2.Start() != origin)
       vec2 = lin2.Start()-origin;
     vec2.Normalize();
 
     return vec1.Dot(lin1.Dir()) + vec2.Dot(lin2.Dir());
     //    std::cout << "dot is: "  << dot << std::endl;
     //    if ( !((dot <= 2) && (dot >= -2)) )
     //      throw GeoAlgoException("commonOrigin failed. Sum of two dot-products must be bound by [-2,2]");
 
     //    return dot;
   }

double geoalgo::GeoAlgo::_commonOrigin_	(	const HalfLine_t &	lin,
		const LineSegment_t &	seg,
		Point_t &	origin,
		bool	backwards
	)		const

protected

Common origin: Line Segment & Half Line. Keep track of origin.

Definition at line 965 of file GeoAlgo.cxx.

   {
     // Make a Half-line out of the line-segment
     // we want to project backwards to a common origin
     // not limit ourselves to an origin that must be on the segment
     HalfLine_t lin2(seg.Start(), seg.Dir());
     return _commonOrigin_(lin, lin2, origin, backwards);
   }

double geoalgo::GeoAlgo::_commonOrigin_	(	const LineSegment_t &	seg1,
		const LineSegment_t &	seg2,
		Point_t &	origin,
		bool	backwards
	)		const

protected

Common origin: Line Segment & Line Segment. Keep track of origin.

Definition at line 974 of file GeoAlgo.cxx.

   {
     // Make a Half-line out of the line-segments
     // we want to project backwards to a common origin
     // not limit ourselves to an origin that must be on the segment
     HalfLine_t lin1(seg1.Start(), seg1.Dir());
     HalfLine_t lin2(seg2.Start(), seg2.Dir());
     return _commonOrigin_(lin1, lin2, origin, backwards);
   }

double geoalgo::GeoAlgo::_commonOrigin_	(	const Trajectory_t &	trj1,
		const Trajectory_t &	trj2,
		Point_t &	origin,
		bool	backwards
	)		const

protected

Common origin: Trajectory & Trajectory. Keep track of origin.

Common origin: Trajectory & Trajectory/ Keep track of origin.

Definition at line 985 of file GeoAlgo.cxx.

   {
     // Turn the trajectory into half-line that connect start -> end
     HalfLine_t lin1(trj1.front(),trj1.back()-trj1.front());
     // Turn the segment into half-line
     HalfLine_t lin2(trj2.front(),trj2.back()-trj2.front());
     return _commonOrigin_(lin1, lin2, origin, backwards);
   }

double geoalgo::GeoAlgo::_commonOrigin_	(	const Trajectory_t &	trj,
		const LineSegment_t &	seg,
		Point_t &	origin,
		bool	backwards
	)		const

protected

Common origin: Trajectory & Line Segment. Keep track of origin.

Definition at line 995 of file GeoAlgo.cxx.

   {
     // Turn the trajectory into half-line that connect start -> end
     HalfLine_t lin1(trj.front(),trj.back()-trj.front());
     // Turn the segment into half-line
     HalfLine_t lin2(seg.Start(), seg.Dir());
     return _commonOrigin_(lin1, lin2, origin, backwards);
   }

double geoalgo::GeoAlgo::_commonOrigin_	(	const Trajectory_t &	trj,
		const HalfLine_t &	lin,
		Point_t &	origin,
		bool	backwards
	)		const

protected

Common origin: Trajectory & Half Line. Keep track of origin.

Definition at line 1005 of file GeoAlgo.cxx.

   {
     // Turn the trajectory into half-line that connect start -> end
     HalfLine_t lin2(trj.front(),trj.back()-trj.front());
     return _commonOrigin_(lin, lin2, origin, backwards);
   }

Sphere_t geoalgo::GeoAlgo::_RemainingPoints_	(	std::vector< Point_t > &	remaining,
		const Sphere_t &	thisSphere
	)		const

protected

Definition at line 1050 of file GeoAlgo.cxx.

   {
 
 
     // if no points lef -> done...return the current sphere
     if (remaining.size() == 0)
       return thisSphere;
 
     //std::cout << "Remaining points: " << remaining.size() << std::endl;
 
     auto const& lastPoint = remaining.back();
 
     // if this point is bounded by the already constructed sphere, continue
     if ( thisSphere.Contain(lastPoint) ){
       remaining.pop_back();
       return _RemainingPoints_(remaining,thisSphere);
     }
     // if not, need to adjust so that the new point is also bound
     // get distance from lastPoint and center
     double dist = lastPoint.Dist(thisSphere.Center());
     //std::cout << "point does not fit: " << lastPoint << std::endl;
     //std::cout << "distance: " << dist << std::endl;
     //std::cout << "center  : " << thisSphere.Center() << std::endl;
     //std::cout << "radius  : " << thisSphere.Radius() << std::endl;
     // the new center should be shifted in the direction
     // of the new point by half the difference between
     // the current radius and "dist"
     // direction in which to move:
     Vector_t dir = lastPoint-thisSphere.Center();
     dir.Normalize();
     // amount to move by
     double shift = (dist-thisSphere.Radius())/2.;
     if (shift < 0) { shift *= -1; }
     Point_t newCenter = thisSphere.Center() + dir*shift;
     double newRadius  = thisSphere.Radius()+shift;
     //std::cout << "new center: " << newCenter << std::endl;
     //std::cout << "new radius: " << newRadius << std::endl;
     Sphere_t newsphere(newCenter,newRadius);
     //if (newsphere.Contain(lastPoint)) { std::cout << "new point contained!" << std::endl; }
     //else { std::cout << "WRONG!" << std::endl; }
     remaining.pop_back();
 
     return _RemainingPoints_(remaining,newsphere);
   }

double geoalgo::GeoAlgo::_SqDist_	(	const Line_t &	l1,
		const Line_t &	l2,
		Point_t &	L1,
		Point_t &	L2
	)		const

protected

Line & Line distance w/o dimensionality check.

Definition at line 193 of file GeoAlgo.cxx.

   {
 
     // closest approach when segment connecting the two lines
     // is perpendicular to both lines
 
     // L1 = P1 + s(Q1-P1)
     // L1 = P2 + t(Q2-P2)
     // L1(s) and L2(t) are the closest approach points
     // d1 = Q1-P1
     // d2 = Q2-P2
     // v(s,t) = L1(s) - L2(t)
     // require d1*v == 0 && d2*v == 0
     Vector_t d1 = l1.Pt2()-l1.Pt1();
     Vector_t d2 = l2.Pt2()-l2.Pt1();
     Vector_t r = l1.Pt1()-l2.Pt1();
 
     double a = d1*d1;
     double b = d1*d2;
     double c = d1*r;
     double e = d2*d2;
     double f = d2*r;
 
     double d = a*e-b*b;
 
     // if d==0 the lines are parallel
     // return Pt1 (doesn't matter) for line 1
     // distance is distance between Pt1 of 1 line & second line
     if (d == 0){
       L1 = l1.Pt1();
       L2 = _ClosestPt_(l1.Pt1(),l2);
       return L1._SqDist_(L2);
     }
 
     double s = (b*f-c*e)/d;
     double t = (a*f-b*c)/d;
 
     // s & t represent the paramteric points on the lines
     // for the closest approach point
     // now find the Point_t object at those locations
 
     L1 = l1.Pt1() + ( l1.Pt2()-l1.Pt1() )*s;
     L2 = l2.Pt1() + ( l2.Pt2()-l2.Pt1() )*t;
 
     // find distance between these points
     double dist = L1._SqDist_(L2);
 
     return dist;
   }

double geoalgo::GeoAlgo::_SqDist_	(	const HalfLine_t &	l1,
		const HalfLine_t &	l2,
		Point_t &	L1,
		Point_t &	L2
	)		const

protected

HalfLine & HalfLine distance w/o dimensionality check.

Definition at line 250 of file GeoAlgo.cxx.

   {
 
     //Same as for _SqDist_ with infinite line but check whether s & t go out of bounds (i.e. negative)
 
     Vector_t d1 = l1.Dir();
     Vector_t d2 = l2.Dir();
     Vector_t r = l1.Start()-l2.Start();
 
     double a = d1*d1;
     double b = d1*d2;
     double c = d1*r;
     double e = d2*d2;
     double f = d2*r;
 
     double d = a*e-b*b;
 
     // Need to make sure d != 0
     if ( d==0 ){
       // lines are parallel
       // check closest distance from one start point
       // to other line. Order indifferent
       // Choose l1 to have cloest point be Start point
       L1 = l1.Start();
       L2 = _ClosestPt_(L1,l2);
       return L1._SqDist_(L2);
     }
 
     double s = (b*f-c*e)/d;
     double t = (a*f-b*c)/d;
 
     // if s or t < 0, out of bounds for half-line
     if (s < 0) s = 0;
     if (t < 0) t = 0;
 
     // s & t represent the paramteric points on the lines
     // for the closest approach point
     // now find the Point_t object at those locations
 
     L1 = l1.Start() + l1.Dir()*s;
     L2 = l2.Start() + l2.Dir()*t;
 
     // find distance between these points
     double dist = L1._SqDist_(L2);
 
     return dist;
   }

double geoalgo::GeoAlgo::_SqDist_	(	const Point_t &	pt,
		const LineSegment_t &	line
	)		const

inlineprotected

Point & LineSegment distance w/o dimensionality check.

Definition at line 385 of file GeoAlgo.h.

386 { return _SqDist_(pt,line.Start(),line.End()); }

double _SqDist_(const Line_t &l1, const Line_t &l2, Point_t &L1, Point_t &L2) const

Line & Line distance w/o dimensionality check.

Definition: GeoAlgo.cxx:193

void line(double t, double *p, double &x, double &y, double &z)

Definition: PDSPAnalyzer_module.cc:4741

double geoalgo::GeoAlgo::_SqDist_	(	const Point_t &	pt,
		const Point_t &	line_s,
		const Point_t &	line_e
	)		const

protected

Point & LineSegment distance w/o dimensionality check.

Definition at line 375 of file GeoAlgo.cxx.

   {
     auto const  ab = line_e - line_s;
     auto const  ac = pt - line_s;
     auto const  bc = pt - line_e;
     auto e = ac * ab;
     if( e <= 0. ) return ac.SqLength();
     auto f = ab.SqLength();
     if( e >= f ) return bc.SqLength();
     return (ac.SqLength() - e * e / f);
   }

double geoalgo::GeoAlgo::_SqDist_	(	const LineSegment_t &	line,
		const Point_t &	pt
	)		const

inlineprotected

Point & LineSegment distance w/o dimensionality check.

Definition at line 392 of file GeoAlgo.h.

393 { return _SqDist_(pt,line); }

double _SqDist_(const Line_t &l1, const Line_t &l2, Point_t &L1, Point_t &L2) const

Line & Line distance w/o dimensionality check.

Definition: GeoAlgo.cxx:193

void line(double t, double *p, double &x, double &y, double &z)

Definition: PDSPAnalyzer_module.cc:4741

double geoalgo::GeoAlgo::_SqDist_	(	const HalfLine_t &	hline,
		const LineSegment_t &	seg,
		Point_t &	L1,
		Point_t &	L2
	)		const

protected

HalfLine & LineSegment distance w/o dimensionality check.

Definition at line 306 of file GeoAlgo.cxx.

   {
 
     //Same as for _SqDist_ with infinite line but check whether s & t go out of bounds (i.e. negative)
 
     auto const  d1 = hline.Dir();
     auto const  d2 = seg.End()-seg.Start();
     auto const   r = hline.Start()-seg.Start();
 
     double a = d1*d1;
     double b = d1*d2;
     double c = d1*r;
     double e = d2*d2;
     double f = d2*r;
 
     double d = a*e-b*b;
 
     // if parallel then d == 0
     if (d == 0){
       // distance is smallest quantity between:
       // - distance from segment start to line
       // - distance from segment end to line
       double sDist = _SqDist_(seg.Start(),hline);
       double eDist = _SqDist_(seg.End(),hline);
       if ( sDist <= eDist ) {
         // get closest point on line
         L1 = _ClosestPt_(seg.Start(),hline);
         L2 = seg.Start();
         return sDist;
       }
       else{
         L1 = _ClosestPt_(seg.End(),hline);
         L2 = seg.End();
         return eDist;
       }
     }// if parallel
 
     double s = (b*f-c*e)/d;
 
 
     // now check if parameters are out of bounds
     if ( s < 0 ){
       s = 0; // closest point on half-line is start
       // re-evaluate closest point on segment using line start point
       L1 = hline.Start();
       L2 = _ClosestPt_(L1,seg);
       return L1._SqDist_(L2);
     }
 
     // if closest point is not beyond half-line
     // it could be due to an intersection between half-line
     // and segment projection.
     // check value of t
     double t = (a*f-b*c)/d;
     // if t > 0 && < 1 then the two lines intersect. We are good!
     if ( (t < 1) and (t > 0) ){
       L1 = hline.Start() + hline.Dir()*s;
       L2 = seg.Start() + (seg.End()-seg.Start())*t;
       return L1._SqDist_(L2);
     }
     // if out of bounds clamp
     // then re-evaluate closest point on line
     t = _Clamp_(t,0,1);
     L2 = seg.Start() + (seg.End()-seg.Start())*t;
     L1 = _ClosestPt_(L2,hline);
     return L1._SqDist_(L2);
   }

double geoalgo::GeoAlgo::_SqDist_	(	const LineSegment_t &	seg1,
		const LineSegment_t &	seg2,
		Point_t &	c1,
		Point_t &	c2
	)		const

protected

LineSegment & LineSegment distance w/o dimensionality check.

Definition at line 768 of file GeoAlgo.cxx.

   {
 
     double t1, t2;
 
     auto const& s1 = seg1.Start();
     auto const& s2 = seg2.Start();
     auto const& e1 = seg1.End();
     auto const& e2 = seg2.End();
 
     auto d1 = e1 - s1;
     auto d2 = e2 - s2;
     auto r  = s1 - s2;
 
     double a = d1.SqLength();
     double e = d2.SqLength();
     double f    = d2 * r;
 
     // check if segment is too short
     if ( (a <= 0) and (e <= 0) ){
       //both segments are too short
       t1 = t2 = 0.;
       c1 = s1;
       c2 = s2;
       Vector_t distVector = c2 - c1;
       return distVector.SqLength();
     }
     if (a <= 0){
       //first segment degenerates into a point
       t1 = 0.;
       t2 = f/e;
       t2 = _Clamp_(t2,0.,1.);
     }
     else{
       double c = d1 * r;
       if (e <= 0){
         //second segment degenerates into a point
         t2 = 0.;
         t1 = _Clamp_(-c/a,0.,1.);
       }
       else{
         // the general case...no degeneracies
         double b = d1 * d2;
         double denom = (a*e)-(b*b);
 
         if (denom != 0.)
           t1 = _Clamp_((b*f-c*e)/denom, 0., 1.);
         else
           t1 = 0.;
 
         t2 = (b*t1+f)/e;
 
         if (t2 < 0.){
           t2 = 0.;
           t1 = _Clamp_(-c/a, 0., 1.);
         }
         else if (t2 > 1.){
           t2 = 1.;
           t1 = _Clamp_((b-c)/a, 0., 1.);
         }
 
       }
     }
 
     c1 = s1 + d1 * t1;
     c2 = s2 + d2 * t2;
 
     Vector_t distVector = c2 - c1;
     return distVector.SqLength();
 
   }

double geoalgo::GeoAlgo::_SqDist_	(	const Point_t &	pt,
		const HalfLine_t &	line
	)		const

protected

Point & HalfLine distance w/o dimensionality check.

Definition at line 406 of file GeoAlgo.cxx.

   {
     auto const& ab = line.Dir();
     auto const  ac = pt - line.Start();
     auto const  bc = ac - ab;
 
     auto e = ac * ab;
     if( e <= 0. ) return (ac * ac);
     auto f = ab.SqLength();
     return (ac.SqLength() - e * e / f);
   }

double geoalgo::GeoAlgo::_SqDist_	(	const HalfLine_t &	line,
		const Point_t &	pt
	)		const

inlineprotected

Point & HalfLine distance w/o dimensionality check.

Definition at line 410 of file GeoAlgo.h.

411 { return _SqDist_(pt,line); }

double _SqDist_(const Line_t &l1, const Line_t &l2, Point_t &L1, Point_t &L2) const

Line & Line distance w/o dimensionality check.

Definition: GeoAlgo.cxx:193

void line(double t, double *p, double &x, double &y, double &z)

Definition: PDSPAnalyzer_module.cc:4741

double geoalgo::GeoAlgo::_SqDist_	(	const Line_t &	line,
		const Point_t &	pt
	)		const

protected

Definition at line 432 of file GeoAlgo.cxx.

   {
     auto const  ab = line.Pt2()-line.Pt1();
     auto const  ac = pt - line.Pt1();
     auto const  bc = ac - ab;
 
     auto e = ac * ab;
     auto f = ab.SqLength();
     return (ac.SqLength() - e * e / f);
   }

double geoalgo::GeoAlgo::_SqDist_	(	const Point_t &	pt,
		const Line_t &	line
	)		const

inlineprotected

Definition at line 426 of file GeoAlgo.h.

427 { return _SqDist_(line,pt); }

double _SqDist_(const Line_t &l1, const Line_t &l2, Point_t &L1, Point_t &L2) const

Line & Line distance w/o dimensionality check.

Definition: GeoAlgo.cxx:193

void line(double t, double *p, double &x, double &y, double &z)

Definition: PDSPAnalyzer_module.cc:4741

double geoalgo::GeoAlgo::_SqDist_	(	const Point_t &	pt,
		const AABox_t &	box
	)		const

protected

Point & AABox distance w/o dimensionality check.

Definition at line 454 of file GeoAlgo.cxx.

   {
     double dist = kINVALID_DOUBLE;
 
     // If a point is inside the box, simply compute the smallest perpendicular distance
     if(box.Contain(pt)) {
 
       auto const& pt_min = box.Min();
       auto const& pt_max = box.Max();
       // (1) Compute the distance to the YZ wall
       double dist_to_yz = pt[0] - pt_min[0];
       if( dist_to_yz > (pt_max[0] - pt[0]) ) dist_to_yz = pt_max[0] - pt[0];
 
       // (2) Compute the distance to the XZ wall
       double dist_to_zx = pt[1] - pt_min[1];
       if( dist_to_zx > (pt_max[1] - pt[1]) ) dist_to_zx = pt_max[1] - pt[1];
 
       // (3) Compute the distance to the XY wall
       double dist_to_xy = pt[2] - pt_min[2];
       if( dist_to_xy > (pt_max[2] - pt[2]) ) dist_to_xy = pt_max[2] - pt[2];
 
       // (4) Compute the minimum of (3), (4), and (5)
       dist = ( dist_to_yz < dist_to_zx ? dist_to_yz : dist_to_zx );
       dist = ( dist < dist_to_xy ? dist : dist_to_xy );
       dist *= dist;
 
     }
 
     else{
       // This refers to Ref. RTCD 5.1.3.1
       // re-set distance
       dist = 0;
       for(size_t i=0; i<pt.size(); ++i) {
 
         auto const& v_pt  = pt[i];
         auto const& v_max = box.Max()[i];
         auto const& v_min = box.Min()[i];
 
         if(v_pt < v_min) dist += (v_min - v_pt) * (v_min - v_pt);
         if(v_pt > v_max) dist += (v_pt - v_max) * (v_pt - v_max);
       }
     }
     return dist;
   }

double geoalgo::GeoAlgo::_SqDist_	(	const AABox_t &	box,
		const Point_t &	pt
	)		const

inlineprotected

Point & AABox distance w/o dimensionality check.

Definition at line 432 of file GeoAlgo.h.

433 { return _SqDist_(pt,box); }

geoalgo::GeoAlgo::_boundingSphere_

double _SqDist_(const Line_t &l1, const Line_t &l2, Point_t &L1, Point_t &L2) const

Line & Line distance w/o dimensionality check.

Definition: GeoAlgo.cxx:193

void geoalgo::GeoAlgo::_Swap_	(	double &	tmin,
		double &	tmax
	)		const

inlineprotected

Swap two points if min & max are inverted.

Definition at line 466 of file GeoAlgo.h.

467 { if(tmin > tmax) std::swap(tmin,tmax); }

art::swap

void swap(Handle< T > &a, Handle< T > &b)

Sphere_t geoalgo::GeoAlgo::_WelzlSphere_	(	const std::vector< Point_t > &	pts,
		int	numPts,
		std::vector< Point_t >	sosPts
	)		const

protected

Definition at line 1096 of file GeoAlgo.cxx.

   {
 
     if (numPts == 0)
       return Sphere_t(sosPts);
     // choose last point in the input set as the one to test (if it fits in current sphere or not)
     int index = numPts-1;
     // recursively compute the smallest bounding sphere of the remaining points
     Sphere_t smallestSphere = _WelzlSphere_(pts, numPts-1, sosPts);
     // if the selected point lies inside this sphere, it is indeed the smallest
     if ( smallestSphere.Contain(pts[index]) )
       return smallestSphere;
     // otherwise, update the set-of-support to additionally contain the new point
     sosPts.push_back(pts[index]);
     return _WelzlSphere_(pts, numPts-1, sosPts);
   }

Sphere_t geoalgo::GeoAlgo::boundingSphere ( const std::vector< Point_t > & pts ) const

inline

Definition at line 373 of file GeoAlgo.h.

374 { for(auto &p : pts) { pts.front().compat(p); } return _boundingSphere_(pts); }

test.p

p

Definition: test.py:223

Sphere_t _boundingSphere_(const std::vector< Point_t > &pts) const

Definition: GeoAlgo.cxx:1015

LineSegment_t geoalgo::GeoAlgo::BoxOverlap	(	const AABox_t &	box,
		const HalfLine_t &	line
	)		const

LineSegment sub-segment of HalfLine inside an AABox.

Definition at line 167 of file GeoAlgo.cxx.

   {
     // First find interection point of half-line and box
     auto xs_v = Intersection(box, line);
     if(xs_v.size()==2) return LineSegment_t(xs_v[0],xs_v[1]);
 
     // Build a new LineSegment
     if(!(xs_v.size())) return LineSegment_t();
 
     // Only other possiblity is # = 1
     return LineSegment_t(line.Start(),xs_v[0]);
   }

LineSegment_t geoalgo::GeoAlgo::BoxOverlap	(	const HalfLine_t &	line,
		const AABox_t &	box
	)		const

inline

LineSegment sub-segment of HalfLine inside an AABox.

Definition at line 72 of file GeoAlgo.h.

73 { return BoxOverlap(box, line); }

geoalgo::GeoAlgo::BoxOverlap

void line(double t, double *p, double &x, double &y, double &z)

Definition: PDSPAnalyzer_module.cc:4741

LineSegment_t BoxOverlap(const AABox_t &box, const HalfLine_t &line) const

LineSegment sub-segment of HalfLine inside an AABox.

Definition: GeoAlgo.cxx:167

Trajectory_t geoalgo::GeoAlgo::BoxOverlap	(	const AABox_t &	box,
		const Trajectory_t &	trj
	)		const

Get Trajectory inside box given some input trajectory -> now assumes trajectory cannot exit and re-enter box.

Definition at line 181 of file GeoAlgo.cxx.

   {
 
     // if first & last points inside, then return full trajectory
     if ( box.Contain(trj[0]) and box.Contain(trj.back()) )
       return trj;
 
     return trj;
   }

Trajectory_t geoalgo::GeoAlgo::BoxOverlap	(	const Trajectory_t &	trj,
		const AABox_t &	box
	)		const

inline

Get Trajectory inside box given some input trajectory -> now assumes trajectory cannot exit and re-enter box.

Definition at line 79 of file GeoAlgo.h.

80 { return BoxOverlap(box, trj); }

geoalgo::GeoAlgo::BoxOverlap

LineSegment_t BoxOverlap(const AABox_t &box, const HalfLine_t &line) const

LineSegment sub-segment of HalfLine inside an AABox.

Definition: GeoAlgo.cxx:167

Point_t geoalgo::GeoAlgo::ClosestPt	(	const Line_t &	line,
		const Point_t &	pt
	)		const

inline

Definition at line 93 of file GeoAlgo.h.

94 { pt.compat(line.Pt1()); return _ClosestPt_(pt,line); }

void line(double t, double *p, double &x, double &y, double &z)

Definition: PDSPAnalyzer_module.cc:4741

Point_t _ClosestPt_(const Point_t &pt, const LineSegment_t &line) const

Definition: GeoAlgo.cxx:388

Point_t geoalgo::GeoAlgo::ClosestPt	(	const Point_t &	pt,
		const Line_t &	line
	)		const

inline

Definition at line 96 of file GeoAlgo.h.

97 { return _ClosestPt_(pt,line); }

void line(double t, double *p, double &x, double &y, double &z)

Definition: PDSPAnalyzer_module.cc:4741

Point_t _ClosestPt_(const Point_t &pt, const LineSegment_t &line) const

Definition: GeoAlgo.cxx:388

Point_t geoalgo::GeoAlgo::ClosestPt	(	const Point_t &	pt,
		const Trajectory_t &	trj
	)		const

inline

Point_t & Trajectory_t closest point.

Definition at line 200 of file GeoAlgo.h.

201 { int idx=0; return ClosestPt(pt,trj,idx); }

Point_t ClosestPt(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:93

Point_t geoalgo::GeoAlgo::ClosestPt	(	const Trajectory_t &	trj,
		const Point_t &	pt
	)		const

inline

Point_t & Trajectory_t closest point.

Definition at line 203 of file GeoAlgo.h.

204 { int idx=0; return ClosestPt(pt,trj,idx); }

Point_t ClosestPt(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:93

Point_t geoalgo::GeoAlgo::ClosestPt	(	const Point_t &	pt,
		const Trajectory_t &	trj,
		int &	idx
	)		const

Point_t & Trajectory_t closest point. Keep track of index of segment.

Definition at line 575 of file GeoAlgo.cxx.

   {
 
     // Make sure trajectory object is properly defined
     if (!trj.size())
       throw GeoAlgoException("Trajectory object not properly set...");
 
     // Check dimensionality compatibility between point and trajectory
     trj.compat(pt);
 
     // Now keep track of smallest distance and loop over traj segments
     double distMin = kINVALID_DOUBLE;
     // For that smallest distance, keep track of the segment for which it was found
     for (size_t l=0; l < trj.size()-1; l++){
       double distTmp = _SqDist_(pt,trj[l],trj[l+1]);
       if (distTmp < distMin) { distMin = distTmp; idx = l; }
     }
 
     // Now that we have the segment for the closest approach
     // Use it to find the closest point on that segment
     LineSegment_t segMin(trj[idx], trj[idx+1]);
     return _ClosestPt_(pt,segMin);
   }

Point_t geoalgo::GeoAlgo::ClosestPt	(	const Trajectory_t &	trj,
		const Point_t &	pt,
		int &	idx
	)		const

inline

Point_t & Trajectory_t closest point. Keep track of index of segment.

Definition at line 208 of file GeoAlgo.h.

209 { return ClosestPt(pt,trj,idx); }

Point_t ClosestPt(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:93

Point_t geoalgo::GeoAlgo::ClosestPt	(	const Point_t &	pt,
		const std::vector< geoalgo::Trajectory_t > &	trj,
		int &	trackIdx
	)		const

Point_t & Trajectory_t closest point - keep track of which track is closest.

Definition at line 604 of file GeoAlgo.cxx.

   {
 
     // since finding the smallest distance is faster than finding the closest point
     // first loop through tracks, and find the one that is closest to the point
     // then finally find the closest point on that track
 
     for (size_t t=0; t < trj.size(); t++){
 
       // holder for smallest distance
       double minDist = kINVALID_DOUBLE;
 
       // track & point dimensionality will be checked per-track by next function
       // now calculate distance w.r.t. this track
       double tmpDist = SqDist(pt, trj[t]);
       if (tmpDist < minDist){
         minDist = tmpDist;
         TrackIdx = t;
       }
 
     }// for all tracks
 
     // now we know which track is closest -> find the closest point to that track
     return ClosestPt(pt, trj[TrackIdx]);
   }

Point_t geoalgo::GeoAlgo::ClosestPt	(	const std::vector< geoalgo::Trajectory_t > &	trj,
		const Point_t &	pt,
		int &	trackIdx
	)		const

inline

Point_t & Trajectory_t closest point - keep track of which track is closest.

Definition at line 229 of file GeoAlgo.h.

230 { return ClosestPt(pt, trj, trackIdx); }

Point_t ClosestPt(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:93

Point_t geoalgo::GeoAlgo::ClosestPt	(	const Point_t &	pt,
		const std::vector< geoalgo::Trajectory_t > &	trj
	)		const

inline

Point_t & Trajectory_t closest point - don't keep track of which track is closest.

Definition at line 232 of file GeoAlgo.h.

233 { int trackIdx; return ClosestPt(pt, trj, trackIdx); }

Point_t ClosestPt(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:93

Point_t geoalgo::GeoAlgo::ClosestPt	(	const std::vector< geoalgo::Trajectory_t > &	trj,
		const Point_t &	pt
	)		const

inline

Point_t & Trajectory_t closest point - don't keep track of which track is closest.

Definition at line 235 of file GeoAlgo.h.

236 { int trackIdx; return ClosestPt(pt, trj, trackIdx); }

Point_t ClosestPt(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:93

Point_t geoalgo::GeoAlgo::ClosestPt	(	const Point_t &	pt,
		const LineSegment_t &	line
	)		const

inline

Point & LineSegment closest point.

Definition at line 249 of file GeoAlgo.h.

250 { pt.compat(line.Start()); return _ClosestPt_(pt,line); }

void line(double t, double *p, double &x, double &y, double &z)

Definition: PDSPAnalyzer_module.cc:4741

Point_t _ClosestPt_(const Point_t &pt, const LineSegment_t &line) const

Definition: GeoAlgo.cxx:388

Point_t geoalgo::GeoAlgo::ClosestPt	(	const LineSegment_t &	line,
		const Point_t &	pt
	)		const

inline

Point & LineSegment closest point.

Definition at line 252 of file GeoAlgo.h.

253 { return ClosestPt(pt,line); }

Point_t ClosestPt(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:93

void line(double t, double *p, double &x, double &y, double &z)

Definition: PDSPAnalyzer_module.cc:4741

Point_t geoalgo::GeoAlgo::ClosestPt	(	const Point_t &	pt,
		const HalfLine_t &	line
	)		const

inline

Point & HalfLine closest point.

Definition at line 265 of file GeoAlgo.h.

266 { pt.compat(line.Start()); return _ClosestPt_(pt,line); }

void line(double t, double *p, double &x, double &y, double &z)

Definition: PDSPAnalyzer_module.cc:4741

Point_t _ClosestPt_(const Point_t &pt, const LineSegment_t &line) const

Definition: GeoAlgo.cxx:388

Point_t geoalgo::GeoAlgo::ClosestPt	(	const HalfLine_t &	line,
		const Point_t &	pt
	)		const

inline

Point & HalfLine closest point.

Definition at line 268 of file GeoAlgo.h.

269 { return ClosestPt(pt,line); }

Point_t ClosestPt(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:93

void line(double t, double *p, double &x, double &y, double &z)

Definition: PDSPAnalyzer_module.cc:4741

Point_t geoalgo::GeoAlgo::ClosestPt	(	const Point_t &	pt,
		const AABox_t &	box
	)		const

inline

Point & AABox closest point.

Definition at line 298 of file GeoAlgo.h.

299 { pt.compat(box.Min()); return _ClosestPt_(pt,box); }

Point_t _ClosestPt_(const Point_t &pt, const LineSegment_t &line) const

Definition: GeoAlgo.cxx:388

Point_t geoalgo::GeoAlgo::ClosestPt	(	const AABox_t &	box,
		const Point_t &	pt
	)		const

inline

Point & AABox closest point.

Definition at line 301 of file GeoAlgo.h.

302 { return ClosestPt(pt,box); }

Point_t ClosestPt(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:93

double geoalgo::GeoAlgo::commonOrigin	(	const Line_t &	lin1,
		const Line_t &	lin2
	)		const

inline

Common origin: Line Segment & Line Segment. Do not keep track of origin.

Definition at line 309 of file GeoAlgo.h.

310 { Point_t origin(lin1.Pt1().size()); return commonOrigin(lin1,lin2, origin); }

ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >> Point_t

Definition: EnergyRecoOutput.h:8

double commonOrigin(const Line_t &lin1, const Line_t &lin2) const

Common origin: Line Segment & Line Segment. Do not keep track of origin.

Definition: GeoAlgo.h:309

constexpr Point origin()

Returns a origin position with a point of the specified type.

Definition: geo_vectors.h:227

double geoalgo::GeoAlgo::commonOrigin	(	const Line_t &	lin1,
		const Line_t &	lin2,
		Point_t &	origin
	)		const

inline

Common origin: Line Segment & Line Segment. Keep track of origin.

Definition at line 312 of file GeoAlgo.h.

313 { lin1.Pt1().compat(lin2.Pt1()); return _commonOrigin_(lin1, lin2, origin); }

double _commonOrigin_(const Line_t &lin1, const Line_t &lin2, Point_t &origin) const

Common origin: Line & Line. Keep track of origin.

Definition: GeoAlgo.cxx:854

constexpr Point origin()

Returns a origin position with a point of the specified type.

Definition: geo_vectors.h:227

double geoalgo::GeoAlgo::commonOrigin	(	const LineSegment_t &	seg1,
		const LineSegment_t &	seg2,
		bool	backwards = `false`
	)		const

inline

Common origin: Line Segment & Line Segment. Do not keep track of origin.

Definition at line 315 of file GeoAlgo.h.

316 { Point_t origin(seg1.Start().size()); return commonOrigin(seg1,seg2, origin, backwards); }

ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >> Point_t

Definition: EnergyRecoOutput.h:8

double commonOrigin(const Line_t &lin1, const Line_t &lin2) const

Common origin: Line Segment & Line Segment. Do not keep track of origin.

Definition: GeoAlgo.h:309

constexpr Point origin()

Returns a origin position with a point of the specified type.

Definition: geo_vectors.h:227

double geoalgo::GeoAlgo::commonOrigin	(	const LineSegment_t &	seg1,
		const LineSegment_t &	seg2,
		Point_t &	origin,
		bool	backwards = `false`
	)		const

inline

Common origin: Line Segment & Line Segment. Keep track of origin.

Definition at line 318 of file GeoAlgo.h.

319 { seg1.Start().compat(seg2.Start()); return _commonOrigin_(seg1, seg2, origin, backwards); }

double _commonOrigin_(const Line_t &lin1, const Line_t &lin2, Point_t &origin) const

Common origin: Line & Line. Keep track of origin.

Definition: GeoAlgo.cxx:854

constexpr Point origin()

Returns a origin position with a point of the specified type.

Definition: geo_vectors.h:227

double geoalgo::GeoAlgo::commonOrigin	(	const HalfLine_t &	lin,
		const LineSegment_t &	seg,
		bool	backwards = `false`
	)		const

inline

Common origin: Line Segment & Half Line. Do not keep track of origin.

Definition at line 321 of file GeoAlgo.h.

322 { Point_t origin(lin.Start().size()); return commonOrigin(lin, seg, origin, backwards); }

ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >> Point_t

Definition: EnergyRecoOutput.h:8

double commonOrigin(const Line_t &lin1, const Line_t &lin2) const

Common origin: Line Segment & Line Segment. Do not keep track of origin.

Definition: GeoAlgo.h:309

constexpr Point origin()

Returns a origin position with a point of the specified type.

Definition: geo_vectors.h:227

double geoalgo::GeoAlgo::commonOrigin	(	const HalfLine_t &	lin,
		const LineSegment_t &	seg,
		Point_t &	origin,
		bool	backwards = `false`
	)		const

inline

Common origin: Line Segment & Line Segment. Keep track of origin.

Definition at line 324 of file GeoAlgo.h.

325 { lin.Start().compat(seg.Start()); return _commonOrigin_(lin, seg, origin, backwards); }

double _commonOrigin_(const Line_t &lin1, const Line_t &lin2, Point_t &origin) const

Common origin: Line & Line. Keep track of origin.

Definition: GeoAlgo.cxx:854

constexpr Point origin()

Returns a origin position with a point of the specified type.

Definition: geo_vectors.h:227

double geoalgo::GeoAlgo::commonOrigin	(	const LineSegment_t &	seg,
		const HalfLine_t &	lin,
		bool	backwards = `false`
	)		const

inline

Common origin: Line Segment & Half Line. Do not keep track of origin.

Definition at line 327 of file GeoAlgo.h.

328 { Point_t origin(lin.Start().size()); return commonOrigin(lin, seg, origin, backwards); }

ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >> Point_t

Definition: EnergyRecoOutput.h:8

double commonOrigin(const Line_t &lin1, const Line_t &lin2) const

Common origin: Line Segment & Line Segment. Do not keep track of origin.

Definition: GeoAlgo.h:309

constexpr Point origin()

Returns a origin position with a point of the specified type.

Definition: geo_vectors.h:227

double geoalgo::GeoAlgo::commonOrigin	(	const LineSegment_t &	seg,
		const HalfLine_t &	lin,
		Point_t &	origin,
		bool	backwards = `false`
	)		const

inline

Common origin: Line Segment & Line Segment. Keep track of origin.

Definition at line 330 of file GeoAlgo.h.

331 { lin.Start().compat(seg.Start()); return _commonOrigin_(lin, seg, origin, backwards); }

double _commonOrigin_(const Line_t &lin1, const Line_t &lin2, Point_t &origin) const

Common origin: Line & Line. Keep track of origin.

Definition: GeoAlgo.cxx:854

constexpr Point origin()

Returns a origin position with a point of the specified type.

Definition: geo_vectors.h:227

double geoalgo::GeoAlgo::commonOrigin	(	const HalfLine_t &	lin1,
		const HalfLine_t &	lin2,
		bool	backwards = `false`
	)		const

inline

Common origin: Half Line & Half Line. Do not keep track of origin.

Definition at line 333 of file GeoAlgo.h.

334 { Point_t origin(lin1.Start().size()); return commonOrigin(lin1,lin2, origin, backwards); }

ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >> Point_t

Definition: EnergyRecoOutput.h:8

double commonOrigin(const Line_t &lin1, const Line_t &lin2) const

Common origin: Line Segment & Line Segment. Do not keep track of origin.

Definition: GeoAlgo.h:309

constexpr Point origin()

Returns a origin position with a point of the specified type.

Definition: geo_vectors.h:227

double geoalgo::GeoAlgo::commonOrigin	(	const HalfLine_t &	lin1,
		const HalfLine_t &	lin2,
		Point_t &	origin,
		bool	backwards = `false`
	)		const

inline

Common origin: Half Line & Half Line. Keep track of origin.

Definition at line 336 of file GeoAlgo.h.

337 { lin1.Start().compat(lin2.Start()); return _commonOrigin_(lin1, lin2, origin, backwards); }

double _commonOrigin_(const Line_t &lin1, const Line_t &lin2, Point_t &origin) const

Common origin: Line & Line. Keep track of origin.

Definition: GeoAlgo.cxx:854

constexpr Point origin()

Returns a origin position with a point of the specified type.

Definition: geo_vectors.h:227

double geoalgo::GeoAlgo::commonOrigin	(	const Trajectory_t &	trj1,
		const Trajectory_t &	trj2,
		bool	backwards = `false`
	)		const

inline

Common origin: Trajectory & Trajectory. Do not keep track of origin.

Definition at line 339 of file GeoAlgo.h.

340 { Point_t origin(trj1.front().size()); return commonOrigin(trj1,trj2, origin, backwards); }

ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >> Point_t

Definition: EnergyRecoOutput.h:8

double commonOrigin(const Line_t &lin1, const Line_t &lin2) const

Common origin: Line Segment & Line Segment. Do not keep track of origin.

Definition: GeoAlgo.h:309

constexpr Point origin()

Returns a origin position with a point of the specified type.

Definition: geo_vectors.h:227

double geoalgo::GeoAlgo::commonOrigin	(	const Trajectory_t &	trj1,
		const Trajectory_t &	trj2,
		Point_t &	origin,
		bool	backwards = `false`
	)		const

inline

Common origin: Trajectory & Trajectory. Keep track of origin.

Definition at line 342 of file GeoAlgo.h.

343 { trj1.front().compat(trj2.front()); return _commonOrigin_(trj1, trj2, origin, backwards); }

double _commonOrigin_(const Line_t &lin1, const Line_t &lin2, Point_t &origin) const

Common origin: Line & Line. Keep track of origin.

Definition: GeoAlgo.cxx:854

constexpr Point origin()

Returns a origin position with a point of the specified type.

Definition: geo_vectors.h:227

double geoalgo::GeoAlgo::commonOrigin	(	const Trajectory_t &	trj,
		const HalfLine_t &	lin,
		bool	backwards = `false`
	)		const

inline

Common origin: Trajectory & Half Line. Do not keep track of origin.

Definition at line 345 of file GeoAlgo.h.

346 { Point_t origin(trj.front().size()); return commonOrigin(trj,lin, origin, backwards); }

ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >> Point_t

Definition: EnergyRecoOutput.h:8

double commonOrigin(const Line_t &lin1, const Line_t &lin2) const

Common origin: Line Segment & Line Segment. Do not keep track of origin.

Definition: GeoAlgo.h:309

constexpr Point origin()

Returns a origin position with a point of the specified type.

Definition: geo_vectors.h:227

double geoalgo::GeoAlgo::commonOrigin	(	const Trajectory_t &	trj,
		const HalfLine_t &	lin,
		Point_t &	origin,
		bool	backwards = `false`
	)		const

inline

Common origin: Trajectory & Half Line. Keep track of origin.

Definition at line 348 of file GeoAlgo.h.

349 { trj.front().compat(lin.Start()); return _commonOrigin_(trj, lin, origin, backwards); }

double _commonOrigin_(const Line_t &lin1, const Line_t &lin2, Point_t &origin) const

Common origin: Line & Line. Keep track of origin.

Definition: GeoAlgo.cxx:854

constexpr Point origin()

Returns a origin position with a point of the specified type.

Definition: geo_vectors.h:227

double geoalgo::GeoAlgo::commonOrigin	(	const HalfLine_t &	lin,
		const Trajectory_t &	trj,
		bool	backwards = `false`
	)		const

inline

Common origin: Trajectory & Half Line. Do not keep track of origin.

Definition at line 351 of file GeoAlgo.h.

352 { Point_t origin(trj.front().size()); return commonOrigin(trj,lin, origin, backwards); }

ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >> Point_t

Definition: EnergyRecoOutput.h:8

double commonOrigin(const Line_t &lin1, const Line_t &lin2) const

Common origin: Line Segment & Line Segment. Do not keep track of origin.

Definition: GeoAlgo.h:309

constexpr Point origin()

Returns a origin position with a point of the specified type.

Definition: geo_vectors.h:227

double geoalgo::GeoAlgo::commonOrigin	(	const HalfLine_t &	lin,
		const Trajectory_t &	trj,
		Point_t &	origin,
		bool	backwards = `false`
	)		const

inline

Common origin: Trajectory & Half Line. Keep track of origin.

Definition at line 354 of file GeoAlgo.h.

355 { trj.front().compat(lin.Start()); return _commonOrigin_(trj, lin, origin, backwards); }

double _commonOrigin_(const Line_t &lin1, const Line_t &lin2, Point_t &origin) const

Common origin: Line & Line. Keep track of origin.

Definition: GeoAlgo.cxx:854

constexpr Point origin()

Returns a origin position with a point of the specified type.

Definition: geo_vectors.h:227

double geoalgo::GeoAlgo::commonOrigin	(	const Trajectory_t &	trj,
		const LineSegment_t &	seg,
		bool	backwards = `false`
	)		const

inline

Common origin: Trajectory & Line Segment. Do not keep track of origin.

Definition at line 357 of file GeoAlgo.h.

358 { Point_t origin(trj.front().size()); return commonOrigin(trj, seg, origin, backwards); }

ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >> Point_t

Definition: EnergyRecoOutput.h:8

double commonOrigin(const Line_t &lin1, const Line_t &lin2) const

Common origin: Line Segment & Line Segment. Do not keep track of origin.

Definition: GeoAlgo.h:309

constexpr Point origin()

Returns a origin position with a point of the specified type.

Definition: geo_vectors.h:227

double geoalgo::GeoAlgo::commonOrigin	(	const Trajectory_t &	trj,
		const LineSegment_t &	seg,
		Point_t &	origin,
		bool	backwards = `false`
	)		const

inline

Common origin: Trajectory & Line Segment. Keep track of origin.

Definition at line 360 of file GeoAlgo.h.

361 { trj.front().compat(seg.Start()); return _commonOrigin_(trj, seg, origin, backwards); }

double _commonOrigin_(const Line_t &lin1, const Line_t &lin2, Point_t &origin) const

Common origin: Line & Line. Keep track of origin.

Definition: GeoAlgo.cxx:854

constexpr Point origin()

Returns a origin position with a point of the specified type.

Definition: geo_vectors.h:227

double geoalgo::GeoAlgo::commonOrigin	(	const LineSegment_t &	seg,
		const Trajectory_t &	trj,
		bool	backwards = `false`
	)		const

inline

Common origin: Trajectory & Line Segment. Do not keep track of origin.

Definition at line 363 of file GeoAlgo.h.

364 { Point_t origin(trj.front().size()); return commonOrigin(trj, seg, origin, backwards); }

ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >> Point_t

Definition: EnergyRecoOutput.h:8

double commonOrigin(const Line_t &lin1, const Line_t &lin2) const

Common origin: Line Segment & Line Segment. Do not keep track of origin.

Definition: GeoAlgo.h:309

constexpr Point origin()

Returns a origin position with a point of the specified type.

Definition: geo_vectors.h:227

double geoalgo::GeoAlgo::commonOrigin	(	const LineSegment_t &	seg,
		const Trajectory_t &	trj,
		Point_t &	origin,
		bool	backwards = `false`
	)		const

inline

Common origin: Trajectory & Line Segment. Keep track of origin.

Definition at line 366 of file GeoAlgo.h.

367 { trj.front().compat(seg.Start()); return _commonOrigin_(trj, seg, origin, backwards); }

double _commonOrigin_(const Line_t &lin1, const Line_t &lin2, Point_t &origin) const

Common origin: Line & Line. Keep track of origin.

Definition: GeoAlgo.cxx:854

constexpr Point origin()

Returns a origin position with a point of the specified type.

Definition: geo_vectors.h:227

std::vector< Point_t > geoalgo::GeoAlgo::Intersection	(	const AABox_t &	box,
		const HalfLine_t &	line,
		bool	back = `false`
	)		const

Intersection between a HalfLine and an AABox.

Definition at line 11 of file GeoAlgo.cxx.

   {
     // Result container
     std::vector<Point_t> result;
     Point_t xs1(3); // Only 2 points max possible
     Point_t xs2(3); // Create in advance for early termination checks
     // One-time only initialization for unit vectors
     static std::vector<Point_t> min_plane_n;
     static std::vector<Point_t> max_plane_n;
     if(!min_plane_n.size()) {
       min_plane_n.reserve(3);
       min_plane_n.push_back(Vector_t(-1,0,0));
       min_plane_n.push_back(Vector_t(0,-1,0));
       min_plane_n.push_back(Vector_t(0,0,-1));
       max_plane_n.reserve(3);
       max_plane_n.push_back(Vector_t(1,0,0));
       max_plane_n.push_back(Vector_t(0,1,0));
       max_plane_n.push_back(Vector_t(0,0,1));
     }
     // min/max points of the AABox
     auto const& min_pt = box.Min();
     auto const& max_pt = box.Max();
     // start/dir of the line
     auto const& start = line.Start();
     auto        dir   = line.Dir();
     if(back) dir *= -1;
     // Inspect the case of parallel line
     for(size_t i=0; i<min_pt.size(); ++i) {
       if ( dir[i] == 0 &&
            (start[i] <= min_pt[i] ||  max_pt[i] <= start[i]) )
         return result;
     }
     // Look for xs w/ 3 planes
     for(size_t i=0; i<3; ++i) {
       auto const& normal = min_plane_n[i];
       double s = (-1.) * ( normal * (start - min_pt) ) / (normal * dir);
       if(s<0) continue;
       auto xs = start + dir * s;
       // Check if the found point is within the surface area of other 2 axis
       bool on_surface=true;
       for(size_t sur_axis=0; sur_axis<3; ++sur_axis) {
         if(sur_axis==i) continue;
         if(xs[sur_axis] < min_pt[sur_axis] || max_pt[sur_axis] < xs[sur_axis]) {
           on_surface=false;
           break;
         }
       }
       if(on_surface && xs != xs1) {
         // Directly assign to xs1 instead of making a copy
         if(!(xs1.IsValid())) for(size_t j=0; j<3; ++j) xs1[j]=xs[j];
         else {
           // If xs2 is filled, no more point to search. Exit.
           for(size_t j=0; j<3; ++j) xs2[j]=xs[j];
           break;
         }
       }
     }
     // If xs2 is filled, simply return the result. Order the output via distance
     if(xs2.IsValid()) {
       result.reserve(2);
       if(xs1._SqDist_(start) > xs2._SqDist_(start)) std::swap(xs1,xs2);
       result.push_back(xs1);
       result.push_back(xs2);
       return result;
     }
     // Look for xs w/ 3 planes
     for(size_t i=0; i<3; ++i) {
       auto const& normal = max_plane_n[i];
       double s = (-1.) * ( normal * (start - max_pt) ) / (normal * dir);
       if(s<0) continue;
       auto xs = start + dir * s;
       bool on_surface=true;
       for(size_t sur_axis=0; sur_axis<3; ++sur_axis) {
         if(sur_axis==i) continue;
         if(xs[sur_axis] < min_pt[sur_axis] || max_pt[sur_axis] < xs[sur_axis]) {
           on_surface=false;
           break;
         }
       }
       if(on_surface && xs != xs1) {
         if(!(xs1.IsValid())) for(size_t j=0; j<3; ++j) xs1[j]=xs[j];
         else {
           for(size_t j=0; j<3; ++j) xs2[j]=xs[j];
           break;
         }
       }
     }
     if(!xs1.IsValid()) return result;
     if(xs2.IsValid()) {
       result.reserve(2);
       if(xs1._SqDist_(start) > xs2._SqDist_(start)) std::swap(xs1,xs2);
       result.push_back(xs1);
       result.push_back(xs2);
       return result;
     }
     result.push_back(xs1);
     return result;
   }

std::vector<Point_t> geoalgo::GeoAlgo::Intersection	(	const HalfLine_t &	line,
		const AABox_t &	box,
		bool	back = `false`
	)		const

inline

Intersection between a HalfLine and an AABox.

Definition at line 54 of file GeoAlgo.h.

55 { return Intersection(box, line, back); }

geoalgo::GeoAlgo::Intersection

void line(double t, double *p, double &x, double &y, double &z)

Definition: PDSPAnalyzer_module.cc:4741

std::vector< Point_t > Intersection(const AABox_t &box, const HalfLine_t &line, bool back=false) const

Intersection between a HalfLine and an AABox.

Definition: GeoAlgo.cxx:11

std::vector< Point_t > geoalgo::GeoAlgo::Intersection	(	const AABox_t &	box,
		const LineSegment_t &	l
	)		const

Intersection between LineSegment and an AABox.

Definition at line 113 of file GeoAlgo.cxx.

   {
     auto const& st = line.Start();
     auto const& ed = line.End();
     // Create a static HalfLine_t for this algorithm
     static HalfLine_t hline(st,ed-st);
     hline.Start(st[0],st[1],st[2]);
     hline.Dir(ed[0]-st[0],ed[1]-st[1],ed[2]-st[2]);
 
     auto hline_result = Intersection(box,hline);
 
     if(!hline_result.size()) return hline_result;
 
     // For non-empty result, only keep ones that is within the line length
     std::vector<Point_t> result;
     auto length = st._SqDist_(ed);
     for(auto const& pt : hline_result)
       if(st._SqDist_(pt) < length) result.push_back(pt);
     return result;
   }

std::vector<Point_t> geoalgo::GeoAlgo::Intersection	(	const LineSegment_t &	l,
		const AABox_t &	box
	)		const

inline

Intersection between LineSegment and an AABox.

Definition at line 60 of file GeoAlgo.h.

61 { return Intersection(box,l); }

l

static QStrList * l

Definition: config.cpp:1044

geoalgo::GeoAlgo::Intersection

std::vector< Point_t > Intersection(const AABox_t &box, const HalfLine_t &line, bool back=false) const

Intersection between a HalfLine and an AABox.

Definition: GeoAlgo.cxx:11

std::vector< Point_t > geoalgo::GeoAlgo::Intersection	(	const AABox_t &	box,
		const Trajectory_t &	trj
	)		const

Intersection between Trajectory and an AABox.

Definition at line 136 of file GeoAlgo.cxx.

   {
 
     std::vector<Point_t> result;
     if(trj.size() < 2) return result; // If only 1 point, return
     // Check compat
     trj.compat(box.Min());
     // Call the onetime-only HalfLine constructor
     static HalfLine_t hline(trj[0],trj[1]);
     for(size_t i=0; i<trj.size()-1; ++i) {
 
       auto const& st = trj[i];
       auto const& ed = trj[i+1];
       hline.Start(st[0],st[1],st[2]);
       hline.Dir(ed[0]-st[0],ed[1]-st[1],ed[2]-st[2]);
 
       auto hline_result = Intersection(box,hline);
 
       if(!hline_result.size()) continue;
 
       // Check if the length makes sense
       auto length = st._SqDist_(ed);
       for(auto const& pt : hline_result)
         if(st._SqDist_(pt) < length) result.push_back(pt);
 
     }
     return result;
   }

std::vector<Point_t> geoalgo::GeoAlgo::Intersection	(	const Trajectory_t &	trj,
		const AABox_t &	box
	)		const

inline

Intersection between Trajectory and an AABox.

Definition at line 66 of file GeoAlgo.h.

67 { return Intersection(box,trj); }

geoalgo::GeoAlgo::Intersection

std::vector< Point_t > Intersection(const AABox_t &box, const HalfLine_t &line, bool back=false) const

Intersection between a HalfLine and an AABox.

Definition: GeoAlgo.cxx:11

double geoalgo::GeoAlgo::SqDist	(	const Line_t &	line,
		const Point_t &	pt
	)		const

inline

Definition at line 87 of file GeoAlgo.h.

88 { pt.compat(line.Pt1()); return _SqDist_(line,pt); }

double _SqDist_(const Line_t &l1, const Line_t &l2, Point_t &L1, Point_t &L2) const

Line & Line distance w/o dimensionality check.

Definition: GeoAlgo.cxx:193

void line(double t, double *p, double &x, double &y, double &z)

Definition: PDSPAnalyzer_module.cc:4741

double geoalgo::GeoAlgo::SqDist	(	const Point_t &	pt,
		const Line_t &	line
	)		const

inline

Definition at line 90 of file GeoAlgo.h.

91 { return SqDist(line,pt); }

double SqDist(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:87

void line(double t, double *p, double &x, double &y, double &z)

Definition: PDSPAnalyzer_module.cc:4741

double geoalgo::GeoAlgo::SqDist	(	const Line_t &	l1,
		const Line_t &	l2,
		Point_t &	L1,
		Point_t &	L2
	)		const

inline

Definition at line 104 of file GeoAlgo.h.

105 { l1.Pt1().compat(l2.Pt1()); return _SqDist_(l1, l2, L1, L2); }

double _SqDist_(const Line_t &l1, const Line_t &l2, Point_t &L1, Point_t &L2) const

Line & Line distance w/o dimensionality check.

Definition: GeoAlgo.cxx:193

l1

Definition: languages.py:76

double geoalgo::GeoAlgo::SqDist	(	const Line_t &	l1,
		const Line_t &	l2
	)		const

inline

Definition at line 107 of file GeoAlgo.h.

108 { Point_t L1; Point_t L2; return SqDist(l1, l2, L1, L2); }

double SqDist(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:87

ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >> Point_t

Definition: EnergyRecoOutput.h:8

l1

Definition: languages.py:76

double geoalgo::GeoAlgo::SqDist	(	const HalfLine_t &	l1,
		const HalfLine_t &	l2,
		Point_t &	L1,
		Point_t &	L2
	)		const

inline

Definition at line 115 of file GeoAlgo.h.

116 { l1.Start().compat(l2.Start()); return _SqDist_(l1, l2, L1, L2); }

double _SqDist_(const Line_t &l1, const Line_t &l2, Point_t &L1, Point_t &L2) const

Line & Line distance w/o dimensionality check.

Definition: GeoAlgo.cxx:193

l1

Definition: languages.py:76

double geoalgo::GeoAlgo::SqDist	(	const HalfLine_t &	l1,
		const HalfLine_t &	l2
	)		const

inline

Definition at line 118 of file GeoAlgo.h.

119 { Point_t L1; Point_t L2; return SqDist(l1, l2, L1, L2); }

double SqDist(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:87

ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >> Point_t

Definition: EnergyRecoOutput.h:8

l1

Definition: languages.py:76

double geoalgo::GeoAlgo::SqDist	(	const LineSegment_t &	seg1,
		const LineSegment_t &	seg2,
		Point_t &	c1,
		Point_t &	c2
	)		const

inline

LineSegment_t & LineSegment_t distance - keep track of points.

Definition at line 126 of file GeoAlgo.h.

127 { seg1.Start().compat(seg2.Start()); return _SqDist_(seg1, seg2, c1, c2); }

double _SqDist_(const Line_t &l1, const Line_t &l2, Point_t &L1, Point_t &L2) const

Line & Line distance w/o dimensionality check.

Definition: GeoAlgo.cxx:193

c1

Definition: ValidateOpDetReco.py:586

double geoalgo::GeoAlgo::SqDist	(	const LineSegment_t &	seg1,
		const LineSegment_t &	seg2
	)		const

inline

LineSegment & LineSegment, don't keep track of points.

Definition at line 129 of file GeoAlgo.h.

130 { Point_t c1; Point_t c2; return SqDist(seg1, seg2, c1, c2); }

double SqDist(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:87

ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >> Point_t

Definition: EnergyRecoOutput.h:8

c1

Definition: ValidateOpDetReco.py:586

double geoalgo::GeoAlgo::SqDist	(	const LineSegment_t &	seg,
		const Trajectory_t &	trj,
		Point_t &	c1,
		Point_t &	c2
	)		const

LineSegment & Trajectory, keep track of points.

Definition at line 634 of file GeoAlgo.cxx.

   {
 
     // Make sure trajectory object is properly defined
     if (!trj.size())
       throw GeoAlgoException("Trajectory object not properly set...");
 
     // Check dimensionality compatibility between point and trajectory
     trj.compat(seg.Start());
 
     // keep track of c1 & c2
     Point_t c1min;
     Point_t c2min;
     // Now keep track of smallest distance and loop over traj segments
     double distMin = kMAX_DOUBLE;
 
     for (size_t l=0; l < trj.size()-1; l++){
       LineSegment_t segTmp(trj[l], trj[l+1]);
       double distTmp = _SqDist_(segTmp, seg, c1min, c2min);
       if ( distTmp < distMin ){
         c1 = c1min;
         c2 = c2min;
         distMin = distTmp;
       }
     }//for all segments in the track
 
     return distMin;
   }

double geoalgo::GeoAlgo::SqDist	(	const Trajectory_t &	trj,
		const LineSegment_t &	seg,
		Point_t &	c1,
		Point_t &	c2
	)		const

inline

LineSegment & Trajectory, keep track of points.

Definition at line 139 of file GeoAlgo.h.

140 { return SqDist(seg, trj, c1, c2); }

double SqDist(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:87

c1

Definition: ValidateOpDetReco.py:586

double geoalgo::GeoAlgo::SqDist	(	const Trajectory_t &	trj,
		const LineSegment_t &	seg
	)		const

inline

LineSegment & Trajectory, don't keep track of points.

Definition at line 142 of file GeoAlgo.h.

143 { Point_t c1; Point_t c2; return SqDist(seg, trj, c1, c2); }

double SqDist(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:87

ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >> Point_t

Definition: EnergyRecoOutput.h:8

c1

Definition: ValidateOpDetReco.py:586

double geoalgo::GeoAlgo::SqDist	(	const LineSegment_t &	seg,
		const Trajectory_t &	trj
	)		const

inline

LineSegment & Trajectory, don't keep track of points.

Definition at line 145 of file GeoAlgo.h.

146 { Point_t c1; Point_t c2; return SqDist(seg, trj, c1, c2); }

double SqDist(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:87

ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >> Point_t

Definition: EnergyRecoOutput.h:8

c1

Definition: ValidateOpDetReco.py:586

double geoalgo::GeoAlgo::SqDist	(	const Trajectory_t &	trj1,
		const Trajectory_t &	trj2,
		Point_t &	c1,
		Point_t &	c2
	)		const

Trajectory & Trajectory, keep track of points.

Definition at line 667 of file GeoAlgo.cxx.

   {
 
     // Make sure trajectory object is properly defined
     if ( !trj1.size() or !trj2.size() )
       throw GeoAlgoException("Trajectory object not properly set...");
 
     // Check dimensionality compatibility between point and trajectory
     trj1.compat(trj2[0]);
 
     // keep track of c1 & c2
     Point_t c1min;
     Point_t c2min;
     // Now keep track of smallest distance and loop over traj segments
     double distMin = kMAX_DOUBLE;
 
     for (size_t l1=0; l1 < trj1.size()-1; l1++){
       for (size_t l2=0; l2 < trj2.size()-1; l2++){
         LineSegment_t segTmp1(trj1[l1], trj1[l1+1]);
         LineSegment_t segTmp2(trj2[l2], trj2[l2+1]);
         double distTmp = _SqDist_(segTmp1, segTmp2, c1min, c2min);
         if ( distTmp < distMin ){
           c1 = c1min;
           c2 = c2min;
           distMin = distTmp;
         }
       }// for segments in trajectory 2
     }//for all segments in trajectory 1
 
     return distMin;
   }

double geoalgo::GeoAlgo::SqDist	(	const Trajectory_t &	trj1,
		const Trajectory_t &	trj2
	)		const

inline

Trajectory & Trajectory, don't keep track of points.

Definition at line 155 of file GeoAlgo.h.

156 { Point_t c1; Point_t c2; return SqDist(trj1, trj2, c1, c2); }

double SqDist(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:87

ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >> Point_t

Definition: EnergyRecoOutput.h:8

c1

Definition: ValidateOpDetReco.py:586

double geoalgo::GeoAlgo::SqDist	(	const LineSegment_t &	seg,
		const std::vector< geoalgo::Trajectory_t > &	trj,
		Point_t &	c1,
		Point_t &	c2,
		int &	trackIdx
	)		const

LineSegment & vector of Trajectories, keep track of points.

Definition at line 736 of file GeoAlgo.cxx.

   {
 
     // holders to keep track of track with shortest distance
     double minDist = kMAX_DOUBLE;
     // holders for points of closest approach
     Point_t c1min;
     Point_t c2min;
 
     for (size_t t=0; t < trj.size(); t++){
 
       //need to loop over all tracks and find the one which is closest
 
       // dimensionality checks will be done in next function, per track.
 
       // now calculate closest approach
       double tmpDist = SqDist(seg, trj[t], c1min, c2min);
 
       // is this the best yet?
       if (tmpDist < minDist){
         minDist = tmpDist;
         c1 = c1min;
         c2 = c2min;
         trackIdx = t;
       }
 
     }// for all tracks in vector
 
     return minDist;
   }

double geoalgo::GeoAlgo::SqDist	(	const std::vector< geoalgo::Trajectory_t > &	trj,
		const LineSegment_t &	seg,
		Point_t &	c1,
		Point_t &	c2,
		int &	trackIdx
	)		const

inline

LineSegment & vector of Trajectories, keep track of points.

Definition at line 165 of file GeoAlgo.h.

166 { return SqDist(seg, trj, c2, c1, trackIdx); }

double SqDist(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:87

c1

Definition: ValidateOpDetReco.py:586

double geoalgo::GeoAlgo::SqDist	(	const std::vector< geoalgo::Trajectory_t > &	trj,
		const LineSegment_t &	seg
	)		const

inline

LineSegment & vector of Trajectories, don't keep track of points.

Definition at line 168 of file GeoAlgo.h.

169 { Point_t c1; Point_t c2; int trackIdx; return SqDist(seg, trj, c1, c2, trackIdx); }

double SqDist(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:87

ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >> Point_t

Definition: EnergyRecoOutput.h:8

c1

Definition: ValidateOpDetReco.py:586

double geoalgo::GeoAlgo::SqDist	(	const LineSegment_t &	seg,
		const std::vector< geoalgo::Trajectory_t > &	trj
	)		const

inline

LineSegment & vector of Trajectories, don't keep track of points.

Definition at line 171 of file GeoAlgo.h.

172 { Point_t c1; Point_t c2; int trackIdx; return SqDist(seg, trj, c1, c2, trackIdx); }

double SqDist(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:87

ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >> Point_t

Definition: EnergyRecoOutput.h:8

c1

Definition: ValidateOpDetReco.py:586

double geoalgo::GeoAlgo::SqDist	(	const HalfLine_t &	hline,
		const Trajectory_t &	trj,
		Point_t &	c1,
		Point_t &	c2
	)		const

HalfLine & Trajectory, keep track of points.

Definition at line 702 of file GeoAlgo.cxx.

   {
 
     // Make sure trajectory object is properly defined
     if (!trj.size())
       throw GeoAlgoException("Trajectory object not properly set...");
 
     // Check dimensionality compatibility between point and trajectory
     trj.compat(hline.Start());
 
     // keep track of c1 & c2
     Point_t c1min;
     Point_t c2min;
     // Now keep track of smallest distance and loop over traj segments
     double distMin = kMAX_DOUBLE;
 
     for (size_t l=0; l < trj.size()-1; l++){
       LineSegment_t segTmp(trj[l], trj[l+1]);
       double distTmp = _SqDist_(hline, segTmp, c1min, c2min);
       if ( distTmp < distMin ){
         c1 = c1min;
         c2 = c2min;
         distMin = distTmp;
       }
     }//for all segments in the track
 
     return distMin;
   }

double geoalgo::GeoAlgo::SqDist	(	const Trajectory_t &	trj,
		const HalfLine_t &	hline,
		Point_t &	c1,
		Point_t &	c2
	)		const

inline

HalfLine & Trajectory, keep track of points.

Definition at line 181 of file GeoAlgo.h.

182 { return SqDist(hline, trj, c2, c1); }

double SqDist(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:87

plot_impactresponse.hline

c1

Definition: ValidateOpDetReco.py:586

hline

Definition: plot_impactresponse.py:86

double geoalgo::GeoAlgo::SqDist	(	const Trajectory_t &	trj,
		const HalfLine_t &	hline
	)		const

inline

HalfLine & Trajectory, don't keep track of points.

Definition at line 184 of file GeoAlgo.h.

185 { Point_t c1; Point_t c2; return SqDist(hline, trj, c1, c2); }

double SqDist(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:87

ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >> Point_t

Definition: EnergyRecoOutput.h:8

plot_impactresponse.hline

c1

Definition: ValidateOpDetReco.py:586

hline

Definition: plot_impactresponse.py:86

double geoalgo::GeoAlgo::SqDist	(	const HalfLine_t &	hline,
		const Trajectory_t &	trj
	)		const

inline

HalfLine & Trajectory, don't keep track of points.

Definition at line 187 of file GeoAlgo.h.

188 { Point_t c1; Point_t c2; return SqDist(hline, trj, c1, c2); }

double SqDist(const Line_t &line, const Point_t &pt) const

Definition: GeoAlgo.h:87

ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >> Point_t

Definition: EnergyRecoOutput.h:8

plot_impactresponse.hline

c1

Definition: ValidateOpDetReco.py:586

hline

Definition: plot_impactresponse.py:86

double geoalgo::GeoAlgo::SqDist	(	const Point_t &	pt,
		const Trajectory_t &	trj
	)		const

Point_t & Trajectory_t distance.

Definition at line 523 of file GeoAlgo.cxx.

   {
 
     // Make sure trajectory object is properly defined
     if (!trj.size())
       throw GeoAlgoException("Trajectory object not properly set...");
 
     // Check dimensionality compatibility between point and trajectory
     trj.compat(pt);
 
     // Now keep track of smallest distance and loop over traj segments
     double distMin = kINVALID_DOUBLE;
     for (size_t l=0; l < trj.size()-1; l++){
       double distTmp = _SqDist_(pt,trj[l],trj[l+1]);
       if (distTmp < distMin) { distMin = distTmp; }
     }
 
     return distMin;
   }

double geoalgo::GeoAlgo::SqDist	(	const Trajectory_t &	trj,
		const Point_t &	pt
	)		const

inline

Point_t & Trajectory_t distance.

Definition at line 197 of file GeoAlgo.h.

198 { return SqDist(pt,trj); }