lar_content::UndershootTracksTool Class Reference

UndershootTracksTool class. More...

#include <UndershootTracksTool.h>

Inheritance diagram for lar_content::UndershootTracksTool:

Classes
class	Particle
	Particle class. More...

Public Member Functions
	UndershootTracksTool ()
	Default constructor. More...
Public Member Functions inherited from lar_content::ThreeDKinkBaseTool
	ThreeDKinkBaseTool (const unsigned int nCommonClusters)
	Constructor. More...
virtual	~ThreeDKinkBaseTool ()
	Destructor. More...
bool	Run (ThreeViewTransverseTracksAlgorithm *const pAlgorithm, TensorType &overlapTensor)
	Run the algorithm tool. More...

Private Member Functions
void	GetIteratorListModifications (ThreeViewTransverseTracksAlgorithm *const pAlgorithm, const IteratorList &iteratorList, ModificationList &modificationList) const
	Get modification objects for a specific elements of the tensor, identifying required splits and merges for clusters. More...
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)
bool	IsThreeDKink (ThreeViewTransverseTracksAlgorithm *const pAlgorithm, const Particle &particle, const pandora::CartesianVector &splitPosition, const bool isALowestInX) const
	Whether the provided particle is consistent with being a kink, when examined in three dimensions at the provided split position. More...

Private Attributes
bool	m_splitMode
	Whether to run in cluster splitting mode, as opposed to cluster merging mode. More...
float	m_maxTransverseImpactParameter
	The maximum transverse impact parameter for connecting broken clusters. More...
float	m_minImpactParameterCosTheta
	The minimum cos theta (angle between vertex directions) for connecting broken clusters. More...
float	m_cosThetaCutForKinkSearch
	The cos theta cut used for the kink search in three dimensions. More...

Additional Inherited Members
Public Types inherited from lar_content::TransverseTensorTool
typedef ThreeViewTransverseTracksAlgorithm::MatchingType::TensorType	TensorType
typedef std::vector < TensorType::ElementList::const_iterator >	IteratorList
Protected Types inherited from lar_content::ThreeDKinkBaseTool
typedef std::vector< Modification >	ModificationList
Protected Member Functions inherited from lar_content::ThreeDKinkBaseTool
virtual bool	PassesElementCuts (TensorType::ElementList::const_iterator eIter, const pandora::ClusterSet &usedClusters) const
	Whether a provided (iterator to a) tensor element passes the selection cuts for overshoot identification. More...
float	GetXSamplingPoint (const pandora::CartesianVector &splitPosition1, const bool isForwardInX, const TwoDSlidingFitResult &fitResult1, const TwoDSlidingFitResult &fitResult2, const TwoDSlidingFitResult &fitResult3) const
	Get a sampling point in x that is common to sliding linear fit objects in three views. More...
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)
Static Protected Member Functions inherited from lar_content::ThreeDKinkBaseTool
static bool	IsALowestInX (const LArPointingCluster &pointingClusterA, const LArPointingCluster &pointingClusterB)
	Whether pointing cluster labelled A extends to lowest x positions (as opposed to that labelled B) More...
Protected Attributes inherited from lar_content::ThreeDKinkBaseTool
unsigned int	m_nCommonClusters
	The number of common clusters. More...
bool	m_majorityRulesMode
	Whether to run in majority rules mode (always split overshoots, always merge undershoots) More...
float	m_minMatchedFraction
	The min matched sampling point fraction for use as a key tensor element. More...
unsigned int	m_minMatchedSamplingPoints
	The min number of matched sampling points for use as a key tensor element. More...
float	m_minLongitudinalImpactParameter
	The min longitudinal impact parameter for connecting accompanying clusters. More...
int	m_nLayersForKinkSearch
	The number of sliding fit layers to step in the kink search. More...
float	m_additionalXStepForKinkSearch
	An additional (safety) step to tack-on when choosing x sampling points. More...

Detailed Description

UndershootTracksTool class.

Definition at line 19 of file UndershootTracksTool.h.

Constructor & Destructor Documentation

lar_content::UndershootTracksTool::UndershootTracksTool

(

)

Default constructor.

Definition at line 24 of file UndershootTracksTool.cc.

                                           :
    ThreeDKinkBaseTool(2),
    m_splitMode(false),
    m_maxTransverseImpactParameter(5.f),
    m_minImpactParameterCosTheta(0.5f),
    m_cosThetaCutForKinkSearch(0.75f)
{
}

Member Function Documentation

void lar_content::UndershootTracksTool::GetIteratorListModifications ( ThreeViewTransverseTracksAlgorithm *const  pAlgorithm, const IteratorList &  iteratorList, ModificationList &  modificationList  ) const

privatevirtual

Get modification objects for a specific elements of the tensor, identifying required splits and merges for clusters.

Parameters

pAlgorithm	address of the calling algorithm
iteratorList	list of iterators to relevant tensor elements
modificationList	to be populated with modifications

Implements lar_content::ThreeDKinkBaseTool.

Definition at line 35 of file UndershootTracksTool.cc.

{
    for (IteratorList::const_iterator iIter1 = iteratorList.begin(), iIter1End = iteratorList.end(); iIter1 != iIter1End; ++iIter1)
    {
        for (IteratorList::const_iterator iIter2 = iIter1; iIter2 != iIter1End; ++iIter2)
        {
            if (iIter1 == iIter2)
                continue;

            try
            {
                const unsigned int nMatchedSamplingPoints1((*iIter1)->GetOverlapResult().GetNMatchedSamplingPoints());
                const unsigned int nMatchedSamplingPoints2((*iIter2)->GetOverlapResult().GetNMatchedSamplingPoints());
                IteratorList::const_iterator iIterA((nMatchedSamplingPoints1 >= nMatchedSamplingPoints2) ? iIter1 : iIter2);
                IteratorList::const_iterator iIterB((nMatchedSamplingPoints1 >= nMatchedSamplingPoints2) ? iIter2 : iIter1);

                Particle particle(*(*iIterA), *(*iIterB));
                const LArPointingCluster pointingClusterA(pAlgorithm->GetCachedSlidingFitResult(particle.m_pClusterA));
                const LArPointingCluster pointingClusterB(pAlgorithm->GetCachedSlidingFitResult(particle.m_pClusterB));

                LArPointingCluster::Vertex vertexA, vertexB;
                LArPointingClusterHelper::GetClosestVertices(pointingClusterA, pointingClusterB, vertexA, vertexB);

                float transverseAB(std::numeric_limits<float>::max()), transverseBA(std::numeric_limits<float>::max());
                float longitudinalAB(-std::numeric_limits<float>::max()), longitudinalBA(-std::numeric_limits<float>::max());

                LArPointingClusterHelper::GetImpactParameters(vertexA, vertexB, longitudinalAB, transverseAB);
                LArPointingClusterHelper::GetImpactParameters(vertexB, vertexA, longitudinalBA, transverseBA);

                if (std::min(longitudinalAB, longitudinalBA) < m_minLongitudinalImpactParameter)
                    continue;

                if (std::min(transverseAB, transverseBA) > m_maxTransverseImpactParameter)
                    continue;

                const float cosTheta(-vertexA.GetDirection().GetCosOpeningAngle(vertexB.GetDirection()));

                if (cosTheta < m_minImpactParameterCosTheta)
                    continue;

                const bool isALowestInX(this->IsALowestInX(pointingClusterA, pointingClusterB));
                const CartesianVector splitPosition((vertexA.GetPosition() + vertexB.GetPosition()) * 0.5f);
                const bool isThreeDKink(m_majorityRulesMode ? false : this->IsThreeDKink(pAlgorithm, particle, splitPosition, isALowestInX));

                if (isThreeDKink != m_splitMode)
                    continue;

                // Construct the modification object
                Modification modification;

                if (m_splitMode)
                {
                    const TwoDSlidingFitResult &fitResult1(pAlgorithm->GetCachedSlidingFitResult(particle.m_pCommonCluster1));
                    const TwoDSlidingFitResult &fitResult2(pAlgorithm->GetCachedSlidingFitResult(particle.m_pCommonCluster2));

                    CartesianVector splitPosition1(0.f, 0.f, 0.f), splitPosition2(0.f, 0.f, 0.f);
                    if ((STATUS_CODE_SUCCESS != fitResult1.GetGlobalFitPositionAtX(splitPosition.GetX(), splitPosition1)) ||
                        (STATUS_CODE_SUCCESS != fitResult2.GetGlobalFitPositionAtX(splitPosition.GetX(), splitPosition2)))
                    {
                        continue;
                    }

                    modification.m_splitPositionMap[particle.m_pCommonCluster1].push_back(splitPosition1);
                    modification.m_splitPositionMap[particle.m_pCommonCluster2].push_back(splitPosition2);
                }
                else
                {
                    const bool vertexAIsLowX(vertexA.GetPosition().GetX() < vertexB.GetPosition().GetX());
                    const Cluster *const pLowXCluster(vertexAIsLowX ? particle.m_pClusterA : particle.m_pClusterB);
                    const Cluster *const pHighXCluster(vertexAIsLowX ? particle.m_pClusterB : particle.m_pClusterA);
                    modification.m_clusterMergeMap[pLowXCluster].push_back(pHighXCluster);
                }

                modification.m_affectedClusters.push_back(particle.m_pClusterA);
                modification.m_affectedClusters.push_back(particle.m_pClusterB);
                modification.m_affectedClusters.push_back(particle.m_pCommonCluster1);
                modification.m_affectedClusters.push_back(particle.m_pCommonCluster2);

                modificationList.push_back(modification);
            }
            catch (StatusCodeException &statusCodeException)
            {
                if (STATUS_CODE_FAILURE == statusCodeException.GetStatusCode())
                    throw statusCodeException;

                continue;
            }
        }
    }
}

bool lar_content::UndershootTracksTool::IsThreeDKink ( ThreeViewTransverseTracksAlgorithm *const  pAlgorithm, const Particle &  particle, const pandora::CartesianVector &  splitPosition, const bool  isALowestInX  ) const

private

Whether the provided particle is consistent with being a kink, when examined in three dimensions at the provided split position.

Parameters

pAlgorithm	the calling algorithm
particle	the particle
splitPosition	the candidate split position
isALowestInX	whether cluster associated with tensor element a extends to lowest x positions

Returns

boolean

Definition at line 129 of file UndershootTracksTool.cc.

{
    try
    {
        const TwoDSlidingFitResult &fitResultCommon1(pAlgorithm->GetCachedSlidingFitResult(particle.m_pCommonCluster1));
        const TwoDSlidingFitResult &fitResultCommon2(pAlgorithm->GetCachedSlidingFitResult(particle.m_pCommonCluster2));
        const TwoDSlidingFitResult &lowXFitResult(isALowestInX ? pAlgorithm->GetCachedSlidingFitResult(particle.m_pClusterA)
                                                               : pAlgorithm->GetCachedSlidingFitResult(particle.m_pClusterB));
        const TwoDSlidingFitResult &highXFitResult(isALowestInX ? pAlgorithm->GetCachedSlidingFitResult(particle.m_pClusterB)
                                                                : pAlgorithm->GetCachedSlidingFitResult(particle.m_pClusterA));

        const float minusX(this->GetXSamplingPoint(splitPosition, false, lowXFitResult, fitResultCommon1, fitResultCommon2));
        const float plusX(this->GetXSamplingPoint(splitPosition, true, highXFitResult, fitResultCommon1, fitResultCommon2));
        const float splitX(splitPosition.GetX());

        CartesianVector minus1(0.f, 0.f, 0.f), split1(0.f, 0.f, 0.f), plus1(0.f, 0.f, 0.f);
        CartesianVector minus2(0.f, 0.f, 0.f), split2(0.f, 0.f, 0.f), plus2(0.f, 0.f, 0.f);
        CartesianVector minus3(0.f, 0.f, 0.f), split3(splitPosition), plus3(0.f, 0.f, 0.f);

        if ((STATUS_CODE_SUCCESS != fitResultCommon1.GetGlobalFitPositionAtX(minusX, minus1)) ||
            (STATUS_CODE_SUCCESS != fitResultCommon1.GetGlobalFitPositionAtX(splitX, split1)) ||
            (STATUS_CODE_SUCCESS != fitResultCommon1.GetGlobalFitPositionAtX(plusX, plus1)) ||
            (STATUS_CODE_SUCCESS != fitResultCommon2.GetGlobalFitPositionAtX(minusX, minus2)) ||
            (STATUS_CODE_SUCCESS != fitResultCommon2.GetGlobalFitPositionAtX(splitX, split2)) ||
            (STATUS_CODE_SUCCESS != fitResultCommon2.GetGlobalFitPositionAtX(plusX, plus2)) ||
            (STATUS_CODE_SUCCESS != lowXFitResult.GetGlobalFitPositionAtX(minusX, minus3)) ||
            (STATUS_CODE_SUCCESS != highXFitResult.GetGlobalFitPositionAtX(plusX, plus3)))
        {
            return false; // majority rules, by default
        }

        // Extract results
        const HitType hitType1(LArClusterHelper::GetClusterHitType(particle.m_pCommonCluster1));
        const HitType hitType2(LArClusterHelper::GetClusterHitType(particle.m_pCommonCluster2));
        const HitType hitType3(LArClusterHelper::GetClusterHitType(particle.m_pClusterA));

        CartesianVector minus(0.f, 0.f, 0.f), split(0.f, 0.f, 0.f), plus(0.f, 0.f, 0.f);
        float chi2Minus(std::numeric_limits<float>::max()), chi2Split(std::numeric_limits<float>::max()),
            chi2Plus(std::numeric_limits<float>::max());
        LArGeometryHelper::MergeThreePositions3D(this->GetPandora(), hitType1, hitType2, hitType3, minus1, minus2, minus3, minus, chi2Minus);
        LArGeometryHelper::MergeThreePositions3D(this->GetPandora(), hitType1, hitType2, hitType3, split1, split2, split3, split, chi2Split);
        LArGeometryHelper::MergeThreePositions3D(this->GetPandora(), hitType1, hitType2, hitType3, plus1, plus2, plus3, plus, chi2Plus);

        // Apply final cuts
        const CartesianVector minusToSplit((split - minus).GetUnitVector());
        const CartesianVector splitToPlus((plus - split).GetUnitVector());
        const float dotProduct(minusToSplit.GetDotProduct(splitToPlus));

        if (dotProduct < m_cosThetaCutForKinkSearch)
            return true;
    }
    catch (StatusCodeException &s)
    {
    }

    return false;
}

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

private

Definition at line 215 of file UndershootTracksTool.cc.

{
    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SplitMode", m_splitMode));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MaxTransverseImpactParameter", m_maxTransverseImpactParameter));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MinImpactParameterCosTheta", m_minImpactParameterCosTheta));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "CosThetaCutForKinkSearch", m_cosThetaCutForKinkSearch));

    return ThreeDKinkBaseTool::ReadSettings(xmlHandle);
}

Member Data Documentation

float lar_content::UndershootTracksTool::m_cosThetaCutForKinkSearch

private

The cos theta cut used for the kink search in three dimensions.

Definition at line 68 of file UndershootTracksTool.h.

float lar_content::UndershootTracksTool::m_maxTransverseImpactParameter

private

The maximum transverse impact parameter for connecting broken clusters.

Definition at line 66 of file UndershootTracksTool.h.

float lar_content::UndershootTracksTool::m_minImpactParameterCosTheta

private

The minimum cos theta (angle between vertex directions) for connecting broken clusters.

Definition at line 67 of file UndershootTracksTool.h.

bool lar_content::UndershootTracksTool::m_splitMode

private

Whether to run in cluster splitting mode, as opposed to cluster merging mode.

Definition at line 65 of file UndershootTracksTool.h.

---

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

• UndershootTracksTool.h
• UndershootTracksTool.cc