lar_content::TrackMergeRefinementAlgorithm Class Reference

TrackMergeRefinementAlgorithm class. More...

#include "TrackMergeRefinementAlgorithm.h"

Inheritance diagram for lar_content::TrackMergeRefinementAlgorithm:

Public Member Functions
	TrackMergeRefinementAlgorithm ()
	Default constructor. More...
template<typename T >
void	InitialiseContainers (const ClusterList *pClusterList, const T sortFunction, ClusterVector &clusterVector, SlidingFitResultMapPair &slidingFitResultMapPair) const
template<typename T >
void	UpdateContainers (const ClusterList &clustersToAdd, const ClusterList &clustersToDelete, const T sortFunction, ClusterVector &clusterVector, SlidingFitResultMapPair &slidingFitResultMapPair) const

Protected Types
typedef std::pair< TwoDSlidingFitResultMap *, TwoDSlidingFitResultMap * >	SlidingFitResultMapPair
typedef std::unordered_map< const pandora::Cluster *, pandora::CaloHitList >	ClusterToCaloHitListMap

Protected Member Functions
template<typename T >
void	InitialiseContainers (const pandora::ClusterList *pClusterList, const T sortFunction, pandora::ClusterVector &clusterVector, SlidingFitResultMapPair &slidingFitResultMapPair) const
	Fill the cluster vector and sliding fit maps with clusters that are determined to be track-like. More...
bool	GetClusterMergingCoordinates (const TwoDSlidingFitResult &clusterMicroFitResult, const TwoDSlidingFitResult &clusterMacroFitResult, const TwoDSlidingFitResult &associatedMacroFitResult, const bool isEndUpstream, pandora::CartesianVector &clusterMergePosition, pandora::CartesianVector &clusterMergeDirection) const
	Get the merging coordinate and direction for an input cluster with respect to an associated cluster. More...
void	GetHitsInBoundingBox (const pandora::CartesianVector &firstCorner, const pandora::CartesianVector &secondCorner, const pandora::ClusterList *const pClusterList, ClusterToCaloHitListMap &clusterToCaloHitListMap, const pandora::ClusterList &unavailableProtectedClusters=pandora::ClusterList(), const float distanceToLine=-1.f) const
	Find the unprotected hits that are contained within a defined box with the option to apply a cut on the distance to the connecting line. More...
bool	IsInBoundingBox (const float minX, const float maxX, const float minZ, const float maxZ, const pandora::CartesianVector &hitPosition) const
	check whether a hit is contained within a defined square region More...
bool	IsCloseToLine (const pandora::CartesianVector &hitPosition, const pandora::CartesianVector &lineStart, const pandora::CartesianVector &lineDirection, const float distanceToLine) const
	Check whether a hit is close to a line. More...
bool	AreExtrapolatedHitsGood (const ClusterToCaloHitListMap &clusterToCaloHitListMap, ClusterAssociation &clusterAssociation) const
	Perform topological checks on the collected hits to ensure no gaps are present. More...
bool	IsNearBoundary (const pandora::CaloHit *const pCaloHit, const pandora::CartesianVector &boundaryPosition2D, const float boundaryTolerance) const
	Check whether a hit is close to a boundary point. More...
bool	IsTrackContinuous (const ClusterAssociation &clusterAssociation, const pandora::CaloHitVector &extrapolatedCaloHitVector) const
	Check whether the extrapolatedCaloHitVector contains a continuous line of hits between the cluster merge points. More...
void	GetTrackSegmentBoundaries (const ClusterAssociation &clusterAssociation, pandora::CartesianPointVector &trackSegmentBoundaries) const
	Obtain the segment boundaries of the connecting line to test whether extrapolated hits are continuous. More...
void	RepositionIfInGap (const pandora::CartesianVector &mergeDirection, pandora::CartesianVector &trackPoint) const
	Move an input position to the higher line gap edge if it lies within a gap. More...
float	DistanceInGap (const pandora::CartesianVector &upstreamPoint, const pandora::CartesianVector &downstreamPoint, const pandora::CartesianVector &connectingLine, pandora::DetectorGapList &consideredGaps) const
	Calculate the track length between two points that lies in gaps. More...
bool	IsInLineSegment (const pandora::CartesianVector &lowerBoundary, const pandora::CartesianVector &upperBoundary, const pandora::CartesianVector &point) const
	Whether a position falls within a specified segment of the cluster connecting line. More...
const pandora::Cluster *	RemoveOffAxisHitsFromTrack (const pandora::Cluster *const pCluster, const pandora::CartesianVector &splitPosition, const bool isEndUpstream, const ClusterToCaloHitListMap &clusterToCaloHitListMap, pandora::ClusterList &remnantClusterList, TwoDSlidingFitResultMap &microSlidingFitResultMap, TwoDSlidingFitResultMap &macroSlidingFitResultMap) const
	Remove any hits in the upstream/downstream cluster that lie off of the main track axis (i.e. clustering errors) More...
void	AddHitsToMainTrack (const pandora::Cluster *const pMainTrackCluster, const pandora::Cluster *const pShowerTrackCluster, const pandora::CaloHitList &caloHitsToMerge, const ClusterAssociation &clusterAssociation, pandora::ClusterList &remnantClusterList) const
	Remove the hits from a shower cluster that belong to the main track and add them into the main track cluster. More...
void	ProcessRemnantClusters (const pandora::ClusterList &remnantClusterList, const pandora::Cluster *const pMainTrackCluster, const pandora::ClusterList *const pClusterList, pandora::ClusterList &createdClusters) const
	Process the remnant clusters separating those that stradle the main track. More...
bool	AddToNearestCluster (const pandora::Cluster *const pClusterToMerge, const pandora::Cluster *const pMainTrackCluster, const pandora::ClusterList *const pClusterList) const
	Add a cluster to the nearest cluster satisfying separation distance thresholds. More...
bool	IsClusterRemnantDisconnected (const pandora::Cluster *const pRemnantCluster) const
	Whether a remnant cluster is considered to be disconnected and therefore should undergo further fragmentation. More...
void	FragmentRemnantCluster (const pandora::Cluster *const pRemnantCluster, pandora::ClusterList &fragmentedClusterList) const
	Fragment a cluster using simple hit separation logic. More...
template<typename T >
void	UpdateContainers (const pandora::ClusterList &clustersToAdd, const pandora::ClusterList &clustersToDelete, const T sortFunction, pandora::ClusterVector &clusterVector, SlidingFitResultMapPair &slidingFitResultMapPair) const
	Remove deleted clusters from the cluster vector and sliding fit maps and add in created clusters that are determined to be track-like. More...
void	RemoveClusterFromContainers (const pandora::Cluster *const pClustertoRemove, pandora::ClusterVector &clusterVector, SlidingFitResultMapPair &slidingFitResultMapPair) const
	Remove a cluster from the cluster vector and sliding fit maps. More...

Protected Attributes
float	m_minClusterLength
	The minimum length of a considered cluster. More...
unsigned int	m_microSlidingFitWindow
	The sliding fit window used in the fits contained within the microSlidingFitResultMap. More...
unsigned int	m_macroSlidingFitWindow
	The sliding fit window used in the fits contained within the macroSlidingFitResultMap. More...
float	m_stableRegionClusterFraction
	The threshold fraction of fit contributing layers which defines the stable region. More...
float	m_mergePointMinCosAngleDeviation
	The threshold cos opening angle between the cluster local gradient and the associated cluster global gradient used to determine merge points. More...
float	m_minHitFractionForHitRemoval
	The threshold fraction of hits to be removed from the cluster for hit removal to proceed. More...
float	m_maxDistanceFromMainTrack
	The threshold distance for a hit to be added to the main track. More...
float	m_maxHitDistanceFromCluster
	The threshold separation between a hit and cluster for the hit to be merged into the cluster. More...
float	m_maxHitSeparationForConnectedCluster
	The maximum separation between two adjacent (in z) hits in a connected cluster. More...
unsigned int	m_maxTrackGaps
	The maximum number of graps allowed in the extrapolated hit vector. More...
float	m_lineSegmentLength
	The length of a track gap. More...
bool	m_hitWidthMode
	Whether to consider the width of hits. More...

Private Member Functions
pandora::StatusCode	Run ()
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)
bool	FindBestClusterAssociation (const pandora::ClusterVector &clusterVector, const SlidingFitResultMapPair &slidingFitResultMapPair, ClusterPairAssociation &clusterAssociation) const
	Find the best cluster association. More...
bool	AreClustersAssociated (const pandora::CartesianVector &upstreamPoint, const pandora::CartesianVector &upstreamDirection, const pandora::CartesianVector &downstreamPoint, const pandora::CartesianVector &downstreamDirection) const
	Whether two clusters are assoicated to one another. More...
void	GetUnavailableProtectedClusters (const ClusterPairAssociation &clusterAssociation, const pandora::ClusterList &createdMainTrackClusters, pandora::ClusterList &unavailableProtectedClusters) const
	Obtain a list of clusters whos hits are protected and cannot be reassigned. More...
bool	AreExtrapolatedHitsNearBoundaries (const pandora::CaloHitVector &extrapolatedHitVector, ClusterAssociation &clusterAssociation) const
	Check the separation of the extremal extrapolated hits with the cluster merge points or, in the case of no hits, the cluster merge point separation. More...
void	ConsiderClusterAssociation (const ClusterPairAssociation &clusterAssociation, pandora::ClusterVector &clusterVector, SlidingFitResultMapPair &slidingFitResultMapPair) const
	Remove the cluster association from the cluster vector so that the same cluster pair is not considered again. More...
const pandora::Cluster *	CreateMainTrack (const ClusterPairAssociation &clusterAssociation, const ClusterToCaloHitListMap &clusterToCaloHitListMap, const pandora::ClusterList *pClusterList, pandora::ClusterVector &clusterVector, SlidingFitResultMapPair &slidingFitResultMapPair) const
	Refine the cluster endpoints and merge together the associated clusters alongside any extrapolated hits. More...

Private Attributes
unsigned int	m_maxLoopIterations
	The maximum number of main loop iterations. More...
float	m_minClusterLengthSum
	The threshold cluster and associated cluster length sum. More...
float	m_minSeparationDistance
	The threshold separation distance between associated clusters. More...
float	m_minDirectionDeviationCosAngle
	The threshold cos opening angle of the associated cluster directions. More...
float	m_maxPredictedMergePointOffset
	The threshold separation distance between the predicted and true cluster merge points. More...
float	m_distanceToLine
	The threshold hit distance of an extrapolated hit from the segment connecting line. More...
float	m_boundaryTolerance
	The maximum allowed distance of an extremal extrapolate hit to a cluster merge point. More...

Detailed Description

TrackMergeRefinementAlgorithm class.

Definition at line 18 of file TrackMergeRefinementAlgorithm.h.

Member Typedef Documentation

typedef std::unordered_map<const pandora::Cluster *, pandora::CaloHitList> lar_content::TrackRefinementBaseAlgorithm::ClusterToCaloHitListMap

protectedinherited

Definition at line 31 of file TrackRefinementBaseAlgorithm.h.

typedef std::pair<TwoDSlidingFitResultMap *, TwoDSlidingFitResultMap *> lar_content::TrackRefinementBaseAlgorithm::SlidingFitResultMapPair

protectedinherited

Definition at line 30 of file TrackRefinementBaseAlgorithm.h.

Constructor & Destructor Documentation

lar_content::TrackMergeRefinementAlgorithm::TrackMergeRefinementAlgorithm

(

)

Default constructor.

Definition at line 21 of file TrackMergeRefinementAlgorithm.cc.

                                                             :
    m_maxLoopIterations(10),
    m_minClusterLengthSum(75.f),
    m_minSeparationDistance(0.f),
    m_minDirectionDeviationCosAngle(0.99f),
    m_maxPredictedMergePointOffset(5.f),
    m_distanceToLine(0.35f),
    m_boundaryTolerance(2.f)
{
}

Member Function Documentation

void lar_content::TrackRefinementBaseAlgorithm::AddHitsToMainTrack ( const pandora::Cluster *const  pMainTrackCluster, const pandora::Cluster *const  pShowerTrackCluster, const pandora::CaloHitList &  caloHitsToMerge, const ClusterAssociation &  clusterAssociation, pandora::ClusterList &  remnantClusterList  ) const

protectedinherited

Remove the hits from a shower cluster that belong to the main track and add them into the main track cluster.

Parameters

pMainTrackCluster	the main track cluster
pShowerCluster	the input shower cluster
caloHitsToMerge	the list of calo hits to remove from the shower cluster
clusterAssociation	the clusterAssociation
remnantClusterList	the input list to store the remnant clusters

Definition at line 572 of file TrackRefinementBaseAlgorithm.cc.

References f, lar_content::ClusterAssociation::GetConnectingLineDirection(), lar_content::LArClusterHelper::GetLengthSquared(), lar_content::ClusterAssociation::GetUpstreamMergePoint(), lar_content::TrackRefinementBaseAlgorithm::m_minClusterLength, and lar_content::TrackRefinementBaseAlgorithm::m_minHitFractionForHitRemoval.

Referenced by CreateMainTrack().

{
    // To ignore crossing CR muon or test beam tracks
    if (((static_cast<float>(caloHitsToMerge.size()) / static_cast<float>(pShowerCluster->GetNCaloHits())) < m_minHitFractionForHitRemoval) &&
        (LArClusterHelper::GetLengthSquared(pShowerCluster) > m_minClusterLength))
        return;

    if (pShowerCluster->GetNCaloHits() == caloHitsToMerge.size())
    {
        PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::MergeAndDeleteClusters(*this, pMainTrackCluster, pShowerCluster));
        return;
    }

    // Fragmentation initialisation
    std::string originalListName, fragmentListName;
    const ClusterList originalClusterList(1, pShowerCluster);
    PANDORA_THROW_RESULT_IF(
        STATUS_CODE_SUCCESS, !=, PandoraContentApi::InitializeFragmentation(*this, originalClusterList, originalListName, fragmentListName));

    const Cluster *pAboveCluster(nullptr), *pBelowCluster(nullptr);

    const bool isVertical(std::fabs(clusterAssociation.GetConnectingLineDirection().GetX()) < std::numeric_limits<float>::epsilon());
    const float connectingLineGradient(
        isVertical ? 0.f : clusterAssociation.GetConnectingLineDirection().GetZ() / clusterAssociation.GetConnectingLineDirection().GetX());
    const float connectingLineIntercept(isVertical
            ? clusterAssociation.GetUpstreamMergePoint().GetX()
            : clusterAssociation.GetUpstreamMergePoint().GetZ() - (connectingLineGradient * clusterAssociation.GetUpstreamMergePoint().GetX()));

    const OrderedCaloHitList orderedCaloHitList(pShowerCluster->GetOrderedCaloHitList());
    for (const OrderedCaloHitList::value_type &mapEntry : orderedCaloHitList)
    {
        for (const CaloHit *const pCaloHit : *mapEntry.second)
        {
            const bool isAnExtrapolatedHit(std::find(caloHitsToMerge.begin(), caloHitsToMerge.end(), pCaloHit) != caloHitsToMerge.end());
            if (isAnExtrapolatedHit)
            {
                PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::RemoveFromCluster(*this, pShowerCluster, pCaloHit));
                PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToCluster(*this, pMainTrackCluster, pCaloHit));
            }
            else
            {
                const CartesianVector &hitPosition(pCaloHit->GetPositionVector());
                const bool isAbove(((connectingLineGradient * hitPosition.GetX()) + connectingLineIntercept) <
                    (isVertical ? hitPosition.GetX() : hitPosition.GetZ()));
                const Cluster *&pClusterToModify(isAbove ? pAboveCluster : pBelowCluster);

                if (pClusterToModify)
                {
                    PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToCluster(*this, pClusterToModify, pCaloHit));
                }
                else
                {
                    PandoraContentApi::Cluster::Parameters parameters;
                    parameters.m_caloHitList.push_back(pCaloHit);
                    PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Cluster::Create(*this, parameters, pClusterToModify));

                    remnantClusterList.push_back(pClusterToModify);
                }
            }
        }
    }

    PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::EndFragmentation(*this, fragmentListName, originalListName));
}

bool lar_content::TrackRefinementBaseAlgorithm::AddToNearestCluster ( const pandora::Cluster *const  pClusterToMerge, const pandora::Cluster *const  pMainTrackCluster, const pandora::ClusterList *const  pClusterList  ) const

protectedinherited

Add a cluster to the nearest cluster satisfying separation distance thresholds.

Parameters

pClusterToMerge	the cluster to merge
pMainTrackCluster	the main track cluster
pClusterList	the list of all clusters

Returns

whether cluster was added to a nearby cluster

Definition at line 667 of file TrackRefinementBaseAlgorithm.cc.

References lar_content::LArClusterHelper::GetClosestDistance(), lar_content::TrackRefinementBaseAlgorithm::m_maxDistanceFromMainTrack, and lar_content::TrackRefinementBaseAlgorithm::m_maxHitDistanceFromCluster.

Referenced by lar_content::TrackRefinementBaseAlgorithm::ProcessRemnantClusters().

{
    const Cluster *pClosestCluster(nullptr);
    float closestDistance(std::numeric_limits<float>::max());

    for (const Cluster *const pCluster : *pClusterList)
    {
        if (pCluster == pClusterToMerge)
            continue;

        const float separationDistance(LArClusterHelper::GetClosestDistance(pClusterToMerge, pCluster));

        if (separationDistance < closestDistance)
        {
            if ((pCluster == pMainTrackCluster) && (separationDistance > m_maxDistanceFromMainTrack))
                continue;

            pClosestCluster = pCluster;
            closestDistance = separationDistance;
        }
    }

    if (closestDistance < m_maxHitDistanceFromCluster)
    {
        PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::MergeAndDeleteClusters(*this, pClosestCluster, pClusterToMerge));
        return true;
    }

    return false;
}

bool lar_content::TrackMergeRefinementAlgorithm::AreClustersAssociated ( const pandora::CartesianVector &  upstreamPoint, const pandora::CartesianVector &  upstreamDirection, const pandora::CartesianVector &  downstreamPoint, const pandora::CartesianVector &  downstreamDirection  ) const

private

Whether two clusters are assoicated to one another.

Parameters

upstreamPoint	the merge point of the upstream cluster
upstreamDirection	the local direction of the upstream cluster at the merge point
downstreamPoint	the merge point of the downstream cluster
downstreamDirection	the local direction of the downstrean cluster at the merge point

Returns

whether the clusters are associated

Definition at line 175 of file TrackMergeRefinementAlgorithm.cc.

References m_maxPredictedMergePointOffset, m_minDirectionDeviationCosAngle, and m_minSeparationDistance.

Referenced by FindBestClusterAssociation().

{
    if (downstreamPoint.GetZ() < upstreamPoint.GetZ())
        return false;

    const float separationDistance(std::sqrt(upstreamPoint.GetDistanceSquared(downstreamPoint)));
    if (separationDistance < m_minSeparationDistance)
        return false;

    if (upstreamDirection.GetCosOpeningAngle(downstreamDirection) < m_minDirectionDeviationCosAngle)
        return false;

    const CartesianVector predictedDownstreamPoint(upstreamPoint + (upstreamDirection * separationDistance));
    const float predictedDownstreamOffset((predictedDownstreamPoint - downstreamPoint).GetMagnitude());

    if (predictedDownstreamOffset > m_maxPredictedMergePointOffset)
        return false;

    const CartesianVector predictedUpstreamPoint(downstreamPoint - (downstreamDirection * separationDistance));
    const float predictedUpstreamOffset((predictedUpstreamPoint - upstreamPoint).GetMagnitude());

    if (predictedUpstreamOffset > m_maxPredictedMergePointOffset)
        return false;

    return true;
}

bool lar_content::TrackRefinementBaseAlgorithm::AreExtrapolatedHitsGood ( const ClusterToCaloHitListMap &  clusterToCaloHitListMap, ClusterAssociation &  clusterAssociation  ) const

protectedinherited

Perform topological checks on the collected hits to ensure no gaps are present.

Parameters

clusterToCaloHitListMap	the input map [parent cluster -> list of hits which belong to the main track]
clusterAssociation	the clusterAssociation

Returns

whether the checks pass

Definition at line 187 of file TrackRefinementBaseAlgorithm.cc.

References lar_content::TrackRefinementBaseAlgorithm::AreExtrapolatedHitsNearBoundaries(), lar_content::ClusterAssociation::GetConnectingLineDirection(), lar_content::ClusterAssociation::GetUpstreamMergePoint(), lar_content::TrackRefinementBaseAlgorithm::IsTrackContinuous(), and lar_content::TrackRefinementBaseAlgorithm::m_hitWidthMode.

Referenced by Run().

{
    CaloHitVector extrapolatedHitVector;
    for (const auto &entry : clusterToCaloHitListMap)
        extrapolatedHitVector.insert(extrapolatedHitVector.begin(), entry.second.begin(), entry.second.end());

    // ATTN: Extrapolated hit checks require extrapolatedHitVector to be ordered from upstream -> downstream merge point
    std::sort(extrapolatedHitVector.begin(), extrapolatedHitVector.end(),
        SortByDistanceAlongLine(clusterAssociation.GetUpstreamMergePoint(), clusterAssociation.GetConnectingLineDirection(), m_hitWidthMode));

    if (!this->AreExtrapolatedHitsNearBoundaries(extrapolatedHitVector, clusterAssociation))
        return false;

    if (clusterToCaloHitListMap.empty())
        return true;

    if (!this->IsTrackContinuous(clusterAssociation, extrapolatedHitVector))
        return false;

    return true;
}

bool lar_content::TrackMergeRefinementAlgorithm::AreExtrapolatedHitsNearBoundaries ( const pandora::CaloHitVector &  extrapolatedHitVector, ClusterAssociation &  clusterAssociation  ) const

privatevirtual

Check the separation of the extremal extrapolated hits with the cluster merge points or, in the case of no hits, the cluster merge point separation.

Parameters

extrapolatedHitVector	the extrapolated hit vector (ordered closest hit to the upstream merge point -> furthest hit)
clusterAssociation	the cluster association

Returns

whether the checks pass

Implements lar_content::TrackRefinementBaseAlgorithm.

Definition at line 217 of file TrackMergeRefinementAlgorithm.cc.

References lar_content::ClusterAssociation::GetDownstreamMergePoint(), lar_content::ClusterAssociation::GetUpstreamMergePoint(), lar_content::TrackRefinementBaseAlgorithm::IsNearBoundary(), and m_boundaryTolerance.

{
    if (extrapolatedHitVector.empty())
    {
        const float separationDistance((clusterAssociation.GetUpstreamMergePoint() - clusterAssociation.GetDownstreamMergePoint()).GetMagnitude());
        return (separationDistance < m_boundaryTolerance);
    }

    if (!this->IsNearBoundary(extrapolatedHitVector.front(), clusterAssociation.GetUpstreamMergePoint(), m_boundaryTolerance))
        return false;

    if (!this->IsNearBoundary(extrapolatedHitVector.back(), clusterAssociation.GetDownstreamMergePoint(), m_boundaryTolerance))
        return false;

    return true;
}

void lar_content::TrackMergeRefinementAlgorithm::ConsiderClusterAssociation ( const ClusterPairAssociation &  clusterAssociation, pandora::ClusterVector &  clusterVector, SlidingFitResultMapPair &  slidingFitResultMapPair  ) const

private

Remove the cluster association from the cluster vector so that the same cluster pair is not considered again.

Parameters

clusterAssociation	the cluster pair association
clusterVector	the vector of clusters considered in future iterations of the algorithm
slidingFitResultMapPair	the {micro, macro} pair of [cluster -> TwoDSlidingFitResult] maps

Definition at line 236 of file TrackMergeRefinementAlgorithm.cc.

References lar_content::ClusterPairAssociation::GetDownstreamCluster(), lar_content::ClusterPairAssociation::GetUpstreamCluster(), and lar_content::TrackRefinementBaseAlgorithm::RemoveClusterFromContainers().

Referenced by Run().

{
    const Cluster *const upstreamCluster(clusterAssociation.GetUpstreamCluster()), *const downstreamCluster(clusterAssociation.GetDownstreamCluster());
    const Cluster *const pConsideredCluster(upstreamCluster->GetNCaloHits() > downstreamCluster->GetNCaloHits() ? downstreamCluster : upstreamCluster);
    RemoveClusterFromContainers(pConsideredCluster, clusterVector, slidingFitResultMapPair);
}

const Cluster * lar_content::TrackMergeRefinementAlgorithm::CreateMainTrack ( const ClusterPairAssociation &  clusterAssociation, const ClusterToCaloHitListMap &  clusterToCaloHitListMap, const pandora::ClusterList *  pClusterList, pandora::ClusterVector &  clusterVector, SlidingFitResultMapPair &  slidingFitResultMapPair  ) const

private

Refine the cluster endpoints and merge together the associated clusters alongside any extrapolated hits.

Parameters

clusterAssociation	the cluster pair association
clusterToCaloHitListMap	the map [parent cluster -> list of hits which belong to the main track]
pClusterList	the list of all clusters
clusterVector	the vector of clusters considered in future iterations of the algorithm
slidingFitResultMapPair	the {micro, macro} pair of [cluster -> TwoDSlidingFitResult] maps

Returns

the address of the created main track cluster

Definition at line 246 of file TrackMergeRefinementAlgorithm.cc.

References lar_content::TrackRefinementBaseAlgorithm::AddHitsToMainTrack(), lar_content::ClusterPairAssociation::GetDownstreamCluster(), lar_content::ClusterAssociation::GetDownstreamMergePoint(), lar_content::ClusterPairAssociation::GetUpstreamCluster(), lar_content::ClusterAssociation::GetUpstreamMergePoint(), lar_content::TrackRefinementBaseAlgorithm::ProcessRemnantClusters(), lar_content::TrackRefinementBaseAlgorithm::RemoveOffAxisHitsFromTrack(), lar_content::LArClusterHelper::SortByNHits(), and lar_content::TrackRefinementBaseAlgorithm::UpdateContainers().

Referenced by Run().

{
    // Determine the shower clusters which contain hits that belong to the main track
    ClusterVector showerClustersToFragment;
    for (const auto &entry : clusterToCaloHitListMap)
    {
        if ((entry.first != clusterAssociation.GetUpstreamCluster()) && (entry.first != clusterAssociation.GetDownstreamCluster()))
            showerClustersToFragment.push_back(entry.first);
    }

    std::sort(showerClustersToFragment.begin(), showerClustersToFragment.end(), LArClusterHelper::SortByNHits);

    ClusterList remnantClusterList;
    const Cluster *const pMainTrackCluster(
        this->RemoveOffAxisHitsFromTrack(clusterAssociation.GetUpstreamCluster(), clusterAssociation.GetUpstreamMergePoint(), false,
            clusterToCaloHitListMap, remnantClusterList, *slidingFitResultMapPair.first, *slidingFitResultMapPair.second));
    const Cluster *const pClusterToDelete(
        this->RemoveOffAxisHitsFromTrack(clusterAssociation.GetDownstreamCluster(), clusterAssociation.GetDownstreamMergePoint(), true,
            clusterToCaloHitListMap, remnantClusterList, *slidingFitResultMapPair.first, *slidingFitResultMapPair.second));

    PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::MergeAndDeleteClusters(*this, pMainTrackCluster, pClusterToDelete));

    for (const Cluster *const pShowerCluster : showerClustersToFragment)
    {
        const CaloHitList &caloHitsToMerge(clusterToCaloHitListMap.at(pShowerCluster));
        this->AddHitsToMainTrack(pMainTrackCluster, pShowerCluster, caloHitsToMerge, clusterAssociation, remnantClusterList);
    }

    ClusterList createdClusters;
    this->ProcessRemnantClusters(remnantClusterList, pMainTrackCluster, pClusterList, createdClusters);

    // ATTN: Cleanup containers - choose to add created clusters back into containers
    ClusterList modifiedClusters(showerClustersToFragment.begin(), showerClustersToFragment.end());
    modifiedClusters.push_back(clusterAssociation.GetUpstreamCluster());
    modifiedClusters.push_back(clusterAssociation.GetDownstreamCluster());
    createdClusters.push_back(pMainTrackCluster);
    this->UpdateContainers(createdClusters, modifiedClusters, LArClusterHelper::SortByNHits, clusterVector, slidingFitResultMapPair);

    return pMainTrackCluster;
}

float lar_content::TrackRefinementBaseAlgorithm::DistanceInGap ( const pandora::CartesianVector &  upstreamPoint, const pandora::CartesianVector &  downstreamPoint, const pandora::CartesianVector &  connectingLine, pandora::DetectorGapList &  consideredGaps  ) const

protectedinherited

Calculate the track length between two points that lies in gaps.

Parameters

upstreamPoint	the upstream point
downstreamPoint	the downstream point
connectingLine	the track direction
consideredGaps	the list of gaps to ignore

Definition at line 384 of file TrackRefinementBaseAlgorithm.cc.

References f.

Referenced by lar_content::TrackRefinementBaseAlgorithm::GetTrackSegmentBoundaries().

{
    const CartesianVector &lowerXPoint(upstreamPoint.GetX() < downstreamPoint.GetX() ? upstreamPoint : downstreamPoint);
    const CartesianVector &higherXPoint(upstreamPoint.GetX() < downstreamPoint.GetX() ? downstreamPoint : upstreamPoint);

    const float cosAngleToX(std::fabs(connectingLine.GetDotProduct(CartesianVector(1.f, 0.f, 0.f))));
    const float cosAngleToZ(std::fabs(connectingLine.GetDotProduct(CartesianVector(0.f, 0.f, 1.f))));

    float distanceInGaps(0.f);
    const DetectorGapList detectorGapList(this->GetPandora().GetGeometry()->GetDetectorGapList());
    for (const DetectorGap *const pDetectorGap : detectorGapList)
    {
        if (std::find(consideredGaps.begin(), consideredGaps.end(), pDetectorGap) != consideredGaps.end())
            continue;

        const LineGap *const pLineGap(dynamic_cast<const LineGap *>(pDetectorGap));

        if (pLineGap)
        {
            const LineGapType lineGapType(pLineGap->GetLineGapType());

            if (lineGapType == TPC_DRIFT_GAP)
            {
                float xDistanceInGap(0.f);

                if ((pLineGap->GetLineStartX() > lowerXPoint.GetX()) && (pLineGap->GetLineEndX() < higherXPoint.GetX()))
                {
                    xDistanceInGap = (pLineGap->GetLineEndX() - pLineGap->GetLineStartX());
                }
                else if ((pLineGap->GetLineStartX() < lowerXPoint.GetX()) && (pLineGap->GetLineEndX() > lowerXPoint.GetX()))
                {
                    xDistanceInGap = (pLineGap->GetLineEndX() - lowerXPoint.GetX());
                }
                else if ((pLineGap->GetLineStartX() < higherXPoint.GetX()) && (pLineGap->GetLineEndX() > higherXPoint.GetX()))
                {
                    xDistanceInGap = (higherXPoint.GetX() - pLineGap->GetLineStartX());
                }
                else
                {
                    continue;
                }

                if (std::fabs(cosAngleToX) < std::numeric_limits<float>::epsilon())
                    throw StatusCodeException(STATUS_CODE_FAILURE);

                distanceInGaps += (xDistanceInGap / cosAngleToX);

                consideredGaps.push_back(pDetectorGap);
            }

            if ((lineGapType == TPC_WIRE_GAP_VIEW_U) || (lineGapType == TPC_WIRE_GAP_VIEW_V) || (lineGapType == TPC_WIRE_GAP_VIEW_W))
            {
                float zDistanceInGap(0.f);

                if ((pLineGap->GetLineStartZ() > upstreamPoint.GetZ()) && (pLineGap->GetLineEndZ() < downstreamPoint.GetZ()))
                {
                    zDistanceInGap = pLineGap->GetLineEndZ() - pLineGap->GetLineStartZ();
                }
                else if ((pLineGap->GetLineStartZ() < upstreamPoint.GetZ()) && (pLineGap->GetLineEndZ() > upstreamPoint.GetZ()))
                {
                    zDistanceInGap = pLineGap->GetLineEndZ() - upstreamPoint.GetZ();
                }
                else if ((pLineGap->GetLineStartZ() < downstreamPoint.GetZ()) && (pLineGap->GetLineEndZ() > downstreamPoint.GetZ()))
                {
                    zDistanceInGap = downstreamPoint.GetZ() - pLineGap->GetLineStartZ();
                }
                else
                {
                    continue;
                }

                if (std::fabs(cosAngleToZ) < std::numeric_limits<float>::epsilon())
                    throw StatusCodeException(STATUS_CODE_FAILURE);

                distanceInGaps += (zDistanceInGap / cosAngleToZ);

                consideredGaps.push_back(pDetectorGap);
            }
        }
    }

    return distanceInGaps;
}

bool lar_content::TrackMergeRefinementAlgorithm::FindBestClusterAssociation ( const pandora::ClusterVector &  clusterVector, const SlidingFitResultMapPair &  slidingFitResultMapPair, ClusterPairAssociation &  clusterAssociation  ) const

private

Find the best cluster association.

Parameters

clusterVector	the vector of clusters to consider
slidingFitResultMapPair	the {micro, macro} pair of [cluster -> TwoDSlidingFitResult] maps
clusterAssociation	the cluster pair association

Returns

whether a cluster pair association was found

Definition at line 91 of file TrackMergeRefinementAlgorithm.cc.

References AreClustersAssociated(), f, lar_content::TrackRefinementBaseAlgorithm::GetClusterMergingCoordinates(), lar_content::LArClusterHelper::GetLength(), m_minClusterLengthSum, and lar_content::LArClusterHelper::SortByPosition().

Referenced by Run().

{
    bool foundAssociation(false);
    float maxLength(0.f);

    // ATTN: Find the associated cluster pair with the longest length sum
    for (ClusterVector::const_iterator currentIter = clusterVector.begin(); currentIter != clusterVector.end(); ++currentIter)
    {
        const Cluster *const pCurrentCluster(*currentIter);

        const TwoDSlidingFitResultMap::const_iterator currentMicroFitIter(slidingFitResultMapPair.first->find(pCurrentCluster));
        if (currentMicroFitIter == slidingFitResultMapPair.first->end())
            return false;

        const TwoDSlidingFitResultMap::const_iterator currentMacroFitIter(slidingFitResultMapPair.second->find(pCurrentCluster));
        if (currentMacroFitIter == slidingFitResultMapPair.second->end())
            return false;

        for (ClusterVector::const_iterator testIter = std::next(currentIter); testIter != clusterVector.end(); ++testIter)
        {
            const Cluster *const pTestCluster(*testIter);

            const float lengthSum(LArClusterHelper::GetLength(pCurrentCluster) + LArClusterHelper::GetLength(pTestCluster));
            if ((lengthSum < maxLength) || (lengthSum < m_minClusterLengthSum))
                continue;

            const TwoDSlidingFitResultMap::const_iterator testMicroFitIter(slidingFitResultMapPair.first->find(pTestCluster));
            if (testMicroFitIter == slidingFitResultMapPair.first->end())
                continue;

            const TwoDSlidingFitResultMap::const_iterator testMacroFitIter(slidingFitResultMapPair.second->find(pTestCluster));
            if (testMacroFitIter == slidingFitResultMapPair.second->end())
                continue;

            const bool isCurrentUpstream(LArClusterHelper::SortByPosition(pCurrentCluster, pTestCluster));

            // ATTN: Ensure that clusters are not contained within one another
            const float currentMinLayerZ(currentMacroFitIter->second.GetGlobalMinLayerPosition().GetZ()),
                currentMaxLayerZ(currentMacroFitIter->second.GetGlobalMaxLayerPosition().GetZ());
            const float testMinLayerZ(testMacroFitIter->second.GetGlobalMinLayerPosition().GetZ()),
                testMaxLayerZ(testMacroFitIter->second.GetGlobalMaxLayerPosition().GetZ());

            if (((currentMinLayerZ > testMinLayerZ) && (currentMaxLayerZ < testMaxLayerZ)) ||
                ((testMinLayerZ > currentMinLayerZ) && (testMaxLayerZ < currentMaxLayerZ)))
                continue;

            CartesianVector currentMergePoint(0.f, 0.f, 0.f), testMergePoint(0.f, 0.f, 0.f), currentMergeDirection(0.f, 0.f, 0.f),
                testMergeDirection(0.f, 0.f, 0.f);
            if (!this->GetClusterMergingCoordinates(currentMicroFitIter->second, currentMacroFitIter->second, testMacroFitIter->second,
                    !isCurrentUpstream, currentMergePoint, currentMergeDirection) ||
                !this->GetClusterMergingCoordinates(testMicroFitIter->second, testMacroFitIter->second, currentMacroFitIter->second,
                    isCurrentUpstream, testMergePoint, testMergeDirection))
            {
                continue;
            }

            if ((isCurrentUpstream && !this->AreClustersAssociated(currentMergePoint, currentMergeDirection, testMergePoint, testMergeDirection)) ||
                (!isCurrentUpstream && !this->AreClustersAssociated(testMergePoint, testMergeDirection, currentMergePoint, currentMergeDirection)))
            {
                continue;
            }

            if (isCurrentUpstream)
            {
                clusterAssociation = ClusterPairAssociation(
                    currentMergePoint, currentMergeDirection, testMergePoint, testMergeDirection * (-1.f), pCurrentCluster, pTestCluster);
            }
            else
            {
                clusterAssociation = ClusterPairAssociation(
                    testMergePoint, testMergeDirection, currentMergePoint, currentMergeDirection * (-1.f), pTestCluster, pCurrentCluster);
            }

            foundAssociation = true;
            maxLength = lengthSum;
        }
    }

    return foundAssociation;
}

void lar_content::TrackRefinementBaseAlgorithm::FragmentRemnantCluster ( const pandora::Cluster *const  pRemnantCluster, pandora::ClusterList &  fragmentedClusterList  ) const

protectedinherited

Fragment a cluster using simple hit separation logic.

Parameters

pRemnantCluster	the input remnant cluster to fragment
fragmentedClusterList	the input list to store the final remnant clusters

Definition at line 730 of file TrackRefinementBaseAlgorithm.cc.

References lar_content::LArClusterHelper::GetClosestDistance(), and lar_content::TrackRefinementBaseAlgorithm::m_maxHitDistanceFromCluster.

Referenced by lar_content::TrackRefinementBaseAlgorithm::ProcessRemnantClusters().

{
    // Fragmentation initialisation
    std::string originalListName, fragmentListName;
    const ClusterList originalClusterList(1, pRemnantCluster);
    PANDORA_THROW_RESULT_IF(
        STATUS_CODE_SUCCESS, !=, PandoraContentApi::InitializeFragmentation(*this, originalClusterList, originalListName, fragmentListName));

    ClusterList createdClusters;

    const OrderedCaloHitList &orderedCaloHitList(pRemnantCluster->GetOrderedCaloHitList());
    for (const OrderedCaloHitList::value_type &mapEntry : orderedCaloHitList)
    {
        for (const CaloHit *const pCaloHit : *mapEntry.second)
        {
            const Cluster *pClosestCluster(nullptr);

            if (!createdClusters.empty())
            {
                float closestDistance(std::numeric_limits<float>::max());

                for (const Cluster *const pCreatedCluster : createdClusters)
                {
                    const float separationDistance(LArClusterHelper::GetClosestDistance(pCaloHit->GetPositionVector(), pCreatedCluster));
                    if ((separationDistance < closestDistance) && (separationDistance < m_maxHitDistanceFromCluster))
                    {
                        closestDistance = separationDistance;
                        pClosestCluster = pCreatedCluster;
                    }
                }
            }

            if (pClosestCluster)
            {
                PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToCluster(*this, pClosestCluster, pCaloHit));
            }
            else
            {
                PandoraContentApi::Cluster::Parameters parameters;
                parameters.m_caloHitList.push_back(pCaloHit);
                PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Cluster::Create(*this, parameters, pClosestCluster));
                createdClusters.push_back(pClosestCluster);
            }
        }
    }

    // End fragmentation
    if (createdClusters.empty())
    {
        PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::EndFragmentation(*this, originalListName, fragmentListName));
        fragmentedClusterList.push_back(pRemnantCluster);
    }
    else
    {
        PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::EndFragmentation(*this, fragmentListName, originalListName));
        fragmentedClusterList.insert(fragmentedClusterList.begin(), createdClusters.begin(), createdClusters.end());
    }
}

bool lar_content::TrackRefinementBaseAlgorithm::GetClusterMergingCoordinates ( const TwoDSlidingFitResult &  clusterMicroFitResult, const TwoDSlidingFitResult &  clusterMacroFitResult, const TwoDSlidingFitResult &  associatedMacroFitResult, const bool  isEndUpstream, pandora::CartesianVector &  clusterMergePosition, pandora::CartesianVector &  clusterMergeDirection  ) const

protectedinherited

Get the merging coordinate and direction for an input cluster with respect to an associated cluster.

Parameters

clusterMicroFitResult	the local TwoDSlidingFitResult of the cluster
clusterMacroFitResult	the global TwoDSlidingFitResult of the cluster
associatedMacroFitReult	the global TwoDSlidingFitResult of the associated cluster
isEndUpstream	whether the sought cluster merge point is the upstream
clusterMergePosition	the merge position of the cluster
clusterMergeDirection	the merge direction of the cluster

Returns

whether it was possible to find a suitable merge position

Definition at line 68 of file TrackRefinementBaseAlgorithm.cc.

References f, lar_content::TwoDSlidingFitResult::GetGlobalDirection(), lar_content::TwoDSlidingFitResult::GetGlobalFitPosition(), lar_content::TwoDSlidingFitResult::GetLayerFitResultMap(), lar_content::TwoDSlidingFitResult::GetMaxLayer(), lar_content::TwoDSlidingFitResult::GetMinLayer(), lar_content::TrackRefinementBaseAlgorithm::m_mergePointMinCosAngleDeviation, and lar_content::TrackRefinementBaseAlgorithm::m_stableRegionClusterFraction.

Referenced by FindBestClusterAssociation().

{
    CartesianVector clusterAverageDirection(0.f, 0.f, 0.f), associatedAverageDirection(0.f, 0.f, 0.f);
    clusterMacroFitResult.GetGlobalDirection(clusterMacroFitResult.GetLayerFitResultMap().begin()->second.GetGradient(), clusterAverageDirection);
    associatedMacroFitResult.GetGlobalDirection(associatedMacroFitResult.GetLayerFitResultMap().begin()->second.GetGradient(), associatedAverageDirection);

    const LayerFitResultMap &clusterMicroLayerFitResultMap(clusterMicroFitResult.GetLayerFitResultMap());
    const int startLayer(isEndUpstream ? clusterMicroFitResult.GetMinLayer() : clusterMicroFitResult.GetMaxLayer());
    const int endLayer(isEndUpstream ? clusterMicroFitResult.GetMaxLayer() : clusterMicroFitResult.GetMinLayer());
    const int loopTerminationLayer(endLayer + (isEndUpstream ? 1 : -1));
    const int step(isEndUpstream ? 1 : -1);

    // ATTN: Search for stable region for which the local layer gradient agrees well with associated cluster global gradient
    unsigned int gradientStabilityWindow(std::ceil(clusterMicroLayerFitResultMap.size() * m_stableRegionClusterFraction));
    unsigned int goodLayerCount(0);

    clusterMicroLayerFitResultMap.at(endLayer);

    for (int i = startLayer; i != loopTerminationLayer; i += step)
    {
        const auto microIter(clusterMicroLayerFitResultMap.find(i));

        if (microIter == clusterMicroLayerFitResultMap.end())
            continue;

        CartesianVector microDirection(0.f, 0.f, 0.f);
        clusterMicroFitResult.GetGlobalDirection(microIter->second.GetGradient(), microDirection);

        const float cosDirectionOpeningAngle(microDirection.GetCosOpeningAngle(associatedAverageDirection));
        if (cosDirectionOpeningAngle > m_mergePointMinCosAngleDeviation)
        {
            // ATTN: Set merge point and direction as that at the first layer in the stable region
            if (goodLayerCount == 0)
            {
                clusterMergeDirection = clusterAverageDirection;
                PANDORA_THROW_RESULT_IF(
                    STATUS_CODE_SUCCESS, !=, clusterMicroFitResult.GetGlobalFitPosition(microIter->second.GetL(), clusterMergePosition));
            }

            ++goodLayerCount;
        }
        else
        {
            goodLayerCount = 0;
        }

        if (goodLayerCount > gradientStabilityWindow)
            break;

        // ATTN: Abort merging process have not found a stable region
        if (i == endLayer)
            return false;
    }

    return true;
}

void lar_content::TrackRefinementBaseAlgorithm::GetHitsInBoundingBox ( const pandora::CartesianVector &  firstCorner, const pandora::CartesianVector &  secondCorner, const pandora::ClusterList *const  pClusterList, ClusterToCaloHitListMap &  clusterToCaloHitListMap, const pandora::ClusterList &  unavailableProtectedClusters = pandora::ClusterList(), const float  distanceToLine = -1.f  ) const

protectedinherited

Find the unprotected hits that are contained within a defined box with the option to apply a cut on the distance to the connecting line.

Parameters

firstCorner	the position of one corner
secondCorner	the position of the opposite corner
pClusterList	the list of all clusters
clusterToCaloHitListMap	the output map [parent cluster -> list of hits which belong to the main track]
unavailableProtectedClusters	the list of clusters whose hits are protected
distanceToLine	the maximum perpendicular distance of a collected hit from the connecting line

Definition at line 129 of file TrackRefinementBaseAlgorithm.cc.

References f, lar_content::LArHitWidthHelper::GetClosestPointToLine2D(), lar_content::TrackRefinementBaseAlgorithm::IsCloseToLine(), lar_content::TrackRefinementBaseAlgorithm::IsInBoundingBox(), and lar_content::TrackRefinementBaseAlgorithm::m_hitWidthMode.

Referenced by Run().

{
    const float minX(std::min(firstCorner.GetX(), secondCorner.GetX())), maxX(std::max(firstCorner.GetX(), secondCorner.GetX()));
    const float minZ(std::min(firstCorner.GetZ(), secondCorner.GetZ())), maxZ(std::max(firstCorner.GetZ(), secondCorner.GetZ()));

    CartesianVector connectingLineDirection(firstCorner - secondCorner);
    connectingLineDirection = connectingLineDirection.GetUnitVector();

    for (const Cluster *const pCluster : *pClusterList)
    {
        if (std::find(unavailableProtectedClusters.begin(), unavailableProtectedClusters.end(), pCluster) != unavailableProtectedClusters.end())
            continue;

        const OrderedCaloHitList &orderedCaloHitList(pCluster->GetOrderedCaloHitList());
        for (const OrderedCaloHitList::value_type &mapEntry : orderedCaloHitList)
        {
            for (const CaloHit *const pCaloHit : *mapEntry.second)
            {
                CartesianVector hitPosition(m_hitWidthMode ? LArHitWidthHelper::GetClosestPointToLine2D(firstCorner, connectingLineDirection, pCaloHit)
                                                           : pCaloHit->GetPositionVector());

                if (!this->IsInBoundingBox(minX, maxX, minZ, maxZ, hitPosition))
                    continue;

                if (distanceToLine > 0.f)
                {
                    if (!this->IsCloseToLine(hitPosition, firstCorner, connectingLineDirection, distanceToLine))
                        continue;
                }

                clusterToCaloHitListMap[pCluster].push_back(pCaloHit);
            }
        }
    }
}

void lar_content::TrackRefinementBaseAlgorithm::GetTrackSegmentBoundaries ( const ClusterAssociation &  clusterAssociation, pandora::CartesianPointVector &  trackSegmentBoundaries  ) const

protectedinherited

Obtain the segment boundaries of the connecting line to test whether extrapolated hits are continuous.

Parameters

clusterAssociation	the clusterAssociation
trackSegmentBoundaries	the output vector of segment boundaries

Definition at line 274 of file TrackRefinementBaseAlgorithm.cc.

References lar_content::TrackRefinementBaseAlgorithm::DistanceInGap(), f, lar_content::ClusterAssociation::GetConnectingLineDirection(), lar_content::ClusterAssociation::GetDownstreamMergePoint(), lar_content::ClusterAssociation::GetUpstreamMergePoint(), lar_content::TrackRefinementBaseAlgorithm::m_lineSegmentLength, and lar_content::TrackRefinementBaseAlgorithm::RepositionIfInGap().

Referenced by lar_content::TrackRefinementBaseAlgorithm::IsTrackContinuous().

{
    if (m_lineSegmentLength < std::numeric_limits<float>::epsilon())
    {
        std::cout << "TrackInEMShowerAlgorithm: Line segment length must be positive and nonzero" << std::endl;
        throw STATUS_CODE_INVALID_PARAMETER;
    }

    const CartesianVector &trackDirection(clusterAssociation.GetConnectingLineDirection());
    float trackLength((clusterAssociation.GetUpstreamMergePoint() - clusterAssociation.GetDownstreamMergePoint()).GetMagnitude());

    // ATTN: Consider the existence of gaps where no hits will be found
    DetectorGapList consideredGaps;
    trackLength -= this->DistanceInGap(
        clusterAssociation.GetUpstreamMergePoint(), clusterAssociation.GetDownstreamMergePoint(), trackDirection, consideredGaps);
    consideredGaps.clear();

    const int fullSegments(std::floor(trackLength / m_lineSegmentLength));

    if (fullSegments == 0)
    {
        trackSegmentBoundaries = {clusterAssociation.GetUpstreamMergePoint(), clusterAssociation.GetDownstreamMergePoint()};
        return;
    }

    // ATTN: To handle final segment merge track remainder with preceding segment and if track remainder was more than half of the segment length split into two
    const float lengthOfTrackRemainder(trackLength - (fullSegments * m_lineSegmentLength));
    const bool splitFinalSegment(lengthOfTrackRemainder > m_lineSegmentLength * 0.5f);
    const int numberOfBoundaries(fullSegments + (splitFinalSegment ? 2 : 1));

    CartesianVector segmentUpstreamBoundary(clusterAssociation.GetUpstreamMergePoint()), segmentDownstreamBoundary(segmentUpstreamBoundary);
    this->RepositionIfInGap(trackDirection, segmentUpstreamBoundary);
    trackSegmentBoundaries.push_back(segmentUpstreamBoundary);

    for (int i = 1; i < numberOfBoundaries; ++i)
    {
        if (i < fullSegments)
        {
            segmentDownstreamBoundary += trackDirection * m_lineSegmentLength;
        }
        else
        {
            if (splitFinalSegment)
            {
                segmentDownstreamBoundary += trackDirection * (m_lineSegmentLength + lengthOfTrackRemainder) * 0.5f;
            }
            else
            {
                segmentDownstreamBoundary += trackDirection * (m_lineSegmentLength + lengthOfTrackRemainder);
            }
        }

        float distanceInGap(this->DistanceInGap(segmentUpstreamBoundary, segmentDownstreamBoundary, trackDirection, consideredGaps));
        while (distanceInGap > std::numeric_limits<float>::epsilon())
        {
            this->RepositionIfInGap(trackDirection, segmentDownstreamBoundary);
            segmentDownstreamBoundary += trackDirection * distanceInGap;
            distanceInGap = this->DistanceInGap(segmentUpstreamBoundary, segmentDownstreamBoundary, trackDirection, consideredGaps);
        }

        trackSegmentBoundaries.push_back(segmentDownstreamBoundary);
    }
}

void lar_content::TrackMergeRefinementAlgorithm::GetUnavailableProtectedClusters ( const ClusterPairAssociation &  clusterAssociation, const pandora::ClusterList &  createdMainTrackClusters, pandora::ClusterList &  unavailableProtectedClusters  ) const

private

Obtain a list of clusters whos hits are protected and cannot be reassigned.

Parameters

clusterAssociation	the clusterPairAssociation
createdMainTrackClusters	the list of main track clusters that have hitherto collected
unavailableProtectedClusters	the output list of protected clusters

Definition at line 205 of file TrackMergeRefinementAlgorithm.cc.

References lar_content::ClusterPairAssociation::GetDownstreamCluster(), and lar_content::ClusterPairAssociation::GetUpstreamCluster().

Referenced by Run().

{
    for (const Cluster *const pMainTrackCluster : createdMainTrackClusters)
    {
        if ((pMainTrackCluster != clusterAssociation.GetUpstreamCluster()) && (pMainTrackCluster != clusterAssociation.GetDownstreamCluster()))
            protectedClusters.push_back(pMainTrackCluster);
    }
}

template<typename T >

void lar_content::TrackRefinementBaseAlgorithm::InitialiseContainers ( const ClusterList *  pClusterList, const T  sortFunction, ClusterVector &  clusterVector, SlidingFitResultMapPair &  slidingFitResultMapPair  ) const

inherited

Definition at line 40 of file TrackRefinementBaseAlgorithm.cc.

References lar_content::LArClusterHelper::GetClusterHitType(), lar_content::LArClusterHelper::GetLengthSquared(), lar_content::LArGeometryHelper::GetWirePitch(), lar_content::TrackRefinementBaseAlgorithm::m_macroSlidingFitWindow, lar_content::TrackRefinementBaseAlgorithm::m_microSlidingFitWindow, and lar_content::TrackRefinementBaseAlgorithm::m_minClusterLength.

{
    for (const Cluster *const pCluster : *pClusterList)
    {
        if (LArClusterHelper::GetLengthSquared(pCluster) < m_minClusterLength * m_minClusterLength)
            continue;

        try
        {
            const float slidingFitPitch(LArGeometryHelper::GetWirePitch(this->GetPandora(), LArClusterHelper::GetClusterHitType(pCluster)));
            const TwoDSlidingFitResult microSlidingFitResult(pCluster, m_microSlidingFitWindow, slidingFitPitch);
            const TwoDSlidingFitResult macroSlidingFitResult(pCluster, m_macroSlidingFitWindow, slidingFitPitch);

            slidingFitResultMapPair.first->insert(TwoDSlidingFitResultMap::value_type(pCluster, microSlidingFitResult));
            slidingFitResultMapPair.second->insert(TwoDSlidingFitResultMap::value_type(pCluster, macroSlidingFitResult));
            clusterVector.push_back(pCluster);
        }
        catch (const StatusCodeException &)
        {
        }
    }

    std::sort(clusterVector.begin(), clusterVector.end(), sortFunction);
}

template<typename T >

void lar_content::TrackRefinementBaseAlgorithm::InitialiseContainers ( const pandora::ClusterList *  pClusterList, const T  sortFunction, pandora::ClusterVector &  clusterVector, SlidingFitResultMapPair &  slidingFitResultMapPair  ) const

protectedinherited

Fill the cluster vector and sliding fit maps with clusters that are determined to be track-like.

Parameters

pClusterList	the list of input clusters
sortFunction	the sort class or function used to sort the clusterVector
clusterVector	the input vector to store clusters considered within the algorithm
slidingFitResultMapPair	the {micro, macro} pair of [cluster -> TwoDSlidingFitResult] maps

Referenced by Run(), and lar_content::TrackRefinementBaseAlgorithm::UpdateContainers().

bool lar_content::TrackRefinementBaseAlgorithm::IsCloseToLine ( const pandora::CartesianVector &  hitPosition, const pandora::CartesianVector &  lineStart, const pandora::CartesianVector &  lineDirection, const float  distanceToLine  ) const

protectedinherited

Check whether a hit is close to a line.

Parameters

hitPosition	the position of the hit
lineStart	the start point of the line (can actually be any point on the line)
lineDirection	the unit vector of the line direction
distanceToLine	the definition of 'close'

Returns

whether the hit is close to the line

Definition at line 177 of file TrackRefinementBaseAlgorithm.cc.

Referenced by lar_content::TrackRefinementBaseAlgorithm::GetHitsInBoundingBox().

{
    const float transverseDistanceFromLine(lineDirection.GetCrossProduct(hitPosition - lineStart).GetMagnitude());

    return (transverseDistanceFromLine < distanceToLine);
}

bool lar_content::TrackRefinementBaseAlgorithm::IsClusterRemnantDisconnected ( const pandora::Cluster *const  pRemnantCluster ) const

protectedinherited

Whether a remnant cluster is considered to be disconnected and therefore should undergo further fragmentation.

Parameters

pRemnantCluster

the input remnant cluster

Returns

whether the remnant cluster is disconnected

Definition at line 701 of file TrackRefinementBaseAlgorithm.cc.

References lar_content::TrackRefinementBaseAlgorithm::m_maxHitSeparationForConnectedCluster.

Referenced by lar_content::TrackRefinementBaseAlgorithm::ProcessRemnantClusters().

{
    if (pRemnantCluster->GetNCaloHits() == 1)
        return false;

    const OrderedCaloHitList &orderedCaloHitList(pRemnantCluster->GetOrderedCaloHitList());
    const CaloHit *pPreviousCaloHit(orderedCaloHitList.begin()->second->front());

    for (const OrderedCaloHitList::value_type &mapEntry : orderedCaloHitList)
    {
        for (const CaloHit *const pCaloHit : *mapEntry.second)
        {
            if (pCaloHit == pPreviousCaloHit)
                continue;

            const float separationDistanceSquared(pCaloHit->GetPositionVector().GetDistanceSquared(pPreviousCaloHit->GetPositionVector()));

            if (separationDistanceSquared > (m_maxHitSeparationForConnectedCluster * m_maxHitSeparationForConnectedCluster))
                return true;

            pPreviousCaloHit = pCaloHit;
        }
    }

    return false;
}

bool lar_content::TrackRefinementBaseAlgorithm::IsInBoundingBox ( const float  minX, const float  maxX, const float  minZ, const float  maxZ, const pandora::CartesianVector &  hitPosition  ) const

protectedinherited

check whether a hit is contained within a defined square region

Parameters

minX	the minimum x coordinate of the square region
maxX	the maximum x coordinate of the square region
minZ	the minimum z coordinate of the square region
maxZ	the maximum z coordinate of the square region
hitPosition	the position of the hit

Returns

whether the hit is contained within the square region

Definition at line 169 of file TrackRefinementBaseAlgorithm.cc.

Referenced by lar_content::TrackRefinementBaseAlgorithm::GetHitsInBoundingBox().

{
    return !((hitPosition.GetX() < minX) || (hitPosition.GetX() > maxX) || (hitPosition.GetZ() < minZ) || (hitPosition.GetZ() > maxZ));
}

bool lar_content::TrackRefinementBaseAlgorithm::IsInLineSegment ( const pandora::CartesianVector &  lowerBoundary, const pandora::CartesianVector &  upperBoundary, const pandora::CartesianVector &  point  ) const

protectedinherited

Whether a position falls within a specified segment of the cluster connecting line.

Parameters

lowerBoundary	the lower boundary of the segment
upperBoundary	the upper boundary of the segment
point	the position

Returns

whether the position falls within segment

Definition at line 471 of file TrackRefinementBaseAlgorithm.cc.

Referenced by lar_content::TrackRefinementBaseAlgorithm::IsTrackContinuous().

{
    const float segmentBoundaryGradient = (-1.f) * (upperBoundary.GetX() - lowerBoundary.GetX()) / (upperBoundary.GetZ() - lowerBoundary.GetZ());
    const float xPointOnUpperLine((point.GetZ() - upperBoundary.GetZ()) / segmentBoundaryGradient + upperBoundary.GetX());
    const float xPointOnLowerLine((point.GetZ() - lowerBoundary.GetZ()) / segmentBoundaryGradient + lowerBoundary.GetX());

    if (std::fabs(xPointOnUpperLine - point.GetX()) < std::numeric_limits<float>::epsilon())
        return true;

    if (std::fabs(xPointOnLowerLine - point.GetX()) < std::numeric_limits<float>::epsilon())
        return true;

    if ((point.GetX() > xPointOnUpperLine) && (point.GetX() > xPointOnLowerLine))
        return false;

    if ((point.GetX() < xPointOnUpperLine) && (point.GetX() < xPointOnLowerLine))
        return false;

    return true;
}

bool lar_content::TrackRefinementBaseAlgorithm::IsNearBoundary ( const pandora::CaloHit *const  pCaloHit, const pandora::CartesianVector &  boundaryPosition2D, const float  boundaryTolerance  ) const

protectedinherited

Check whether a hit is close to a boundary point.

Parameters

pCaloHit	the input calo hit
boundaryPosition2D	the position of the 2D boundary point
boundaryTolerance	the definition of close

Returns

whether the check passes

Definition at line 211 of file TrackRefinementBaseAlgorithm.cc.

References lar_content::LArHitWidthHelper::GetClosestDistanceToPoint2D().

Referenced by AreExtrapolatedHitsNearBoundaries().

{
    const float distanceToBoundary(LArHitWidthHelper::GetClosestDistanceToPoint2D(pCaloHit, boundaryPosition2D));

    return (distanceToBoundary < boundaryTolerance);
}

bool lar_content::TrackRefinementBaseAlgorithm::IsTrackContinuous ( const ClusterAssociation &  clusterAssociation, const pandora::CaloHitVector &  extrapolatedCaloHitVector  ) const

protectedinherited

Check whether the extrapolatedCaloHitVector contains a continuous line of hits between the cluster merge points.

Parameters

clusterAssociation	the clusterAssociation
extrapolatedCaloHitVector	the vector of extrapolated calo hits

Returns

whether the calo hits are continuous

Definition at line 220 of file TrackRefinementBaseAlgorithm.cc.

References lar_content::LArHitWidthHelper::GetClosestPointToLine2D(), lar_content::ClusterAssociation::GetConnectingLineDirection(), lar_content::TrackRefinementBaseAlgorithm::GetTrackSegmentBoundaries(), lar_content::ClusterAssociation::GetUpstreamMergePoint(), lar_content::TrackRefinementBaseAlgorithm::IsInLineSegment(), lar_content::TrackRefinementBaseAlgorithm::m_hitWidthMode, and lar_content::TrackRefinementBaseAlgorithm::m_maxTrackGaps.

Referenced by lar_content::TrackRefinementBaseAlgorithm::AreExtrapolatedHitsGood().

{
    CartesianPointVector trackSegmentBoundaries;
    this->GetTrackSegmentBoundaries(clusterAssociation, trackSegmentBoundaries);

    if (trackSegmentBoundaries.size() < 2)
    {
        std::cout << "TrackInEMShowerAlgorithm: Less than two track segment boundaries" << std::endl;
        throw STATUS_CODE_NOT_ALLOWED;
    }

    unsigned int segmentsWithoutHits(0);
    CaloHitVector::const_iterator caloHitIter(extrapolatedCaloHitVector.begin());
    CartesianVector hitPosition(m_hitWidthMode ? LArHitWidthHelper::GetClosestPointToLine2D(clusterAssociation.GetUpstreamMergePoint(),
                                                     clusterAssociation.GetConnectingLineDirection(), *caloHitIter)
                                               : (*caloHitIter)->GetPositionVector());

    for (unsigned int i = 0; i < (trackSegmentBoundaries.size() - 1); ++i)
    {
        if (caloHitIter == extrapolatedCaloHitVector.end())
        {
            ++segmentsWithoutHits;

            if (segmentsWithoutHits > m_maxTrackGaps)
                return false;

            continue;
        }

        unsigned int hitsInSegment(0);
        while (this->IsInLineSegment(trackSegmentBoundaries.at(i), trackSegmentBoundaries.at(i + 1), hitPosition))
        {
            ++hitsInSegment;
            ++caloHitIter;

            if (caloHitIter == extrapolatedCaloHitVector.end())
                break;

            hitPosition = m_hitWidthMode ? LArHitWidthHelper::GetClosestPointToLine2D(clusterAssociation.GetUpstreamMergePoint(),
                                               clusterAssociation.GetConnectingLineDirection(), *caloHitIter)
                                         : (*caloHitIter)->GetPositionVector();
        }

        segmentsWithoutHits = hitsInSegment ? 0 : segmentsWithoutHits + 1;

        if (segmentsWithoutHits > m_maxTrackGaps)
            return false;
    }

    return true;
}

void lar_content::TrackRefinementBaseAlgorithm::ProcessRemnantClusters ( const pandora::ClusterList &  remnantClusterList, const pandora::Cluster *const  pMainTrackCluster, const pandora::ClusterList *const  pClusterList, pandora::ClusterList &  createdClusters  ) const

protectedinherited

Process the remnant clusters separating those that stradle the main track.

Parameters

remnantClusterList	the list of remnant clusters to process
pMainTrackCluster	the main track cluster
pClusterList	the list of all clusters
createdClusters	the input list to store the final remnant clusters

Definition at line 640 of file TrackRefinementBaseAlgorithm.cc.

References lar_content::TrackRefinementBaseAlgorithm::AddToNearestCluster(), lar_content::TrackRefinementBaseAlgorithm::FragmentRemnantCluster(), and lar_content::TrackRefinementBaseAlgorithm::IsClusterRemnantDisconnected().

Referenced by CreateMainTrack().

{
    ClusterList fragmentedClusters;
    for (const Cluster *const pRemnantCluster : remnantClusterList)
    {
        if (this->IsClusterRemnantDisconnected(pRemnantCluster))
        {
            this->FragmentRemnantCluster(pRemnantCluster, fragmentedClusters);
        }
        else
        {
            fragmentedClusters.push_back(pRemnantCluster);
        }
    }

    for (const Cluster *const pFragmentedCluster : fragmentedClusters)
    {
        if ((pFragmentedCluster->GetNCaloHits() == 1) && (this->AddToNearestCluster(pFragmentedCluster, pMainTrackCluster, pClusterList)))
            continue;

        createdClusters.push_back(pFragmentedCluster);
    }
}

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

privatevirtual

Implements lar_content::TrackRefinementBaseAlgorithm.

Definition at line 291 of file TrackMergeRefinementAlgorithm.cc.

References m_boundaryTolerance, m_distanceToLine, m_maxLoopIterations, m_maxPredictedMergePointOffset, m_minClusterLengthSum, m_minDirectionDeviationCosAngle, m_minSeparationDistance, and lar_content::TrackRefinementBaseAlgorithm::ReadSettings().

{
    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxLoopIterations", m_maxLoopIterations));

    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinClusterLengthSum", m_minClusterLengthSum));

    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinSeparationDistance", m_minSeparationDistance));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MinDirectionDeviationCosAngle", m_minDirectionDeviationCosAngle));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MaxPredictedMergePointOffset", m_maxPredictedMergePointOffset));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "DistanceToLine", m_distanceToLine));

    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "BoundaryTolerance", m_boundaryTolerance));

    return TrackRefinementBaseAlgorithm::ReadSettings(xmlHandle);
}

void lar_content::TrackRefinementBaseAlgorithm::RemoveClusterFromContainers ( const pandora::Cluster *const  pClustertoRemove, pandora::ClusterVector &  clusterVector, SlidingFitResultMapPair &  slidingFitResultMapPair  ) const

protectedinherited

Remove a cluster from the cluster vector and sliding fit maps.

Parameters

pClustertoRemove	the clusters to remove from the containers
clusterVector	the vector to store clusters considered within the algorithm
slidingFitResultMapPair	the {micro, macro} pair of [cluster -> TwoDSlidingFitResult] maps

Definition at line 804 of file TrackRefinementBaseAlgorithm.cc.

Referenced by ConsiderClusterAssociation(), and lar_content::TrackRefinementBaseAlgorithm::UpdateContainers().

{
    const TwoDSlidingFitResultMap::const_iterator microFitToDelete(slidingFitResultMapPair.first->find(pClusterToRemove));
    if (microFitToDelete != slidingFitResultMapPair.first->end())
        slidingFitResultMapPair.first->erase(microFitToDelete);

    const TwoDSlidingFitResultMap::const_iterator macroFitToDelete(slidingFitResultMapPair.second->find(pClusterToRemove));
    if (macroFitToDelete != slidingFitResultMapPair.second->end())
        slidingFitResultMapPair.second->erase(macroFitToDelete);

    const ClusterVector::const_iterator clusterToDelete(std::find(clusterVector.begin(), clusterVector.end(), pClusterToRemove));
    if (clusterToDelete != clusterVector.end())
        clusterVector.erase(clusterToDelete);
}

const Cluster * lar_content::TrackRefinementBaseAlgorithm::RemoveOffAxisHitsFromTrack ( const pandora::Cluster *const  pCluster, const pandora::CartesianVector &  splitPosition, const bool  isEndUpstream, const ClusterToCaloHitListMap &  clusterToCaloHitListMap, pandora::ClusterList &  remnantClusterList, TwoDSlidingFitResultMap &  microSlidingFitResultMap, TwoDSlidingFitResultMap &  macroSlidingFitResultMap  ) const

protectedinherited

Remove any hits in the upstream/downstream cluster that lie off of the main track axis (i.e. clustering errors)

Parameters

pCluster	the input cluster
splitPosition	the position after which hits are considered for removal
isEndUpstream	whether the upstream end is to be refined
clusterToCaloHitListMap	the map [parent cluster -> list of hits which belong to the main track]
remnantClusterList	the input list to store the remnant clusters
microSlidingFitResultMap	the mapping [cluster -> TwoDSlidingFitResult] where fits correspond to local gradients
macroSlidingFitResultMap	the mapping [cluster -> TwoDSlidingFitResult] where fits correspond to global cluster gradients

Returns

the address of the (possibly) modified cluster

Definition at line 495 of file TrackRefinementBaseAlgorithm.cc.

References f, and lar_content::TwoDSlidingFitResult::GetLocalPosition().

Referenced by CreateMainTrack().

{
    float rL(0.f), rT(0.f);
    const TwoDSlidingFitResult &microFitResult(microSlidingFitResultMap.at(pCluster));
    microFitResult.GetLocalPosition(splitPosition, rL, rT);

    const TwoDSlidingFitResult &macroFitResult(macroSlidingFitResultMap.at(pCluster));
    CartesianVector averageDirection(0.f, 0.f, 0.f);
    macroFitResult.GetGlobalDirection(macroFitResult.GetLayerFitResultMap().begin()->second.GetGradient(), averageDirection);

    const bool isVertical(std::fabs(averageDirection.GetX()) < std::numeric_limits<float>::epsilon());
    const float clusterGradient(isVertical ? 0.f : averageDirection.GetZ() / averageDirection.GetX());
    const float clusterIntercept(isVertical ? splitPosition.GetX() : splitPosition.GetZ() - (clusterGradient * splitPosition.GetX()));

    // Fragmentation initialisation
    std::string originalListName, fragmentListName;
    const ClusterList originalClusterList(1, pCluster);
    PANDORA_THROW_RESULT_IF(
        STATUS_CODE_SUCCESS, !=, PandoraContentApi::InitializeFragmentation(*this, originalClusterList, originalListName, fragmentListName));

    const Cluster *pMainTrackCluster(nullptr), *pAboveCluster(nullptr), *pBelowCluster(nullptr);

    const OrderedCaloHitList &orderedCaloHitList(pCluster->GetOrderedCaloHitList());
    for (const OrderedCaloHitList::value_type &mapEntry : orderedCaloHitList)
    {
        for (const CaloHit *const pCaloHit : *mapEntry.second)
        {
            const CartesianVector &hitPosition(pCaloHit->GetPositionVector());
            float thisL(0.f), thisT(0.f);

            microFitResult.GetLocalPosition(pCaloHit->GetPositionVector(), thisL, thisT);

            bool isAnExtrapolatedHit(false);
            const auto extrapolatedCaloHitIter(clusterToCaloHitListMap.find(pCluster));

            if (extrapolatedCaloHitIter != clusterToCaloHitListMap.end())
                isAnExtrapolatedHit = std::find(extrapolatedCaloHitIter->second.begin(), extrapolatedCaloHitIter->second.end(), pCaloHit) !=
                    extrapolatedCaloHitIter->second.end();

            const bool isAbove(((clusterGradient * hitPosition.GetX()) + clusterIntercept) < (isVertical ? hitPosition.GetX() : hitPosition.GetZ()));
            const bool isToRemove(!isAnExtrapolatedHit && (((thisL < rL) && isEndUpstream) || ((thisL > rL) && !isEndUpstream)));

            const Cluster *&pClusterToModify(isToRemove ? (isAbove ? pAboveCluster : pBelowCluster) : pMainTrackCluster);

            if (pClusterToModify)
            {
                PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToCluster(*this, pClusterToModify, pCaloHit));
            }
            else
            {
                PandoraContentApi::Cluster::Parameters parameters;
                parameters.m_caloHitList.push_back(pCaloHit);
                PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Cluster::Create(*this, parameters, pClusterToModify));

                if (pClusterToModify != pMainTrackCluster)
                    remnantClusterList.push_back(pClusterToModify);
            }
        }
    }

    // End fragmentation
    if (pAboveCluster || pBelowCluster)
    {
        PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::EndFragmentation(*this, fragmentListName, originalListName));
        return pMainTrackCluster;
    }
    else
    {
        PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::EndFragmentation(*this, originalListName, fragmentListName));
        return pCluster;
    }
}

void lar_content::TrackRefinementBaseAlgorithm::RepositionIfInGap ( const pandora::CartesianVector &  mergeDirection, pandora::CartesianVector &  trackPoint  ) const

protectedinherited

Move an input position to the higher line gap edge if it lies within a gap.

Parameters

mergeDirection	the direction of the track
trackPoint	the input position

Definition at line 340 of file TrackRefinementBaseAlgorithm.cc.

Referenced by lar_content::TrackRefinementBaseAlgorithm::GetTrackSegmentBoundaries().

{
    const DetectorGapList detectorGapList(this->GetPandora().GetGeometry()->GetDetectorGapList());
    for (const DetectorGap *const pDetectorGap : detectorGapList)
    {
        const LineGap *const pLineGap(dynamic_cast<const LineGap *>(pDetectorGap));

        if (pLineGap)
        {
            const LineGapType lineGapType(pLineGap->GetLineGapType());

            if (lineGapType == TPC_DRIFT_GAP)
            {
                if ((pLineGap->GetLineStartX() < trackPoint.GetX()) && (pLineGap->GetLineEndX() > trackPoint.GetX()))
                {
                    if (std::fabs(mergeDirection.GetX()) < std::numeric_limits<float>::epsilon())
                        throw StatusCodeException(STATUS_CODE_FAILURE);

                    const float gradient(mergeDirection.GetZ() / mergeDirection.GetX());

                    trackPoint = CartesianVector(
                        pLineGap->GetLineEndX(), 0.f, trackPoint.GetZ() + (gradient * (pLineGap->GetLineEndX() - trackPoint.GetX())));
                }
            }

            if ((lineGapType == TPC_WIRE_GAP_VIEW_U) || (lineGapType == TPC_WIRE_GAP_VIEW_V) || (lineGapType == TPC_WIRE_GAP_VIEW_W))
            {
                if ((pLineGap->GetLineStartZ() < trackPoint.GetZ()) && (pLineGap->GetLineEndZ() > trackPoint.GetZ()))
                {
                    if (std::fabs(mergeDirection.GetZ()) < std::numeric_limits<float>::epsilon())
                        throw StatusCodeException(STATUS_CODE_FAILURE);

                    const float gradient(mergeDirection.GetX() / mergeDirection.GetZ());

                    trackPoint = CartesianVector(
                        trackPoint.GetX() + (gradient * (pLineGap->GetLineEndZ() - trackPoint.GetZ())), 0.f, pLineGap->GetLineEndZ());
                }
            }
        }
    }
}

StatusCode lar_content::TrackMergeRefinementAlgorithm::Run ( )

privatevirtual

Implements lar_content::TrackRefinementBaseAlgorithm.

Definition at line 34 of file TrackMergeRefinementAlgorithm.cc.

References lar_content::TrackRefinementBaseAlgorithm::AreExtrapolatedHitsGood(), ConsiderClusterAssociation(), CreateMainTrack(), FindBestClusterAssociation(), lar_content::ClusterPairAssociation::GetDownstreamCluster(), lar_content::ClusterAssociation::GetDownstreamMergePoint(), lar_content::TrackRefinementBaseAlgorithm::GetHitsInBoundingBox(), GetUnavailableProtectedClusters(), lar_content::ClusterPairAssociation::GetUpstreamCluster(), lar_content::ClusterAssociation::GetUpstreamMergePoint(), lar_content::TrackRefinementBaseAlgorithm::InitialiseContainers(), m_distanceToLine, m_maxLoopIterations, and lar_content::LArClusterHelper::SortByNHits().

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

    const CaloHitList *pCaloHitList(nullptr);
    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pCaloHitList));

    ClusterVector clusterVector;
    TwoDSlidingFitResultMap microSlidingFitResultMap, macroSlidingFitResultMap;
    SlidingFitResultMapPair slidingFitResultMapPair({&microSlidingFitResultMap, &macroSlidingFitResultMap});

    this->InitialiseContainers(pClusterList, LArClusterHelper::SortByNHits, clusterVector, slidingFitResultMapPair);

    // ATTN: Keep track of created main track clusters so their hits can be protected in future iterations
    unsigned int loopIterations(0);
    ClusterList createdMainTrackClusters;
    while (loopIterations < m_maxLoopIterations)
    {
        ++loopIterations;

        ClusterPairAssociation clusterAssociation;
        if (!this->FindBestClusterAssociation(clusterVector, slidingFitResultMapPair, clusterAssociation))
            break;

        ClusterList unavailableProtectedClusters;
        this->GetUnavailableProtectedClusters(clusterAssociation, createdMainTrackClusters, unavailableProtectedClusters);

        ClusterToCaloHitListMap clusterToCaloHitListMap;
        this->GetHitsInBoundingBox(clusterAssociation.GetUpstreamMergePoint(), clusterAssociation.GetDownstreamMergePoint(), pClusterList,
            clusterToCaloHitListMap, unavailableProtectedClusters, m_distanceToLine);

        if (!this->AreExtrapolatedHitsGood(clusterToCaloHitListMap, clusterAssociation))
        {
            this->ConsiderClusterAssociation(clusterAssociation, clusterVector, slidingFitResultMapPair);
            continue;
        }

        const ClusterList::const_iterator upstreamIter(
            std::find(createdMainTrackClusters.begin(), createdMainTrackClusters.end(), clusterAssociation.GetUpstreamCluster()));
        if (upstreamIter != createdMainTrackClusters.end())
            createdMainTrackClusters.erase(upstreamIter);

        const ClusterList::const_iterator downstreamIter(
            std::find(createdMainTrackClusters.begin(), createdMainTrackClusters.end(), clusterAssociation.GetDownstreamCluster()));
        if (downstreamIter != createdMainTrackClusters.end())
            createdMainTrackClusters.erase(downstreamIter);

        createdMainTrackClusters.push_back(
            this->CreateMainTrack(clusterAssociation, clusterToCaloHitListMap, pClusterList, clusterVector, slidingFitResultMapPair));
    }

    return STATUS_CODE_SUCCESS;
}

template<typename T >

void lar_content::TrackRefinementBaseAlgorithm::UpdateContainers ( const pandora::ClusterList &  clustersToAdd, const pandora::ClusterList &  clustersToDelete, const T  sortFunction, pandora::ClusterVector &  clusterVector, SlidingFitResultMapPair &  slidingFitResultMapPair  ) const

protectedinherited

Remove deleted clusters from the cluster vector and sliding fit maps and add in created clusters that are determined to be track-like.

Parameters

clustersToAdd	the list of clusters to add to the containers
clustersToDelete	the list of clusters to remove from the containers
sortFunction	the sort class or function used to sort the clusterVector
clusterVector	the vector to store clusters considered within the algorithm
slidingFitResultMapPair	the {micro, macro} pair of [cluster -> TwoDSlidingFitResult] maps

Referenced by CreateMainTrack().

template<typename T >

void lar_content::TrackRefinementBaseAlgorithm::UpdateContainers ( const ClusterList &  clustersToAdd, const ClusterList &  clustersToDelete, const T  sortFunction, ClusterVector &  clusterVector, SlidingFitResultMapPair &  slidingFitResultMapPair  ) const

inherited

Definition at line 792 of file TrackRefinementBaseAlgorithm.cc.

References lar_content::TrackRefinementBaseAlgorithm::InitialiseContainers(), and lar_content::TrackRefinementBaseAlgorithm::RemoveClusterFromContainers().

{
    //ATTN: Very important to first delete pointers from containers
    for (const Cluster *const pClusterToDelete : clustersToDelete)
        this->RemoveClusterFromContainers(pClusterToDelete, clusterVector, slidingFitResultMapPair);

    this->InitialiseContainers(&clustersToAdd, sortFunction, clusterVector, slidingFitResultMapPair);
}

Member Data Documentation

float lar_content::TrackMergeRefinementAlgorithm::m_boundaryTolerance

private

The maximum allowed distance of an extremal extrapolate hit to a cluster merge point.

Definition at line 105 of file TrackMergeRefinementAlgorithm.h.

Referenced by AreExtrapolatedHitsNearBoundaries(), and ReadSettings().

float lar_content::TrackMergeRefinementAlgorithm::m_distanceToLine

private

The threshold hit distance of an extrapolated hit from the segment connecting line.

Definition at line 104 of file TrackMergeRefinementAlgorithm.h.

Referenced by ReadSettings(), and Run().

bool lar_content::TrackRefinementBaseAlgorithm::m_hitWidthMode

protectedinherited

Whether to consider the width of hits.

Definition at line 318 of file TrackRefinementBaseAlgorithm.h.

Referenced by lar_content::TrackRefinementBaseAlgorithm::AreExtrapolatedHitsGood(), lar_content::TrackRefinementBaseAlgorithm::GetHitsInBoundingBox(), lar_content::TrackRefinementBaseAlgorithm::IsTrackContinuous(), lar_content::TrackRefinementBaseAlgorithm::SortByDistanceAlongLine::operator()(), and lar_content::TrackRefinementBaseAlgorithm::ReadSettings().

float lar_content::TrackRefinementBaseAlgorithm::m_lineSegmentLength

protectedinherited

The length of a track gap.

Definition at line 317 of file TrackRefinementBaseAlgorithm.h.

Referenced by lar_content::TrackRefinementBaseAlgorithm::GetTrackSegmentBoundaries(), and lar_content::TrackRefinementBaseAlgorithm::ReadSettings().

unsigned int lar_content::TrackRefinementBaseAlgorithm::m_macroSlidingFitWindow

protectedinherited

The sliding fit window used in the fits contained within the macroSlidingFitResultMap.

Definition at line 309 of file TrackRefinementBaseAlgorithm.h.

Referenced by lar_content::TrackRefinementBaseAlgorithm::InitialiseContainers(), and lar_content::TrackRefinementBaseAlgorithm::ReadSettings().

float lar_content::TrackRefinementBaseAlgorithm::m_maxDistanceFromMainTrack

protectedinherited

The threshold distance for a hit to be added to the main track.

Definition at line 313 of file TrackRefinementBaseAlgorithm.h.

Referenced by lar_content::TrackRefinementBaseAlgorithm::AddToNearestCluster(), and lar_content::TrackRefinementBaseAlgorithm::ReadSettings().

float lar_content::TrackRefinementBaseAlgorithm::m_maxHitDistanceFromCluster

protectedinherited

The threshold separation between a hit and cluster for the hit to be merged into the cluster.

Definition at line 314 of file TrackRefinementBaseAlgorithm.h.

Referenced by lar_content::TrackRefinementBaseAlgorithm::AddToNearestCluster(), lar_content::TrackRefinementBaseAlgorithm::FragmentRemnantCluster(), and lar_content::TrackRefinementBaseAlgorithm::ReadSettings().

float lar_content::TrackRefinementBaseAlgorithm::m_maxHitSeparationForConnectedCluster

protectedinherited

The maximum separation between two adjacent (in z) hits in a connected cluster.

Definition at line 315 of file TrackRefinementBaseAlgorithm.h.

Referenced by lar_content::TrackRefinementBaseAlgorithm::IsClusterRemnantDisconnected(), and lar_content::TrackRefinementBaseAlgorithm::ReadSettings().

unsigned int lar_content::TrackMergeRefinementAlgorithm::m_maxLoopIterations

private

The maximum number of main loop iterations.

Definition at line 99 of file TrackMergeRefinementAlgorithm.h.

Referenced by ReadSettings(), and Run().

float lar_content::TrackMergeRefinementAlgorithm::m_maxPredictedMergePointOffset

private

The threshold separation distance between the predicted and true cluster merge points.

Definition at line 103 of file TrackMergeRefinementAlgorithm.h.

Referenced by AreClustersAssociated(), and ReadSettings().

unsigned int lar_content::TrackRefinementBaseAlgorithm::m_maxTrackGaps

protectedinherited

The maximum number of graps allowed in the extrapolated hit vector.

Definition at line 316 of file TrackRefinementBaseAlgorithm.h.

Referenced by lar_content::TrackRefinementBaseAlgorithm::IsTrackContinuous(), and lar_content::TrackRefinementBaseAlgorithm::ReadSettings().

float lar_content::TrackRefinementBaseAlgorithm::m_mergePointMinCosAngleDeviation

protectedinherited

The threshold cos opening angle between the cluster local gradient and the associated cluster global gradient used to determine merge points.

Definition at line 311 of file TrackRefinementBaseAlgorithm.h.

Referenced by lar_content::TrackRefinementBaseAlgorithm::GetClusterMergingCoordinates(), and lar_content::TrackRefinementBaseAlgorithm::ReadSettings().

unsigned int lar_content::TrackRefinementBaseAlgorithm::m_microSlidingFitWindow

protectedinherited

The sliding fit window used in the fits contained within the microSlidingFitResultMap.

Definition at line 308 of file TrackRefinementBaseAlgorithm.h.

Referenced by lar_content::TrackRefinementBaseAlgorithm::InitialiseContainers(), and lar_content::TrackRefinementBaseAlgorithm::ReadSettings().

float lar_content::TrackRefinementBaseAlgorithm::m_minClusterLength

protectedinherited

The minimum length of a considered cluster.

Definition at line 307 of file TrackRefinementBaseAlgorithm.h.

Referenced by lar_content::TrackRefinementBaseAlgorithm::AddHitsToMainTrack(), lar_content::TrackRefinementBaseAlgorithm::InitialiseContainers(), and lar_content::TrackRefinementBaseAlgorithm::ReadSettings().

float lar_content::TrackMergeRefinementAlgorithm::m_minClusterLengthSum

private

The threshold cluster and associated cluster length sum.

Definition at line 100 of file TrackMergeRefinementAlgorithm.h.

Referenced by FindBestClusterAssociation(), and ReadSettings().

float lar_content::TrackMergeRefinementAlgorithm::m_minDirectionDeviationCosAngle

private

The threshold cos opening angle of the associated cluster directions.

Definition at line 102 of file TrackMergeRefinementAlgorithm.h.

Referenced by AreClustersAssociated(), and ReadSettings().

float lar_content::TrackRefinementBaseAlgorithm::m_minHitFractionForHitRemoval

protectedinherited

The threshold fraction of hits to be removed from the cluster for hit removal to proceed.

Definition at line 312 of file TrackRefinementBaseAlgorithm.h.

Referenced by lar_content::TrackRefinementBaseAlgorithm::AddHitsToMainTrack(), and lar_content::TrackRefinementBaseAlgorithm::ReadSettings().

float lar_content::TrackMergeRefinementAlgorithm::m_minSeparationDistance

private

The threshold separation distance between associated clusters.

Definition at line 101 of file TrackMergeRefinementAlgorithm.h.

Referenced by AreClustersAssociated(), and ReadSettings().

float lar_content::TrackRefinementBaseAlgorithm::m_stableRegionClusterFraction

protectedinherited

The threshold fraction of fit contributing layers which defines the stable region.

Definition at line 310 of file TrackRefinementBaseAlgorithm.h.

Referenced by lar_content::TrackRefinementBaseAlgorithm::GetClusterMergingCoordinates(), and lar_content::TrackRefinementBaseAlgorithm::ReadSettings().

---

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

• larpandoracontent/v04_08_01/source/larpandoracontent/LArTwoDReco/LArCosmicRay/TrackMergeRefinementAlgorithm.h
• larpandoracontent/v04_08_01/source/larpandoracontent/LArTwoDReco/LArCosmicRay/TrackMergeRefinementAlgorithm.cc