#include <TracksCrossingGapsTool.h>

Inheritance diagram for lar_content::TracksCrossingGapsTool:

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

Additional Inherited Members
Public Types inherited from lar_content::TransverseTensorTool
typedef ThreeViewTransverseTracksAlgorithm::MatchingType::TensorType	TensorType

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

Detailed Description

TracksCrossingGapsTool class.

Definition at line 20 of file TracksCrossingGapsTool.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.

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

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

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

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

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

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

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

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

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

float lar_content::TracksCrossingGapsTool::m_maxGapTolerance

private

The max gap tolerance.

Definition at line 125 of file TracksCrossingGapsTool.h.

float lar_content::TracksCrossingGapsTool::m_minMatchedFraction

private

The min matched sampling point fraction for particle creation.

Definition at line 121 of file TracksCrossingGapsTool.h.

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.

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.

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.

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.

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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation