lar_content::DeltaRaySplittingAlgorithm Class Reference

DeltaRaySplittingAlgorithm class. More...

#include "DeltaRaySplittingAlgorithm.h"

Inheritance diagram for lar_content::DeltaRaySplittingAlgorithm:

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

Protected Types
typedef std::vector< ClusterExtension >	ClusterExtensionList

Protected Member Functions
virtual pandora::StatusCode	Run ()

Private Member Functions
void	FindBestSplitPosition (const TwoDSlidingFitResult &branchSlidingFit, const TwoDSlidingFitResult &replacementSlidingFit, pandora::CartesianVector &replacementStartPosition, pandora::CartesianVector &branchSplitPosition, pandora::CartesianVector &branchSplitDirection) const
	Output the best split positions in branch and replacement clusters. More...
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

Private Attributes
float	m_stepSize
float	m_maxTransverseDisplacement
float	m_maxLongitudinalDisplacement
float	m_minCosRelativeAngle

Detailed Description

DeltaRaySplittingAlgorithm class.

Definition at line 19 of file DeltaRaySplittingAlgorithm.h.

Member Typedef Documentation

typedef std::vector<ClusterExtension> lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::ClusterExtensionList

protectedinherited

Definition at line 85 of file TwoDSlidingFitSplittingAndSplicingAlgorithm.h.

Constructor & Destructor Documentation

lar_content::DeltaRaySplittingAlgorithm::DeltaRaySplittingAlgorithm

(

)

Default constructor.

Definition at line 20 of file DeltaRaySplittingAlgorithm.cc.

                                                       :
    m_stepSize(1.f),
    m_maxTransverseDisplacement(1.5f),
    m_maxLongitudinalDisplacement(10.f),
    m_minCosRelativeAngle(0.985f)
{
}

Member Function Documentation

void lar_content::DeltaRaySplittingAlgorithm::FindBestSplitPosition ( const TwoDSlidingFitResult &  branchSlidingFit, const TwoDSlidingFitResult &  replacementSlidingFit, pandora::CartesianVector &  replacementStartPosition, pandora::CartesianVector &  branchSplitPosition, pandora::CartesianVector &  branchSplitDirection  ) const

privatevirtual

Output the best split positions in branch and replacement clusters.

Parameters

branchSlidingFit	the inputted sliding fit result for possible branch cluster
pReplacementCluster	the inputted sliding fit result for possible replacement cluster
replacementStartPosition	the outputted start position of the replacement
branchSplitPosition	the outputted start position of the branch
branchSplitDirection	the outputted start direction of the branch

Implements lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm.

Definition at line 30 of file DeltaRaySplittingAlgorithm.cc.

References f, lar_content::LArClusterHelper::GetClosestDistance(), lar_content::TwoDSlidingFitResult::GetCluster(), lar_content::TwoDSlidingFitResult::GetGlobalFitDirection(), lar_content::TwoDSlidingFitResult::GetGlobalFitPosition(), lar_content::TwoDSlidingFitResult::GetGlobalMaxLayerDirection(), lar_content::TwoDSlidingFitResult::GetGlobalMaxLayerPosition(), lar_content::TwoDSlidingFitResult::GetGlobalMinLayerDirection(), lar_content::TwoDSlidingFitResult::GetGlobalMinLayerPosition(), lar_content::LArPointingClusterHelper::GetImpactParameters(), lar_content::TwoDSlidingFitResult::GetLayerFitHalfWindowLength(), lar_content::TwoDSlidingFitResult::GetLocalPosition(), m_maxLongitudinalDisplacement, m_maxTransverseDisplacement, m_minCosRelativeAngle, and m_stepSize.

{
    // Conventions:
    // (1) Delta ray is split from the branch cluster
    // (2) Delta ray occurs where the vertex of the principal cluster meets the vertex of the branch cluster
    //     Method loops over the inner and outer positions of the principal and branch clusters, trying all
    //     possible assignments of vertex and end position until a split is found

    for (unsigned int principalForward = 0; principalForward < 2; ++principalForward)
    {
        const CartesianVector principalVertex(
            1 == principalForward ? principalSlidingFit.GetGlobalMinLayerPosition() : principalSlidingFit.GetGlobalMaxLayerPosition());
        const CartesianVector principalEnd(
            1 == principalForward ? principalSlidingFit.GetGlobalMaxLayerPosition() : principalSlidingFit.GetGlobalMinLayerPosition());
        const CartesianVector principalDirection(1 == principalForward ? principalSlidingFit.GetGlobalMinLayerDirection()
                                                                       : principalSlidingFit.GetGlobalMaxLayerDirection() * -1.f);

        if (LArClusterHelper::GetClosestDistance(principalVertex, branchSlidingFit.GetCluster()) > m_maxLongitudinalDisplacement)
            continue;

        for (unsigned int branchForward = 0; branchForward < 2; ++branchForward)
        {
            const CartesianVector branchVertex(
                1 == branchForward ? branchSlidingFit.GetGlobalMinLayerPosition() : branchSlidingFit.GetGlobalMaxLayerPosition());
            const CartesianVector branchEnd(
                1 == branchForward ? branchSlidingFit.GetGlobalMaxLayerPosition() : branchSlidingFit.GetGlobalMinLayerPosition());
            const CartesianVector branchDirection(
                1 == branchForward ? branchSlidingFit.GetGlobalMinLayerDirection() : branchSlidingFit.GetGlobalMaxLayerDirection() * -1.f);

            // Require vertices to be closest two ends
            const float vertex_to_vertex((principalVertex - branchVertex).GetMagnitudeSquared());
            const float vertex_to_end((principalVertex - branchEnd).GetMagnitudeSquared());
            const float end_to_vertex((principalEnd - branchVertex).GetMagnitudeSquared());
            const float end_to_end((principalEnd - branchEnd).GetMagnitudeSquared());

            // (sign convention for vertexProjection: positive means that clusters overlap)
            const float vertexProjection(+branchDirection.GetDotProduct(principalVertex - branchVertex));
            const float cosRelativeAngle(-branchDirection.GetDotProduct(principalDirection));

            if (vertex_to_vertex > std::min(end_to_end, std::min(vertex_to_end, end_to_vertex)))
                continue;

            if (end_to_end < std::max(vertex_to_vertex, std::max(vertex_to_end, end_to_vertex)))
                continue;

            if (vertexProjection < 0.f && cosRelativeAngle > m_minCosRelativeAngle)
                continue;

            if (cosRelativeAngle < 0.f)
                continue;

            // Serach for a split by winding back the branch cluster sliding fit
            bool foundSplit(false);

            const float halfWindowLength(branchSlidingFit.GetLayerFitHalfWindowLength());
            const float deltaL(1 == branchForward ? +halfWindowLength : -halfWindowLength);

            float branchDistance(std::max(0.f, vertexProjection) + 0.5f * m_stepSize);

            while (!foundSplit)
            {
                branchDistance += m_stepSize;

                const CartesianVector linearProjection(branchVertex + branchDirection * branchDistance);

                if (principalDirection.GetDotProduct(linearProjection - principalVertex) < -m_maxLongitudinalDisplacement)
                    break;

                if ((linearProjection - branchVertex).GetMagnitudeSquared() > (linearProjection - branchEnd).GetMagnitudeSquared())
                    break;

                float localL(0.f), localT(0.f);
                CartesianVector truncatedPosition(0.f, 0.f, 0.f);
                CartesianVector forwardDirection(0.f, 0.f, 0.f);
                branchSlidingFit.GetLocalPosition(linearProjection, localL, localT);

                if ((STATUS_CODE_SUCCESS != branchSlidingFit.GetGlobalFitPosition(localL, truncatedPosition)) ||
                    (STATUS_CODE_SUCCESS != branchSlidingFit.GetGlobalFitDirection(localL + deltaL, forwardDirection)))
                {
                    continue;
                }

                CartesianVector truncatedDirection(1 == branchForward ? forwardDirection : forwardDirection * -1.f);
                const float cosTheta(-truncatedDirection.GetDotProduct(principalDirection));

                float rT1(0.f), rL1(0.f), rT2(0.f), rL2(0.f);
                LArPointingClusterHelper::GetImpactParameters(truncatedPosition, truncatedDirection, principalVertex, rL1, rT1);
                LArPointingClusterHelper::GetImpactParameters(principalVertex, principalDirection, truncatedPosition, rL2, rT2);

                if ((cosTheta > m_minCosRelativeAngle) && (rT1 < m_maxTransverseDisplacement) && (rT2 < m_maxTransverseDisplacement))
                {
                    foundSplit = true;
                    principalStartPosition = principalVertex;
                    branchSplitPosition = truncatedPosition;
                    branchSplitDirection = truncatedDirection * -1.f;
                }
            }

            if (foundSplit)
                return;
        }
    }

    throw StatusCodeException(STATUS_CODE_NOT_FOUND);
}

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

privatevirtual

Reimplemented from lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm.

Definition at line 139 of file DeltaRaySplittingAlgorithm.cc.

References m_maxLongitudinalDisplacement, m_maxTransverseDisplacement, m_minCosRelativeAngle, m_stepSize, and lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::ReadSettings().

{
    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "StepSize", m_stepSize));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MaxTransverseDisplacement", m_maxTransverseDisplacement));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MaxLongitudinalDisplacement", m_maxLongitudinalDisplacement));

    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinCosRelativeAngle", m_minCosRelativeAngle));

    return TwoDSlidingFitSplittingAndSplicingAlgorithm::ReadSettings(xmlHandle);
}

StatusCode lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::Run ( )

protectedvirtualinherited

Definition at line 32 of file TwoDSlidingFitSplittingAndSplicingAlgorithm.cc.

References lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::BuildClusterExtensionList(), lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::BuildSlidingFitResultMap(), lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::GetListOfCleanClusters(), lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::m_longHalfWindowLayers, lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::m_runCosmicMode, lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::m_shortHalfWindowLayers, lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::PruneClusterExtensionList(), and lar_content::TwoDSlidingFitSplittingAndSplicingAlgorithm::RunSplitAndExtension().

{
    const ClusterList *pClusterList = NULL;
    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pClusterList));

    TwoDSlidingFitResultMap branchSlidingFitResultMap, replacementSlidingFitResultMap;

    unsigned int nIterations(0);

    while (++nIterations < 100) // Protect against flip-flopping between two answers
    {
        // Get ordered list of candidate clusters
        ClusterVector clusterVector;
        this->GetListOfCleanClusters(pClusterList, clusterVector);

        // Calculate sliding fit results for branch clusters (use a soft sliding fit for these)
        this->BuildSlidingFitResultMap(clusterVector, m_shortHalfWindowLayers, branchSlidingFitResultMap);

        // Calculate sliding fit results for replacement clusters (use a hard linear fit for these)
        this->BuildSlidingFitResultMap(clusterVector, m_longHalfWindowLayers, replacementSlidingFitResultMap);

        // Compile a list of possible splits
        ClusterExtensionList splitList;

        if (m_runCosmicMode)
        {
            this->BuildClusterExtensionList(clusterVector, branchSlidingFitResultMap, replacementSlidingFitResultMap, splitList);
        }
        else
        {
            ClusterExtensionList intermediateList;
            this->BuildClusterExtensionList(clusterVector, branchSlidingFitResultMap, replacementSlidingFitResultMap, intermediateList);
            this->PruneClusterExtensionList(intermediateList, branchSlidingFitResultMap, replacementSlidingFitResultMap, splitList);
        }

        // Run splitting and extension
        if (STATUS_CODE_SUCCESS != this->RunSplitAndExtension(splitList, branchSlidingFitResultMap, replacementSlidingFitResultMap))
            break;
    }

    return STATUS_CODE_SUCCESS;
}

Member Data Documentation

float lar_content::DeltaRaySplittingAlgorithm::m_maxLongitudinalDisplacement

private

Definition at line 36 of file DeltaRaySplittingAlgorithm.h.

Referenced by FindBestSplitPosition(), and ReadSettings().

float lar_content::DeltaRaySplittingAlgorithm::m_maxTransverseDisplacement

private

Definition at line 35 of file DeltaRaySplittingAlgorithm.h.

Referenced by FindBestSplitPosition(), and ReadSettings().

float lar_content::DeltaRaySplittingAlgorithm::m_minCosRelativeAngle

private

Definition at line 37 of file DeltaRaySplittingAlgorithm.h.

Referenced by FindBestSplitPosition(), and ReadSettings().

float lar_content::DeltaRaySplittingAlgorithm::m_stepSize

private

Definition at line 34 of file DeltaRaySplittingAlgorithm.h.

Referenced by FindBestSplitPosition(), and ReadSettings().

---

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

• larpandoracontent/v04_08_01/source/larpandoracontent/LArTwoDReco/LArClusterSplitting/DeltaRaySplittingAlgorithm.h
• larpandoracontent/v04_08_01/source/larpandoracontent/LArTwoDReco/LArClusterSplitting/DeltaRaySplittingAlgorithm.cc