lar_content::MissingTrackSegmentTool Class Reference

MissingTrackSegmentTool class. More...

#include <MissingTrackSegmentTool.h>

Inheritance diagram for lar_content::MissingTrackSegmentTool:

Classes
class	Particle
	Particle class. More...
class	SegmentOverlap
	SegmentOverlap class. More...

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

Private Types
typedef std::unordered_map < const pandora::Cluster *, SegmentOverlap >	SegmentOverlapMap
typedef std::unordered_map < const pandora::Cluster *, pandora::ClusterList >	ClusterMergeMap

Private Member Functions
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)
void	FindTracks (ThreeViewTransverseTracksAlgorithm *const pAlgorithm, const TensorType &overlapTensor, ProtoParticleVector &protoParticleVector, ClusterMergeMap &clusterMergeMap) const
	Find remaining tracks, hidden by missing track segments (and maybe other ambiguities) in the tensor. More...
void	SelectElements (const TensorType::ElementList &elementList, const pandora::ClusterSet &usedClusters, IteratorList &iteratorList) const
	Select a list of the relevant elements from a set of connected tensor elements. More...
bool	PassesParticleChecks (ThreeViewTransverseTracksAlgorithm *const pAlgorithm, const TensorType::Element &element, pandora::ClusterSet &usedClusters, ClusterMergeMap &clusterMergeMap) const
	Whether a provided tensor element can be used to construct a pfo. More...
void	GetCandidateClusters (ThreeViewTransverseTracksAlgorithm *const pAlgorithm, const Particle &particle, pandora::ClusterList &candidateClusters) const
	Get a list of candidate clusters, which may represent missing track segments for a provided particle. More...
void	GetSlidingFitResultMap (ThreeViewTransverseTracksAlgorithm *const pAlgorithm, const pandora::ClusterList &candidateClusterList, TwoDSlidingFitResultMap &slidingFitResultMap) const
	Get a sliding fit result map for the list of candidate clusters. More...
void	GetSegmentOverlapMap (ThreeViewTransverseTracksAlgorithm *const pAlgorithm, const Particle &particle, const TwoDSlidingFitResultMap &slidingFitResultMap, SegmentOverlapMap &segmentOverlapMap) const
	Get a segment overlap map, describing overlap between a provided particle and all clusters in a sliding fit result map. More...
bool	MakeDecisions (const Particle &particle, const TwoDSlidingFitResultMap &slidingFitResultMap, const SegmentOverlapMap &segmentOverlapMap, pandora::ClusterSet &usedClusters, ClusterMergeMap &clusterMergeMap) const
	Make decisions about whether to create a pfo for a provided particle and whether to make cluster merges. More...
bool	PassesSamplingCuts (const SegmentOverlap &segmentOverlap) const
	Whether the segment overlap object passes cuts on matched sampling points, etc. More...
bool	IsPossibleMerge (const pandora::Cluster *const pCluster, const Particle &particle, const SegmentOverlap &segmentOverlap, const TwoDSlidingFitResultMap &slidingFitResultMap) const
	Whether the cluster could be merged with the candidate particle. More...

Private Attributes
float	m_minMatchedFraction
	The min matched sampling point fraction for particle creation. More...
unsigned int	m_minMatchedSamplingPoints
	The min number of matched sampling points for particle creation. More...
unsigned int	m_minMatchedSamplingPointRatio
	The min ratio between 1st and 2nd highest msps for simple ambiguity resolution. More...
float	m_minInitialXOverlapFraction
	The min x overlap fraction (between long clusters and short cluster vs. shared overlap) More...
float	m_minFinalXOverlapFraction
	The min x overlap fraction between extended short cluster and the long clusters. More...
unsigned int	m_minCaloHitsInCandidateCluster
	The min no. of calo hits in a candidate cluster, for matching with long clusters. More...
float	m_pseudoChi2Cut
	The pseudo chi2 cut to determine whether a sampling point is matched. More...
unsigned int	m_makePfoMinSamplingPoints
	The min number of sampling points in order to be able to make pfo. More...
unsigned int	m_makePfoMinMatchedSamplingPoints
	The min number of matched sampling points in order to be able to make pfo. More...
float	m_makePfoMinMatchedFraction
	The min matched sampling point fraction in order to be able to make pfo. More...
float	m_makePfoMaxImpactParameter
	The max transverse impact parameter in order to be able to make pfo. More...
float	m_mergeMaxChi2PerSamplingPoint
	The max value of chi2 per sampling point in order to merge cluster with parent. More...
float	m_mergeXContainmentTolerance
	The tolerance in determining whether candidate cluster is contained in x window. More...

Additional Inherited Members
Public Types inherited from lar_content::TransverseTensorTool
typedef ThreeViewTransverseTracksAlgorithm::MatchingType::TensorType	TensorType
typedef std::vector < TensorType::ElementList::const_iterator >	IteratorList

Detailed Description

MissingTrackSegmentTool class.

Definition at line 21 of file MissingTrackSegmentTool.h.

Member Typedef Documentation

typedef std::unordered_map<const pandora::Cluster *, pandora::ClusterList> lar_content::MissingTrackSegmentTool::ClusterMergeMap

private

Definition at line 78 of file MissingTrackSegmentTool.h.

typedef std::unordered_map<const pandora::Cluster *, SegmentOverlap> lar_content::MissingTrackSegmentTool::SegmentOverlapMap

private

Definition at line 77 of file MissingTrackSegmentTool.h.

Constructor & Destructor Documentation

lar_content::MissingTrackSegmentTool::MissingTrackSegmentTool

(

)

Default constructor.

Definition at line 25 of file MissingTrackSegmentTool.cc.

                                                 :
    m_minMatchedFraction(0.9f),
    m_minMatchedSamplingPoints(10),
    m_minMatchedSamplingPointRatio(2),
    m_minInitialXOverlapFraction(0.75f),
    m_minFinalXOverlapFraction(0.75f),
    m_minCaloHitsInCandidateCluster(5),
    m_pseudoChi2Cut(1.f),
    m_makePfoMinSamplingPoints(5),
    m_makePfoMinMatchedSamplingPoints(5),
    m_makePfoMinMatchedFraction(0.8f),
    m_makePfoMaxImpactParameter(3.f),
    m_mergeMaxChi2PerSamplingPoint(0.25f),
    m_mergeXContainmentTolerance(1.f)
{
}

Member Function Documentation

void lar_content::MissingTrackSegmentTool::FindTracks ( ThreeViewTransverseTracksAlgorithm *const  pAlgorithm, const TensorType &  overlapTensor, ProtoParticleVector &  protoParticleVector, ClusterMergeMap &  clusterMergeMap  ) const

private

Find remaining tracks, hidden by missing track segments (and maybe other ambiguities) in the tensor.

Parameters

pAlgorithm	address of the calling algorithm
overlapTensor	the overlap tensor
protoParticleVector	to receive the list of proto particles
clusterMergeMap	to receive the cluster merge map

Definition at line 61 of file MissingTrackSegmentTool.cc.

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

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

        unsigned int nU(0), nV(0), nW(0);
        TensorType::ElementList elementList;
        overlapTensor.GetConnectedElements(pKeyCluster, true, elementList, nU, nV, nW);

        IteratorList iteratorList;
        this->SelectElements(elementList, usedClusters, iteratorList);

        for (IteratorList::const_iterator iIter = iteratorList.begin(), iIterEnd = iteratorList.end(); iIter != iIterEnd; ++iIter)
        {
            if (LongTracksTool::HasLongDirectConnections(iIter, iteratorList))
                continue;

            if (!LongTracksTool::IsLongerThanDirectConnections(iIter, elementList, m_minMatchedSamplingPointRatio, usedClusters))
                continue;

            if (!this->PassesParticleChecks(pAlgorithm, *(*iIter), usedClusters, clusterMergeMap))
                continue;

            ProtoParticle protoParticle;
            protoParticle.m_clusterList.push_back((*iIter)->GetClusterU());
            protoParticle.m_clusterList.push_back((*iIter)->GetClusterV());
            protoParticle.m_clusterList.push_back((*iIter)->GetClusterW());
            protoParticleVector.push_back(protoParticle);

            usedClusters.insert((*iIter)->GetClusterU());
            usedClusters.insert((*iIter)->GetClusterV());
            usedClusters.insert((*iIter)->GetClusterW());
        }
    }
}

void lar_content::MissingTrackSegmentTool::GetCandidateClusters ( ThreeViewTransverseTracksAlgorithm *const  pAlgorithm, const Particle &  particle, pandora::ClusterList &  candidateClusters  ) const

private

Get a list of candidate clusters, which may represent missing track segments for a provided particle.

Parameters

pAlgorithm	address of the calling algorithm
particle	the particle
candidateClusters	to receive the list of candidate clusters

Definition at line 175 of file MissingTrackSegmentTool.cc.

{
    const ClusterList &clusterList(pAlgorithm->GetInputClusterList(particle.m_shortHitType));

    for (ClusterList::const_iterator iter = clusterList.begin(), iterEnd = clusterList.end(); iter != iterEnd; ++iter)
    {
        const Cluster *const pCluster(*iter);

        if (pCluster == particle.m_pShortCluster)
            continue;

        if (pCluster->GetNCaloHits() < m_minCaloHitsInCandidateCluster)
            continue;

        candidateClusters.push_back(pCluster);
    }
}

void lar_content::MissingTrackSegmentTool::GetSegmentOverlapMap ( ThreeViewTransverseTracksAlgorithm *const  pAlgorithm, const Particle &  particle, const TwoDSlidingFitResultMap &  slidingFitResultMap, SegmentOverlapMap &  segmentOverlapMap  ) const

private

Get a segment overlap map, describing overlap between a provided particle and all clusters in a sliding fit result map.

Parameters

pAlgorithm	address of the calling algorithm
particle	the particle
slidingFitResultMap	the sliding fit result map
segmentOverlapMap	to receive the segment overlap map

Definition at line 229 of file MissingTrackSegmentTool.cc.

{
    const TwoDSlidingFitResult &fitResult1(pAlgorithm->GetCachedSlidingFitResult(particle.m_pCluster1));
    const TwoDSlidingFitResult &fitResult2(pAlgorithm->GetCachedSlidingFitResult(particle.m_pCluster2));

    const float nPoints1(std::fabs(static_cast<float>(fitResult1.GetMaxLayer() - fitResult1.GetMinLayer())));
    const float nPoints2(std::fabs(static_cast<float>(fitResult2.GetMaxLayer() - fitResult2.GetMinLayer())));

    const unsigned int nPoints(static_cast<unsigned int>(1.f + (nPoints1 + nPoints2) / 2.f));

    ClusterList clusterList;
    for (const auto &mapEntry : slidingFitResultMap)
        clusterList.push_back(mapEntry.first);
    clusterList.sort(LArClusterHelper::SortByNHits);

    for (unsigned n = 0; n <= nPoints; ++n)
    {
        const float x(particle.m_longMinX + (particle.m_longMaxX - particle.m_longMinX) * static_cast<float>(n) / static_cast<float>(nPoints));

        if ((x > particle.m_shortMinX) && (x < particle.m_shortMaxX))
            continue;

        CartesianVector fitVector1(0.f, 0.f, 0.f), fitVector2(0.f, 0.f, 0.f);

        if ((STATUS_CODE_SUCCESS != fitResult1.GetGlobalFitPositionAtX(x, fitVector1)) ||
            (STATUS_CODE_SUCCESS != fitResult2.GetGlobalFitPositionAtX(x, fitVector2)))
        {
            continue;
        }

        const float prediction(LArGeometryHelper::MergeTwoPositions(
            this->GetPandora(), particle.m_hitType1, particle.m_hitType2, fitVector1.GetZ(), fitVector2.GetZ()));

        for (const Cluster *const pCluster : clusterList)
        {
            const TwoDSlidingFitResult &slidingFitResult(slidingFitResultMap.at(pCluster));
            CartesianVector fitVector(0.f, 0.f, 0.f), fitDirection(0.f, 0.f, 0.f);

            if ((STATUS_CODE_SUCCESS != slidingFitResult.GetGlobalFitPositionAtX(x, fitVector)) ||
                (STATUS_CODE_SUCCESS != slidingFitResult.GetGlobalFitDirectionAtX(x, fitDirection)))
            {
                continue;
            }

            const float delta((prediction - fitVector.GetZ()) * fitDirection.GetX());
            const float pseudoChi2(delta * delta);

            SegmentOverlap &segmentOverlap(segmentOverlapMap[pCluster]);
            ++segmentOverlap.m_nSamplingPoints;
            segmentOverlap.m_pseudoChi2Sum += pseudoChi2;

            if (pseudoChi2 < m_pseudoChi2Cut)
            {
                ++segmentOverlap.m_nMatchedSamplingPoints;
                segmentOverlap.m_matchedSamplingMinX = std::min(x, segmentOverlap.m_matchedSamplingMinX);
                segmentOverlap.m_matchedSamplingMaxX = std::max(x, segmentOverlap.m_matchedSamplingMaxX);
            }
        }
    }
}

void lar_content::MissingTrackSegmentTool::GetSlidingFitResultMap ( ThreeViewTransverseTracksAlgorithm *const  pAlgorithm, const pandora::ClusterList &  candidateClusterList, TwoDSlidingFitResultMap &  slidingFitResultMap  ) const

private

Get a sliding fit result map for the list of candidate clusters.

Parameters

pAlgorithm	address of the calling algorithm
candidateClusters	the list of candidate clusters
slidingFitResultMap	to receive the sliding fit result map

Definition at line 196 of file MissingTrackSegmentTool.cc.

{
    const float slidingFitPitch(LArGeometryHelper::GetWireZPitch(this->GetPandora()));

    for (ClusterList::const_iterator iter = candidateClusterList.begin(), iterEnd = candidateClusterList.end(); iter != iterEnd; ++iter)
    {
        const Cluster *const pCluster(*iter);

        try
        {
            const TwoDSlidingFitResult &slidingFitResult(pAlgorithm->GetCachedSlidingFitResult(pCluster));
            (void)slidingFitResultMap.insert(TwoDSlidingFitResultMap::value_type(pCluster, slidingFitResult));
            continue;
        }
        catch (StatusCodeException &)
        {
        }

        try
        {
            const TwoDSlidingFitResult slidingFitResult(pCluster, pAlgorithm->GetSlidingFitWindow(), slidingFitPitch);
            (void)slidingFitResultMap.insert(TwoDSlidingFitResultMap::value_type(pCluster, slidingFitResult));
            continue;
        }
        catch (StatusCodeException &)
        {
        }
    }
}

bool lar_content::MissingTrackSegmentTool::IsPossibleMerge ( const pandora::Cluster *const  pCluster, const Particle &  particle, const SegmentOverlap &  segmentOverlap, const TwoDSlidingFitResultMap &  slidingFitResultMap  ) const

private

Whether the cluster could be merged with the candidate particle.

Parameters

pCluster	address of the cluster
particle	the particle
segmentOverlap	the segment overlap
slidingFitResultMap	the sliding fit result map

Returns

boolean

Definition at line 358 of file MissingTrackSegmentTool.cc.

{
    if ((segmentOverlap.m_pseudoChi2Sum / static_cast<float>(segmentOverlap.m_nSamplingPoints)) > m_mergeMaxChi2PerSamplingPoint)
        return false;

    TwoDSlidingFitResultMap::const_iterator fitIter = slidingFitResultMap.find(pCluster);

    if (slidingFitResultMap.end() == fitIter)
        throw StatusCodeException(STATUS_CODE_FAILURE);

    float mergeMinX(std::numeric_limits<float>::max()), mergeMaxX(-std::numeric_limits<float>::max());
    fitIter->second.GetMinAndMaxX(mergeMinX, mergeMaxX);

    // cluster should not be wider than the longest span
    if ((mergeMinX < particle.m_longMinX - m_mergeXContainmentTolerance) || (mergeMaxX > particle.m_longMaxX + m_mergeXContainmentTolerance))
        return false;

    // cluster should not overlap with the shortest span
    if ((mergeMinX < particle.m_shortMaxX - m_mergeXContainmentTolerance) && (mergeMaxX > particle.m_shortMinX + m_mergeXContainmentTolerance))
        return false;

    return true;
}

bool lar_content::MissingTrackSegmentTool::MakeDecisions ( const Particle &  particle, const TwoDSlidingFitResultMap &  slidingFitResultMap, const SegmentOverlapMap &  segmentOverlapMap, pandora::ClusterSet &  usedClusters, ClusterMergeMap &  clusterMergeMap  ) const

private

Make decisions about whether to create a pfo for a provided particle and whether to make cluster merges.

Parameters

particle	the particle
slidingFitResultMap	the sliding fit result map
segmentOverlapMap	the segment overlap map
usedClusters	the list of used clusters
clusterMergeMap	to receive details of cluster merges clusterMergeMap

Returns

whether to make the particle

Definition at line 293 of file MissingTrackSegmentTool.cc.

{
    ClusterVector possibleMerges;
    float shortMinX(particle.m_shortMinX), shortMaxX(particle.m_shortMaxX);
    bool matchesACluster(false);

    ClusterVector sortedClusters;
    for (const auto &mapEntry : segmentOverlapMap)
        sortedClusters.push_back(mapEntry.first);
    std::sort(sortedClusters.begin(), sortedClusters.end(), LArClusterHelper::SortByNHits);

    for (const Cluster *const pCluster : sortedClusters)
    {
        const SegmentOverlap &segmentOverlap(segmentOverlapMap.at(pCluster));

        if (!this->PassesSamplingCuts(segmentOverlap))
            continue;

        shortMinX = std::min(segmentOverlap.m_matchedSamplingMinX, shortMinX);
        shortMaxX = std::max(segmentOverlap.m_matchedSamplingMaxX, shortMaxX);
        matchesACluster = true;

        // Allow pfo construction if find hits in an unavailable cluster, but can't merge unavailable cluster into this pfo
        if (!usedClusters.insert(pCluster).second || !pCluster->IsAvailable())
            continue;

        if (!this->IsPossibleMerge(pCluster, particle, segmentOverlap, slidingFitResultMap))
            continue;

        possibleMerges.push_back(pCluster);
    }

    if (std::fabs(particle.m_longMaxX - particle.m_longMinX) < std::numeric_limits<float>::epsilon())
        throw StatusCodeException(STATUS_CODE_FAILURE);

    if (!matchesACluster || possibleMerges.empty())
        return false;

    if (((shortMaxX - shortMinX) / (particle.m_longMaxX - particle.m_longMinX)) < m_minFinalXOverlapFraction)
        return false;

    ClusterList &clusterList(clusterMergeMap[particle.m_pShortCluster]);
    clusterList.insert(clusterList.end(), possibleMerges.begin(), possibleMerges.end());
    return true;
}

bool lar_content::MissingTrackSegmentTool::PassesParticleChecks ( ThreeViewTransverseTracksAlgorithm *const  pAlgorithm, const TensorType::Element &  element, pandora::ClusterSet &  usedClusters, ClusterMergeMap &  clusterMergeMap  ) const

private

Whether a provided tensor element can be used to construct a pfo.

Parameters

pAlgorithm	address of the calling algorithm
element	the tensor element
usedClusters	the list of used clusters
clusterMergeMap	to receive the cluster merge map

Definition at line 140 of file MissingTrackSegmentTool.cc.

{
    try
    {
        const Particle particle(element);

        ClusterList candidateClusters;
        this->GetCandidateClusters(pAlgorithm, particle, candidateClusters);

        if (candidateClusters.empty())
            return false;

        TwoDSlidingFitResultMap slidingFitResultMap;
        this->GetSlidingFitResultMap(pAlgorithm, candidateClusters, slidingFitResultMap);

        if (slidingFitResultMap.empty())
            return false;

        SegmentOverlapMap segmentOverlapMap;
        this->GetSegmentOverlapMap(pAlgorithm, particle, slidingFitResultMap, segmentOverlapMap);

        if (segmentOverlapMap.empty())
            return false;

        return this->MakeDecisions(particle, slidingFitResultMap, segmentOverlapMap, usedClusters, clusterMergeMap);
    }
    catch (StatusCodeException &)
    {
        return false;
    }
}

bool lar_content::MissingTrackSegmentTool::PassesSamplingCuts ( const SegmentOverlap &  segmentOverlap ) const

private

Whether the segment overlap object passes cuts on matched sampling points, etc.

Parameters

segmentOverlap

the segment overlap

Returns

boolean

Definition at line 342 of file MissingTrackSegmentTool.cc.

{
    if (0 == segmentOverlap.m_nSamplingPoints)
        return false;

    if ((segmentOverlap.m_nSamplingPoints < m_makePfoMinSamplingPoints) || (segmentOverlap.m_nMatchedSamplingPoints < m_makePfoMinMatchedSamplingPoints))
        return false;

    if ((static_cast<float>(segmentOverlap.m_nMatchedSamplingPoints) / static_cast<float>(segmentOverlap.m_nSamplingPoints)) < m_makePfoMinMatchedFraction)
        return false;

    return true;
}

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

private

Definition at line 419 of file MissingTrackSegmentTool.cc.

{
    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinMatchedFraction", m_minMatchedFraction));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MinMatchedSamplingPoints", m_minMatchedSamplingPoints));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MinMatchedSamplingPointRatio", m_minMatchedSamplingPointRatio));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MinInitialXOverlapFraction", m_minInitialXOverlapFraction));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MinFinalXOverlapFraction", m_minFinalXOverlapFraction));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MinCaloHitsInCandidateCluster", m_minCaloHitsInCandidateCluster));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "PseudoChi2Cut", m_pseudoChi2Cut));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MakePfoMinSamplingPoints", m_makePfoMinSamplingPoints));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MakePfoMinMatchedSamplingPoints", m_makePfoMinMatchedSamplingPoints));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MakePfoMinMatchedFraction", m_makePfoMinMatchedFraction));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MakePfoMaxImpactParameter", m_makePfoMaxImpactParameter));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MergeMaxChi2PerSamplingPoint", m_mergeMaxChi2PerSamplingPoint));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MergeXContainmentTolerance", m_mergeXContainmentTolerance));

    return STATUS_CODE_SUCCESS;
}

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

virtual

Run the algorithm tool.

Parameters

pAlgorithm	address of the calling algorithm
overlapTensor	the overlap tensor

Returns

whether changes have been made by the tool

Implements lar_content::TransverseTensorTool.

Definition at line 44 of file MissingTrackSegmentTool.cc.

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

    ProtoParticleVector protoParticleVector;
    ClusterMergeMap clusterMergeMap;
    this->FindTracks(pAlgorithm, overlapTensor, protoParticleVector, clusterMergeMap);

    const bool particlesMade(pAlgorithm->CreateThreeDParticles(protoParticleVector));
    const bool mergesMade(pAlgorithm->MakeClusterMerges(clusterMergeMap));

    return (particlesMade || mergesMade);
}

void lar_content::MissingTrackSegmentTool::SelectElements ( const TensorType::ElementList &  elementList, const pandora::ClusterSet &  usedClusters, IteratorList &  iteratorList  ) const

private

Select a list of the relevant elements from a set of connected tensor elements.

Parameters

elementList	the full list of connected tensor elements
usedClusters	the list of clusters already marked as to be added to a pfo
iteratorList	to receive a list of iterators to long track-like elements

Definition at line 106 of file MissingTrackSegmentTool.cc.

{
    for (TensorType::ElementList::const_iterator eIter = elementList.begin(); eIter != elementList.end(); ++eIter)
    {
        if (usedClusters.count(eIter->GetClusterU()) || usedClusters.count(eIter->GetClusterV()) || usedClusters.count(eIter->GetClusterW()))
            continue;

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

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

        const XOverlap &xOverlap(eIter->GetOverlapResult().GetXOverlap());
        const float shortSpan(std::min(xOverlap.GetXSpanU(), std::min(xOverlap.GetXSpanV(), xOverlap.GetXSpanW())));
        const float longSpan1(std::max(xOverlap.GetXSpanU(), std::max(xOverlap.GetXSpanV(), xOverlap.GetXSpanW())));
        const float longSpan2(
            ((xOverlap.GetXSpanU() > shortSpan) && (xOverlap.GetXSpanU() < longSpan1))
                ? xOverlap.GetXSpanU()
                : ((xOverlap.GetXSpanV() > shortSpan) && (xOverlap.GetXSpanV() < longSpan1)) ? xOverlap.GetXSpanV() : xOverlap.GetXSpanW());

        if ((xOverlap.GetXOverlapSpan() < std::numeric_limits<float>::epsilon()) || (longSpan1 < std::numeric_limits<float>::epsilon()))
            continue;

        if (((shortSpan / xOverlap.GetXOverlapSpan()) < m_minInitialXOverlapFraction) || ((longSpan2 / longSpan1) < m_minInitialXOverlapFraction))
            continue;

        iteratorList.push_back(eIter);
    }
}

Member Data Documentation

float lar_content::MissingTrackSegmentTool::m_makePfoMaxImpactParameter

private

The max transverse impact parameter in order to be able to make pfo.

Definition at line 190 of file MissingTrackSegmentTool.h.

float lar_content::MissingTrackSegmentTool::m_makePfoMinMatchedFraction

private

The min matched sampling point fraction in order to be able to make pfo.

Definition at line 189 of file MissingTrackSegmentTool.h.

unsigned int lar_content::MissingTrackSegmentTool::m_makePfoMinMatchedSamplingPoints

private

The min number of matched sampling points in order to be able to make pfo.

Definition at line 188 of file MissingTrackSegmentTool.h.

unsigned int lar_content::MissingTrackSegmentTool::m_makePfoMinSamplingPoints

private

The min number of sampling points in order to be able to make pfo.

Definition at line 187 of file MissingTrackSegmentTool.h.

float lar_content::MissingTrackSegmentTool::m_mergeMaxChi2PerSamplingPoint

private

The max value of chi2 per sampling point in order to merge cluster with parent.

Definition at line 192 of file MissingTrackSegmentTool.h.

float lar_content::MissingTrackSegmentTool::m_mergeXContainmentTolerance

private

The tolerance in determining whether candidate cluster is contained in x window.

Definition at line 193 of file MissingTrackSegmentTool.h.

unsigned int lar_content::MissingTrackSegmentTool::m_minCaloHitsInCandidateCluster

private

The min no. of calo hits in a candidate cluster, for matching with long clusters.

Definition at line 184 of file MissingTrackSegmentTool.h.

float lar_content::MissingTrackSegmentTool::m_minFinalXOverlapFraction

private

The min x overlap fraction between extended short cluster and the long clusters.

Definition at line 182 of file MissingTrackSegmentTool.h.

float lar_content::MissingTrackSegmentTool::m_minInitialXOverlapFraction

private

The min x overlap fraction (between long clusters and short cluster vs. shared overlap)

Definition at line 181 of file MissingTrackSegmentTool.h.

float lar_content::MissingTrackSegmentTool::m_minMatchedFraction

private

The min matched sampling point fraction for particle creation.

Definition at line 177 of file MissingTrackSegmentTool.h.

unsigned int lar_content::MissingTrackSegmentTool::m_minMatchedSamplingPointRatio

private

The min ratio between 1st and 2nd highest msps for simple ambiguity resolution.

Definition at line 179 of file MissingTrackSegmentTool.h.

unsigned int lar_content::MissingTrackSegmentTool::m_minMatchedSamplingPoints

private

The min number of matched sampling points for particle creation.

Definition at line 178 of file MissingTrackSegmentTool.h.

float lar_content::MissingTrackSegmentTool::m_pseudoChi2Cut

private

The pseudo chi2 cut to determine whether a sampling point is matched.

Definition at line 185 of file MissingTrackSegmentTool.h.

---

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

• MissingTrackSegmentTool.h
• MissingTrackSegmentTool.cc