lar_content::LayerSplittingAlgorithm Class Reference

LayerSplittingAlgorithm class. More...

#include "LayerSplittingAlgorithm.h"

Inheritance diagram for lar_content::LayerSplittingAlgorithm:

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

Protected Member Functions
virtual pandora::StatusCode	Run ()
pandora::StatusCode	RunUsingCurrentList () const
	Run the algorithm using the current cluster list as input. More...

Private Member Functions
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)
pandora::StatusCode	DivideCaloHits (const pandora::Cluster *const pCluster, pandora::CaloHitList &firstCaloHitList, pandora::CaloHitList &secondCaloHitList) const
	Divide calo hits in a cluster into two lists, each associated with a separate fragment cluster. More...
pandora::StatusCode	FindBestSplitLayer (const pandora::Cluster *const pCluster, unsigned int &splitLayer) const
	Find the best layer for splitting the cluster. More...
pandora::StatusCode	DivideCaloHits (const pandora::Cluster *const pCluster, const unsigned int &splitLayer, pandora::CaloHitList &firstCaloHitList, pandora::CaloHitList &secondCaloHitList) const
	Split the cluster into two fragments at the input layer. More...
float	CalculateRms (const pandora::Cluster *const pCluster, const unsigned int &firstLayer, const unsigned int &secondLayer) const
	Calculate rms deviation of cluster centroids between two extremal layers. More...

Private Attributes
unsigned int	m_minClusterLayers
unsigned int	m_layerWindow
float	m_maxScatterRms
float	m_maxScatterCosTheta
float	m_maxSlidingCosTheta

Detailed Description

LayerSplittingAlgorithm class.

Definition at line 19 of file LayerSplittingAlgorithm.h.

Constructor & Destructor Documentation

lar_content::LayerSplittingAlgorithm::LayerSplittingAlgorithm

(

)

Default constructor.

Definition at line 18 of file LayerSplittingAlgorithm.cc.

References DivideCaloHits(), and FindBestSplitLayer().

                                                 :
    m_minClusterLayers(20),
    m_layerWindow(10),
    m_maxScatterRms(0.35f),
    m_maxScatterCosTheta(0.5f),
    m_maxSlidingCosTheta(0.866f)
{
}

Member Function Documentation

float lar_content::LayerSplittingAlgorithm::CalculateRms ( const pandora::Cluster *const  pCluster, const unsigned int &  firstLayer, const unsigned int &  secondLayer  ) const

private

Calculate rms deviation of cluster centroids between two extremal layers.

Parameters

pCluster	the input cluster
firstLayer	the first extremal layer
secondLayer	the second extremal layer

Definition at line 118 of file LayerSplittingAlgorithm.cc.

References DivideCaloHits(), f, max, and min.

Referenced by FindBestSplitLayer().

{
    const OrderedCaloHitList &orderedCaloHitList(pCluster->GetOrderedCaloHitList());

    const unsigned int innerLayer(std::min(firstLayer, secondLayer));
    const unsigned int outerLayer(std::max(firstLayer, secondLayer));

    const CartesianVector innerPosition(pCluster->GetCentroid(innerLayer));
    const CartesianVector outerPosition(pCluster->GetCentroid(outerLayer));
    const CartesianVector predictedDirection((outerPosition - innerPosition).GetUnitVector());

    float totalChi2(0.f);
    float totalLayers(0.f);

    for (unsigned int iLayer = innerLayer + 1; iLayer + 1 < outerLayer; ++iLayer)
    {
        if (orderedCaloHitList.find(iLayer) == orderedCaloHitList.end())
            continue;

        const CartesianVector hitPosition(pCluster->GetCentroid(iLayer));
        const CartesianVector predictedPosition(innerPosition + predictedDirection * predictedDirection.GetDotProduct(hitPosition - innerPosition));

        totalChi2 += (predictedPosition - hitPosition).GetMagnitudeSquared();
        totalLayers += 1.f;
    }

    if (totalLayers > 0.f)
        return std::sqrt(totalChi2/totalLayers);

    return 0.f;
}

pandora::StatusCode lar_content::LayerSplittingAlgorithm::DivideCaloHits ( const pandora::Cluster *const  pCluster, pandora::CaloHitList &  firstCaloHitList, pandora::CaloHitList &  secondCaloHitList  ) const

privatevirtual

Divide calo hits in a cluster into two lists, each associated with a separate fragment cluster.

Parameters

pCluster	address of the cluster
firstCaloHitList	the hits in the first fragment
secondCaloHitList	the hits in the second fragment

Implements lar_content::ClusterSplittingAlgorithm.

Referenced by CalculateRms(), and LayerSplittingAlgorithm().

pandora::StatusCode lar_content::LayerSplittingAlgorithm::DivideCaloHits ( const pandora::Cluster *const  pCluster, const unsigned int &  splitLayer, pandora::CaloHitList &  firstCaloHitList, pandora::CaloHitList &  secondCaloHitList  ) const

private

Split the cluster into two fragments at the input layer.

Parameters

pCluster	the input cluster
splitLayer	the split layer
firstCaloHitList	the hits in the first cluster fragment
secondCaloHitList	the hits in the second cluster fragment

StatusCode lar_content::LayerSplittingAlgorithm::FindBestSplitLayer ( const pandora::Cluster *const  pCluster, unsigned int &  splitLayer  ) const

private

Find the best layer for splitting the cluster.

Parameters

pCluster	the input cluster
splitLayer	the best layer

Definition at line 41 of file LayerSplittingAlgorithm.cc.

References CalculateRms(), f, m_layerWindow, m_maxScatterCosTheta, m_maxScatterRms, m_maxSlidingCosTheta, m_minClusterLayers, and max.

Referenced by LayerSplittingAlgorithm().

{
    const OrderedCaloHitList &orderedCaloHitList(pCluster->GetOrderedCaloHitList());

    if (orderedCaloHitList.size() < m_minClusterLayers)
        return STATUS_CODE_NOT_FOUND;

    bool foundSplit(false);

    float bestCosTheta(1.f);
    CartesianVector bestPosition(0.f,0.f,0.f);

    for (unsigned int iLayer = pCluster->GetInnerPseudoLayer() + 4; iLayer + 4 <= pCluster->GetOuterPseudoLayer(); ++iLayer)
    {
        if (orderedCaloHitList.find(iLayer) == orderedCaloHitList.end())
            continue;

        unsigned int innerLayer((pCluster->GetInnerPseudoLayer() + m_layerWindow > iLayer) ? pCluster->GetInnerPseudoLayer() : iLayer - m_layerWindow);
        unsigned int outerLayer((iLayer + m_layerWindow > pCluster->GetOuterPseudoLayer()) ? pCluster->GetOuterPseudoLayer() : iLayer + m_layerWindow);

        for ( ; innerLayer >= pCluster->GetInnerPseudoLayer(); --innerLayer)
        {
            if (orderedCaloHitList.find(innerLayer) != orderedCaloHitList.end())
                break;
        }

        for ( ; outerLayer <= pCluster->GetOuterPseudoLayer(); ++outerLayer)
        {
            if (orderedCaloHitList.find(outerLayer) != orderedCaloHitList.end())
                break;
        }

        const CartesianVector splitPosition(pCluster->GetCentroid(iLayer));
        const CartesianVector innerPosition(pCluster->GetCentroid(innerLayer));
        const CartesianVector outerPosition(pCluster->GetCentroid(outerLayer));

        const CartesianVector r1(innerPosition - splitPosition);
        const CartesianVector r2(outerPosition - splitPosition);
        const CartesianVector p1(r1.GetUnitVector());
        const CartesianVector p2(r2.GetUnitVector());

        const float cosTheta(-p1.GetDotProduct(p2));
        const float rms1(this->CalculateRms(pCluster, innerLayer, iLayer));
        const float rms2(this->CalculateRms(pCluster, outerLayer, iLayer));
        const float rms(std::max(rms1, rms2));

        float rmsCut(std::numeric_limits<float>::max());

        if (cosTheta > 0.f)
        {
            rmsCut = m_maxScatterRms;

            if (cosTheta > m_maxScatterCosTheta)
            {
            rmsCut *= ((m_maxSlidingCosTheta > cosTheta) ? (m_maxSlidingCosTheta - cosTheta) /
                    (m_maxSlidingCosTheta - m_maxScatterCosTheta) : 0.f);
            }
        }

        if (rms < rmsCut && cosTheta < bestCosTheta)
        {
            bestCosTheta = cosTheta;
            bestPosition = splitPosition;

            splitLayer = iLayer;
            foundSplit = true;
        }
    }

    if (!foundSplit)
        return STATUS_CODE_NOT_FOUND;

    return STATUS_CODE_SUCCESS;
}

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

privatevirtual

Reimplemented from lar_content::ClusterSplittingAlgorithm.

Definition at line 183 of file LayerSplittingAlgorithm.cc.

References m_layerWindow, m_maxScatterCosTheta, m_maxScatterRms, m_maxSlidingCosTheta, m_minClusterLayers, and lar_content::ClusterSplittingAlgorithm::ReadSettings().

{
    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
        "MinClusterLayers", m_minClusterLayers));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
        "LayerWindow", m_layerWindow));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
        "MaxScatterRms", m_maxScatterRms));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
        "MaxScatterCosTheta", m_maxScatterCosTheta));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle,
        "MaxSlidingCosTheta", m_maxSlidingCosTheta));

    return ClusterSplittingAlgorithm::ReadSettings(xmlHandle);
}

StatusCode lar_content::ClusterSplittingAlgorithm::Run ( )

protectedvirtualinherited

Definition at line 20 of file ClusterSplittingAlgorithm.cc.

{
    if (m_inputClusterListNames.empty())
        return this->RunUsingCurrentList();

    std::string originalListName;
    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentListName<Cluster>(*this, originalListName));

    for (const std::string &clusterListName : m_inputClusterListNames)
    {
        const StatusCode listChangeStatusCode(PandoraContentApi::ReplaceCurrentList<Cluster>(*this, clusterListName));

        if (STATUS_CODE_NOT_FOUND == listChangeStatusCode)
        {
            if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())
                std::cout << "ClusterSplittingAlgorithm: cluster list not found " << clusterListName << std::endl;

            continue;
        }

        if (STATUS_CODE_SUCCESS != listChangeStatusCode)
            return listChangeStatusCode;

        PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->RunUsingCurrentList());
    }

    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<Cluster>(*this, originalListName));
    return STATUS_CODE_SUCCESS;
}

StatusCode lar_content::ClusterSplittingAlgorithm::RunUsingCurrentList ( ) const

protectedinherited

Run the algorithm using the current cluster list as input.

Definition at line 52 of file ClusterSplittingAlgorithm.cc.

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

    ClusterList internalClusterList(pClusterList->begin(), pClusterList->end());
    internalClusterList.sort(LArClusterHelper::SortByNHits);

    for (ClusterList::iterator iter = internalClusterList.begin(); iter != internalClusterList.end(); ++iter)
    {
        const Cluster *const pCluster = *iter;
        ClusterList clusterSplittingList;

        if (STATUS_CODE_SUCCESS != this->SplitCluster(pCluster, clusterSplittingList))
            continue;

        internalClusterList.splice(internalClusterList.end(), clusterSplittingList);
        *iter = NULL;
    }

    return STATUS_CODE_SUCCESS;
}

Member Data Documentation

unsigned int lar_content::LayerSplittingAlgorithm::m_layerWindow

private

Definition at line 61 of file LayerSplittingAlgorithm.h.

Referenced by FindBestSplitLayer(), and ReadSettings().

float lar_content::LayerSplittingAlgorithm::m_maxScatterCosTheta

private

Definition at line 63 of file LayerSplittingAlgorithm.h.

Referenced by FindBestSplitLayer(), and ReadSettings().

float lar_content::LayerSplittingAlgorithm::m_maxScatterRms

private

Definition at line 62 of file LayerSplittingAlgorithm.h.

Referenced by FindBestSplitLayer(), and ReadSettings().

float lar_content::LayerSplittingAlgorithm::m_maxSlidingCosTheta

private

Definition at line 64 of file LayerSplittingAlgorithm.h.

Referenced by FindBestSplitLayer(), and ReadSettings().

unsigned int lar_content::LayerSplittingAlgorithm::m_minClusterLayers

private

Definition at line 60 of file LayerSplittingAlgorithm.h.

Referenced by FindBestSplitLayer(), and ReadSettings().

---

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

• larpandoracontent/v03_13_02/source/larpandoracontent/LArTwoDReco/LArClusterSplitting/LayerSplittingAlgorithm.h
• larpandoracontent/v03_13_02/source/larpandoracontent/LArTwoDReco/LArClusterSplitting/LayerSplittingAlgorithm.cc