#include "TracksCrossingGapsTool.h"

Inheritance diagram for lar_content::TracksCrossingGapsTool:

Public Types
typedef ThreeViewTransverseTracksAlgorithm::MatchingType::TensorType	TensorType

typedef std::vector< TensorType::ElementList::const_iterator >	IteratorList

Public Member Functions
	TracksCrossingGapsTool ()
	Default constructor. More...

bool	Run (ThreeViewTransverseTracksAlgorithm *const pAlgorithm, TensorType &overlapTensor)
	Run the algorithm tool. More...

Private Member Functions
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

void	FindTracks (ThreeViewTransverseTracksAlgorithm *const pAlgorithm, const TensorType &overlapTensor, ProtoParticleVector &protoParticleVector) const
	Find tracks crossing gaps, with unambiguous connection but poor overlap due to gaps. More...

void	SelectElements (ThreeViewTransverseTracksAlgorithm *const pAlgorithm, const TensorType::ElementList &elementList, const pandora::ClusterSet &usedClusters, IteratorList &iteratorList) const
	Select a list of track-like elements crossing a gap in one or more views from a set of connected tensor elements. More...

void	CalculateEffectiveOverlapFractions (ThreeViewTransverseTracksAlgorithm *const pAlgorithm, const TensorType::Element &element, float &xOverlapFractionU, float &xOverlapFractionV, float &xOverlapFractionW) const
	Calculate the effective overlap fractions given a set of clusters, taking gaps into account. More...

void	CalculateEffectiveOverlapSpan (ThreeViewTransverseTracksAlgorithm *const pAlgorithm, const TensorType::Element &element, float &xMinEffU, float &xMaxEffU, float &xMinEffV, float &xMaxEffV, float &xMinEffW, float &xMaxEffW) const
	Calculate the effective overlap span given a set of clusters, taking gaps into account. More...

bool	PassesGapChecks (ThreeViewTransverseTracksAlgorithm *const pAlgorithm, const TensorType::Element &element, const float xSample, bool &gapInU, bool &gapInV, bool &gapInW) const
	Check whether there is any gap in the three U-V-W clusters combination. More...

bool	CheckXPositionInGap (const float xSample, const TwoDSlidingFitResult &slidingFitResult1, const TwoDSlidingFitResult &slidingFitResult2, const TwoDSlidingFitResult &slidingFitResult3, bool &gapIn1, bool &gapIn2, bool &gapIn3) const
	Check individually each cluster where a gap might be present. More...

bool	IsEndOfCluster (const float xSample, const TwoDSlidingFitResult &slidingFitResult) const
	Check whether a x position is at the end of the cluster. More...

Private Attributes
float	m_minMatchedFraction
	The min matched sampling point fraction for particle creation. More...

unsigned int	m_minMatchedSamplingPoints
	The min number of matched sampling points for particle creation. More...

float	m_minXOverlapFraction
	The min x overlap fraction (in each view) for particle creation. More...

unsigned int	m_minMatchedSamplingPointRatio
	The min ratio between 1st and 2nd highest msps for simple ambiguity resolution. More...

float	m_maxGapTolerance
	The max gap tolerance. More...

float	m_sampleStepSize
	The sampling step size used in association checks, units cm. More...

unsigned int	m_maxAngleRatio
	The max ratio allowed in the angle. More...

Detailed Description

TracksCrossingGapsTool class.

Definition at line 20 of file TracksCrossingGapsTool.h.

Member Typedef Documentation

typedef std::vector<TensorType::ElementList::const_iterator> lar_content::TransverseTensorTool::IteratorList

inherited

Definition at line 131 of file ThreeViewTransverseTracksAlgorithm.h.

typedef ThreeViewTransverseTracksAlgorithm::MatchingType::TensorType lar_content::TransverseTensorTool::TensorType

inherited

Definition at line 130 of file ThreeViewTransverseTracksAlgorithm.h.

Constructor & Destructor Documentation

lar_content::TracksCrossingGapsTool::TracksCrossingGapsTool ( )

Default constructor.

Definition at line 22 of file TracksCrossingGapsTool.cc.

                                                :
     m_minMatchedFraction(0.5f),
     m_minMatchedSamplingPoints(10),
     m_minXOverlapFraction(0.9f),
     m_minMatchedSamplingPointRatio(2),
     m_maxGapTolerance(2.f),
     m_sampleStepSize(0.5f),
     m_maxAngleRatio(2)
 {
 }

Member Function Documentation

void lar_content::TracksCrossingGapsTool::CalculateEffectiveOverlapFractions	(	ThreeViewTransverseTracksAlgorithm *const	pAlgorithm,
		const TensorType::Element &	element,
		float &	xOverlapFractionU,
		float &	xOverlapFractionV,
		float &	xOverlapFractionW
	)		const

private

Calculate the effective overlap fractions given a set of clusters, taking gaps into account.

Parameters

pAlgorithm	address of the calling algorithm
element	the connected tensor element
xOverlapFractionU	to receive the effective overlap fraction in the u view
xOverlapFractionV	to receive the effective overlap fraction in the v view
xOverlapFractionW	to receive the effective overlap fraction in the w view

Definition at line 129 of file TracksCrossingGapsTool.cc.

References CalculateEffectiveOverlapSpan(), and f.

Referenced by SelectElements().

 {
     float xMinEffU(element.GetOverlapResult().GetXOverlap().GetUMinX()), xMaxEffU(element.GetOverlapResult().GetXOverlap().GetUMaxX());
     float xMinEffV(element.GetOverlapResult().GetXOverlap().GetVMinX()), xMaxEffV(element.GetOverlapResult().GetXOverlap().GetVMaxX());
     float xMinEffW(element.GetOverlapResult().GetXOverlap().GetWMinX()), xMaxEffW(element.GetOverlapResult().GetXOverlap().GetWMaxX());
     this->CalculateEffectiveOverlapSpan(pAlgorithm, element, xMinEffU, xMaxEffU, xMinEffV, xMaxEffV, xMinEffW, xMaxEffW);
 
     const float effectiveXSpanU(xMaxEffU - xMinEffU), effectiveXSpanV(xMaxEffV - xMinEffV), effectiveXSpanW(xMaxEffW - xMinEffW);
     const float minCommonX(std::max(xMinEffU, std::max(xMinEffV, xMinEffW)));
     const float maxCommonX(std::min(xMaxEffU, std::min(xMaxEffV, xMaxEffW)));
     const float effectiveXOverlapSpan(maxCommonX - minCommonX);
 
     // TODO check that this shouldn't be greater than 1 any more
     xOverlapFractionU = effectiveXSpanU > 0.f ? std::min(1.f, (effectiveXOverlapSpan / effectiveXSpanU)) : 0.f;
     xOverlapFractionV = effectiveXSpanV > 0.f ? std::min(1.f, (effectiveXOverlapSpan / effectiveXSpanV)) : 0.f;
     xOverlapFractionW = effectiveXSpanW > 0.f ? std::min(1.f, (effectiveXOverlapSpan / effectiveXSpanW)) : 0.f;
 }

void lar_content::TracksCrossingGapsTool::CalculateEffectiveOverlapSpan	(	ThreeViewTransverseTracksAlgorithm *const	pAlgorithm,
		const TensorType::Element &	element,
		float &	xMinEffU,
		float &	xMaxEffU,
		float &	xMinEffV,
		float &	xMaxEffV,
		float &	xMinEffW,
		float &	xMaxEffW
	)		const

private

Calculate the effective overlap span given a set of clusters, taking gaps into account.

Parameters

pAlgorithm	address of the calling algorithm
element	the connected tensor element
xMinEffU	to receive the effective min u coordinate
xMaxEffU	to receive the effective max u coordinate
xMinEffV	to receive the effective min v coordinate
xMaxEffV	to receive the effective max v coordinate
xMinEffW	to receive the effective min w coordinate
xMaxEffW	to receive the effective max w coordinate

Definition at line 150 of file TracksCrossingGapsTool.cc.

References f, m_sampleStepSize, and PassesGapChecks().

Referenced by CalculateEffectiveOverlapFractions().

 {
     const float xMinAll(std::min(xMinEffU, std::min(xMinEffV, xMinEffW)));
     const float xMaxAll(std::max(xMaxEffU, std::max(xMaxEffV, xMaxEffW)));
     const float minCommonX(std::max(xMinEffU, std::max(xMinEffV, xMinEffW)));
     const float maxCommonX(std::min(xMaxEffU, std::min(xMaxEffV, xMaxEffW)));
 
     float dxUmin(0.f), dxVmin(0.f), dxWmin(0.f);
     float dxUmax(0.f), dxVmax(0.f), dxWmax(0.f);
 
     // ATTN break out of loops to to avoid finding a non-related gap far from  cluster itself
     const int nSamplingPointsLeft(1 + static_cast<int>((minCommonX - xMinAll) / m_sampleStepSize));
     const int nSamplingPointsRight(1 + static_cast<int>((xMaxAll - maxCommonX) / m_sampleStepSize));
 
     for (int iSample = 1; iSample <= nSamplingPointsLeft; ++iSample)
     {
         bool gapInU(false), gapInV(false), gapInW(false);
         const float xSample(std::max(xMinAll, minCommonX - static_cast<float>(iSample) * m_sampleStepSize));
 
         if (!this->PassesGapChecks(pAlgorithm, element, xSample, gapInU, gapInV, gapInW))
             break;
 
         if (gapInU)
             dxUmin = xMinEffU - xSample;
         if (gapInV)
             dxVmin = xMinEffV - xSample;
         if (gapInW)
             dxWmin = xMinEffW - xSample;
     }
 
     for (int iSample = 1; iSample <= nSamplingPointsRight; ++iSample)
     {
         bool gapInU(false), gapInV(false), gapInW(false);
         const float xSample(std::min(xMaxAll, maxCommonX + static_cast<float>(iSample) * m_sampleStepSize));
 
         if (!this->PassesGapChecks(pAlgorithm, element, xSample, gapInU, gapInV, gapInW))
             break;
 
         if (gapInU)
             dxUmax = xSample - xMaxEffU;
         if (gapInV)
             dxVmax = xSample - xMaxEffV;
         if (gapInW)
             dxWmax = xSample - xMaxEffW;
     }
 
     xMinEffU -= dxUmin;
     xMaxEffU += dxUmax;
     xMinEffV -= dxVmin;
     xMaxEffV += dxVmax;
     xMinEffW -= dxWmin;
     xMaxEffW += dxWmax;
 }

bool lar_content::TracksCrossingGapsTool::CheckXPositionInGap	(	const float	xSample,
		const TwoDSlidingFitResult &	slidingFitResult1,
		const TwoDSlidingFitResult &	slidingFitResult2,
		const TwoDSlidingFitResult &	slidingFitResult3,
		bool &	gapIn1,
		bool &	gapIn2,
		bool &	gapIn3
	)		const

private

Check individually each cluster where a gap might be present.

Parameters

xSample,the	x coordinate we are checking
slidingFitResult1	the sliding fit result for the cluster in view 1
slidingFitResult2	the sliding fit result for the cluster in view 2
slidingFitResult3	the sliding fit result for the cluster in view 3
gapIn1	whether there is a gap in view 1
gapIn2	whether there is a gap in view 2
gapIn3	whether there is a gap in view 3

Returns: boolean

Definition at line 244 of file TracksCrossingGapsTool.cc.

References f, lar_content::TwoDSlidingFitResult::GetCluster(), lar_content::LArClusterHelper::GetClusterHitType(), lar_content::TwoDSlidingFitResult::GetGlobalFitPositionAtX(), IsEndOfCluster(), lar_content::LArGeometryHelper::IsInGap(), lar_content::LArGeometryHelper::IsXSamplingPointInGap(), m_maxGapTolerance, m_sampleStepSize, and lar_content::LArGeometryHelper::MergeTwoPositions().

Referenced by PassesGapChecks().

 {
     CartesianVector fitPosition2(0.f, 0.f, 0.f), fitPosition3(0.f, 0.f, 0.f);
 
     // If we have the global position at X from the two other clusters, calculate projection in the first view and check for gaps
     if ((STATUS_CODE_SUCCESS == slidingFitResult2.GetGlobalFitPositionAtX(xSample, fitPosition2)) &&
         (STATUS_CODE_SUCCESS == slidingFitResult3.GetGlobalFitPositionAtX(xSample, fitPosition3)))
     {
         const HitType hitType1(LArClusterHelper::GetClusterHitType(slidingFitResult1.GetCluster()));
         const HitType hitType2(LArClusterHelper::GetClusterHitType(slidingFitResult2.GetCluster()));
         const HitType hitType3(LArClusterHelper::GetClusterHitType(slidingFitResult3.GetCluster()));
 
         const float zSample(LArGeometryHelper::MergeTwoPositions(this->GetPandora(), hitType2, hitType3, fitPosition2.GetZ(), fitPosition3.GetZ()));
         const CartesianVector samplingPoint(xSample, 0.f, zSample);
         return LArGeometryHelper::IsInGap(this->GetPandora(), CartesianVector(xSample, 0.f, zSample), hitType1, m_maxGapTolerance);
     }
 
     // ATTN Only safe to return here (for efficiency) because gapIn2 and gapIn3 values aren't used by calling function if we return false
     gapIn1 = LArGeometryHelper::IsXSamplingPointInGap(this->GetPandora(), xSample, slidingFitResult1, m_sampleStepSize);
 
     if (!gapIn1)
         return false;
 
     // If we dont have a projection at x in the other two clusters, check if they are in gaps or at the end of the cluster
     if ((STATUS_CODE_SUCCESS != slidingFitResult2.GetGlobalFitPositionAtX(xSample, fitPosition2)) &&
         (STATUS_CODE_SUCCESS != slidingFitResult3.GetGlobalFitPositionAtX(xSample, fitPosition3)))
     {
         const bool endIn2(this->IsEndOfCluster(xSample, slidingFitResult2));
         const bool endIn3(this->IsEndOfCluster(xSample, slidingFitResult3));
 
         if (!endIn2)
             gapIn2 = LArGeometryHelper::IsXSamplingPointInGap(this->GetPandora(), xSample, slidingFitResult2, m_sampleStepSize);
 
         if (!endIn3)
             gapIn3 = LArGeometryHelper::IsXSamplingPointInGap(this->GetPandora(), xSample, slidingFitResult3, m_sampleStepSize);
 
         return ((gapIn2 && endIn3) || (gapIn3 && endIn2) || (endIn2 && endIn3));
     }
 
     // Finally, check whether there is a second gap involved
     if (STATUS_CODE_SUCCESS != slidingFitResult2.GetGlobalFitPositionAtX(xSample, fitPosition2))
     {
         gapIn2 = LArGeometryHelper::IsXSamplingPointInGap(this->GetPandora(), xSample, slidingFitResult2, m_sampleStepSize);
         return (gapIn2 || this->IsEndOfCluster(xSample, slidingFitResult2));
     }
     else
     {
         gapIn3 = LArGeometryHelper::IsXSamplingPointInGap(this->GetPandora(), xSample, slidingFitResult3, m_sampleStepSize);
         return (gapIn3 || this->IsEndOfCluster(xSample, slidingFitResult3));
     }
 }

void lar_content::TracksCrossingGapsTool::FindTracks	(	ThreeViewTransverseTracksAlgorithm *const	pAlgorithm,
		const TensorType &	overlapTensor,
		ProtoParticleVector &	protoParticleVector
	)		const

private

Find tracks crossing gaps, with unambiguous connection but poor overlap due to gaps.

Parameters

pAlgorithm	address of the calling algorithm
overlapTensor	the overlap tensor
protoParticleVector	to receive the list of proto particles

Definition at line 52 of file TracksCrossingGapsTool.cc.

References lar_content::OverlapTensor< T >::GetConnectedElements(), lar_content::OverlapTensor< T >::GetSortedKeyClusters(), lar_content::LongTracksTool::HasLongDirectConnections(), lar_content::LongTracksTool::IsLongerThanDirectConnections(), lar_content::ProtoParticle::m_clusterList, m_minMatchedSamplingPointRatio, and SelectElements().

Referenced by Run().

 {
     ClusterSet usedClusters;
     ClusterVector sortedKeyClusters;
     overlapTensor.GetSortedKeyClusters(sortedKeyClusters);
 
     for (const Cluster *const pKeyCluster : sortedKeyClusters)
     {
         if (!pKeyCluster->IsAvailable())
             continue;
 
         unsigned int nU(0), nV(0), nW(0);
         TensorType::ElementList elementList;
         overlapTensor.GetConnectedElements(pKeyCluster, true, elementList, nU, nV, nW);
 
         IteratorList iteratorList;
         this->SelectElements(pAlgorithm, elementList, usedClusters, iteratorList);
 
         // Check that elements are not directly connected and are significantly longer than any other directly connected elements
         for (IteratorList::const_iterator iIter = iteratorList.begin(), iIterEnd = iteratorList.end(); iIter != iIterEnd; ++iIter)
         {
             if (LongTracksTool::HasLongDirectConnections(iIter, iteratorList))
                 continue;
 
             if (!LongTracksTool::IsLongerThanDirectConnections(iIter, elementList, m_minMatchedSamplingPointRatio, usedClusters))
                 continue;
 
             ProtoParticle protoParticle;
             protoParticle.m_clusterList.push_back((*iIter)->GetClusterU());
             protoParticle.m_clusterList.push_back((*iIter)->GetClusterV());
             protoParticle.m_clusterList.push_back((*iIter)->GetClusterW());
             protoParticleVector.push_back(protoParticle);
 
             usedClusters.insert((*iIter)->GetClusterU());
             usedClusters.insert((*iIter)->GetClusterV());
             usedClusters.insert((*iIter)->GetClusterW());
         }
     }
 }

bool lar_content::TracksCrossingGapsTool::IsEndOfCluster	(	const float	xSample,
		const TwoDSlidingFitResult &	slidingFitResult
	)		const

private

Check whether a x position is at the end of the cluster.

Parameters

xSample,the	x coordinate of the point tested
pCluster	the cluster we are interrogating for its extreme coordinates

Returns: boolean

Definition at line 299 of file TracksCrossingGapsTool.cc.

References lar_content::TwoDSlidingFitResult::GetGlobalMaxLayerPosition(), lar_content::TwoDSlidingFitResult::GetGlobalMinLayerPosition(), and lar_content::TwoDSlidingFitResult::GetLayerPitch().

Referenced by CheckXPositionInGap(), and PassesGapChecks().

 {
     return ((std::fabs(slidingFitResult.GetGlobalMinLayerPosition().GetX() - xSample) < slidingFitResult.GetLayerPitch()) ||
         (std::fabs(slidingFitResult.GetGlobalMaxLayerPosition().GetX() - xSample) < slidingFitResult.GetLayerPitch()));
 }

bool lar_content::TracksCrossingGapsTool::PassesGapChecks	(	ThreeViewTransverseTracksAlgorithm *const	pAlgorithm,
		const TensorType::Element &	element,
		const float	xSample,
		bool &	gapInU,
		bool &	gapInV,
		bool &	gapInW
	)		const

private

Check whether there is any gap in the three U-V-W clusters combination.

Parameters

pAlgorithm	address of the calling algorithm
element	the connected tensor element
xSample	the x sampling position
gapInU	to receive whether there is a gap in the u view
gapInV	to receive whether there is a gap in the v view
gapInW	to receive whether there is a gap in the w view

Returns: boolean

Definition at line 207 of file TracksCrossingGapsTool.cc.

References CheckXPositionInGap(), f, lar_content::NViewTrackMatchingAlgorithm< T >::GetCachedSlidingFitResult(), lar_content::TwoDSlidingFitResult::GetGlobalFitPositionAtX(), and IsEndOfCluster().

Referenced by CalculateEffectiveOverlapSpan().

 {
     const TwoDSlidingFitResult &slidingFitResultU(pAlgorithm->GetCachedSlidingFitResult(element.GetClusterU()));
     const TwoDSlidingFitResult &slidingFitResultV(pAlgorithm->GetCachedSlidingFitResult(element.GetClusterV()));
     const TwoDSlidingFitResult &slidingFitResultW(pAlgorithm->GetCachedSlidingFitResult(element.GetClusterW()));
 
     // If we have access to the global x position in all three clusters, there are no gaps involved (or cluster already spans small gaps)
     CartesianVector fitUPosition(0.f, 0.f, 0.f), fitVPosition(0.f, 0.f, 0.f), fitWPosition(0.f, 0.f, 0.f);
     const StatusCode statusCodeU(slidingFitResultU.GetGlobalFitPositionAtX(xSample, fitUPosition));
     const StatusCode statusCodeV(slidingFitResultV.GetGlobalFitPositionAtX(xSample, fitVPosition));
     const StatusCode statusCodeW(slidingFitResultW.GetGlobalFitPositionAtX(xSample, fitWPosition));
 
     if ((STATUS_CODE_SUCCESS == statusCodeU) && (STATUS_CODE_SUCCESS == statusCodeV) && (STATUS_CODE_SUCCESS == statusCodeW))
         return false;
 
     try
     {
         // Note: argument order important - initially assume first view has a gap, but inside CheckXPositionInGap do check other two views
         if ((STATUS_CODE_SUCCESS != statusCodeU) && (!this->IsEndOfCluster(xSample, slidingFitResultU)))
             return this->CheckXPositionInGap(xSample, slidingFitResultU, slidingFitResultV, slidingFitResultW, gapInU, gapInV, gapInW);
 
         if ((STATUS_CODE_SUCCESS != statusCodeV) && (!this->IsEndOfCluster(xSample, slidingFitResultV)))
             return this->CheckXPositionInGap(xSample, slidingFitResultV, slidingFitResultU, slidingFitResultW, gapInV, gapInU, gapInW);
 
         if ((STATUS_CODE_SUCCESS != statusCodeW) && (!this->IsEndOfCluster(xSample, slidingFitResultW)))
             return this->CheckXPositionInGap(xSample, slidingFitResultW, slidingFitResultU, slidingFitResultV, gapInW, gapInU, gapInV);
     }
     catch (const StatusCodeException &statusCodeException)
     {
     }
 
     return false;
 }

StatusCode lar_content::TracksCrossingGapsTool::ReadSettings ( const pandora::TiXmlHandle xmlHandle )

private

Definition at line 307 of file TracksCrossingGapsTool.cc.

References m_maxAngleRatio, m_maxGapTolerance, m_minMatchedFraction, m_minMatchedSamplingPointRatio, m_minMatchedSamplingPoints, m_minXOverlapFraction, and m_sampleStepSize.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinMatchedFraction", m_minMatchedFraction));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MinMatchedSamplingPoints", m_minMatchedSamplingPoints));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinXOverlapFraction", m_minXOverlapFraction));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MinMatchedSamplingPointRatio", m_minMatchedSamplingPointRatio));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxGapTolerance", m_maxGapTolerance));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SampleStepSize", m_sampleStepSize));
 
     if (m_sampleStepSize < std::numeric_limits<float>::epsilon())
     {
         std::cout << "TracksCrossingGapsTool: Invalid value for SampleStepSize " << m_sampleStepSize << std::endl;
         throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
     }
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxAngleRatio", m_maxAngleRatio));
 
     return STATUS_CODE_SUCCESS;
 }

bool lar_content::TracksCrossingGapsTool::Run	(	ThreeViewTransverseTracksAlgorithm *const	pAlgorithm,
		TensorType &	overlapTensor
	)

virtual

Run the algorithm tool.

Parameters

pAlgorithm	address of the calling algorithm
overlapTensor	the overlap tensor

Returns: whether changes have been made by the tool

Implements lar_content::TransverseTensorTool.

Definition at line 35 of file TracksCrossingGapsTool.cc.

References lar_content::MatchingBaseAlgorithm::CreateThreeDParticles(), and FindTracks().

 {
     if (PandoraContentApi::GetSettings(*pAlgorithm)->ShouldDisplayAlgorithmInfo())
         std::cout << "----> Running Algorithm Tool: " << this->GetInstanceName() << ", " << this->GetType() << std::endl;
 
     if (PandoraContentApi::GetGeometry(*pAlgorithm)->GetDetectorGapList().empty())
         return false;
 
     ProtoParticleVector protoParticleVector;
     this->FindTracks(pAlgorithm, overlapTensor, protoParticleVector);
 
     const bool particlesMade(pAlgorithm->CreateThreeDParticles(protoParticleVector));
     return particlesMade;
 }

void lar_content::TracksCrossingGapsTool::SelectElements	(	ThreeViewTransverseTracksAlgorithm *const	pAlgorithm,
		const TensorType::ElementList &	elementList,
		const pandora::ClusterSet &	usedClusters,
		IteratorList &	iteratorList
	)		const

private

Select a list of track-like elements crossing a gap in one or more views from a set of connected tensor elements.

Parameters

pAlgorithm	address of the calling algorithm
elementList	the full list of connected tensor elements
usedClusters	the set of clusters already marked as to be added to a pfo
iteratorList	to receive a list of iterators to long track-like elements

Definition at line 95 of file TracksCrossingGapsTool.cc.

References CalculateEffectiveOverlapFractions(), f, m_minMatchedFraction, m_minMatchedSamplingPoints, and m_minXOverlapFraction.

Referenced by FindTracks().

 {
     for (TensorType::ElementList::const_iterator eIter = elementList.begin(); eIter != elementList.end(); ++eIter)
     {
         if (usedClusters.count(eIter->GetClusterU()) || usedClusters.count(eIter->GetClusterV()) || usedClusters.count(eIter->GetClusterW()))
             continue;
 
         if (eIter->GetOverlapResult().GetMatchedFraction() < m_minMatchedFraction)
             continue;
 
         if (eIter->GetOverlapResult().GetNMatchedSamplingPoints() < m_minMatchedSamplingPoints)
             continue;
 
         const XOverlap &xOverlap(eIter->GetOverlapResult().GetXOverlap());
 
         if (xOverlap.GetXOverlapSpan() < std::numeric_limits<float>::epsilon())
             continue;
 
         // Calculate effective overlap fraction, including the information about gaps
         float xOverlapFractionU(0.f), xOverlapFractionV(0.f), xOverlapFractionW(0.f);
         this->CalculateEffectiveOverlapFractions(pAlgorithm, *eIter, xOverlapFractionU, xOverlapFractionV, xOverlapFractionW);
 
         if ((xOverlap.GetXSpanU() > std::numeric_limits<float>::epsilon()) && (xOverlapFractionU > m_minXOverlapFraction) &&
             (xOverlap.GetXSpanV() > std::numeric_limits<float>::epsilon()) && (xOverlapFractionV > m_minXOverlapFraction) &&
             (xOverlap.GetXSpanW() > std::numeric_limits<float>::epsilon()) && (xOverlapFractionW > m_minXOverlapFraction))
         {
             iteratorList.push_back(eIter);
         }
     }
 }

Member Data Documentation

unsigned int lar_content::TracksCrossingGapsTool::m_maxAngleRatio

private

The max ratio allowed in the angle.

Definition at line 127 of file TracksCrossingGapsTool.h.

Referenced by ReadSettings().

float lar_content::TracksCrossingGapsTool::m_maxGapTolerance

private

The max gap tolerance.

Definition at line 125 of file TracksCrossingGapsTool.h.

Referenced by CheckXPositionInGap(), and ReadSettings().

float lar_content::TracksCrossingGapsTool::m_minMatchedFraction

private

The min matched sampling point fraction for particle creation.

Definition at line 121 of file TracksCrossingGapsTool.h.

Referenced by ReadSettings(), and SelectElements().

unsigned int lar_content::TracksCrossingGapsTool::m_minMatchedSamplingPointRatio

private

The min ratio between 1st and 2nd highest msps for simple ambiguity resolution.

Definition at line 124 of file TracksCrossingGapsTool.h.

Referenced by FindTracks(), and ReadSettings().

unsigned int lar_content::TracksCrossingGapsTool::m_minMatchedSamplingPoints

private

The min number of matched sampling points for particle creation.

Definition at line 122 of file TracksCrossingGapsTool.h.

Referenced by ReadSettings(), and SelectElements().

float lar_content::TracksCrossingGapsTool::m_minXOverlapFraction

private

The min x overlap fraction (in each view) for particle creation.

Definition at line 123 of file TracksCrossingGapsTool.h.

Referenced by ReadSettings(), and SelectElements().

float lar_content::TracksCrossingGapsTool::m_sampleStepSize

private

The sampling step size used in association checks, units cm.

Definition at line 126 of file TracksCrossingGapsTool.h.

Referenced by CalculateEffectiveOverlapSpan(), CheckXPositionInGap(), and ReadSettings().

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

larpandoracontent/v04_08_01/source/larpandoracontent/LArThreeDReco/LArTransverseTrackMatching/TracksCrossingGapsTool.h
larpandoracontent/v04_08_01/source/larpandoracontent/LArThreeDReco/LArTransverseTrackMatching/TracksCrossingGapsTool.cc

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation