lar_content::ConeClusterMopUpAlgorithm Class Reference

ConeClusterMopUpAlgorithm class. More...

#include <ConeClusterMopUpAlgorithm.h>

Inheritance diagram for lar_content::ConeClusterMopUpAlgorithm:

Public Member Functions
	ConeClusterMopUpAlgorithm ()
	Default constructor. More...
Public Member Functions inherited from lar_content::ClusterMopUpBaseAlgorithm
	ClusterMopUpBaseAlgorithm ()
	Default constructor. More...
Public Member Functions inherited from lar_content::MopUpBaseAlgorithm
template<typename T >
const std::string	GetListName (const T *const pT) const
	Find the name of the list hosting a specific object. More...

Private Types
typedef std::pair< float, float >	Coordinate
typedef std::vector< Coordinate >	CoordinateList

Private Member Functions
void	ClusterMopUp (const pandora::ClusterList &pfoClusters, const pandora::ClusterList &remnantClusters) const
	Cluster mop up for a single view. This function is responsible for instructing pandora to make cluster alterations. More...
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

Static Private Member Functions
static bool	SortCoordinates (const Coordinate &lhs, const Coordinate &rhs)
	Sort coordinates by increasing transverse displacement. More...

Private Attributes
unsigned int	m_slidingFitWindow
	The layer window for the sliding linear fits. More...
float	m_showerEdgeMultiplier
	Artificially tune width of shower envelope so as to make it more/less inclusive. More...
float	m_coneAngleCentile
	Cluster cone angle is defined using specified centile of distribution of hit half angles. More...
float	m_maxConeLengthMultiplier
	Consider hits as bound if inside cone, with projected distance less than N times cone length. More...
float	m_minBoundedFraction
	The minimum cluster bounded fraction for merging. More...

Additional Inherited Members
Protected Types inherited from lar_content::ClusterMopUpBaseAlgorithm
typedef std::unordered_map < const pandora::Cluster *, float >	AssociationDetails
typedef std::unordered_map < const pandora::Cluster *, AssociationDetails >	ClusterAssociationMap
Protected Member Functions inherited from lar_content::ClusterMopUpBaseAlgorithm
virtual pandora::StatusCode	Run ()
virtual void	GetPfoClusterLists (pandora::ClusterList &clusterListU, pandora::ClusterList &clusterListV, pandora::ClusterList &clusterListW) const
	Get the two dimensional clusters contained in the input pfo list, divided into three different views. More...
virtual void	GetDaughterClusterLists (pandora::ClusterList &clusterListU, pandora::ClusterList &clusterListV, pandora::ClusterList &clusterListW) const
	Get the two dimensional clusters contained in the input remant/daughter cluster lists, divided into three different views. More...
virtual void	GetClusterLists (const pandora::ClusterList &inputClusterList, const bool availabilityFlag, pandora::ClusterList &clusterListU, pandora::ClusterList &clusterListV, pandora::ClusterList &clusterListW) const
	Get the two dimensional clusters contained in an input cluster list, divided into three different views. More...
virtual void	MakeClusterMerges (const ClusterAssociationMap &clusterAssociationMap) const
	Make the cluster merges specified in the cluster association map, using list name information in the cluster list name map. More...
Protected Attributes inherited from lar_content::ClusterMopUpBaseAlgorithm
pandora::StringVector	m_pfoListNames
	The list of pfo list names. More...
bool	m_excludePfosContainingTracks
	Whether to exclude any pfos containing clusters flagged as fixed tracks. More...
Protected Attributes inherited from lar_content::MopUpBaseAlgorithm
pandora::StringVector	m_daughterListNames
	The list of potential daughter object list names. More...

Detailed Description

ConeClusterMopUpAlgorithm class.

Definition at line 21 of file ConeClusterMopUpAlgorithm.h.

Member Typedef Documentation

typedef std::pair<float, float> lar_content::ConeClusterMopUpAlgorithm::Coordinate

private

Definition at line 32 of file ConeClusterMopUpAlgorithm.h.

typedef std::vector<Coordinate> lar_content::ConeClusterMopUpAlgorithm::CoordinateList

private

Definition at line 33 of file ConeClusterMopUpAlgorithm.h.

Constructor & Destructor Documentation

lar_content::ConeClusterMopUpAlgorithm::ConeClusterMopUpAlgorithm

(

)

Default constructor.

Definition at line 23 of file ConeClusterMopUpAlgorithm.cc.

                                                     :
    m_slidingFitWindow(20),
    m_showerEdgeMultiplier(1.5f),
    m_coneAngleCentile(0.85f),
    m_maxConeLengthMultiplier(1.5f),
    m_minBoundedFraction(0.5f)
{
}

Member Function Documentation

void lar_content::ConeClusterMopUpAlgorithm::ClusterMopUp ( const pandora::ClusterList &  pfoClusters, const pandora::ClusterList &  remnantClusters  ) const

privatevirtual

Cluster mop up for a single view. This function is responsible for instructing pandora to make cluster alterations.

Parameters

pfoClusters	the list of pfo clusters
remnantClusters	the list of remnant clusters

Implements lar_content::ClusterMopUpBaseAlgorithm.

Definition at line 34 of file ConeClusterMopUpAlgorithm.cc.

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

    const VertexList *pVertexList(NULL);
    PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pVertexList));

    if ((pVertexList->size() != 1) || (VERTEX_3D != (*(pVertexList->begin()))->GetVertexType()))
        return;

    const Vertex *const pVertex(*(pVertexList->begin()));

    ClusterVector sortedPfoClusters(pfoClusters.begin(), pfoClusters.end());
    std::sort(sortedPfoClusters.begin(), sortedPfoClusters.end(), LArClusterHelper::SortByNHits);

    ClusterVector sortedRemnantClusters(remnantClusters.begin(), remnantClusters.end());
    std::sort(sortedRemnantClusters.begin(), sortedRemnantClusters.end(), LArClusterHelper::SortByNHits);

    for (const Cluster *const pPfoCluster : sortedPfoClusters)
    {
        try
        {
            const TwoDSlidingShowerFitResult showerFitResult(pPfoCluster, m_slidingFitWindow, slidingFitPitch, m_showerEdgeMultiplier);

            const LayerFitResultMap &layerFitResultMapS(showerFitResult.GetShowerFitResult().GetLayerFitResultMap());
            const LayerFitResultMap &layerFitResultMapP(showerFitResult.GetPositiveEdgeFitResult().GetLayerFitResultMap());
            const LayerFitResultMap &layerFitResultMapN(showerFitResult.GetNegativeEdgeFitResult().GetLayerFitResultMap());

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

            // Cone direction
            CartesianVector minLayerPositionOnAxis(0.f, 0.f, 0.f), maxLayerPositionOnAxis(0.f, 0.f, 0.f);
            showerFitResult.GetShowerFitResult().GetGlobalPosition(layerFitResultMapS.begin()->second.GetL(), 0.f, minLayerPositionOnAxis);
            showerFitResult.GetShowerFitResult().GetGlobalPosition(layerFitResultMapS.rbegin()->second.GetL(), 0.f, maxLayerPositionOnAxis);

            const HitType hitType(LArClusterHelper::GetClusterHitType(pPfoCluster));
            const CartesianVector vertexPosition2D(LArGeometryHelper::ProjectPosition(this->GetPandora(), pVertex->GetPosition(), hitType));
            const bool vertexAtMinL((vertexPosition2D - minLayerPositionOnAxis).GetMagnitudeSquared() <
                                    (vertexPosition2D - maxLayerPositionOnAxis).GetMagnitudeSquared());

            // Cone edges
            CoordinateList coordinateListP, coordinateListN;

            for (LayerFitResultMap::const_iterator iterS = layerFitResultMapS.begin(); iterS != layerFitResultMapS.end(); ++iterS)
            {
                LayerFitResultMap::const_iterator iterP = layerFitResultMapP.find(iterS->first);
                LayerFitResultMap::const_iterator iterN = layerFitResultMapN.find(iterS->first);

                if (layerFitResultMapP.end() != iterP)
                    coordinateListP.push_back(Coordinate(iterP->second.GetL(), iterP->second.GetFitT()));

                if (layerFitResultMapN.end() != iterN)
                    coordinateListN.push_back(Coordinate(iterN->second.GetL(), iterN->second.GetFitT()));
            }

            if (coordinateListP.empty() || coordinateListN.empty())
                continue;

            std::sort(coordinateListP.begin(), coordinateListP.end(), ConeClusterMopUpAlgorithm::SortCoordinates);
            std::sort(coordinateListN.begin(), coordinateListN.end(), ConeClusterMopUpAlgorithm::SortCoordinates);

            const Coordinate maxP(coordinateListP.at(m_coneAngleCentile * coordinateListP.size()));
            const Coordinate minP(vertexAtMinL
                                      ? Coordinate(layerFitResultMapP.begin()->second.GetL(), layerFitResultMapP.begin()->second.GetFitT())
                                      : Coordinate(layerFitResultMapP.rbegin()->second.GetL(), layerFitResultMapP.rbegin()->second.GetFitT()));

            const Coordinate maxN(coordinateListN.at((1.f - m_coneAngleCentile) * coordinateListN.size()));
            const Coordinate minN(vertexAtMinL
                                      ? Coordinate(layerFitResultMapN.begin()->second.GetL(), layerFitResultMapN.begin()->second.GetFitT())
                                      : Coordinate(layerFitResultMapN.rbegin()->second.GetL(), layerFitResultMapN.rbegin()->second.GetFitT()));

            const float minL(layerFitResultMapS.begin()->second.GetL());
            const float maxL(minL + m_maxConeLengthMultiplier * std::fabs(layerFitResultMapS.rbegin()->second.GetL() - minL));

            if ((std::fabs(maxP.first - minP.first) < std::numeric_limits<float>::epsilon()) ||
                (std::fabs(maxN.first - minN.first) < std::numeric_limits<float>::epsilon()) ||
                (std::fabs(maxL - minL) < std::numeric_limits<float>::epsilon()))
            {
                continue;
            }

            // Bounded fraction calculation
            for (const Cluster *const pRemnantCluster : sortedRemnantClusters)
            {
                const unsigned int nHits(pRemnantCluster->GetNCaloHits());

                unsigned int nMatchedHits(0);
                const OrderedCaloHitList &orderedCaloHitList(pRemnantCluster->GetOrderedCaloHitList());

                for (OrderedCaloHitList::const_iterator iter = orderedCaloHitList.begin(), iterEnd = orderedCaloHitList.end(); iter != iterEnd; ++iter)
                {
                    for (CaloHitList::const_iterator hIter = iter->second->begin(), hIterEnd = iter->second->end(); hIter != hIterEnd; ++hIter)
                    {
                        float rL(0.f), rT(0.f);
                        showerFitResult.GetShowerFitResult().GetLocalPosition((*hIter)->GetPositionVector(), rL, rT);

                        if ((rL < minL) || (rL > maxL))
                            continue;

                        const float rTP(minP.second + (rL - minP.first) * ((maxP.second - minP.second) / (maxP.first - minP.first)));
                        const float rTN(minN.second + (rL - minN.first) * ((maxN.second - minN.second) / (maxN.first - minN.first)));

                        if ((rT > rTP) || (rT < rTN))
                            continue;

                        ++nMatchedHits;
                    }
                }

                const float boundedFraction((nHits > 0) ? static_cast<float>(nMatchedHits) / static_cast<float>(nHits) : 0.f);

                if (boundedFraction < m_minBoundedFraction)
                    continue;

                AssociationDetails &associationDetails(clusterAssociationMap[pRemnantCluster]);

                if (!associationDetails.insert(AssociationDetails::value_type(pPfoCluster, boundedFraction)).second)
                    throw StatusCodeException(STATUS_CODE_FAILURE);
            }
        }
        catch (StatusCodeException &statusCodeException)
        {
            if (STATUS_CODE_FAILURE == statusCodeException.GetStatusCode())
                throw statusCodeException;
        }
    }

    this->MakeClusterMerges(clusterAssociationMap);
}

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

privatevirtual

Reimplemented from lar_content::ClusterMopUpBaseAlgorithm.

Definition at line 175 of file ConeClusterMopUpAlgorithm.cc.

{
    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SlidingFitWindow", m_slidingFitWindow));

    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ShowerEdgeMultiplier", m_showerEdgeMultiplier));

    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ConeAngleCentile", m_coneAngleCentile));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MaxConeLengthMultiplier", m_maxConeLengthMultiplier));

    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinBoundedFraction", m_minBoundedFraction));

    return ClusterMopUpBaseAlgorithm::ReadSettings(xmlHandle);
}

bool lar_content::ConeClusterMopUpAlgorithm::SortCoordinates ( const Coordinate &  lhs, const Coordinate &  rhs  )

staticprivate

Sort coordinates by increasing transverse displacement.

Parameters

lhs	the first coordinate for comparison
rhs	the second coordinate for comparison

Returns

boolean

Definition at line 168 of file ConeClusterMopUpAlgorithm.cc.

{
    return (lhs.second < rhs.second);
}

Member Data Documentation

float lar_content::ConeClusterMopUpAlgorithm::m_coneAngleCentile

private

Cluster cone angle is defined using specified centile of distribution of hit half angles.

Definition at line 49 of file ConeClusterMopUpAlgorithm.h.

float lar_content::ConeClusterMopUpAlgorithm::m_maxConeLengthMultiplier

private

Consider hits as bound if inside cone, with projected distance less than N times cone length.

Definition at line 50 of file ConeClusterMopUpAlgorithm.h.

float lar_content::ConeClusterMopUpAlgorithm::m_minBoundedFraction

private

The minimum cluster bounded fraction for merging.

Definition at line 51 of file ConeClusterMopUpAlgorithm.h.

float lar_content::ConeClusterMopUpAlgorithm::m_showerEdgeMultiplier

private

Artificially tune width of shower envelope so as to make it more/less inclusive.

Definition at line 48 of file ConeClusterMopUpAlgorithm.h.

unsigned int lar_content::ConeClusterMopUpAlgorithm::m_slidingFitWindow

private

The layer window for the sliding linear fits.

Definition at line 47 of file ConeClusterMopUpAlgorithm.h.

---

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

• ConeClusterMopUpAlgorithm.h
• ConeClusterMopUpAlgorithm.cc