lar_content::TwoViewThreeDKinkTool Class Reference

TwoViewThreeDKinkTool class. More...

#include <TwoViewThreeDKinkTool.h>

Inheritance diagram for lar_content::TwoViewThreeDKinkTool:

Classes
class	Modification
	Modification class. More...
class	Particle
	Particle class. More...

Public Member Functions
	TwoViewThreeDKinkTool ()
	Constructor. More...
virtual	~TwoViewThreeDKinkTool ()
	Destructor. More...
bool	Run (TwoViewTransverseTracksAlgorithm *const pAlgorithm, MatrixType &overlapMatrix)
	Run the algorithm tool. More...

Private Types
typedef std::vector< Modification >	ModificationList

Private Member Functions
void	GetModifications (TwoViewTransverseTracksAlgorithm *const pAlgorithm, const MatrixType &overlapMatrix, ModificationList &modificationList) const
	Get modification objects, identifying required splits and merges for clusters. More...
bool	PassesElementCuts (MatrixType::ElementList::const_iterator eIter, const pandora::ClusterSet &usedClusters) const
	Whether a provided (iterator to a) matrix element passes the selection cuts for overshoot identification. More...
void	SelectMatrixElements (MatrixType::ElementList::const_iterator eIter, const MatrixType::ElementList &elementList, const pandora::ClusterSet &usedClusters, IteratorList &iteratorList) const
	Select elements representing possible components of interest due to overshoots or undershoots in clustering. More...
void	GetIteratorListModifications (TwoViewTransverseTracksAlgorithm *const pAlgorithm, const IteratorList &iteratorList, ModificationList &modificationList) const
	Get modification objects for specific elements of the matrix, identifying required splits and merges for clusters. More...
bool	IsThreeDKink (TwoViewTransverseTracksAlgorithm *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...
float	GetXSamplingPoint (const pandora::CartesianVector &splitPosition1, const bool isForwardInX, const TwoDSlidingFitResult &fitResult1, const TwoDSlidingFitResult &fitResult2) const
	Get a sampling point in x that is common to sliding linear fit objects in two views. More...
bool	ApplyChanges (TwoViewTransverseTracksAlgorithm *const pAlgorithm, const ModificationList &modificationList) const
	Apply the changes cached in a modification list and update the matrix accordingly. More...
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

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

Private Attributes
float	m_minXOverlapFraction
	The min x overlap fraction value for particle creation. More...
float	m_minMatchingScore
	The min global matching score for particle creation. More...
float	m_minLocallyMatchedFraction
	The min locally matched fraction for particle creation. 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. 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::TransverseMatrixTool
typedef TwoViewTransverseTracksAlgorithm::MatchingType::MatrixType	MatrixType
typedef std::vector< MatrixType::ElementList::const_iterator >	IteratorList

Detailed Description

TwoViewThreeDKinkTool class.

Definition at line 21 of file TwoViewThreeDKinkTool.h.

Member Typedef Documentation

typedef std::vector<Modification> lar_content::TwoViewThreeDKinkTool::ModificationList

private

Definition at line 50 of file TwoViewThreeDKinkTool.h.

Constructor & Destructor Documentation

lar_content::TwoViewThreeDKinkTool::TwoViewThreeDKinkTool

(

)

Constructor.

Parameters

nCommonClusters

the number of common clusters to select

Definition at line 23 of file TwoViewThreeDKinkTool.cc.

                                             :
    m_minXOverlapFraction(0.1f),
    m_minMatchingScore(0.95f),
    m_minLocallyMatchedFraction(0.3f),
    m_minLongitudinalImpactParameter(-1.f),
    m_nLayersForKinkSearch(10),
    m_additionalXStepForKinkSearch(0.01f),
    m_maxTransverseImpactParameter(5.f),
    m_minImpactParameterCosTheta(0.5f),
    m_cosThetaCutForKinkSearch(0.75f)
{
}

lar_content::TwoViewThreeDKinkTool::~TwoViewThreeDKinkTool ( )

virtual

Destructor.

Definition at line 38 of file TwoViewThreeDKinkTool.cc.

{
}

Member Function Documentation

bool lar_content::TwoViewThreeDKinkTool::ApplyChanges ( TwoViewTransverseTracksAlgorithm *const  pAlgorithm, const ModificationList &  modificationList  ) const

private

Apply the changes cached in a modification list and update the matrix accordingly.

Parameters

pAlgorithm	address of the calling algorithm
modificationList	the modification list

Returns

whether changes to the matrix have been made

Definition at line 179 of file TwoViewThreeDKinkTool.cc.

{
    ClusterMergeMap consolidatedMergeMap;
    SplitPositionMap consolidatedSplitMap;

    for (const Modification &modification : modificationList)
    {
        ClusterList parentClusters;
        for (const auto &mapEntry : modification.m_clusterMergeMap)
            parentClusters.push_back(mapEntry.first);
        parentClusters.sort(LArClusterHelper::SortByNHits);

        for (const Cluster *const pParentCluster : parentClusters)
        {
            const ClusterList &daughterClusters(modification.m_clusterMergeMap.at(pParentCluster));

            for (const Cluster *const pDaughterCluster : daughterClusters)
            {
                if (consolidatedMergeMap.count(pDaughterCluster))
                    throw StatusCodeException(STATUS_CODE_FAILURE);
            }

            ClusterList &targetClusterList(consolidatedMergeMap[pParentCluster]);
            targetClusterList.insert(targetClusterList.end(), daughterClusters.begin(), daughterClusters.end());
        }

        ClusterList splitClusters;
        for (const auto &mapEntry : modification.m_splitPositionMap)
            splitClusters.push_back(mapEntry.first);
        splitClusters.sort(LArClusterHelper::SortByNHits);

        for (const Cluster *const pSplitCluster : splitClusters)
        {
            const CartesianPointVector &splitPositions(modification.m_splitPositionMap.at(pSplitCluster));

            CartesianPointVector &cartesianPointVector(consolidatedSplitMap[pSplitCluster]);
            cartesianPointVector.insert(cartesianPointVector.end(), splitPositions.begin(), splitPositions.end());
        }
    }

    bool changesMade(false);
    changesMade |= pAlgorithm->MakeClusterMerges(consolidatedMergeMap);
    changesMade |= pAlgorithm->MakeClusterSplits(consolidatedSplitMap);

    return changesMade;
}

void lar_content::TwoViewThreeDKinkTool::GetIteratorListModifications ( TwoViewTransverseTracksAlgorithm *const  pAlgorithm, const IteratorList &  iteratorList, ModificationList &  modificationList  ) const

private

Get modification objects for specific elements of the matrix, 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

Definition at line 268 of file TwoViewThreeDKinkTool.cc.

{
    for (IteratorList::const_iterator iIter1 = iteratorList.begin(), iIter1End = iteratorList.end(); iIter1 != iIter1End; ++iIter1)
    {
        for (IteratorList::const_iterator iIter2 = std::next(iIter1); iIter2 != iIter1End; ++iIter2)
        {
            try
            {
                const unsigned int nMatchedReUpsampledSamplingPoints1((*iIter1)->GetOverlapResult().GetNMatchedReUpsampledSamplingPoints());
                const unsigned int nMatchedReUpsampledSamplingPoints2((*iIter2)->GetOverlapResult().GetNMatchedReUpsampledSamplingPoints());
                IteratorList::const_iterator iIterA((nMatchedReUpsampledSamplingPoints1 >= nMatchedReUpsampledSamplingPoints2) ? iIter1 : iIter2);
                IteratorList::const_iterator iIterB((nMatchedReUpsampledSamplingPoints1 >= nMatchedReUpsampledSamplingPoints2) ? 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(this->IsThreeDKink(pAlgorithm, particle, splitPosition, isALowestInX));

                // Construct the modification object
                Modification modification;

                if (isThreeDKink)
                {
                    const TwoDSlidingFitResult &fitResultCommon(pAlgorithm->GetCachedSlidingFitResult(particle.m_pCommonCluster));

                    CartesianVector splitPositionCommon(0.f, 0.f, 0.f);
                    if (STATUS_CODE_SUCCESS != fitResultCommon.GetGlobalFitPositionAtX(splitPosition.GetX(), splitPositionCommon))
                    {
                        continue;
                    }

                    modification.m_splitPositionMap[particle.m_pCommonCluster].push_back(splitPositionCommon);
                }
                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_pCommonCluster);

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

                continue;
            }
        }
    }
}

void lar_content::TwoViewThreeDKinkTool::GetModifications ( TwoViewTransverseTracksAlgorithm *const  pAlgorithm, const MatrixType &  overlapMatrix, ModificationList &  modificationList  ) const

private

Get modification objects, identifying required splits and merges for clusters.

Parameters

pAlgorithm	address of the calling algorithm
overlapMatrix	the overlap matrix
modificationList	to be populated with modifications

Definition at line 131 of file TwoViewThreeDKinkTool.cc.

{
    ClusterSet usedClusters;
    ClusterVector sortedKeyClusters;
    overlapMatrix.GetSortedKeyClusters(sortedKeyClusters);

    for (const Cluster *const pKeyCluster : sortedKeyClusters)
    {
        if (!pKeyCluster->IsAvailable())
            continue;

        unsigned int n1(0), n2(0);
        MatrixType::ElementList elementList;
        overlapMatrix.GetConnectedElements(pKeyCluster, true, elementList, n1, n2);

        if (n1 * n2 < 2)
            continue;

        for (MatrixType::ElementList::const_iterator eIter = elementList.begin(); eIter != elementList.end(); ++eIter)
        {
            if (!this->PassesElementCuts(eIter, usedClusters))
                continue;

            IteratorList iteratorList;
            this->SelectMatrixElements(eIter, elementList, usedClusters, iteratorList);

            if (iteratorList.size() < 2)
                continue;

            ModificationList localModificationList;
            this->GetIteratorListModifications(pAlgorithm, iteratorList, localModificationList);

            if (localModificationList.empty())
                continue;

            for (ModificationList::const_iterator mIter = localModificationList.begin(), mIterEnd = localModificationList.end(); mIter != mIterEnd; ++mIter)
            {
                usedClusters.insert(mIter->m_affectedClusters.begin(), mIter->m_affectedClusters.end());
            }

            modificationList.insert(modificationList.end(), localModificationList.begin(), localModificationList.end());
        }
    }
}

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

private

Get a sampling point in x that is common to sliding linear fit objects in two 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

Returns

the sampling point

Definition at line 80 of file TwoViewThreeDKinkTool.cc.

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

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

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

    if (!isForwardInX && ((commonX < xMin1) || (commonX < xMin2)))
        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())
        std::swap(minus, plus);

    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::TwoViewThreeDKinkTool::IsALowestInX ( const LArPointingCluster &  pointingClusterA, const LArPointingCluster &  pointingClusterB  )

staticprivate

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 122 of file TwoViewThreeDKinkTool.cc.

{
    const float xMinA{std::min(pointingClusterA.GetInnerVertex().GetPosition().GetX(), pointingClusterA.GetOuterVertex().GetPosition().GetX())};
    const float xMinB{std::min(pointingClusterB.GetInnerVertex().GetPosition().GetX(), pointingClusterB.GetOuterVertex().GetPosition().GetX())};
    return xMinA < xMinB;
}

bool lar_content::TwoViewThreeDKinkTool::IsThreeDKink ( TwoViewTransverseTracksAlgorithm *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 matrix element a extends to lowest x positions

Returns

boolean

Definition at line 352 of file TwoViewThreeDKinkTool.cc.

{
    try
    {
        const TwoDSlidingFitResult &fitResultCommon(pAlgorithm->GetCachedSlidingFitResult(particle.m_pCommonCluster));
        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, fitResultCommon));
        const float plusX(this->GetXSamplingPoint(splitPosition, true, highXFitResult, fitResultCommon));
        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(splitPosition), plus2(0.f, 0.f, 0.f);

        if ((STATUS_CODE_SUCCESS != fitResultCommon.GetGlobalFitPositionAtX(minusX, minus1)) ||
            (STATUS_CODE_SUCCESS != fitResultCommon.GetGlobalFitPositionAtX(splitX, split1)) ||
            (STATUS_CODE_SUCCESS != fitResultCommon.GetGlobalFitPositionAtX(plusX, plus1)) ||
            (STATUS_CODE_SUCCESS != lowXFitResult.GetGlobalFitPositionAtX(minusX, minus2)) ||
            (STATUS_CODE_SUCCESS != highXFitResult.GetGlobalFitPositionAtX(plusX, plus2)))
        {
            return true; // split by default
        }

        // Extract results
        const HitType hitType1(LArClusterHelper::GetClusterHitType(particle.m_pCommonCluster));
        const HitType hitType2(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 chi2Dummy(std::numeric_limits<float>::max());
        LArGeometryHelper::MergeTwoPositions3D(this->GetPandora(), hitType1, hitType2, minus1, minus2, minus, chi2Dummy);
        LArGeometryHelper::MergeTwoPositions3D(this->GetPandora(), hitType1, hitType2, split1, split2, split, chi2Dummy);
        LArGeometryHelper::MergeTwoPositions3D(this->GetPandora(), hitType1, hitType2, plus1, plus2, plus, chi2Dummy);

        // 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 (const StatusCodeException &)
    {
    }

    return false;
}

bool lar_content::TwoViewThreeDKinkTool::PassesElementCuts ( MatrixType::ElementList::const_iterator  eIter, const pandora::ClusterSet &  usedClusters  ) const

private

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

Parameters

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

Definition at line 58 of file TwoViewThreeDKinkTool.cc.

{
    if (usedClusters.count(eIter->GetCluster1()) || usedClusters.count(eIter->GetCluster2()))
        return false;

    if (eIter->GetOverlapResult().GetTwoViewXOverlap().GetXOverlapFraction0() - m_minXOverlapFraction < std::numeric_limits<float>::epsilon())
        return false;

    if (eIter->GetOverlapResult().GetTwoViewXOverlap().GetXOverlapFraction1() - m_minXOverlapFraction < std::numeric_limits<float>::epsilon())
        return false;

    if (eIter->GetOverlapResult().GetMatchingScore() - m_minMatchingScore < std::numeric_limits<float>::epsilon())
        return false;

    if (eIter->GetOverlapResult().GetLocallyMatchedFraction() - m_minLocallyMatchedFraction < std::numeric_limits<float>::epsilon())
        return false;

    return true;
}

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

private

Definition at line 419 of file TwoViewThreeDKinkTool.cc.

{
    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinMatchingScore", m_minMatchingScore));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MinLocallyMatchedFraction", m_minLocallyMatchedFraction));

    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, "MinLongitudinalImpactParameter", m_minLongitudinalImpactParameter));

    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "NLayersForKinkSearch", m_nLayersForKinkSearch));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "AdditionalXStepForKinkSearch", m_additionalXStepForKinkSearch));

    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 STATUS_CODE_SUCCESS;
}

bool lar_content::TwoViewThreeDKinkTool::Run ( TwoViewTransverseTracksAlgorithm *const  pAlgorithm, MatrixType &  overlapMatrix  )

virtual

Run the algorithm tool.

Parameters

pAlgorithm	address of the calling algorithm
overlapMatrix	the overlap matrix

Returns

whether changes have been made by the tool

Implements lar_content::TransverseMatrixTool.

Definition at line 44 of file TwoViewThreeDKinkTool.cc.

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

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

    return changesMade;
}

void lar_content::TwoViewThreeDKinkTool::SelectMatrixElements ( MatrixType::ElementList::const_iterator  eIter, const MatrixType::ElementList &  elementList, const pandora::ClusterSet &  usedClusters, IteratorList &  iteratorList  ) const

private

Select elements representing possible components of interest due to overshoots or undershoots in clustering.

Parameters

eIter	iterator to a candidate element
elementList	the provided element list
usedClusters	the list of used clusters
iteratorList	to receive a list of iterators to relevant elements

Definition at line 228 of file TwoViewThreeDKinkTool.cc.

{
    iteratorList.push_back(eIter);

    for (MatrixType::ElementList::const_iterator eIter2 = elementList.begin(); eIter2 != elementList.end(); ++eIter2)
    {
        if (eIter == eIter2)
            continue;

        if (!this->PassesElementCuts(eIter2, usedClusters))
            continue;

        for (IteratorList::const_iterator iIter = iteratorList.begin(); iIter != iteratorList.end(); ++iIter)
        {
            if ((*iIter) == eIter2)
                continue;

            unsigned int nMatchedClusters(0);

            if ((*iIter)->GetCluster1() == eIter2->GetCluster1())
                ++nMatchedClusters;

            if ((*iIter)->GetCluster2() == eIter2->GetCluster2())
                ++nMatchedClusters;

            if (nMatchedClusters > 1)
                continue;

            if (nMatchedClusters)
            {
                iteratorList.push_back(eIter2);
                return;
            }
        }
    }
}

Member Data Documentation

float lar_content::TwoViewThreeDKinkTool::m_additionalXStepForKinkSearch

private

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

Definition at line 168 of file TwoViewThreeDKinkTool.h.

float lar_content::TwoViewThreeDKinkTool::m_cosThetaCutForKinkSearch

private

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

Definition at line 171 of file TwoViewThreeDKinkTool.h.

float lar_content::TwoViewThreeDKinkTool::m_maxTransverseImpactParameter

private

The maximum transverse impact parameter for connecting broken clusters.

Definition at line 169 of file TwoViewThreeDKinkTool.h.

float lar_content::TwoViewThreeDKinkTool::m_minImpactParameterCosTheta

private

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

Definition at line 170 of file TwoViewThreeDKinkTool.h.

float lar_content::TwoViewThreeDKinkTool::m_minLocallyMatchedFraction

private

The min locally matched fraction for particle creation.

Definition at line 165 of file TwoViewThreeDKinkTool.h.

float lar_content::TwoViewThreeDKinkTool::m_minLongitudinalImpactParameter

private

The min longitudinal impact parameter for connecting accompanying clusters.

Definition at line 166 of file TwoViewThreeDKinkTool.h.

float lar_content::TwoViewThreeDKinkTool::m_minMatchingScore

private

The min global matching score for particle creation.

Definition at line 164 of file TwoViewThreeDKinkTool.h.

float lar_content::TwoViewThreeDKinkTool::m_minXOverlapFraction

private

The min x overlap fraction value for particle creation.

Definition at line 163 of file TwoViewThreeDKinkTool.h.

int lar_content::TwoViewThreeDKinkTool::m_nLayersForKinkSearch

private

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

Definition at line 167 of file TwoViewThreeDKinkTool.h.

---

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

• larpandoracontent/larpandoracontent/LArThreeDReco/LArTwoViewMatching/TwoViewThreeDKinkTool.h
• larpandoracontent/larpandoracontent/LArThreeDReco/LArTwoViewMatching/TwoViewThreeDKinkTool.cc