#include <PmaSegment3D.h>

Inheritance diagram for pma::Segment3D:

Public Member Functions
	Segment3D (void)

	Segment3D (pma::Track3D trk, pma::Node3D vstart, pma::Node3D *vstop)

Vector3D	Start (void) const

Vector3D	End (void) const

double	GetDistance2To (const TVector3 &p3d) const override
	Distance [cm] from the 3D segment to the point 3D. More...

double	GetDistance2To (const TVector2 &p2d, unsigned int view) const override
	Distance [cm] from the 2D point to the object's 2D projection in one of wire views. More...

pma::Vector3D	GetDirection3D (void) const override
	Get 3D direction cosines of this segment. More...

TVector3	GetProjection (const TVector2 &p, unsigned int view) const
	Get 3D projection of a 2D point from the view. More...

TVector3	GetUnconstrainedProj3D (const TVector2 &p2d, unsigned int view) const override

void	SetProjection (pma::Hit3D &h) const override
	Set hit 3D position and its 2D projection to the vertex. More...

double	Length2 (void) const override

pma::Track3D *	Parent (void) const

Public Member Functions inherited from pma::Element3D
int	TPC (void) const
	TPC index or -1 if out of any TPC. More...

int	Cryo (void) const
	Cryostat index or -1 if out of any cryostat. More...

double	Length (void) const

const std::vector< pma::Hit3D * > &	Hits (void) const

bool	HasHit (const pma::Hit3D *h) const

pma::Hit3D &	Hit (size_t index)

void	RemoveHitAt (size_t index)

void	AddHit (pma::Hit3D *h)

size_t	NHits (void) const

size_t	NEnabledHits (unsigned int view=geo::kUnknown) const

size_t	NPrecalcEnabledHits (void) const

TVector3 const &	ReferencePoint (size_t index) const

size_t	NPoints (void) const

void	AddPoint (TVector3 *p)

virtual void	ClearAssigned (pma::Track3D *trk=0)

void	UpdateHitParams (void)

void	UpdateProjection (void)

void	SortHits (void)

double	SumDist2 (void) const

double	SumDist2 (unsigned int view) const

double	SumHitsQ (unsigned int view) const

unsigned int	NHits (unsigned int view) const

unsigned int	NThisHits (unsigned int view) const

double	HitsRadius3D (unsigned int view) const

bool	IsFrozen (void) const
	Check if the vertex 3D position is fixed. More...

void	SetFrozen (bool state)
	Fix / relese vertex 3D position. More...

bool	SelectRndHits (size_t nmax_per_view)

bool	SelectAllHits (void)

Public Member Functions inherited from pma::SortedObjectBase
	SortedObjectBase (void)

	SortedObjectBase (pma::SortedObjectBase prevElement, pma::SortedObjectBase nextElement)

	SortedObjectBase (const pma::SortedObjectBase &src)
	Note: copy constructor does not preserve connections. More...

virtual	~SortedObjectBase (void)

virtual void	Disconnect (void)

virtual bool	AddNext (pma::SortedObjectBase *nextElement)

virtual int	RemoveNext (pma::SortedObjectBase *nextElement)

virtual bool	IsFirst (void) const

virtual bool	IsLast (void) const

virtual pma::SortedObjectBase *	Prev (void) const

virtual pma::SortedObjectBase *	Next (unsigned int index=0) const

virtual unsigned int	NextCount (void) const

Private Member Functions
	Segment3D (const pma::Segment3D &src)

double	SumDist2Hits (void) const override

Static Private Member Functions
static double	GetDist2 (const TVector3 &psrc, const TVector3 &p0, const TVector3 &p1)

static double	GetDist2 (const TVector2 &psrc, const TVector2 &p0, const TVector2 &p1)

Private Attributes
pma::Track3D *	fParent

Additional Inherited Members
Static Public Member Functions inherited from pma::Element3D
static float	OptFactor (unsigned int view)

static void	SetOptFactor (unsigned int view, float value)

Protected Member Functions inherited from pma::Element3D
	Element3D (void)

Protected Attributes inherited from pma::Element3D
int	fTPC

int	fCryo

bool	fFrozen

std::vector< pma::Hit3D * >	fAssignedHits

std::vector< TVector3 * >	fAssignedPoints

size_t	fNThisHits [3]

size_t	fNThisHitsEnabledAll

size_t	fNHits [3]

double	fSumHitsQ [3]

double	fHitsRadius

Protected Attributes inherited from pma::SortedObjectBase
pma::SortedObjectBase *	next

pma::SortedObjectBase *	prev

Static Protected Attributes inherited from pma::Element3D
static float	fOptFactors [3] = { 0.2F, 0.8F, 1.0F }

Detailed Description

Definition at line 28 of file PmaSegment3D.h.

Constructor & Destructor Documentation

pma::Segment3D::Segment3D ( void )

inline

Definition at line 31 of file PmaSegment3D.h.

31 : fParent(0) {}

pma::Segment3D::fParent

pma::Track3D * fParent

Definition: PmaSegment3D.h:75

pma::Segment3D::Segment3D	(	pma::Track3D *	trk,
		pma::Node3D *	vstart,
		pma::Node3D *	vstop
	)

Definition at line 20 of file PmaSegment3D.cxx.

                                                                             :
         SortedObjectBase(vstart, vstop),
         fParent(trk)
 {
         if (vstart->TPC() == vstop->TPC()) fTPC = vstart->TPC();
         if (vstart->Cryo() == vstop->Cryo()) fCryo = vstart->Cryo();
 }

pma::Segment3D::Segment3D ( const pma::Segment3D & src )

private

Member Function Documentation

Vector3D pma::Segment3D::End ( void ) const

inline

Definition at line 39 of file PmaSegment3D.h.

     {
         auto const & p = static_cast< Node3D* >(Next())->Point3D();
         return Vector3D(p.X(), p.Y(), p.Z());
     }

pma::Vector3D pma::Segment3D::GetDirection3D ( void ) const

overridevirtual

Get 3D direction cosines of this segment.

Implements pma::Element3D.

Definition at line 61 of file PmaSegment3D.cxx.

 {
         pma::Node3D* v0 = static_cast< pma::Node3D* >(prev);
         pma::Node3D* v1 = static_cast< pma::Node3D* >(next);
         pma::Vector3D dir(
             v1->Point3D().X() - v0->Point3D().X(),
             v1->Point3D().Y() - v0->Point3D().Y(),
             v1->Point3D().Z() - v0->Point3D().Z());
         return dir.Unit();
 }

double pma::Segment3D::GetDist2	(	const TVector3 &	psrc,
		const TVector3 &	p0,
		const TVector3 &	p1
	)

staticprivate

Definition at line 221 of file PmaSegment3D.cxx.

 {
         pma::Vector3D v0(psrc.X() - p0.X(), psrc.Y() - p0.Y(), psrc.Z() - p0.Z());
         pma::Vector3D v1(p1.X() - p0.X(), p1.Y() - p0.Y(), p1.Z() - p0.Z());
         pma::Vector3D v2(psrc.X() - p1.X(), psrc.Y() - p1.Y(), psrc.Z() - p1.Z());
 
         double v1Norm2 = v1.Mag2();
         if (v1Norm2 >= 1.0E-6) // >= 0.01mm
     {
             double v0v1 = v0.Dot(v1);
             double v2v1 = v2.Dot(v1);
             double v0Norm2 = v0.Mag2();
             double v2Norm2 = v2.Mag2();
 
             double result = 0.0;
             if ((v0v1 > 0.0) && (v2v1 < 0.0))
             {
                     double cosine01_square = 0.0;
                     double mag01_square = v0Norm2 * v1Norm2;
                     if (mag01_square != 0.0) cosine01_square = v0v1 * v0v1 / mag01_square;
 
                     result = (1.0 - cosine01_square) * v0Norm2;
             }
             else // increase distance to prefer hit assigned to the vertex, not segment
             {
                     if (v0v1 <= 0.0) result = 1.0001 * v0Norm2;
                     else result = 1.0001 * v2Norm2;
             }
 
             if (result >= 0.0) return result;
             else return 0.0;
         }
         else // short segment or its projection
         {
                 double dx = 0.5 * (p0.X() + p1.X()) - psrc.X();
                 double dy = 0.5 * (p0.Y() + p1.Y()) - psrc.Y();
                 double dz = 0.5 * (p0.Z() + p1.Z()) - psrc.Z();
                 return dx * dx + dy * dy + dz * dz;
         }
 }

double pma::Segment3D::GetDist2	(	const TVector2 &	psrc,
		const TVector2 &	p0,
		const TVector2 &	p1
	)

staticprivate

Definition at line 262 of file PmaSegment3D.cxx.

 {
         pma::Vector2D v0(psrc.X() - p0.X(), psrc.Y() - p0.Y());
         pma::Vector2D v1(p1.X() - p0.X(), p1.Y() - p0.Y());
         pma::Vector2D v2(psrc.X() - p1.X(), psrc.Y() - p1.Y());
 
         double v1Norm2 = v1.Mag2();
         if (v1Norm2 >= 1.0E-6) // >= 0.01mm
         {
             double v0v1 = v0.Dot(v1);
             double v2v1 = v2.Dot(v1);
             double v0Norm2 = v0.Mag2();
             double v2Norm2 = v2.Mag2();
 
             double result = 0.0;
             if ((v0v1 > 0.0) && (v2v1 < 0.0))
             {
                     double cosine01_square = 0.0;
                     double mag01_square = v0Norm2 * v1Norm2;
                     if (mag01_square != 0.0) cosine01_square = v0v1 * v0v1 / mag01_square;
 
                     result = (1.0 - cosine01_square) * v0Norm2;
             }
             else // increase distance to prefer hit assigned to the vertex, not segment
             {
                     if (v0v1 <= 0.0) result = 1.0001 * v0Norm2;
                     else result = 1.0001 * v2Norm2;
             }
             if (result >= 0.0) return result;
             else return 0.0;
         }
         else // short segment or its projection
         {
                 double dx = 0.5 * (p0.X() + p1.X()) - psrc.X();
                 double dy = 0.5 * (p0.Y() + p1.Y()) - psrc.Y();
                 return dx * dx + dy * dy;
         }
 }

double pma::Segment3D::GetDistance2To ( const TVector3 & p3d ) const

overridevirtual

Distance [cm] from the 3D segment to the point 3D.

Implements pma::Element3D.

Definition at line 28 of file PmaSegment3D.cxx.

 {
         pma::Node3D* v0 = static_cast< pma::Node3D* >(prev);
         pma::Node3D* v1 = static_cast< pma::Node3D* >(next);
         return GetDist2(p3d, v0->Point3D(), v1->Point3D());
 }

double pma::Segment3D::GetDistance2To	(	const TVector2 &	p2d,
		unsigned int	view
	)		const

overridevirtual

Distance [cm] from the 2D point to the object's 2D projection in one of wire views.

Implements pma::Element3D.

Definition at line 35 of file PmaSegment3D.cxx.

 {
         pma::Node3D* v0 = static_cast< pma::Node3D* >(prev);
         pma::Node3D* v1 = static_cast< pma::Node3D* >(next);
         return GetDist2(p2d, v0->Projection2D(view), v1->Projection2D(view));
 }

TVector3 pma::Segment3D::GetProjection	(	const TVector2 &	p,
		unsigned int	view
	)		const

Get 3D projection of a 2D point from the view.

Definition at line 72 of file PmaSegment3D.cxx.

 {
         pma::Node3D* vStart = static_cast< pma::Node3D* >(prev);
         pma::Node3D* vStop = static_cast< pma::Node3D* >(next);
 
         TVector2 v0(p);
         v0 -= vStart->Projection2D(view);
 
         TVector2 v1(vStop->Projection2D(view));
         v1 -= vStart->Projection2D(view);
 
         TVector3 v3d(vStop->Point3D());
         v3d -= vStart->Point3D();
 
         TVector3 v3dStart(vStart->Point3D());
         TVector3 v3dStop(vStop->Point3D());
 
         double v0Norm = v0.Mod();
         double v1Norm = v1.Mod();
 
         TVector3 result(0, 0, 0);
         if (v1Norm > 1.0E-6)// 0.01mm
         {
                 double mag = v0Norm * v1Norm;
                 double cosine = 0.0;
                 if (mag != 0.0) cosine = v0 * v1 / mag;
                 double b = v0Norm * cosine / v1Norm;
 
                 if (b < 1.0)
                 {
                         result = v3dStart;
                         if (b > 0.0) result += (v3d * b);
                 }
                 else result = v3dStop;
         }
         else // segment 2D projection is almost a point
         {
                 mf::LogWarning("pma::Segment3D") << "Short segment projection.";
 
                 result = v3dStart;
                 result += v3dStop;
                 result *= 0.5;
         }
         return result;
 }

TVector3 pma::Segment3D::GetUnconstrainedProj3D	(	const TVector2 &	p2d,
		unsigned int	view
	)		const

overridevirtual

Get 3D projection of a 2D point from the view, no limitations if it falls beyond the segment endpoints.

Implements pma::Element3D.

Definition at line 118 of file PmaSegment3D.cxx.

 {
         pma::Node3D* vStart = static_cast< pma::Node3D* >(prev);
         pma::Node3D* vStop = static_cast< pma::Node3D* >(next);
 
         TVector2 v0(p2d);
         v0 -= vStart->Projection2D(view);
 
         TVector2 v1(vStop->Projection2D(view));
         v1 -= vStart->Projection2D(view);
 
         TVector3 v3d(vStop->Point3D());
         v3d -= vStart->Point3D();
 
         double v0Norm = v0.Mod();
         double v1Norm = v1.Mod();
         if (v1Norm > 1.0E-6) // 0.01mm
         {
                 double mag = v0Norm * v1Norm;
                 double cosine = 0.0;
                 if (mag != 0.0) cosine = v0 * v1 / mag;
                 double b = v0Norm * cosine / v1Norm;
 
                 return vStart->Point3D() + (v3d * b);
         }
         else // segment 2D projection is almost a point
         {
                 v3d = vStart->Point3D();
                 v3d += vStop->Point3D();
                 v3d *= 0.5;
 
                 return v3d;
         }
 }

double pma::Segment3D::Length2 ( void ) const

overridevirtual

Squared sum of half-lengths of connected 3D segments (used in the vertex position optimization).

Implements pma::Element3D.

Definition at line 209 of file PmaSegment3D.cxx.

 {
         if (prev && next)
                 return pma::Dist2( ((pma::Node3D*)prev)->Point3D(), ((pma::Node3D*)next)->Point3D() );
         else
         {
                 mf::LogError("pma::Segment3D") << "Segment endpoints not set.";
                 return 0.0;
         }
 }

pma::Track3D* pma::Segment3D::Parent ( void ) const

inline

Definition at line 68 of file PmaSegment3D.h.

68 { return fParent; }

pma::Segment3D::fParent

pma::Track3D * fParent

Definition: PmaSegment3D.h:75

void pma::Segment3D::SetProjection ( pma::Hit3D & h ) const

overridevirtual

Set hit 3D position and its 2D projection to the vertex.

Implements pma::Element3D.

Definition at line 153 of file PmaSegment3D.cxx.

 {
         pma::Node3D* vStart = static_cast< pma::Node3D* >(prev);
         pma::Node3D* vStop = static_cast< pma::Node3D* >(next);
 
         auto const & pointStart = vStart->Point3D();
         auto const & pointStop = vStop->Point3D();
 
         auto const & projStart = vStart->Projection2D(h.View2D());
         auto const & projStop = vStop->Projection2D(h.View2D());
 
         pma::Vector2D v0(
                 h.Point2D().X() - projStart.X(),
                 h.Point2D().Y() - projStart.Y());
 
         pma::Vector2D v1(
                 projStop.X() - projStart.X(),
                 projStop.Y() - projStart.Y());
 
         pma::Vector3D v3d(
                 pointStop.X() - pointStart.X(),
                 pointStop.Y() - pointStart.Y(),
                 pointStop.Z() - pointStart.Z());
 
         double v0Norm = sqrt(v0.Mag2());
         double v1Norm = sqrt(v1.Mag2());
         if (v1Norm > 1.0E-6) // 0.01mm
         {
                 double mag = v0Norm * v1Norm;
                 double cosine = 0.0;
                 if (mag != 0.0) cosine = v0.Dot(v1) / mag;
                 double b = v0Norm * cosine / v1Norm;
 
                 pma::Vector2D p(projStart.X(), projStart.Y());
                 p += (v1 * b);
                 v3d *= b;
 
                 h.SetProjection(p.X(), p.Y(), (float)b);
                 h.SetPoint3D(
                         pointStart.X() + v3d.X(),
                         pointStart.Y() + v3d.Y(),
                         pointStart.Z() + v3d.Z());
         }
         else // segment 2D projection is almost a point
         {
                 h.SetProjection(
                         0.5 * (projStart.X() + projStop.X()),
                         0.5 * (projStart.Y() + projStop.Y()), 0.0F);
 
                 h.SetPoint3D(
                         0.5 * (pointStart.X() + pointStop.X()),
                         0.5 * (pointStart.Y() + pointStop.Y()),
                         0.5 * (pointStart.Z() + pointStop.Z()));
         }
 }

Vector3D pma::Segment3D::Start ( void ) const

inline

Definition at line 34 of file PmaSegment3D.h.

     {
         auto const & p = static_cast< Node3D* >(Prev())->Point3D();
         return Vector3D(p.X(), p.Y(), p.Z());
     }

double pma::Segment3D::SumDist2Hits ( void ) const

overrideprivatevirtual

Implements pma::Element3D.

Definition at line 42 of file PmaSegment3D.cxx.

 {
         pma::Node3D* v0 = static_cast< pma::Node3D* >(prev);
         pma::Node3D* v1 = static_cast< pma::Node3D* >(next);
 
         double sum = 0.0F;
         for (auto h : fAssignedHits)
         {
                 if (h->IsEnabled())
                 {
                         unsigned int view = h->View2D();
 
                         sum += OptFactor(view) * h->GetSigmaFactor() // alpha_i * (hit_amp / hit_max_amp)
                                 * GetDist2(h->Point2D(), v0->Projection2D(view), v1->Projection2D(view));
                 }
         }
         return sum;
 }

Member Data Documentation

pma::Track3D* pma::Segment3D::fParent

private

Definition at line 75 of file PmaSegment3D.h.

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

larreco/larreco/RecoAlg/PMAlg/PmaSegment3D.h
larreco/larreco/RecoAlg/PMAlg/PmaSegment3D.cxx

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation