pma::Node3D Class Reference

#include "PmaNode3D.h"

Inheritance diagram for pma::Node3D:

Public Member Functions
	Node3D (void)
	Node3D (const TVector3 &p3d, unsigned int tpc, unsigned int cryo, bool vtx=false, double xshift=0)
TVector3 const &	Point3D (void) const
bool	SetPoint3D (const TVector3 &p3d)
TVector2 const &	Projection2D (unsigned int view) const
double	GetDistToWall (void) const
bool	SameTPC (const TVector3 &p3d, float margin=0.0F) const
	Check if p3d is in the same TPC as the node. More...
bool	SameTPC (const pma::Vector3D &p3d, float margin=0.0F) const
bool	IsBranching (void) const
	Belongs to more than one track? More...
bool	IsTPCEdge (void) const
	Is the first/last in this TPC? More...
bool	IsVertex (void) const
	Check fIsVertex flag. More...
void	SetVertex (bool state)
void	SetVertexToBranching (bool setAllNodes)
std::vector< pma::Track3D * >	GetBranches (void) const
double	GetDistance2To (const TVector3 &p3d) const override
	Distance [cm] from the 3D point 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 the next segment, or pevious segment if this is the last node. More...
TVector3	GetUnconstrainedProj3D (const TVector2 &p2d, unsigned int view) const override
	In case of a node it is simply 3D position of the node. More...
void	SetProjection (pma::Hit3D &h) const override
	Set hit 3D position and its 2D projection to the vertex. More...
double	Length2 (void) const override
double	SegmentCos (void) const
	Cosine of 3D angle between connected segments. More...
double	SegmentCosWirePlane (void) const
double	SegmentCosTransverse (void) const
double	GetObjFunction (float penaltyValue, float endSegWeight) const
	Objective function minimized during oprimization. More...
void	Optimize (float penaltyValue, float endSegWeight)
void	ClearAssigned (pma::Track3D *trk=0) override
void	ApplyDriftShift (double dx)
double	GetDriftShift (void) const
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
unsigned int	NHits (unsigned int view) 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)
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	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)
virtual void	Disconnect (void)
virtual bool	AddNext (pma::SortedObjectBase *nextElement)
virtual int	RemoveNext (pma::SortedObjectBase *nextElement)
virtual pma::SortedObjectBase *	Next (unsigned int index=0) const
virtual unsigned int	NextCount (void) const
virtual bool	IsLast (void) const
virtual bool	IsFirst (void) const
virtual pma::SortedObjectBase *	Prev (void) const

Static Public Member Functions
static void	SetMargin (double m)
	Set allowed node position margin around TPC. More...
static float	OptFactor (unsigned int view)
static void	SetOptFactor (unsigned int view, float value)

Protected Attributes
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
std::vector< pma::SortedObjectBase * >	next_vector
pma::SortedObjectBase *	next
pma::SortedObjectBase *	prev

Static Protected Attributes
static float	fOptFactors [3] = { 0.2F, 0.8F, 1.0F }

Private Member Functions
bool	LimitPoint3D (void)
	Returns true if node position was trimmed to its TPC volume + fMargin. More...
void	UpdateProj2D (void)
double	EndPtCos2Transverse (void) const
double	PiInWirePlane (void) const
double	PenaltyInWirePlane (void) const
double	Pi (float endSegWeight, bool doAsymm) const
double	Penalty (float endSegWeight) const
double	Mse (void) const
double	MakeGradient (float penaltyValue, float endSegWeight)
double	StepWithGradient (float alfa, float tol, float penalty, float weight)
double	SumDist2Hits (void) const override

Private Attributes
geo::TPCGeo const &	fTpcGeo
double	fMinX
double	fMaxX
double	fMinY
double	fMaxY
double	fMinZ
double	fMaxZ
TVector3	fPoint3D
TVector2	fProj2D [3]
double	fDriftOffset
TVector3	fGradient
bool	fIsVertex

Static Private Attributes
static bool	fGradFixed [3] = { false, false, false }
static double	fMargin = 3.0

Detailed Description

Definition at line 27 of file PmaNode3D.h.

Constructor & Destructor Documentation

pma::Node3D::Node3D

(

void

)

Definition at line 25 of file PmaNode3D.cxx.

References pma::Element3D::fCryo, fProj2D, and pma::Element3D::fTPC.

                      :
    fTpcGeo(art::ServiceHandle<geo::Geometry>()->TPC(0, 0)),
        fMinX(0), fMaxX(0),
        fMinY(0), fMaxY(0),
        fMinZ(0), fMaxZ(0),
        fPoint3D(0, 0, 0),
        fDriftOffset(0),
        fIsVertex(false)
{
        fTPC = 0; fCryo = 0;

        fProj2D[0].Set(0);
        fProj2D[1].Set(0);
        fProj2D[2].Set(0);
}

pma::Node3D::Node3D	(	const TVector3 &	p3d,
		unsigned int	tpc,
		unsigned int	cryo,
		bool	vtx = false,
		double	xshift = 0
	)

Definition at line 41 of file PmaNode3D.cxx.

References pma::Element3D::fCryo, fMaxX, fMaxY, fMaxZ, fMinX, fMinY, fMinZ, pma::Element3D::fTPC, fTpcGeo, geo::TPCGeo::HasPlane(), geo::kZ, geo::BoxBoundedGeo::MaxX(), geo::BoxBoundedGeo::MaxY(), geo::BoxBoundedGeo::MaxZ(), geo::BoxBoundedGeo::MinX(), geo::BoxBoundedGeo::MinY(), geo::BoxBoundedGeo::MinZ(), SetPoint3D(), and tmp.

                                                                                                   :
    fTpcGeo( art::ServiceHandle<geo::Geometry>()->TPC(tpc, cryo) ),
    fDriftOffset(xshift),
        fIsVertex(vtx)
{
        fTPC = tpc; fCryo = cryo;

        unsigned int lastPlane = geo::kZ;
        while ((lastPlane > 0) && !fTpcGeo.HasPlane(lastPlane)) lastPlane--;

//      auto const *detprop = lar::providerFrom<detinfo::DetectorPropertiesService>();
//      fMinX = detprop->ConvertTicksToX(0, lastPlane, tpc, cryo);
//      fMaxX = detprop->ConvertTicksToX(detprop->NumberTimeSamples() - 1, lastPlane, tpc, cryo);
    fMinX = fTpcGeo.MinX();
    fMaxX = fTpcGeo.MaxX();
        if (fMaxX < fMinX) { double tmp = fMaxX; fMaxX = fMinX; fMinX = tmp; }

        fMinY = fTpcGeo.MinY(); fMaxY = fTpcGeo.MaxY();
        fMinZ = fTpcGeo.MinZ(); fMaxZ = fTpcGeo.MaxZ();

        SetPoint3D(p3d);
}

Member Function Documentation

void pma::Element3D::AddHit ( pma::Hit3D *  h )

inlineinherited

Definition at line 65 of file PmaElement3D.h.

References pma::Element3D::fAssignedHits, and pma::Element3D::SetProjection().

Referenced by pma::Track3D::MakeProjection().

        {
                fAssignedHits.push_back(h);
                SetProjection(*h);
        }

bool pma::SortedBranchBase::AddNext ( pma::SortedObjectBase *  nextElement )

virtualinherited

Reimplemented from pma::SortedObjectBase.

Definition at line 71 of file SortedObjects.cxx.

References pma::SortedObjectBase::next, art::productstatus::present(), pma::SortedObjectBase::prev, and pma::SortedObjectBase::RemoveNext().

Referenced by pma::Track3D::AttachBackToSameTPC(), and pma::Track3D::AttachToSameTPC().

{
        if (!nextElement)
        {
                mf::LogError("pma::SortedBranchBase") << "Next == 0.";
                return false;
        }

        if (nextElement == this)
        {
                mf::LogWarning("pma::SortedBranchBase") << "Next == This.";
                return false;
        }

        bool present = false;
        for (size_t i = 0; i < next_vector.size(); i++)
        {
                if (next_vector[i] == nextElement)
                {
                        mf::LogWarning("pma::SortedBranchBase") << "Contained.";
                        present = true; break;
                }
        }
        if (!present)
        {
                if (nextElement->prev) // && (nextElement->prev != this)
                        nextElement->prev->RemoveNext(nextElement);

                next = nextElement;
                next->prev = this;
                next_vector.push_back(next);
                return true;
        }
        else return false;
}

void pma::Element3D::AddPoint ( TVector3 *  p )

inlineinherited

Definition at line 77 of file PmaElement3D.h.

References pma::Element3D::ClearAssigned(), pma::Element3D::fAssignedPoints, and pma::Element3D::UpdateHitParams().

Referenced by pma::Track3D::MakeProjection().

{ fAssignedPoints.push_back(p); }

void pma::Node3D::ApplyDriftShift ( double  dx )

inline

Definition at line 101 of file PmaNode3D.h.

References fDriftOffset, and fPoint3D.

Referenced by pma::Track3D::ApplyDriftShiftInTree().

{ fPoint3D[0] += dx; fDriftOffset += dx; }

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

overridevirtual

Clear hits/points vectors of this element, optionally only those which are owned by given track.

Reimplemented from pma::Element3D.

Definition at line 766 of file PmaNode3D.cxx.

References pma::Element3D::fAssignedHits, pma::Element3D::fAssignedPoints, pma::Element3D::fHitsRadius, pma::SortedBranchBase::Next(), pma::SortedBranchBase::NextCount(), pma::Segment3D::Parent(), and pma::SortedObjectBase::Prev().

Referenced by GetUnconstrainedProj3D(), and pma::Track3D::Split().

{
        if (!trk)
        {
                // like in the base class:
                fAssignedPoints.clear();
                fAssignedHits.clear();
        }
        else
        {
                std::vector< pma::Track3D* > to_check;
                pma::Segment3D* seg;
                if (Prev())
                {
                        seg = static_cast< pma::Segment3D* >(Prev());
                        if (seg->Parent() != trk) to_check.push_back(seg->Parent());
                }
                for (unsigned int i = 0; i < NextCount(); i++)
                {
                        seg = static_cast< pma::Segment3D* >(Next(i));
                        if (seg->Parent() != trk) to_check.push_back(seg->Parent());
                }
                        
                unsigned int p = 0;
                while (p < fAssignedPoints.size())
                {
                        bool found = false;
                        for (size_t t = 0; t < to_check.size(); t++)
                                if (to_check[t]->HasRefPoint(fAssignedPoints[p]))
                                {
                                        found = true; break;
                                }

                        if (!found) fAssignedPoints.erase(fAssignedPoints.begin() + p);
                        else p++;
                }

                unsigned int h = 0;
                while (h < fAssignedHits.size())
                {
                        bool found = false;
                        pma::Hit3D* hit = fAssignedHits[h];

                        for (size_t t = 0; (t < to_check.size()) && !found; t++)
                                for (size_t i = 0; i < to_check[t]->size(); i++)
                                {
                                        pma::Hit3D* pmaHit = static_cast< pma::Hit3D* >((*(to_check[t]))[i]);
                                        if (hit == pmaHit)
                                        {
                                                found = true; break;
                                        }
                                }

                        if (!found) fAssignedHits.erase(fAssignedHits.begin() + h);
                        else h++;
                }
        }

        fHitsRadius = 0.0F;
}

int pma::Element3D::Cryo ( void  ) const

inlineinherited

Cryostat index or -1 if out of any cryostat.

Definition at line 33 of file PmaElement3D.h.

References pma::Element3D::fCryo, pma::Element3D::GetDirection3D(), pma::Element3D::GetDistance2To(), pma::Element3D::GetUnconstrainedProj3D(), pma::Element3D::Length2(), and pma::Element3D::SetProjection().

Referenced by pma::ProjectionMatchingAlg::mergeTracks(), pma::Segment3D::Segment3D(), and pma::Track3D::Split().

{ return fCryo; }

void pma::SortedBranchBase::Disconnect ( void  )

virtualinherited

Reimplemented from pma::SortedObjectBase.

Definition at line 65 of file SortedObjects.cxx.

References pma::SortedObjectBase::prev, and pma::SortedObjectBase::RemoveNext().

{
        while (next_vector.size()) RemoveNext(next_vector.front());
        if (prev) prev->RemoveNext(this);
}

double pma::Node3D::EndPtCos2Transverse ( void  ) const

private

Definition at line 321 of file PmaNode3D.cxx.

References fPoint3D, pma::SortedObjectBase::Next(), pma::SortedObjectBase::next, pma::SortedObjectBase::Prev(), and pma::SortedObjectBase::prev.

Referenced by PenaltyInWirePlane(), and SetMargin().

{
        if (prev && next)
        {
                auto const & vStart = static_cast< pma::Node3D* >(prev->Prev())->fPoint3D;
                auto const & vStop = static_cast< pma::Node3D* >(next->Next())->fPoint3D;

                double dy = vStop.X() - vStart.X();
                double dz = vStop.Z() - vStart.Z();
                double len2 = dy * dy + dz * dz;
                double cosine2 = 0.0;
                if (len2 > 0.0) cosine2 = dz * dz / len2;
                return cosine2;
        }
        else return 0.0;
}

std::vector< pma::Track3D * > pma::Node3D::GetBranches

(

void

)

const

Definition at line 406 of file PmaNode3D.cxx.

References pma::SortedBranchBase::Next(), pma::SortedBranchBase::NextCount(), and pma::Segment3D::Parent().

Referenced by pma::VtxCandidate::JoinTracks(), and SetVertexToBranching().

{
        std::vector< pma::Track3D* > branches;
        if (NextCount())
        {
                branches.reserve(NextCount());
                for (size_t i = 0; i < NextCount(); ++i)
                {
                        pma::Segment3D* seg = static_cast< pma::Segment3D* >(Next(i));
                        branches.push_back(seg->Parent());
                }
        }
        return branches;
}

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

overridevirtual

Get 3D direction cosines of the next segment, or pevious segment if this is the last node.

Implements pma::Element3D.

Definition at line 160 of file PmaNode3D.cxx.

References pma::Element3D::GetDirection3D(), pma::SortedObjectBase::next, and pma::SortedObjectBase::prev.

Referenced by SetVertexToBranching().

{
    pma::Element3D* seg = 0;
    if (next) { seg = dynamic_cast< pma::Element3D* >(next); }
    else if (prev) { seg = dynamic_cast< pma::Element3D* >(prev); }
    else { throw cet::exception("Node3D") << "Isolated vertex." << std::endl; }

    if (seg) { return seg->GetDirection3D(); }
    else { throw cet::exception("Node3D") << "Corrupted vertex." << std::endl; }
}

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

overridevirtual

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

Implements pma::Element3D.

Definition at line 133 of file PmaNode3D.cxx.

References pma::Dist2(), and fPoint3D.

Referenced by pma::Track3D::MakeFastProjection(), and SetVertexToBranching().

{
        return pma::Dist2(fPoint3D, p3d);
}

double pma::Node3D::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 138 of file PmaNode3D.cxx.

References pma::Dist2(), and fProj2D.

{
        return pma::Dist2(fProj2D[view], p2d);
}

double pma::Node3D::GetDistToWall

(

void

)

const

Definition at line 64 of file PmaNode3D.cxx.

References d, fMaxX, fMaxY, fMaxZ, fMinX, fMinY, fMinZ, and fPoint3D.

Referenced by Projection2D(), and pma::PMAlgTracker::validate().

{
        double d, dmin = fPoint3D.X() - fMinX;
        d = fMaxX - fPoint3D.X();
        if (d < dmin) dmin = d;

        d = fPoint3D.Y() - fMinY;
        if (d < dmin) dmin = d;
        d = fMaxY - fPoint3D.Y();
        if (d < dmin) dmin = d;

        d = fPoint3D.Z() - fMinZ;
        if (d < dmin) dmin = d;
        d = fMaxZ - fPoint3D.Z();
        if (d < dmin) dmin = d;

        return dmin;
}

double pma::Node3D::GetDriftShift ( void  ) const

inline

Definition at line 102 of file PmaNode3D.h.

References fDriftOffset.

Referenced by pma::Track3D::Split().

{ return fDriftOffset; }

double pma::Node3D::GetObjFunction	(	float	penaltyValue,
		float	endSegWeight
	)		const

Objective function minimized during oprimization.

Definition at line 522 of file PmaNode3D.cxx.

References Mse(), Penalty(), and PenaltyInWirePlane().

Referenced by GetUnconstrainedProj3D(), MakeGradient(), and StepWithGradient().

{
        return Mse() + penaltyValue * (Penalty(endSegWeight) + PenaltyInWirePlane());
}

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

inlineoverridevirtual

In case of a node it is simply 3D position of the node.

Implements pma::Element3D.

Definition at line 73 of file PmaNode3D.h.

References ClearAssigned(), fPoint3D, GetObjFunction(), Length2(), Optimize(), SegmentCos(), SegmentCosTransverse(), SegmentCosWirePlane(), and SetProjection().

{ return fPoint3D; }

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

inlineinherited

Definition at line 53 of file PmaElement3D.h.

References pma::Element3D::fAssignedHits.

    {
        for (const auto a : fAssignedHits) { if (h == a) return true; }
        return false;
    } 

pma::Hit3D& pma::Element3D::Hit ( size_t  index )

inlineinherited

Definition at line 59 of file PmaElement3D.h.

References pma::Element3D::fAssignedHits.

Referenced by pma::Track3D::AddNode(), pma::Track3D::DisableSingleViewEnds(), and pma::Track3D::SortHits().

{ return *(fAssignedHits[index]); }

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

inlineinherited

Definition at line 51 of file PmaElement3D.h.

References pma::Element3D::fAssignedHits.

{ return fAssignedHits; }

double pma::Element3D::HitsRadius3D ( unsigned int  view ) const

inherited

Definition at line 224 of file PmaElement3D.cxx.

References pma::Dist2(), pma::Element3D::fAssignedHits, and pma::Element3D::fTPC.

Referenced by pma::Element3D::NThisHits().

{
        if (fTPC < 0)
        {
                if (!fAssignedHits.empty()) mf::LogWarning("pma::Element3D") << "Hits assigned to TPC-crossing element.";
                return 0.0F;
        }

        TVector3 mean3D(0, 0, 0);
        size_t nHits = 0;
        for (auto h : fAssignedHits)
                if (h->View2D() == view)
                        { mean3D += h->Point3D(); nHits++; }
        if (!nHits) return 0.0;
        mean3D *= (1.0 / nHits);

        double r2, maxR2 = 0.0;
        for (auto h : fAssignedHits)
                if (h->View2D() == view)
                {
                        r2 = pma::Dist2(h->Point3D(), mean3D);
                        if (r2 > maxR2) maxR2 = r2;
                }
        return sqrt(maxR2);
}

bool pma::Node3D::IsBranching

(

void

)

const

Belongs to more than one track?

Definition at line 379 of file PmaNode3D.cxx.

References pma::SortedBranchBase::Next(), pma::SortedBranchBase::NextCount(), pma::Segment3D::Parent(), and pma::SortedObjectBase::prev.

Referenced by pma::PMAlgVertexing::getKinks(), pma::PMAlgVertexing::getVertices(), Projection2D(), and SetVertexToBranching().

{
        size_t nnext = NextCount();
        if (nnext > 1) return true; // 1 trk -> vtx -> n*trk

        if (prev && nnext)
        {
                pma::Segment3D* segPrev = static_cast< pma::Segment3D* >(prev);
                pma::Segment3D* segNext = static_cast< pma::Segment3D* >(Next(0));
                if (segNext->Parent() != segPrev->Parent()) // 1 trk -> vtx -> 1 trk
                        return true;
        }
        return false;
}

virtual bool pma::SortedObjectBase::IsFirst ( void  ) const

inlinevirtualinherited

Definition at line 41 of file SortedObjects.h.

References pma::SortedObjectBase::prev.

{ return !prev; }

bool pma::Element3D::IsFrozen ( void  ) const

inlineinherited

Check if the vertex 3D position is fixed.

Definition at line 96 of file PmaElement3D.h.

References pma::Element3D::fFrozen.

Referenced by pma::Track3D::AddNode(), and pma::ProjectionMatchingAlg::mergeTracks().

{ return fFrozen; }

virtual bool pma::SortedBranchBase::IsLast ( void  ) const

inlinevirtualinherited

Reimplemented from pma::SortedObjectBase.

Definition at line 85 of file SortedObjects.h.

{ return !(next_vector.size()); }

bool pma::Node3D::IsTPCEdge

(

void

)

const

Is the first/last in this TPC?

Definition at line 394 of file PmaNode3D.cxx.

References pma::SortedBranchBase::Next(), pma::SortedBranchBase::NextCount(), pma::SortedObjectBase::prev, and pma::Element3D::TPC().

Referenced by Projection2D().

{
        if (prev && (NextCount() == 1))
        {
                pma::Segment3D* segPrev = static_cast< pma::Segment3D* >(prev);
                pma::Segment3D* segNext = static_cast< pma::Segment3D* >(Next(0));

                if ((segPrev->TPC() < 0) || (segNext->TPC() < 0)) return true;
        }
        return false;
}

bool pma::Node3D::IsVertex ( void  ) const

inline

Check fIsVertex flag.

Definition at line 54 of file PmaNode3D.h.

References fIsVertex.

Referenced by pma::PMAlgVertexing::getKinks().

{ return fIsVertex; }

double pma::Element3D::Length ( void  ) const

inlineinherited

Definition at line 49 of file PmaElement3D.h.

References pma::Element3D::Length2().

Referenced by pma::VtxCandidate::Add(), pma::Track3D::AddNode(), pma::VtxCandidate::Compute(), pma::ProjectionMatchingAlg::guideEndpoints(), Pi(), and pma::Track3D::ShiftEndsToHits().

{ return sqrt(Length2()); }

double pma::Node3D::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 250 of file PmaNode3D.cxx.

References pma::SortedObjectBase::next, and pma::SortedObjectBase::prev.

Referenced by GetUnconstrainedProj3D(), Pi(), and PiInWirePlane().

{
        double l = 0.0;
        if (next) l += (static_cast< pma::Segment3D* >(next))->Length();
        if (prev) l += (static_cast< pma::Segment3D* >(prev))->Length();

        if (next && prev) return 0.25 * l * l;
        else return l * l;
}

bool pma::Node3D::LimitPoint3D ( void  )

private

Returns true if node position was trimmed to its TPC volume + fMargin.

Definition at line 99 of file PmaNode3D.cxx.

References fMargin, fMaxX, fMaxY, fMaxZ, fMinX, fMinY, fMinZ, and fPoint3D.

Referenced by SetMargin(), and SetPoint3D().

{
        bool trimmed = false;

        if (fPoint3D.X() < fMinX - fMargin) { fPoint3D.SetX(fMinX - fMargin); trimmed = true; }
        if (fPoint3D.X() > fMaxX + fMargin) { fPoint3D.SetX(fMaxX + fMargin); trimmed = true; }

        if (fPoint3D.Y() < fMinY - fMargin) { fPoint3D.SetY(fMinY - fMargin); trimmed = true; }
        if (fPoint3D.Y() > fMaxY + fMargin) { fPoint3D.SetY(fMaxY + fMargin); trimmed = true; }

        if (fPoint3D.Z() < fMinZ - fMargin) { fPoint3D.SetZ(fMinZ - fMargin); trimmed = true; }
        if (fPoint3D.Z() > fMaxZ + fMargin) { fPoint3D.SetZ(fMaxZ + fMargin); trimmed = true; }

        return trimmed;
}

double pma::Node3D::MakeGradient ( float  penaltyValue, float  endSegWeight  )

private

Definition at line 527 of file PmaNode3D.cxx.

References E, fGradFixed, fGradient, fPoint3D, GetObjFunction(), pma::Segment3D::Length2(), pma::SortedObjectBase::next, pma::SortedObjectBase::prev, SetPoint3D(), and tmp.

Referenced by SetMargin(), and StepWithGradient().

{       
        double l1 = 0.0, l2 = 0.0, minLength2 = 0.0;
        TVector3 tmp(fPoint3D), gpoint(fPoint3D);

        pma::Segment3D* seg;
        if (prev)
        {
                seg = static_cast< pma::Segment3D* >(prev);
                l1 = seg->Length2();
        }
        if (next)
        {
                seg = static_cast< pma::Segment3D* >(next);
                l2 = seg->Length2();
        }
        if ((l1 > 0.01) && (l1 < l2)) minLength2 = l1;
        else if ((l2 > 0.01) && (l2 < l1)) minLength2 = l2;
        else minLength2 = 0.01;

        double dxi = 0.001 * sqrt(minLength2);

        if (dxi < 6.0E-37) return 0.0;

        double gi, g0, gz;
        gz = g0 = GetObjFunction(penaltyValue, endSegWeight);

        //if (fQPenaltyFactor > 0.0F) gz += fQPenaltyFactor * QPenalty(); <----------------------- maybe later..

        if (!fGradFixed[0]) // gradX
        {
                gpoint[0] = tmp[0] + dxi;
                SetPoint3D(gpoint);
                gi = GetObjFunction(penaltyValue, endSegWeight);
                fGradient[0] = (g0 - gi) / dxi;

                gpoint[0] = tmp[0] - dxi;
                SetPoint3D(gpoint);
                gi = GetObjFunction(penaltyValue, endSegWeight);
                fGradient[0] = 0.5 * (fGradient[0] + (gi - g0) / dxi);

                gpoint[0] = tmp[0];
        }

        if (!fGradFixed[1]) // gradY
        {
                gpoint[1] = tmp[1] + dxi;
                SetPoint3D(gpoint);
                gi = GetObjFunction(penaltyValue, endSegWeight);
                fGradient[1] = (g0 - gi) / dxi;

                gpoint[1] = tmp[1] - dxi;
                SetPoint3D(gpoint);
                gi = GetObjFunction(penaltyValue, endSegWeight);
                fGradient[1] = 0.5 * (fGradient[1] + (gi - g0) / dxi);

                gpoint[1] = tmp[1];
        }

        if (!fGradFixed[2]) // gradZ
        {
                gpoint[2] = tmp[2] + dxi;
                SetPoint3D(gpoint);
                gi = GetObjFunction(penaltyValue, endSegWeight);
                //if (fQPenaltyFactor > 0.0F) gi += fQPenaltyFactor * QPenalty();
                fGradient[2] = (gz - gi) / dxi;

                gpoint[2] = tmp[2] - dxi;
                SetPoint3D(gpoint);
                gi = GetObjFunction(penaltyValue, endSegWeight);
                //if (fQPenaltyFactor > 0.0F) gi += fQPenaltyFactor * QPenalty();
                fGradient[2] = 0.5 * (fGradient[2] + (gi - gz) / dxi);

                gpoint[2] = tmp[2];
        }

        SetPoint3D(tmp);
        if (fGradient.Mag2() < 6.0E-37) return 0.0;

        return g0;
}

double pma::Node3D::Mse ( void  ) const

private

Definition at line 500 of file PmaNode3D.cxx.

References pma::SortedBranchBase::Next(), pma::SortedBranchBase::NextCount(), pma::Element3D::NPrecalcEnabledHits(), pma::SortedObjectBase::prev, and pma::Element3D::SumDist2().

Referenced by GetObjFunction(), and SetMargin().

{
        unsigned int nhits = NPrecalcEnabledHits(); //NEnabledHits();
        double mse = SumDist2();

        pma::Segment3D* seg;
        for (unsigned int i = 0; i < NextCount(); i++)
        {
                seg = static_cast< pma::Segment3D* >(Next(i));
                nhits += seg->NPrecalcEnabledHits(); //NEnabledHits();
                mse += seg->SumDist2();
        }
        if (prev)
        {
                seg = static_cast< pma::Segment3D* >(prev);
                nhits += seg->NPrecalcEnabledHits(); //NEnabledHits();
                mse += seg->SumDist2();
        }
        if (!nhits) return 0.0;
        else return mse / nhits;
}

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

inherited

Definition at line 35 of file PmaElement3D.cxx.

References pma::Element3D::fAssignedHits, geo::kUnknown, and n.

Referenced by pma::Track3D::AddNode(), and pma::Element3D::NHits().

{
        size_t n = 0;
        for (size_t i = 0; i < fAssignedHits.size(); i++)
                if (fAssignedHits[i]->IsEnabled() &&
                    ((view == geo::kUnknown) || (view == fAssignedHits[i]->View2D()))) n++;
        return n;
}

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

inlinevirtualinherited

Reimplemented from pma::SortedObjectBase.

Definition at line 79 of file SortedObjects.h.

Referenced by pma::Track3D::ApplyDriftShiftInTree(), pma::Track3D::AttachBackTo(), pma::Track3D::AttachBackToSameTPC(), pma::Track3D::AttachTo(), pma::Track3D::AttachToSameTPC(), ClearAssigned(), GetBranches(), pma::Track3D::GetNearestTrkInTree(), pma::Track3D::GetObjFnInTree(), pma::TrkCandidateColl::getTreeCopy(), IsBranching(), IsTPCEdge(), pma::VtxCandidate::JoinTracks(), pma::Track3D::MakeProjectionInTree(), pma::PMAlgVertexing::mergeBrokenTracks(), Mse(), pma::Track3D::NextSegment(), Penalty(), Pi(), PiInWirePlane(), pma::Track3D::ReassignHitsInTree(), pma::TrkCandidateColl::setParentDaughterConnections(), pma::TrkCandidateColl::setTreeId(), pma::Track3D::SortHitsInTree(), pma::Track3D::Split(), pma::Track3D::TuneSinglePass(), and pma::Track3D::UpdateParamsInTree().

        {
                if (next_vector.size()) return next_vector[index];
                else return 0;
        }

virtual unsigned int pma::SortedBranchBase::NextCount ( void  ) const

inlinevirtualinherited

Reimplemented from pma::SortedObjectBase.

Definition at line 84 of file SortedObjects.h.

Referenced by pma::Track3D::ApplyDriftShiftInTree(), pma::Track3D::AttachBackTo(), pma::Track3D::AttachBackToSameTPC(), pma::Track3D::AttachTo(), pma::Track3D::AttachToSameTPC(), pma::Track3D::CleanupTails(), ClearAssigned(), GetBranches(), pma::Track3D::GetNearestTrkInTree(), pma::Track3D::GetObjFnInTree(), pma::TrkCandidateColl::getTreeCopy(), IsBranching(), IsTPCEdge(), pma::VtxCandidate::JoinTracks(), pma::Track3D::MakeProjectionInTree(), pma::PMAlgVertexing::mergeBrokenTracks(), Mse(), pma::Track3D::NextSegment(), Penalty(), Pi(), PiInWirePlane(), pma::Track3D::ReassignHitsInTree(), pma::Track3D::RemoveNode(), pma::TrkCandidateColl::setParentDaughterConnections(), pma::TrkCandidateColl::setTreeId(), pma::Track3D::ShiftEndsToHits(), pma::Track3D::SortHitsInTree(), pma::Track3D::TuneSinglePass(), and pma::Track3D::UpdateParamsInTree().

{ return next_vector.size(); }

size_t pma::Element3D::NHits ( void  ) const

inlineinherited

Definition at line 71 of file PmaElement3D.h.

References pma::Element3D::fAssignedHits, geo::kUnknown, and pma::Element3D::NEnabledHits().

Referenced by pma::Track3D::CleanupTails(), pma::Track3D::DisableSingleViewEnds(), PiInWirePlane(), pma::Element3D::SelectRndHits(), and pma::Track3D::SortHits().

{ return fAssignedHits.size(); }

unsigned int pma::Element3D::NHits ( unsigned int  view ) const

inlineinherited

Definition at line 90 of file PmaElement3D.h.

References pma::Element3D::fNHits.

{ return fNHits[view]; }

size_t pma::Element3D::NPoints ( void  ) const

inlineinherited

Definition at line 76 of file PmaElement3D.h.

References pma::Element3D::fAssignedPoints.

Referenced by pma::Track3D::DisableSingleViewEnds().

{ return fAssignedPoints.size(); }

size_t pma::Element3D::NPrecalcEnabledHits ( void  ) const

inlineinherited

Definition at line 73 of file PmaElement3D.h.

References pma::Element3D::fNThisHitsEnabledAll.

Referenced by Mse().

{ return fNThisHitsEnabledAll; }

unsigned int pma::Element3D::NThisHits ( unsigned int  view ) const

inlineinherited

Definition at line 91 of file PmaElement3D.h.

References pma::Element3D::fNThisHits, and pma::Element3D::HitsRadius3D().

{ return fNThisHits[view]; }

static float pma::Element3D::OptFactor ( unsigned int  view )

inlinestaticinherited

Definition at line 103 of file PmaElement3D.h.

References pma::Element3D::fOptFactors.

Referenced by pma::Element3D::SumDist2(), pma::Segment3D::SumDist2Hits(), and SumDist2Hits().

{ return fOptFactors[view]; }

void pma::Node3D::Optimize	(	float	penaltyValue,
		float	endSegWeight
	)

Optimize vertex 3D position with given penalty on connected segments angle and weight assigned to the outermost segments. Only MSE is used in case of branching nodes.

Definition at line 756 of file PmaNode3D.cxx.

References pma::Element3D::fFrozen, and StepWithGradient().

Referenced by GetUnconstrainedProj3D(), and pma::Track3D::TuneSinglePass().

{
        if (!fFrozen)
        {
                double dg = StepWithGradient(0.1F, 0.002F, penaltyValue, endSegWeight);
                if (dg > 0.01) dg = StepWithGradient(0.03F, 0.0001F, penaltyValue, endSegWeight);
                if (dg > 0.0) dg = StepWithGradient(0.03F, 0.0001F, penaltyValue, endSegWeight);
        }
}

double pma::Node3D::Penalty ( float  endSegWeight ) const

private

Definition at line 481 of file PmaNode3D.cxx.

References pma::SortedObjectBase::Next(), pma::SortedBranchBase::Next(), pma::SortedBranchBase::NextCount(), Pi(), pma::SortedObjectBase::Prev(), and pma::SortedObjectBase::prev.

Referenced by GetObjFunction(), and SetMargin().

{
        unsigned int nseg = 1;
        double penalty = Pi(endSegWeight, true);

        pma::Node3D* v;
        for (unsigned int i = 0; i < NextCount(); i++)
        {
                v = static_cast< pma::Node3D* >(Next(i)->Next());
                penalty += v->Pi(endSegWeight, false); nseg++;
        }
        if (prev)
        {
                v = static_cast< pma::Node3D* >(prev->Prev());
                penalty += v->Pi(endSegWeight, false); nseg++;
        }
        return penalty / nseg;
}

double pma::Node3D::PenaltyInWirePlane ( void  ) const

private

Definition at line 358 of file PmaNode3D.cxx.

References EndPtCos2Transverse(), fIsVertex, pma::SortedObjectBase::Next(), pma::SortedObjectBase::next, PiInWirePlane(), pma::SortedObjectBase::Prev(), and pma::SortedObjectBase::prev.

Referenced by GetObjFunction(), and SetMargin().

{
        if (fIsVertex) return 0.0;

        unsigned int nseg = 1;
        double penalty = PiInWirePlane();
        pma::Node3D* v;
        if (next)
        {
                v = static_cast< pma::Node3D* >(next->Next());
                penalty += v->PiInWirePlane(); nseg++;
        }
        if (prev)
        {
                v = static_cast< pma::Node3D* >(prev->Prev());
                penalty += v->PiInWirePlane(); nseg++;
        }
        if (penalty > 0.0) return pow(EndPtCos2Transverse(), 10) * penalty / nseg;
        else return 0.0;
}

double pma::Node3D::Pi ( float  endSegWeight, bool  doAsymm  ) const

private

Definition at line 421 of file PmaNode3D.cxx.

References pma::Element3D::fHitsRadius, fIsVertex, pma::Element3D::Length(), pma::Segment3D::Length2(), Length2(), pma::SortedObjectBase::Next(), pma::SortedObjectBase::next, pma::SortedBranchBase::Next(), pma::SortedObjectBase::NextCount(), pma::SortedBranchBase::NextCount(), pma::SortedObjectBase::Prev(), pma::SortedObjectBase::prev, scale, SegmentCos(), and pma::Element3D::TPC().

Referenced by Penalty(), and SetMargin().

{
        if (fIsVertex) return 0.0;

        if (prev && NextCount())
        {
                pma::Segment3D* segPrev = static_cast< pma::Segment3D* >(prev);
                pma::Segment3D* segNext = static_cast< pma::Segment3D* >(Next(0));

                double scale = 1.0;
                if ((segPrev->TPC() < 0) || (segNext->TPC() < 0)) scale = 0.5; // lower penalty on segments between tpc's

                double segCos = SegmentCos();

                double lAsymmFactor = 0.0;
                if (doAsymm)
                {
                        double lPrev = segPrev->Length();
                        double lNext = segNext->Length();
                        double lSum = lPrev + lNext;
                        if (lSum > 0.1)
                        {
                                double lAsymm = (1.0 - segCos) * (lPrev - lNext) / lSum;
                                lAsymmFactor = 0.05 * lAsymm * lAsymm;
                        }
                }

                if (fHitsRadius > 0.0F) return scale * (1.0 + segCos + lAsymmFactor) * fHitsRadius * fHitsRadius;
                else return scale * (1.0 + segCos + lAsymmFactor) * Length2();
        }
        else
        {
                double pi_result = 0.0;
                unsigned int nSeg = 0;
                pma::Segment3D* seg = 0;
                if (prev)
                {
                        seg = static_cast< pma::Segment3D* >(prev);

                        SortedObjectBase* prevVtx = seg->Prev();
                        if (prevVtx->Prev()) nSeg++;
                        nSeg += prevVtx->NextCount();
                }
                else if (next)
                {
                        seg = static_cast< pma::Segment3D* >(next);
                        
                        SortedObjectBase* nextVtx = seg->Next(0);
                        nSeg += nextVtx->NextCount() + 1;
                }
                else
                {
                        mf::LogWarning("pma::Node3D") << "pma::Node3D::Pi(): an isolated vertex?";
                        return 0.0;
                }
                if (nSeg == 1) pi_result = endSegWeight * seg->Length2();
                return pi_result;
        }
}

double pma::Node3D::PiInWirePlane ( void  ) const

private

Definition at line 338 of file PmaNode3D.cxx.

References pma::Element3D::fHitsRadius, geo::kU, Length2(), pma::SortedBranchBase::Next(), pma::SortedBranchBase::NextCount(), pma::Element3D::NHits(), pma::SortedObjectBase::prev, and SegmentCosWirePlane().

Referenced by PenaltyInWirePlane(), and SetMargin().

{
        if (prev && NextCount())
        {
                pma::Segment3D* seg0 = dynamic_cast< pma::Segment3D* >(prev);
                pma::Segment3D* seg1 = dynamic_cast< pma::Segment3D* >(Next(0));
                unsigned int nInd1 = NHits(geo::kU) + seg0->NHits(geo::kU) + seg1->NHits(geo::kU);

                if (fHitsRadius > 0.0F)
                        return (1.0 + SegmentCosWirePlane()) * fHitsRadius * fHitsRadius / (4 * nInd1 + 1.0);
                else return (1.0 + SegmentCosWirePlane()) * Length2() / (4 * nInd1 + 1.0);
        }
        else return 0.0;
}

TVector3 const& pma::Node3D::Point3D ( void  ) const

inline

Definition at line 33 of file PmaNode3D.h.

References fPoint3D, and SetPoint3D().

Referenced by pma::Track3D::AttachTo(), pma::VtxCandidate::Compute(), pma::Segment3D::GetDirection3D(), pma::Segment3D::GetDistance2To(), pma::PMAlgVertexing::getKinks(), pma::Segment3D::GetProjection(), pma::Segment3D::GetUnconstrainedProj3D(), pma::VtxCandidate::JoinTracks(), pma::VtxCandidate::MaxAngle(), pma::Segment3D::SetProjection(), SetProjection(), and pma::Track3D::Split().

{ return fPoint3D; }

virtual pma::SortedObjectBase* pma::SortedObjectBase::Prev ( void  ) const

inlinevirtualinherited

Definition at line 44 of file SortedObjects.h.

References pma::SortedObjectBase::prev.

Referenced by pma::Track3D::AttachBackTo(), pma::Track3D::AttachBackToOtherTPC(), pma::Track3D::AttachBackToSameTPC(), pma::Track3D::AttachTo(), pma::Track3D::AttachToSameTPC(), pma::Track3D::CanFlip(), ClearAssigned(), EndPtCos2Transverse(), pma::Track3D::Flip(), pma::VtxCandidate::JoinTracks(), pma::Track3D::MakeFastProjection(), pma::PMAlgVertexing::mergeBrokenTracks(), Penalty(), PenaltyInWirePlane(), Pi(), pma::Track3D::PrevSegment(), pma::Track3D::RemoveNode(), SegmentCos(), SegmentCosTransverse(), SegmentCosWirePlane(), pma::TrkCandidateColl::setParentDaughterConnections(), SetProjection(), pma::TrkCandidateColl::setTreeOriginAtFront(), pma::Track3D::ShiftEndsToHits(), pma::Track3D::Split(), pma::Segment3D::Start(), and pma::Element3D::UpdateHitParams().

{ return prev; }

TVector2 const& pma::Node3D::Projection2D ( unsigned int  view ) const

inline

Definition at line 39 of file PmaNode3D.h.

References fProj2D, GetDistToWall(), IsBranching(), IsTPCEdge(), and SameTPC().

Referenced by pma::Segment3D::GetDistance2To(), pma::Segment3D::GetProjection(), pma::Segment3D::GetUnconstrainedProj3D(), pma::Segment3D::SetProjection(), SetProjection(), and pma::Segment3D::SumDist2Hits().

{ return fProj2D[view]; }

TVector3 const& pma::Element3D::ReferencePoint ( size_t  index ) const

inlineinherited

Definition at line 75 of file PmaElement3D.h.

References pma::Element3D::fAssignedPoints.

{ return *(fAssignedPoints[index]); }

void pma::Element3D::RemoveHitAt ( size_t  index )

inlineinherited

Definition at line 60 of file PmaElement3D.h.

References pma::Element3D::fAssignedHits.

        {
                if (index < fAssignedHits.size())
                        fAssignedHits.erase(fAssignedHits.begin() + index);
        }

int pma::SortedBranchBase::RemoveNext ( pma::SortedObjectBase *  nextElement )

virtualinherited

Reimplemented from pma::SortedObjectBase.

Definition at line 107 of file SortedObjects.cxx.

References pma::SortedObjectBase::next, and pma::SortedObjectBase::prev.

Referenced by pma::Track3D::AttachBackToSameTPC(), pma::Track3D::AttachToSameTPC(), and pma::Track3D::Split().

{
        if (!nextElement || (nextElement == this)) return -1;

        int index = -1;
        for (unsigned int i = 0; i < next_vector.size(); i++)
        {
                if (next_vector[i] == nextElement) { index = i; break; }
        }
        if (index >= 0)
        {
                if (next_vector[index]->prev != this)
                {
                        mf::LogError("pma::SortedBranchBase") << "Object structure is broken.";
                        return -1;
                }
                next_vector[index]->prev = 0;
                next_vector.erase(next_vector.begin() + index);

                if (next_vector.size() > 0) next = next_vector.back();
                else next = 0;
        }
        return index;
}

bool pma::Node3D::SameTPC	(	const TVector3 &	p3d,
		float	margin = 0.0F
	)		const

Check if p3d is in the same TPC as the node.

Definition at line 83 of file PmaNode3D.cxx.

References fMaxX, fMaxY, fMaxZ, fMinX, fMinY, and fMinZ.

Referenced by pma::Track3D::GetUnconstrainedProj3D(), pma::ProjectionMatchingAlg::isContained(), Projection2D(), pma::ProjectionMatchingAlg::validate(), pma::ProjectionMatchingAlg::validate_on_adc(), and pma::ProjectionMatchingAlg::validate_on_adc_test().

{
        if (((fMinX - margin) <= p3d.X()) && (p3d.X() <= (fMaxX + margin)) &&
            ((fMinY - margin) <= p3d.Y()) && (p3d.Y() <= (fMaxY + margin)) &&
            ((fMinZ - margin) <= p3d.Z()) && (p3d.Z() <= (fMaxZ + margin))) return true;
        else return false;
}

bool pma::Node3D::SameTPC	(	const pma::Vector3D &	p3d,
		float	margin = 0.0F
	)		const

Definition at line 91 of file PmaNode3D.cxx.

References fMaxX, fMaxY, fMaxZ, fMinX, fMinY, and fMinZ.

{
        if (((fMinX - margin) <= p3d.X()) && (p3d.X() <= (fMaxX + margin)) &&
            ((fMinY - margin) <= p3d.Y()) && (p3d.Y() <= (fMaxY + margin)) &&
            ((fMinZ - margin) <= p3d.Z()) && (p3d.Z() <= (fMaxZ + margin))) return true;
        else return false;
}

double pma::Node3D::SegmentCos

(

void

)

const

Cosine of 3D angle between connected segments.

Definition at line 260 of file PmaNode3D.cxx.

References fPoint3D, pma::SortedObjectBase::Next(), pma::SortedObjectBase::next, pma::SortedObjectBase::Prev(), and pma::SortedObjectBase::prev.

Referenced by GetUnconstrainedProj3D(), and Pi().

{
        if (prev && next)
        {
                auto const & vStop1 = static_cast< pma::Node3D* >(prev->Prev())->fPoint3D;
                auto const & vStop2 = static_cast< pma::Node3D* >(next->Next())->fPoint3D;
                pma::Vector3D v1(vStop1.X() - fPoint3D.X(), vStop1.Y() - fPoint3D.Y(), vStop1.Z() - fPoint3D.Z());
                pma::Vector3D v2(vStop2.X() - fPoint3D.X(), vStop2.Y() - fPoint3D.Y(), vStop2.Z() - fPoint3D.Z());
                double mag = sqrt(v1.Mag2() * v2.Mag2());
                double cosine = 0.0;
                if (mag != 0.0) cosine = v1.Dot(v2) / mag;
                return cosine;
        }
        else
        {
                mf::LogError("pma::Node3D") << "pma::Node3D::SegmentCos(): neighbours not initialized.";
                return -1.0;
        }
}

double pma::Node3D::SegmentCosTransverse

(

void

)

const

Cosine of 2D angle (in horizontal plane, parallel to drift) between connected segments. Should be changed / generalized for horizontal wire planes (e.g. 2-phase LAr).

Definition at line 300 of file PmaNode3D.cxx.

References fPoint3D, pma::SortedObjectBase::Next(), pma::SortedObjectBase::next, pma::SortedObjectBase::Prev(), and pma::SortedObjectBase::prev.

Referenced by GetUnconstrainedProj3D().

{
        if (prev && next)
        {
                auto const & vStop1 = static_cast< pma::Node3D* >(prev->Prev())->fPoint3D;
                auto const & vStop2 = static_cast< pma::Node3D* >(next->Next())->fPoint3D;
                pma::Vector2D v1( vStop1.X() - fPoint3D.X(), vStop1.Z() - fPoint3D.Z());
                pma::Vector2D v2( vStop2.X() - fPoint3D.X(), vStop2.Z() - fPoint3D.Z());
                double mag = sqrt(v1.Mag2() * v2.Mag2());
                double cosine = 0.0;
                if (mag != 0.0) cosine = v1.Dot(v2) / mag;
                return cosine;
        }
        else
        {
                mf::LogError("pma::Node3D") << "pma::Node3D::SegmentCosZY(): neighbours not initialized.";
                return -1.0;
        }
}

double pma::Node3D::SegmentCosWirePlane

(

void

)

const

Cosine of 2D angle (in plane parallel to wire planes) between connected segments. Should be changed / generalized for horizontal wire planes (e.g. 2-phase LAr).

Definition at line 280 of file PmaNode3D.cxx.

References fPoint3D, pma::SortedObjectBase::Next(), pma::SortedObjectBase::next, pma::SortedObjectBase::Prev(), and pma::SortedObjectBase::prev.

Referenced by GetUnconstrainedProj3D(), and PiInWirePlane().

{
        if (prev && next)
        {
                auto const & vStop1 = static_cast< pma::Node3D* >(prev->Prev())->fPoint3D;
                auto const & vStop2 = static_cast< pma::Node3D* >(next->Next())->fPoint3D;
                pma::Vector2D v1(vStop1.Y() - fPoint3D.Y(), vStop1.Z() - fPoint3D.Z());
                pma::Vector2D v2(vStop2.Y() - fPoint3D.Y(), vStop2.Z() - fPoint3D.Z());
                double mag = sqrt(v1.Mag2() * v2.Mag2());
                double cosine = 0.0;
                if (mag != 0.0) cosine = v1.Dot(v2) / mag;
                return cosine;
        }
        else
        {
                mf::LogError("pma::Node3D") << "pma::Node3D::SegmentCosZX(): neighbours not initialized.";
                return -1.0;
        }
}

bool pma::Element3D::SelectAllHits ( void  )

inherited

Definition at line 296 of file PmaElement3D.cxx.

References pma::Element3D::fAssignedHits.

Referenced by pma::Track3D::SelectHits(), pma::Element3D::SelectRndHits(), and pma::Element3D::SetFrozen().

{
        bool changed = false;
        for (auto h : fAssignedHits)
        {
                changed |= !(h->IsEnabled());
                h->SetEnabled(true);
        }
        return changed;
}

bool pma::Element3D::SelectRndHits ( size_t  nmax_per_view )

inherited

Definition at line 250 of file PmaElement3D.cxx.

References pma::Element3D::fAssignedHits, pma::Element3D::NHits(), and pma::Element3D::SelectAllHits().

Referenced by pma::Element3D::SetFrozen().

{
        if (!nmax_per_view) { return SelectAllHits(); }

        size_t nhits[3];
        for (size_t i = 0; i < 3; ++i) nhits[i] = NHits(i);

        int m[3], count[3];
        bool state[3];
        for (size_t i = 0; i < 3; ++i)
        {
                if (nhits[i] >= 2 * nmax_per_view)
                {
                        m[i] = nhits[i] / nmax_per_view;
                        state[i] = true;
                }
                else if (nhits[i] > nmax_per_view)
                {
                        m[i] = nhits[i] / (nhits[i] - nmax_per_view);
                        state[i] = false;
                }
                else { m[i] = 0; state[i] = false; }

                count[i] = 0;
        }

        bool b, changed = false;
        for (auto h : fAssignedHits)
        {
                b = h->IsEnabled();

                size_t view = h->View2D();
                if (m[view])
                {
                        if (count[view] % m[view] == 0) h->SetEnabled(state[view]);
                        else h->SetEnabled(!(state[view]));

                        ++count[view];
                }
                else h->SetEnabled(true);

                changed |= (b != h->IsEnabled());
        }
        return changed;
}

void pma::Element3D::SetFrozen ( bool  state )

inlineinherited

Fix / relese vertex 3D position.

Definition at line 98 of file PmaElement3D.h.

References pma::Element3D::fFrozen, pma::Element3D::SelectAllHits(), and pma::Element3D::SelectRndHits().

{ fFrozen = state; }

static void pma::Node3D::SetMargin ( double  m )

inlinestatic

Set allowed node position margin around TPC.

Definition at line 105 of file PmaNode3D.h.

References EndPtCos2Transverse(), fMargin, LimitPoint3D(), MakeGradient(), Mse(), Penalty(), PenaltyInWirePlane(), Pi(), PiInWirePlane(), StepWithGradient(), SumDist2Hits(), UpdateProj2D(), and weight.

Referenced by pma::ProjectionMatchingAlg::ProjectionMatchingAlg().

{ if (m >= 0.0) fMargin = m; }

static void pma::Element3D::SetOptFactor ( unsigned int  view, float  value  )

inlinestaticinherited

Definition at line 104 of file PmaElement3D.h.

References pma::Element3D::Element3D(), pma::Element3D::fOptFactors, and fhicl::detail::atom::value().

Referenced by pma::ProjectionMatchingAlg::ProjectionMatchingAlg().

{ fOptFactors[view] = value; }

bool pma::Node3D::SetPoint3D

(

const TVector3 &

p3d

)

Returns true if the new position was accepted; returns false if the new position was trimmed to fit insite TPC volume + fMargin.

Definition at line 123 of file PmaNode3D.cxx.

References fPoint3D, LimitPoint3D(), and UpdateProj2D().

Referenced by pma::VtxCandidate::JoinTracks(), MakeGradient(), Node3D(), Point3D(), and StepWithGradient().

{
        fPoint3D = p3d;

        bool accepted = !LimitPoint3D();
        UpdateProj2D();

        return accepted;
}

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

overridevirtual

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

Implements pma::Element3D.

Definition at line 171 of file PmaNode3D.cxx.

References pma::Element3D::fFrozen, fPoint3D, pma::SortedObjectBase::Next(), pma::SortedObjectBase::next, pma::Hit3D::Point2D(), Point3D(), pma::SortedObjectBase::Prev(), pma::SortedObjectBase::prev, Projection2D(), pma::Hit3D::SetPoint3D(), pma::Hit3D::SetProjection(), and pma::Hit3D::View2D().

Referenced by GetUnconstrainedProj3D().

{
        TVector2 gstart;
        TVector3 g3d;
        if (prev)
        {
                pma::Node3D* vtx = static_cast< pma::Node3D* >(prev->Prev());
                gstart = vtx->Projection2D(h.View2D());
                if (!next) g3d = vtx->Point3D();
        }
        else if (next)
        {
                pma::Node3D* vtx = static_cast< pma::Node3D* >(next->Next());
                gstart = Projection2D(h.View2D());
                gstart -= vtx->Projection2D(h.View2D()) - Projection2D(h.View2D());
                if (!prev)
                {
                        g3d = fPoint3D;
                        g3d -= vtx->Point3D() - fPoint3D;
                }
        }
        else
        {
                mf::LogError("pma::Node3D") << "Isolated vertex.";
                TVector2 p(Projection2D(h.View2D()));
                h.SetProjection(p, 0.0F);
                h.SetPoint3D(fPoint3D);
                return;
        }

        TVector2 v0(h.Point2D());
        v0 -= Projection2D(h.View2D());

        TVector2 v1(gstart);
        v1 -= Projection2D(h.View2D());

        double v0Norm = v0.Mod();
        double v1Norm = v1.Mod();
        double mag = v0Norm * v1Norm;
        double cosine = 0.0;
        if (mag != 0.0) cosine = v0 * v1 / mag;

        TVector2 p(Projection2D(h.View2D()));

        if (prev && next)
        {
                pma::Node3D* vNext = static_cast< pma::Node3D* >(next->Next());
                TVector2 vN(vNext->Projection2D(h.View2D()));
                vN -= Projection2D(h.View2D());

                mag = v0Norm * vN.Mod();
                double cosineN = 0.0;
                if (mag != 0.0) cosineN = v0 * vN / mag;

                // hit on the previous segment side, sorting on the -cosine(prev_seg, point)  /max.val. = 1/
                if (cosineN <= cosine) h.SetProjection(p, -(float)cosine);
                // hit on the next segment side, sorting on the 1+cosine(next_seg, point)  /min.val. = 1/
                else h.SetProjection(p, 2.0F + (float)cosineN);

                h.SetPoint3D(fPoint3D);
        }
        else
        {
                float b = (float)(v0Norm * cosine / v1Norm);
                if (fFrozen) // limit 3D positions to outermose node if frozen
                {
                        h.SetPoint3D(fPoint3D);
                }
                else // or set 3D positions along the line of outermost segment
                {
                        g3d -= fPoint3D;
                        h.SetPoint3D(fPoint3D + (g3d * b));

                        p += (v1 * b);
                }
                h.SetProjection(p, -b);
        }
}

void pma::Node3D::SetVertex ( bool  state )

inline

Definition at line 55 of file PmaNode3D.h.

References fIsVertex.

{ fIsVertex = state; }

void pma::Node3D::SetVertexToBranching ( bool  setAllNodes )

inline

Definition at line 56 of file PmaNode3D.h.

References fIsVertex, GetBranches(), GetDirection3D(), GetDistance2To(), and IsBranching().

        {
                if (setAllNodes || !fIsVertex) fIsVertex = IsBranching();
        }

void pma::Element3D::SortHits ( void  )

inherited

Definition at line 44 of file PmaElement3D.cxx.

References pma::Element3D::fAssignedHits.

Referenced by pma::Track3D::AddNode(), pma::Track3D::SortHits(), and pma::Element3D::UpdateProjection().

{
        std::sort(fAssignedHits.begin(), fAssignedHits.end(), pma::bTrajectory3DOrderLess());
}

double pma::Node3D::StepWithGradient ( float  alfa, float  tol, float  penalty, float  weight  )

private

Definition at line 609 of file PmaNode3D.cxx.

References fGradient, fPoint3D, GetObjFunction(), MakeGradient(), SetPoint3D(), t1, t2, and tmp.

Referenced by Optimize(), and SetMargin().

{
        unsigned int steps = 0;
        double t, t1, t2, t3, g, g0, g1, g2, g3, p1, p2;
        double eps = 6.0E-37, zero_tol = 1.0E-15;
        TVector3 tmp(fPoint3D), gpoint(fPoint3D);

        g = MakeGradient(penalty, weight);
        if (g < zero_tol) return 0.0;
        g0 = g;

        //**** first three points ****//
        alfa *= 0.8F;
        t2 = 0.0; g2 = g;
        t3 = 0.0; g3 = g;
        do
        {
                t1 = t2; g1 = g2;
                t2 = t3; g2 = g3;

                alfa *= 1.25F;
                t3 += alfa;
                gpoint = tmp;
                gpoint += (fGradient * t3);
                if (!SetPoint3D(gpoint)) // stepped out of allowed volume
                {
                        //std::cout << "****  SetPoint trimmed 1 ****" << std::endl;
                        g3 = GetObjFunction(penalty, weight);
                        if (g3 < g2) return (g0 - g3) / g3;   // exit with the node at the border
                        else { SetPoint3D(tmp); return 0.0; } // exit with restored original position
                }
                
                g3 = GetObjFunction(penalty, weight);
                
                if (g3 < zero_tol) return 0.0;

                if (++steps > 1000) { SetPoint3D(tmp); return 0.0; }

        } while (g3 < g2);
        //****************************//

        //*** first step overshoot ***//
        if (steps == 1)
        {
                t2 = t3; g2 = g3;
                do
                {
                        t3 = t2; g3 = g2;
                        t2 = (t1 * g3 + t3 * g1) / (g1 + g3);

                        // small shift...
                        t2 = 0.05 * t3 + 0.95 * t2;

                        // break: starting point is at the minimum
                        //if (t2 == t1) { SetPoint3D(tmp); return 0.0F; }

                        // break: starting point is very close to the minimum
                        if (fabs(t2 - t1) < tol) { SetPoint3D(tmp); return 0.0; }

                        gpoint = tmp;
                        gpoint += (fGradient * t2);
                        if (!SetPoint3D(gpoint)) // select the best point to exit
                        {
                                //std::cout << "****  SetPoint trimmed 2 ****" << std::endl;
                                g2 = GetObjFunction(penalty, weight);
                                if (g2 < g0) return (g0 - g2) / g2;   // exit with the node at the border
                                else if (g1 < g0)
                                {
                                        gpoint = tmp; gpoint += (fGradient * t1);
                                        return (g0 - g1) / g1;
                                }
                                else if (g3 < g0)
                                {
                                        gpoint = tmp; gpoint += (fGradient * t3);
                                        return (g0 - g3) / g3;
                                }
                                else { SetPoint3D(tmp); return 0.0; }
                        }
                        g2 = GetObjFunction(penalty, weight);

                        if (g2 < zero_tol) return 0.0;
                        steps++;

                } while (g2 >= g1);
        }
        //****************************//

        while (fabs(t1 - t3) > tol)
        {
                //*** 3-point minimization ***//
                if ((fabs(t2 - t1) < eps) || (fabs(t2 - t3) < eps))
                        break; // minimum on the edge
                if ((fabs(g2 - g1) < eps) && (fabs(g2 - g3) < eps))
                        break; // ~singularity

                p1 = (t2 - t1) * (g2 - g3);
                p2 = (t2 - t3) * (g2 - g1);
                if (fabs(p1 - p2) < eps) break; // ~linearity

                t = t2 + ((t2 - t1) * p1 - (t2 - t3) * p2) / (2 * (p2 - p1));
                if ((t <= t1) || (t >= t3))
                        t = (t1 * g3 + t3 * g1) / (g1 + g3);

                gpoint = tmp;
                gpoint += (fGradient * t);
                if (!SetPoint3D(gpoint)) // select the best point to exit
                {
                        //std::cout << "****  SetPoint trimmed 3 ****" << std::endl;
                        g = GetObjFunction(penalty, weight);
                        if ((g < g0) && (g < g1) && (g < g3)) return (g0 - g) / g;   // exit with the node at the border
                        else if ((g1 < g0) && (g1 < g3))
                        {
                                gpoint = tmp; gpoint += (fGradient * t1);
                                return (g0 - g1) / g1;
                        }
                        else if (g3 < g0)
                        {
                                gpoint = tmp; gpoint += (fGradient * t3);
                                return (g0 - g3) / g3;
                        }
                        else { SetPoint3D(tmp); return 0.0; }
                }
                
                g = GetObjFunction(penalty, weight);
                if (g < zero_tol) return 0.0;
                steps++;
                //****************************//

                //*** select next 3 points ***//
                if (fabs(t - t2) < 0.2 * tol) break; // start in a new direction
                if (g < g2)
                {
                        if (t < t2) { t3 = t2; g3 = g2; }
                        else { t1 = t2; g1 = g2; }
                        t2 = t; g2 = g;
                }
                else
                {
                        if (t < t2) { t1 = t; g1 = g; }
                        else { t3 = t; g3 = g; }
                }
                //****************************//
        }

        return (g0 - g) / g;
}

double pma::Element3D::SumDist2 ( void  ) const

inherited

Definition at line 171 of file PmaElement3D.cxx.

References d, pma::Element3D::fAssignedHits, pma::Element3D::fAssignedPoints, pma::Element3D::fTPC, pma::Element3D::GetDistance2To(), and pma::Element3D::SumDist2Hits().

Referenced by Mse(), and pma::Element3D::UpdateProjection().

{
        if (fTPC < 0)
        {
                if (!fAssignedHits.empty()) mf::LogWarning("pma::Element3D") << "Hits assigned to TPC-crossing element.";
                return 0.0F;
        }

    double hit_sum = SumDist2Hits();

        if (fAssignedPoints.size())
        {
                double d, ref_sum = 0.0F;
                for (auto p : fAssignedPoints)
                {
                        d = sqrt( GetDistance2To(*p) ) - 0.5; // guide by ref points up to ~ 3D resolution
                        if (d > 0.0) ref_sum += d * d;
                }
                if (fAssignedHits.size())
                {
                        ref_sum *= 0.2 * fAssignedHits.size() / fAssignedPoints.size();
                }
                hit_sum += ref_sum;
        }

        return hit_sum;
}

double pma::Element3D::SumDist2 ( unsigned int  view ) const

inherited

Definition at line 199 of file PmaElement3D.cxx.

References pma::Element3D::fAssignedHits, pma::Element3D::fTPC, pma::Element3D::GetDistance2To(), geo::kUnknown, and pma::Element3D::OptFactor().

{
        if (fTPC < 0)
        {
                if (!fAssignedHits.empty()) mf::LogWarning("pma::Element3D") << "Hits assigned to TPC-crossing element.";
                return 0.0F;
        }

        double hit_sum = 0.0F;
        for (auto h : fAssignedHits)
        {
                if (h->IsEnabled())
                {
                        unsigned int hitView = h->View2D();
                        if ((view == geo::kUnknown) || (view == hitView))
                        {
                                hit_sum += OptFactor(hitView) *              // alpha_i
                                        h->GetSigmaFactor() *                    // hit_amp / hit_max_amp
                                        GetDistance2To(h->Point2D(), hitView);   // hit_to_fit_dist^2
                        }
                }
        }
        return hit_sum;
}

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

overrideprivatevirtual

Implements pma::Element3D.

Definition at line 143 of file PmaNode3D.cxx.

References pma::Dist2(), pma::Element3D::fAssignedHits, fProj2D, and pma::Element3D::OptFactor().

Referenced by SetMargin().

{
        double sum = 0.0F;
        for (auto h : fAssignedHits)
        {
                if (h->IsEnabled())
                {
                        unsigned int view = h->View2D();

                        sum += OptFactor(view) *    // alpha_i
                                h->GetSigmaFactor() *   // hit_amp / hit_max_amp
                                pma::Dist2(h->Point2D(), fProj2D[view]);
                }
        }
        return sum;
}

double pma::Element3D::SumHitsQ ( unsigned int  view ) const

inlineinherited

Definition at line 89 of file PmaElement3D.h.

References pma::Element3D::fSumHitsQ.

{ return fSumHitsQ[view]; }

int pma::Element3D::TPC ( void  ) const

inlineinherited

TPC index or -1 if out of any TPC.

Definition at line 31 of file PmaElement3D.h.

References pma::Element3D::fTPC.

Referenced by pma::Track3D::AttachBackTo(), pma::Track3D::AttachTo(), pma::Track3D::HasTPC(), IsTPCEdge(), pma::Track3D::MakeFastProjection(), pma::ProjectionMatchingAlg::mergeTracks(), Pi(), pma::Segment3D::Segment3D(), pma::Track3D::Split(), pma::ProjectionMatchingAlg::validate(), pma::ProjectionMatchingAlg::validate_on_adc(), and pma::ProjectionMatchingAlg::validate_on_adc_test().

{ return fTPC; }

void pma::Element3D::UpdateHitParams ( void  )

inherited

Definition at line 56 of file PmaElement3D.cxx.

References pma::Element3D::fAssignedHits, pma::Element3D::fHitsRadius, pma::Element3D::fNHits, pma::Element3D::fNThisHits, pma::Element3D::fNThisHitsEnabledAll, pma::Element3D::fSumHitsQ, pma::GetHitsRadius2D(), geo::kU, geo::kV, geo::kZ, pma::SortedObjectBase::Next(), pma::SortedObjectBase::NextCount(), and pma::SortedObjectBase::Prev().

Referenced by pma::Element3D::AddPoint().

{
        std::vector< pma::Hit3D* > hitsColl, hitsInd1, hitsInd2;
        for (size_t i = 0; i < 3; ++i) fNThisHitsEnabledAll = 0;
        for (auto h : fAssignedHits)
        {
                if (h->IsEnabled()) fNThisHitsEnabledAll++;
                switch (h->View2D())
                {
                        case geo::kZ: hitsColl.push_back(h); break;
                        case geo::kV: hitsInd2.push_back(h); break;
                        case geo::kU: hitsInd1.push_back(h); break;
                }
        }
        fNThisHits[0] = hitsInd1.size();
        fNThisHits[1] = hitsInd2.size();
        fNThisHits[2] = hitsColl.size();

        pma::SortedObjectBase const * chain = dynamic_cast< pma::SortedObjectBase* >(this);
        pma::Element3D* el = 0;
        for (size_t b = 0; b < chain->NextCount(); b++)
        {
                el = dynamic_cast< pma::Element3D* >(chain->Next(b));
                if (el)
                        for (auto h : el->fAssignedHits)
                        {
                                switch (h->View2D())
                                {
                                        case geo::kZ: hitsColl.push_back(h); break;
                                        case geo::kV: hitsInd2.push_back(h); break;
                                        case geo::kU: hitsInd1.push_back(h); break;
                                }
                        }
        }
        el = dynamic_cast< pma::Element3D* >(chain->Prev());
        if (el)
        {
                for (auto h : el->fAssignedHits)
                {
                        switch (h->View2D())
                        {
                                case geo::kZ: hitsColl.push_back(h); break;
                                case geo::kV: hitsInd2.push_back(h); break;
                                case geo::kU: hitsInd1.push_back(h); break;
                        }
                }
        }

        fHitsRadius = GetHitsRadius2D(hitsColl);
        double r = GetHitsRadius2D(hitsInd2);
        if (r > fHitsRadius) fHitsRadius = r;
        r = GetHitsRadius2D(hitsInd1);
        if (r > fHitsRadius) fHitsRadius = r;

        float amp, sigmaMax = 0.0F;
        fSumHitsQ[0] = 0.0; fNHits[0] = hitsInd1.size();
        for (size_t i = 0; i < hitsInd1.size(); i++)
        {
                amp = hitsInd1[i]->GetAmplitude();
                if (amp > sigmaMax) sigmaMax = amp;
                fSumHitsQ[0] += amp;
        }
        for (size_t i = 0; i < hitsInd1.size(); i++)
        {
                if (sigmaMax > 0.0F)
                {
                        amp = hitsInd1[i]->GetAmplitude();
                        if (amp > 0.0F)
                                hitsInd1[i]->SetSigmaFactor((float)sqrt(amp / sigmaMax));
                        else hitsInd1[i]->SetSigmaFactor(0.01F);
                }
                else hitsInd1[i]->SetSigmaFactor(1.0F);
        }

        sigmaMax = 0.0F;
        fSumHitsQ[1] = 0.0; fNHits[1] = hitsInd2.size();
        for (size_t i = 0; i < hitsInd2.size(); i++)
        {
                amp = hitsInd2[i]->GetAmplitude();
                if (amp > sigmaMax) sigmaMax = amp;
                fSumHitsQ[1] += amp;
        }
        for (size_t i = 0; i < hitsInd2.size(); i++)
        {
                if (sigmaMax > 0.0F)
                {
                        amp = hitsInd2[i]->GetAmplitude();
                        if (amp > 0.0F)
                                hitsInd2[i]->SetSigmaFactor((float)sqrt(amp / sigmaMax));
                        else hitsInd2[i]->SetSigmaFactor(0.01F);
                }
                else hitsInd2[i]->SetSigmaFactor(1.0F);
        }

        sigmaMax = 0.0F;
        fSumHitsQ[2] = 0.0; fNHits[2] = hitsColl.size();
        for (size_t i = 0; i < hitsColl.size(); i++)
        {
                amp = hitsColl[i]->SummedADC();
                if (amp > sigmaMax) sigmaMax = amp;
                fSumHitsQ[2] += amp;
        }
        for (size_t i = 0; i < hitsColl.size(); i++)
        {
                if (sigmaMax > 0.0F)
                {
                        amp = hitsColl[i]->SummedADC();
                        if (amp > 0.0F)
                                hitsColl[i]->SetSigmaFactor((float)sqrt(amp / sigmaMax));
                        else hitsColl[i]->SetSigmaFactor(0.01F);
                }
                else hitsColl[i]->SetSigmaFactor(1.0F);
        }
}

void pma::Node3D::UpdateProj2D ( void  )

private

Definition at line 115 of file PmaNode3D.cxx.

References fDriftOffset, fPoint3D, fProj2D, fTpcGeo, geo::TPCGeo::Nplanes(), geo::TPCGeo::Plane(), and geo::PlaneGeo::PlaneCoordinate().

Referenced by SetMargin(), and SetPoint3D().

{
    for (size_t i = 0; i < fTpcGeo.Nplanes(); ++i)
    {
        fProj2D[i].Set(fTpcGeo.Plane(i).PlaneCoordinate(fPoint3D), fPoint3D.X() - fDriftOffset);
        }
}

void pma::Element3D::UpdateProjection ( void  )

inlineinherited

Definition at line 84 of file PmaElement3D.h.

References pma::Element3D::fAssignedHits, pma::Element3D::SetProjection(), pma::Element3D::SortHits(), and pma::Element3D::SumDist2().

{ for (auto h : fAssignedHits) SetProjection(*h); }

Member Data Documentation

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

protectedinherited

Definition at line 113 of file PmaElement3D.h.

Referenced by pma::Element3D::AddHit(), pma::Element3D::ClearAssigned(), ClearAssigned(), pma::Element3D::HasHit(), pma::Element3D::Hit(), pma::Element3D::Hits(), pma::Element3D::HitsRadius3D(), pma::Element3D::NEnabledHits(), pma::Element3D::NHits(), pma::Element3D::RemoveHitAt(), pma::Element3D::SelectAllHits(), pma::Element3D::SelectRndHits(), pma::Element3D::SortHits(), pma::Element3D::SumDist2(), pma::Segment3D::SumDist2Hits(), SumDist2Hits(), pma::Element3D::UpdateHitParams(), and pma::Element3D::UpdateProjection().

std::vector< TVector3* > pma::Element3D::fAssignedPoints

protectedinherited

Definition at line 114 of file PmaElement3D.h.

Referenced by pma::Element3D::AddPoint(), pma::Element3D::ClearAssigned(), ClearAssigned(), pma::Element3D::NPoints(), pma::Element3D::ReferencePoint(), and pma::Element3D::SumDist2().

int pma::Element3D::fCryo

protectedinherited

Definition at line 108 of file PmaElement3D.h.

Referenced by pma::Element3D::Cryo(), Node3D(), and pma::Segment3D::Segment3D().

double pma::Node3D::fDriftOffset

private

Definition at line 131 of file PmaNode3D.h.

Referenced by ApplyDriftShift(), GetDriftShift(), and UpdateProj2D().

bool pma::Element3D::fFrozen

protectedinherited

Definition at line 112 of file PmaElement3D.h.

Referenced by pma::Element3D::IsFrozen(), Optimize(), pma::Element3D::SetFrozen(), and SetProjection().

bool pma::Node3D::fGradFixed = { false, false, false }

staticprivate

Definition at line 136 of file PmaNode3D.h.

Referenced by MakeGradient().

TVector3 pma::Node3D::fGradient

private

Definition at line 133 of file PmaNode3D.h.

Referenced by MakeGradient(), and StepWithGradient().

double pma::Element3D::fHitsRadius

protectedinherited

Definition at line 119 of file PmaElement3D.h.

Referenced by pma::Element3D::ClearAssigned(), ClearAssigned(), Pi(), PiInWirePlane(), and pma::Element3D::UpdateHitParams().

bool pma::Node3D::fIsVertex

private

Definition at line 134 of file PmaNode3D.h.

Referenced by IsVertex(), PenaltyInWirePlane(), Pi(), SetVertex(), and SetVertexToBranching().

double pma::Node3D::fMargin = 3.0

staticprivate

Definition at line 137 of file PmaNode3D.h.

Referenced by LimitPoint3D(), and SetMargin().

double pma::Node3D::fMaxX

private

Definition at line 127 of file PmaNode3D.h.

Referenced by GetDistToWall(), LimitPoint3D(), Node3D(), and SameTPC().

double pma::Node3D::fMaxY

private

Definition at line 127 of file PmaNode3D.h.

Referenced by GetDistToWall(), LimitPoint3D(), Node3D(), and SameTPC().

double pma::Node3D::fMaxZ

private

Definition at line 127 of file PmaNode3D.h.

Referenced by GetDistToWall(), LimitPoint3D(), Node3D(), and SameTPC().

double pma::Node3D::fMinX

private

Definition at line 127 of file PmaNode3D.h.

Referenced by GetDistToWall(), LimitPoint3D(), Node3D(), and SameTPC().

double pma::Node3D::fMinY

private

Definition at line 127 of file PmaNode3D.h.

Referenced by GetDistToWall(), LimitPoint3D(), Node3D(), and SameTPC().

double pma::Node3D::fMinZ

private

Definition at line 127 of file PmaNode3D.h.

Referenced by GetDistToWall(), LimitPoint3D(), Node3D(), and SameTPC().

size_t pma::Element3D::fNHits[3]

protectedinherited

Definition at line 117 of file PmaElement3D.h.

Referenced by pma::Element3D::Element3D(), pma::Element3D::NHits(), and pma::Element3D::UpdateHitParams().

size_t pma::Element3D::fNThisHits[3]

protectedinherited

Definition at line 115 of file PmaElement3D.h.

Referenced by pma::Element3D::Element3D(), pma::Element3D::NThisHits(), and pma::Element3D::UpdateHitParams().

size_t pma::Element3D::fNThisHitsEnabledAll

protectedinherited

Definition at line 116 of file PmaElement3D.h.

Referenced by pma::Element3D::Element3D(), pma::Element3D::NPrecalcEnabledHits(), and pma::Element3D::UpdateHitParams().

float pma::Element3D::fOptFactors = { 0.2F, 0.8F, 1.0F }

staticprotectedinherited

Definition at line 121 of file PmaElement3D.h.

Referenced by pma::Element3D::OptFactor(), and pma::Element3D::SetOptFactor().

TVector3 pma::Node3D::fPoint3D

private

Definition at line 129 of file PmaNode3D.h.

Referenced by ApplyDriftShift(), pma::Track3D::ApplyDriftShiftInTree(), EndPtCos2Transverse(), GetDistance2To(), GetDistToWall(), GetUnconstrainedProj3D(), LimitPoint3D(), MakeGradient(), Point3D(), SegmentCos(), SegmentCosTransverse(), SegmentCosWirePlane(), SetPoint3D(), SetProjection(), StepWithGradient(), and UpdateProj2D().

TVector2 pma::Node3D::fProj2D[3]

private

Definition at line 130 of file PmaNode3D.h.

Referenced by GetDistance2To(), Node3D(), Projection2D(), SumDist2Hits(), and UpdateProj2D().

double pma::Element3D::fSumHitsQ[3]

protectedinherited

Definition at line 118 of file PmaElement3D.h.

Referenced by pma::Element3D::Element3D(), pma::Element3D::SumHitsQ(), and pma::Element3D::UpdateHitParams().

int pma::Element3D::fTPC

protectedinherited

Definition at line 108 of file PmaElement3D.h.

Referenced by pma::Element3D::HitsRadius3D(), Node3D(), pma::Segment3D::Segment3D(), pma::Element3D::SumDist2(), and pma::Element3D::TPC().

geo::TPCGeo const& pma::Node3D::fTpcGeo

private

Definition at line 125 of file PmaNode3D.h.

Referenced by Node3D(), and UpdateProj2D().

pma::SortedObjectBase* pma::SortedObjectBase::next

protectedinherited

Definition at line 53 of file SortedObjects.h.

Referenced by pma::SortedObjectBase::AddNext(), pma::SortedBranchBase::AddNext(), pma::SortedObjectBase::Disconnect(), EndPtCos2Transverse(), pma::Segment3D::GetDirection3D(), GetDirection3D(), pma::Segment3D::GetDistance2To(), pma::Segment3D::GetProjection(), pma::Segment3D::GetUnconstrainedProj3D(), pma::SortedObjectBase::IsLast(), pma::Segment3D::Length2(), Length2(), MakeGradient(), pma::SortedObjectBase::Next(), pma::SortedObjectBase::NextCount(), PenaltyInWirePlane(), Pi(), pma::SortedObjectBase::RemoveNext(), pma::SortedBranchBase::RemoveNext(), SegmentCos(), SegmentCosTransverse(), SegmentCosWirePlane(), pma::Segment3D::SetProjection(), SetProjection(), pma::SortedBranchBase::SortedBranchBase(), and pma::Segment3D::SumDist2Hits().

std::vector< pma::SortedObjectBase* > pma::SortedBranchBase::next_vector

protectedinherited

Definition at line 88 of file SortedObjects.h.

pma::SortedObjectBase* pma::SortedObjectBase::prev

protectedinherited

Definition at line 54 of file SortedObjects.h.

Referenced by pma::SortedObjectBase::AddNext(), pma::SortedBranchBase::AddNext(), pma::SortedObjectBase::Disconnect(), pma::SortedBranchBase::Disconnect(), EndPtCos2Transverse(), pma::Segment3D::GetDirection3D(), GetDirection3D(), pma::Segment3D::GetDistance2To(), pma::Segment3D::GetProjection(), pma::Segment3D::GetUnconstrainedProj3D(), IsBranching(), pma::SortedObjectBase::IsFirst(), IsTPCEdge(), pma::Segment3D::Length2(), Length2(), MakeGradient(), Mse(), Penalty(), PenaltyInWirePlane(), Pi(), PiInWirePlane(), pma::SortedObjectBase::Prev(), pma::SortedObjectBase::RemoveNext(), pma::SortedBranchBase::RemoveNext(), SegmentCos(), SegmentCosTransverse(), SegmentCosWirePlane(), pma::Segment3D::SetProjection(), SetProjection(), and pma::Segment3D::SumDist2Hits().

---

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

• larreco/v06_64_02/source/larreco/RecoAlg/PMAlg/PmaNode3D.h
• larreco/v06_64_02/source/larreco/RecoAlg/PMAlg/PmaNode3D.cxx