lar_content::OvershootTracksTool Class Reference

OvershootTracksTool class. More...

#include "OvershootTracksTool.h"

Inheritance diagram for lar_content::OvershootTracksTool:

Classes
class	Particle
	Particle class. More...

Public Types
typedef ThreeViewTransverseTracksAlgorithm::MatchingType::TensorType	TensorType
typedef std::vector< TensorType::ElementList::const_iterator >	IteratorList

Public Member Functions
	OvershootTracksTool ()
	Default constructor. More...
bool	Run (ThreeViewTransverseTracksAlgorithm *const pAlgorithm, TensorType &overlapTensor)
	Run the algorithm tool. More...

Protected Types
typedef std::vector< Modification >	ModificationList

Protected Member Functions
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...

Static Protected Member Functions
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
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...

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	PassesVertexCuts (const LArPointingCluster::Vertex &vertexA, const LArPointingCluster::Vertex &vertexB) const
	Whether a pair of vertices pass longitudinal projection cuts. More...
void	SetSplitPosition (const LArPointingCluster::Vertex &vertexA1, const LArPointingCluster::Vertex &vertexA2, const LArPointingCluster::Vertex &vertexB1, const LArPointingCluster::Vertex &vertexB2, Particle &particle) const
	Set split position for a provided particle. More...
bool	IsThreeDKink (ThreeViewTransverseTracksAlgorithm *const pAlgorithm, const Particle &particle, const bool isA1LowestInX, const bool isA2LowestInX) const
	Whether the provided particle is consistent with being a kink, when examined in three dimensions at the split position. More...

Private Attributes
bool	m_splitMode
	Whether to run in cluster splitting mode, as opposed to cluster merging mode. More...
float	m_maxVertexXSeparation
	The max separation between accompanying clusters vertex x positions to make split. More...
float	m_cosThetaCutForKinkSearch
	The cos theta cut used for the kink search in three dimensions. More...

Detailed Description

OvershootTracksTool class.

Definition at line 19 of file OvershootTracksTool.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 std::vector<Modification> lar_content::ThreeDKinkBaseTool::ModificationList

protectedinherited

Definition at line 50 of file ThreeDKinkBaseTool.h.

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

inherited

Definition at line 130 of file ThreeViewTransverseTracksAlgorithm.h.

Constructor & Destructor Documentation

lar_content::OvershootTracksTool::OvershootTracksTool

(

)

Default constructor.

Definition at line 22 of file OvershootTracksTool.cc.

                                         :
    ThreeDKinkBaseTool(1),
    m_splitMode(true),
    m_maxVertexXSeparation(2.f),
    m_cosThetaCutForKinkSearch(0.94f)
{
}

Member Function Documentation

void lar_content::OvershootTracksTool::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 32 of file OvershootTracksTool.cc.

References lar_content::NViewTrackMatchingAlgorithm< T >::GetCachedSlidingFitResult(), lar_content::LArPointingClusterHelper::GetClosestVerticesInX(), lar_content::ThreeDKinkBaseTool::IsALowestInX(), IsThreeDKink(), lar_content::ThreeDKinkBaseTool::Modification::m_affectedClusters, lar_content::ThreeDKinkBaseTool::Modification::m_clusterMergeMap, lar_content::ThreeDKinkBaseTool::m_majorityRulesMode, lar_content::OvershootTracksTool::Particle::m_pClusterA1, lar_content::OvershootTracksTool::Particle::m_pClusterA2, lar_content::OvershootTracksTool::Particle::m_pClusterB1, lar_content::OvershootTracksTool::Particle::m_pClusterB2, lar_content::OvershootTracksTool::Particle::m_pCommonCluster, m_splitMode, lar_content::OvershootTracksTool::Particle::m_splitPosition, lar_content::ThreeDKinkBaseTool::Modification::m_splitPositionMap, PassesVertexCuts(), and SetSplitPosition().

{
    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 pointingClusterA1(pAlgorithm->GetCachedSlidingFitResult(particle.m_pClusterA1));
                const LArPointingCluster pointingClusterB1(pAlgorithm->GetCachedSlidingFitResult(particle.m_pClusterB1));
                const LArPointingCluster pointingClusterA2(pAlgorithm->GetCachedSlidingFitResult(particle.m_pClusterA2));
                const LArPointingCluster pointingClusterB2(pAlgorithm->GetCachedSlidingFitResult(particle.m_pClusterB2));

                LArPointingCluster::Vertex vertexA1, vertexB1, vertexA2, vertexB2;
                LArPointingClusterHelper::GetClosestVerticesInX(pointingClusterA1, pointingClusterB1, vertexA1, vertexB1);
                LArPointingClusterHelper::GetClosestVerticesInX(pointingClusterA2, pointingClusterB2, vertexA2, vertexB2);

                if (!this->PassesVertexCuts(vertexA1, vertexB1) || !this->PassesVertexCuts(vertexA2, vertexB2))
                    continue;

                this->SetSplitPosition(vertexA1, vertexA2, vertexB1, vertexB2, particle);

                const bool isA1LowestInX(this->IsALowestInX(pointingClusterA1, pointingClusterB1));
                const bool isA2LowestInX(this->IsALowestInX(pointingClusterA2, pointingClusterB2));
                const bool isThreeDKink(m_majorityRulesMode ? true : this->IsThreeDKink(pAlgorithm, particle, isA1LowestInX, isA2LowestInX));

                if (isThreeDKink != m_splitMode)
                    continue;

                // Construct the modification object
                Modification modification;

                if (m_splitMode)
                {
                    modification.m_splitPositionMap[particle.m_pCommonCluster].push_back(particle.m_splitPosition);
                }
                else
                {
                    const bool vertex1AIsLowX(vertexA1.GetPosition().GetX() < vertexB1.GetPosition().GetX());
                    const Cluster *const pLowXCluster1(vertex1AIsLowX ? particle.m_pClusterA1 : particle.m_pClusterB1);
                    const Cluster *const pHighXCluster1(vertex1AIsLowX ? particle.m_pClusterB1 : particle.m_pClusterA1);
                    modification.m_clusterMergeMap[pLowXCluster1].push_back(pHighXCluster1);

                    const bool vertex2AIsLowX(vertexA2.GetPosition().GetX() < vertexB2.GetPosition().GetX());
                    const Cluster *const pLowXCluster2(vertex2AIsLowX ? particle.m_pClusterA2 : particle.m_pClusterB2);
                    const Cluster *const pHighXCluster2(vertex2AIsLowX ? particle.m_pClusterB2 : particle.m_pClusterA2);
                    modification.m_clusterMergeMap[pLowXCluster2].push_back(pHighXCluster2);
                }

                modification.m_affectedClusters.push_back(particle.m_pCommonCluster);
                modification.m_affectedClusters.push_back(particle.m_pClusterA1);
                modification.m_affectedClusters.push_back(particle.m_pClusterA2);
                modification.m_affectedClusters.push_back(particle.m_pClusterB1);
                modification.m_affectedClusters.push_back(particle.m_pClusterB2);

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

                continue;
            }
        }
    }
}

float lar_content::ThreeDKinkBaseTool::GetXSamplingPoint ( const pandora::CartesianVector &  splitPosition1, const bool  isForwardInX, const TwoDSlidingFitResult &  fitResult1, const TwoDSlidingFitResult &  fitResult2, const TwoDSlidingFitResult &  fitResult3  ) const

protectedinherited

Get a sampling point in x that is common to sliding linear fit objects in three views.

Parameters

splitPosition1	the split position in view 1
isForwardInX	whether to work forwards (or backwards) in x
fitResult1	the sliding fit result in view 1
fitResult2	the sliding fit result in view 2
fitResult3	the sliding fit result in view 3

Returns

the sampling point

Definition at line 59 of file ThreeDKinkBaseTool.cc.

References f, lar_content::TwoDSlidingFitResult::GetGlobalFitPosition(), lar_content::TwoDSlidingFitResult::GetL(), lar_content::TwoDSlidingFitResult::GetLayer(), lar_content::TwoDSlidingFitResult::GetLocalPosition(), lar_content::TwoDSlidingFitResult::GetMaxLayer(), lar_content::TwoDSlidingFitResult::GetMinAndMaxX(), lar_content::TwoDSlidingFitResult::GetMinLayer(), lar_content::ThreeDKinkBaseTool::m_additionalXStepForKinkSearch, and lar_content::ThreeDKinkBaseTool::m_nLayersForKinkSearch.

Referenced by lar_content::UndershootTracksTool::IsThreeDKink(), and IsThreeDKink().

{
    // Nearest common x position
    float xMin1(std::numeric_limits<float>::max()), xMax1(-std::numeric_limits<float>::max());
    float xMin2(std::numeric_limits<float>::max()), xMax2(-std::numeric_limits<float>::max());
    float xMin3(std::numeric_limits<float>::max()), xMax3(-std::numeric_limits<float>::max());
    fitResult1.GetMinAndMaxX(xMin1, xMax1);
    fitResult2.GetMinAndMaxX(xMin2, xMax2);
    fitResult3.GetMinAndMaxX(xMin3, xMax3);

    const float commonX(isForwardInX ? std::max(xMin1, std::max(xMin2, xMin3)) : std::min(xMax1, std::min(xMax2, xMax3)));

    if (isForwardInX && ((commonX > xMax1) || (commonX > xMax2) || (commonX > xMax3)))
        throw StatusCodeException(STATUS_CODE_NOT_FOUND);

    if (!isForwardInX && ((commonX < xMin1) || (commonX < xMin2) || (commonX < xMin3)))
        throw StatusCodeException(STATUS_CODE_NOT_FOUND);

    // Layer step x position
    float rL1(0.f), rT1(0.f);
    fitResult1.GetLocalPosition(splitPosition1, rL1, rT1);
    const int splitLayer(fitResult1.GetLayer(rL1));

    const int lowLayer(std::max(fitResult1.GetMinLayer(), std::min(fitResult1.GetMaxLayer(), splitLayer - m_nLayersForKinkSearch)));
    const int highLayer(std::max(fitResult1.GetMinLayer(), std::min(fitResult1.GetMaxLayer(), splitLayer + m_nLayersForKinkSearch)));

    CartesianVector minus(0.f, 0.f, 0.f), plus(0.f, 0.f, 0.f);
    PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, fitResult1.GetGlobalFitPosition(fitResult1.GetL(lowLayer), minus));
    PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, fitResult1.GetGlobalFitPosition(fitResult1.GetL(highLayer), plus));

    if (minus.GetX() > plus.GetX())
    {
        CartesianVector temporary(minus);
        minus = plus;
        plus = temporary;
    }

    const float layerStepX(isForwardInX ? plus.GetX() : minus.GetX());

    // Final x position selection
    const float chosenX(isForwardInX ? std::max(layerStepX, commonX) : std::min(layerStepX, commonX));
    const float finalX(isForwardInX ? chosenX + m_additionalXStepForKinkSearch : chosenX - m_additionalXStepForKinkSearch);
    return finalX;
}

bool lar_content::ThreeDKinkBaseTool::IsALowestInX ( const LArPointingCluster &  pointingClusterA, const LArPointingCluster &  pointingClusterB  )

staticprotectedinherited

Whether pointing cluster labelled A extends to lowest x positions (as opposed to that labelled B)

Parameters

pointingClusterA	pointing cluster A
pointingClusterB	pointing cluster B

Definition at line 107 of file ThreeDKinkBaseTool.cc.

References lar_content::LArPointingCluster::GetInnerVertex(), lar_content::LArPointingCluster::GetOuterVertex(), and lar_content::LArPointingCluster::Vertex::GetPosition().

Referenced by lar_content::UndershootTracksTool::GetIteratorListModifications(), and GetIteratorListModifications().

{
    if ((pointingClusterA.GetInnerVertex().GetPosition().GetX() < pointingClusterB.GetInnerVertex().GetPosition().GetX()) &&
        (pointingClusterA.GetInnerVertex().GetPosition().GetX() < pointingClusterB.GetOuterVertex().GetPosition().GetX()))
    {
        return true;
    }

    if ((pointingClusterA.GetOuterVertex().GetPosition().GetX() < pointingClusterB.GetInnerVertex().GetPosition().GetX()) &&
        (pointingClusterA.GetOuterVertex().GetPosition().GetX() < pointingClusterB.GetOuterVertex().GetPosition().GetX()))
    {
        return true;
    }

    return false;
}

bool lar_content::OvershootTracksTool::IsThreeDKink ( ThreeViewTransverseTracksAlgorithm *const  pAlgorithm, const Particle &  particle, const bool  isA1LowestInX, const bool  isA2LowestInX  ) const

private

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

Parameters

pAlgorithm	the calling algorithm
particle	the particle
isA1LowestInX	whether cluster associated with tensor element a extends to lowest x positions in view 1
isA2LowestInX	whether cluster associated with tensor element a extends to lowest x positions in view 2

Returns

boolean

Definition at line 158 of file OvershootTracksTool.cc.

References f, lar_content::NViewTrackMatchingAlgorithm< T >::GetCachedSlidingFitResult(), lar_content::LArClusterHelper::GetClusterHitType(), lar_content::ThreeDKinkBaseTool::GetXSamplingPoint(), m_cosThetaCutForKinkSearch, lar_content::OvershootTracksTool::Particle::m_pClusterA1, lar_content::OvershootTracksTool::Particle::m_pClusterA2, lar_content::OvershootTracksTool::Particle::m_pClusterB1, lar_content::OvershootTracksTool::Particle::m_pClusterB2, lar_content::OvershootTracksTool::Particle::m_pCommonCluster, lar_content::OvershootTracksTool::Particle::m_splitPosition, lar_content::OvershootTracksTool::Particle::m_splitPosition1, lar_content::OvershootTracksTool::Particle::m_splitPosition2, and lar_content::LArGeometryHelper::MergeThreePositions3D().

Referenced by GetIteratorListModifications().

{
    try
    {
        const TwoDSlidingFitResult &lowXFitResult1(isA1LowestInX ? pAlgorithm->GetCachedSlidingFitResult(particle.m_pClusterA1)
                                                                 : pAlgorithm->GetCachedSlidingFitResult(particle.m_pClusterB1));
        const TwoDSlidingFitResult &highXFitResult1(isA1LowestInX ? pAlgorithm->GetCachedSlidingFitResult(particle.m_pClusterB1)
                                                                  : pAlgorithm->GetCachedSlidingFitResult(particle.m_pClusterA1));
        const TwoDSlidingFitResult &lowXFitResult2(isA2LowestInX ? pAlgorithm->GetCachedSlidingFitResult(particle.m_pClusterA2)
                                                                 : pAlgorithm->GetCachedSlidingFitResult(particle.m_pClusterB2));
        const TwoDSlidingFitResult &highXFitResult2(isA2LowestInX ? pAlgorithm->GetCachedSlidingFitResult(particle.m_pClusterB2)
                                                                  : pAlgorithm->GetCachedSlidingFitResult(particle.m_pClusterA2));
        const TwoDSlidingFitResult &fitResultCommon3(pAlgorithm->GetCachedSlidingFitResult(particle.m_pCommonCluster));

        const float minusX(this->GetXSamplingPoint(particle.m_splitPosition, false, fitResultCommon3, lowXFitResult1, lowXFitResult2));
        const float plusX(this->GetXSamplingPoint(particle.m_splitPosition, true, fitResultCommon3, highXFitResult1, highXFitResult2));

        CartesianVector minus1(0.f, 0.f, 0.f), split1(particle.m_splitPosition1), plus1(0.f, 0.f, 0.f);
        CartesianVector minus2(0.f, 0.f, 0.f), split2(particle.m_splitPosition2), plus2(0.f, 0.f, 0.f);
        CartesianVector minus3(0.f, 0.f, 0.f), split3(particle.m_splitPosition), plus3(0.f, 0.f, 0.f);

        if ((STATUS_CODE_SUCCESS != lowXFitResult1.GetGlobalFitPositionAtX(minusX, minus1)) ||
            (STATUS_CODE_SUCCESS != highXFitResult1.GetGlobalFitPositionAtX(plusX, plus1)) ||
            (STATUS_CODE_SUCCESS != lowXFitResult2.GetGlobalFitPositionAtX(minusX, minus2)) ||
            (STATUS_CODE_SUCCESS != highXFitResult2.GetGlobalFitPositionAtX(plusX, plus2)) ||
            (STATUS_CODE_SUCCESS != fitResultCommon3.GetGlobalFitPositionAtX(minusX, minus3)) ||
            (STATUS_CODE_SUCCESS != fitResultCommon3.GetGlobalFitPositionAtX(plusX, plus3)))
        {
            return true; // majority rules, by default
        }

        // Extract results
        const HitType hitType1(LArClusterHelper::GetClusterHitType(particle.m_pClusterA1));
        const HitType hitType2(LArClusterHelper::GetClusterHitType(particle.m_pClusterA2));
        const HitType hitType3(LArClusterHelper::GetClusterHitType(particle.m_pCommonCluster));

        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 false;
    }
    catch (StatusCodeException &)
    {
    }

    return true;
}

bool lar_content::ThreeDKinkBaseTool::PassesElementCuts ( TensorType::ElementList::const_iterator  eIter, const pandora::ClusterSet &  usedClusters  ) const

protectedvirtualinherited

Whether a provided (iterator to a) tensor element passes the selection cuts for overshoot identification.

Parameters

eIter	the iterator to the tensor element
usedClusters	the list of used clusters

Definition at line 43 of file ThreeDKinkBaseTool.cc.

References lar_content::ThreeDKinkBaseTool::m_minMatchedFraction, and lar_content::ThreeDKinkBaseTool::m_minMatchedSamplingPoints.

Referenced by lar_content::ThreeDKinkBaseTool::GetModifications(), and lar_content::ThreeDKinkBaseTool::SelectTensorElements().

{
    if (usedClusters.count(eIter->GetClusterU()) || usedClusters.count(eIter->GetClusterV()) || usedClusters.count(eIter->GetClusterW()))
        return false;

    if (eIter->GetOverlapResult().GetMatchedFraction() < m_minMatchedFraction)
        return false;

    if (eIter->GetOverlapResult().GetNMatchedSamplingPoints() < m_minMatchedSamplingPoints)
        return false;

    return true;
}

bool lar_content::OvershootTracksTool::PassesVertexCuts ( const LArPointingCluster::Vertex &  vertexA, const LArPointingCluster::Vertex &  vertexB  ) const

private

Whether a pair of vertices pass longitudinal projection cuts.

Parameters

vertexA	vertex from cluster in tensor element a
vertexB	vertex from cluster in tensor element b

Definition at line 112 of file OvershootTracksTool.cc.

References lar_content::LArPointingClusterHelper::GetImpactParameters(), and lar_content::ThreeDKinkBaseTool::m_minLongitudinalImpactParameter.

Referenced by GetIteratorListModifications().

{
    float longitudinalAB(-std::numeric_limits<float>::max()), transverseAB(std::numeric_limits<float>::max());
    LArPointingClusterHelper::GetImpactParameters(vertexA, vertexB, longitudinalAB, transverseAB);

    float longitudinalBA(-std::numeric_limits<float>::max()), transverseBA(std::numeric_limits<float>::max());
    LArPointingClusterHelper::GetImpactParameters(vertexB, vertexA, longitudinalBA, transverseBA);

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

    return true;
}

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

private

Definition at line 252 of file OvershootTracksTool.cc.

References m_cosThetaCutForKinkSearch, m_maxVertexXSeparation, m_splitMode, and lar_content::ThreeDKinkBaseTool::ReadSettings().

{
    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, "MaxVertexXSeparation", m_maxVertexXSeparation));

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

    return ThreeDKinkBaseTool::ReadSettings(xmlHandle);
}

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

virtualinherited

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 126 of file ThreeDKinkBaseTool.cc.

References lar_content::ThreeDKinkBaseTool::ApplyChanges(), and lar_content::ThreeDKinkBaseTool::GetModifications().

{
    if (PandoraContentApi::GetSettings(*pAlgorithm)->ShouldDisplayAlgorithmInfo())
        std::cout << "----> Running Algorithm Tool: " << this->GetInstanceName() << ", " << this->GetType() << std::endl;

    ModificationList modificationList;
    this->GetModifications(pAlgorithm, overlapTensor, modificationList);
    const bool changesMade(this->ApplyChanges(pAlgorithm, modificationList));

    return changesMade;
}

void lar_content::OvershootTracksTool::SetSplitPosition ( const LArPointingCluster::Vertex &  vertexA1, const LArPointingCluster::Vertex &  vertexA2, const LArPointingCluster::Vertex &  vertexB1, const LArPointingCluster::Vertex &  vertexB2, Particle &  particle  ) const

private

Set split position for a provided particle.

Parameters

vertexA1	vertex for tensor element a in view 1
vertexA2	vertex for tensor element a in view 2
vertexB1	vertex for tensor element b in view 1
vertexB2	vertex for tensor element b in view 2
particle	the particle

Definition at line 128 of file OvershootTracksTool.cc.

References f, lar_content::LArClusterHelper::GetClusterHitType(), lar_content::LArPointingCluster::Vertex::GetPosition(), m_maxVertexXSeparation, lar_content::OvershootTracksTool::Particle::m_pClusterA1, lar_content::OvershootTracksTool::Particle::m_pClusterA2, lar_content::OvershootTracksTool::Particle::m_splitPosition, lar_content::OvershootTracksTool::Particle::m_splitPosition1, lar_content::OvershootTracksTool::Particle::m_splitPosition2, and lar_content::LArGeometryHelper::MergeTwoPositions().

Referenced by GetIteratorListModifications().

{
    bool splitAtElementA(false), splitAtElementB(false);

    if (std::fabs(vertexA1.GetPosition().GetX() - vertexA2.GetPosition().GetX()) < m_maxVertexXSeparation)
    {
        splitAtElementA = true;
    }
    else if (std::fabs(vertexB1.GetPosition().GetX() - vertexB2.GetPosition().GetX()) < m_maxVertexXSeparation)
    {
        splitAtElementB = true;
    }

    if (!splitAtElementA && !splitAtElementB)
        throw StatusCodeException(STATUS_CODE_NOT_FOUND);

    particle.m_splitPosition1 = splitAtElementA ? vertexA1.GetPosition() : vertexB1.GetPosition();
    particle.m_splitPosition2 = splitAtElementA ? vertexA2.GetPosition() : vertexB2.GetPosition();

    CartesianVector splitPosition(0.f, 0.f, 0.f);
    float chiSquared(std::numeric_limits<float>::max());
    LArGeometryHelper::MergeTwoPositions(this->GetPandora(), LArClusterHelper::GetClusterHitType(particle.m_pClusterA1),
        LArClusterHelper::GetClusterHitType(particle.m_pClusterA2), particle.m_splitPosition1, particle.m_splitPosition2, splitPosition, chiSquared);

    particle.m_splitPosition = splitPosition;
}

Member Data Documentation

float lar_content::ThreeDKinkBaseTool::m_additionalXStepForKinkSearch

protectedinherited

An additional (safety) step to tack-on when choosing x sampling points.

Definition at line 100 of file ThreeDKinkBaseTool.h.

Referenced by lar_content::ThreeDKinkBaseTool::GetXSamplingPoint(), and lar_content::ThreeDKinkBaseTool::ReadSettings().

float lar_content::OvershootTracksTool::m_cosThetaCutForKinkSearch

private

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

Definition at line 91 of file OvershootTracksTool.h.

Referenced by IsThreeDKink(), and ReadSettings().

bool lar_content::ThreeDKinkBaseTool::m_majorityRulesMode

protectedinherited

Whether to run in majority rules mode (always split overshoots, always merge undershoots)

Definition at line 95 of file ThreeDKinkBaseTool.h.

Referenced by lar_content::UndershootTracksTool::GetIteratorListModifications(), GetIteratorListModifications(), and lar_content::ThreeDKinkBaseTool::ReadSettings().

float lar_content::OvershootTracksTool::m_maxVertexXSeparation

private

The max separation between accompanying clusters vertex x positions to make split.

Definition at line 90 of file OvershootTracksTool.h.

Referenced by ReadSettings(), and SetSplitPosition().

float lar_content::ThreeDKinkBaseTool::m_minLongitudinalImpactParameter

protectedinherited

The min longitudinal impact parameter for connecting accompanying clusters.

Definition at line 98 of file ThreeDKinkBaseTool.h.

Referenced by lar_content::UndershootTracksTool::GetIteratorListModifications(), PassesVertexCuts(), and lar_content::ThreeDKinkBaseTool::ReadSettings().

float lar_content::ThreeDKinkBaseTool::m_minMatchedFraction

protectedinherited

The min matched sampling point fraction for use as a key tensor element.

Definition at line 96 of file ThreeDKinkBaseTool.h.

Referenced by lar_content::ThreeDKinkBaseTool::PassesElementCuts(), and lar_content::ThreeDKinkBaseTool::ReadSettings().

unsigned int lar_content::ThreeDKinkBaseTool::m_minMatchedSamplingPoints

protectedinherited

The min number of matched sampling points for use as a key tensor element.

Definition at line 97 of file ThreeDKinkBaseTool.h.

Referenced by lar_content::ThreeDKinkBaseTool::PassesElementCuts(), and lar_content::ThreeDKinkBaseTool::ReadSettings().

unsigned int lar_content::ThreeDKinkBaseTool::m_nCommonClusters

protectedinherited

The number of common clusters.

Definition at line 94 of file ThreeDKinkBaseTool.h.

Referenced by lar_content::ThreeDKinkBaseTool::SelectTensorElements(), and lar_content::ThreeDKinkBaseTool::ThreeDKinkBaseTool().

int lar_content::ThreeDKinkBaseTool::m_nLayersForKinkSearch

protectedinherited

The number of sliding fit layers to step in the kink search.

Definition at line 99 of file ThreeDKinkBaseTool.h.

Referenced by lar_content::ThreeDKinkBaseTool::GetXSamplingPoint(), and lar_content::ThreeDKinkBaseTool::ReadSettings().

bool lar_content::OvershootTracksTool::m_splitMode

private

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

Definition at line 89 of file OvershootTracksTool.h.

Referenced by GetIteratorListModifications(), and ReadSettings().

---

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

• larpandoracontent/v04_08_01/source/larpandoracontent/LArThreeDReco/LArTransverseTrackMatching/OvershootTracksTool.h
• larpandoracontent/v04_08_01/source/larpandoracontent/LArThreeDReco/LArTransverseTrackMatching/OvershootTracksTool.cc