lar_content::TwoDSlidingFitMultiSplitAlgorithm Class Reference

TwoDTrackSplittingAlgorithm class. More...

#include <TwoDSlidingFitMultiSplitAlgorithm.h>

Inheritance diagram for lar_content::TwoDSlidingFitMultiSplitAlgorithm:

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

Protected Types
typedef std::unordered_map < const pandora::Cluster *, pandora::CartesianPointVector >	ClusterPositionMap

Protected Member Functions
virtual void	GetListOfCleanClusters (const pandora::ClusterList *const pClusterList, pandora::ClusterVector &clusterVector) const =0
	Populate cluster vector with subset of cluster list, containing clusters judged to be clean. More...
virtual void	FindBestSplitPositions (const TwoDSlidingFitResultMap &slidingFitResultMap, ClusterPositionMap &clusterSplittingMap) const =0
	Determine best split positions based on sliding fit result. More...
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

Private Member Functions
pandora::StatusCode	Run ()
void	BuildSlidingFitResultMap (const pandora::ClusterVector &clusterVector, const unsigned int halfWindowLayers, TwoDSlidingFitResultMap &slidingFitResultMap) const
	Build the map of sliding fit results. More...
pandora::StatusCode	SplitClusters (const TwoDSlidingFitResultMap &slidingFitResultMap, const ClusterPositionMap &clusterSplittingMap) const
	Split clusters. More...
pandora::StatusCode	SplitCluster (const TwoDSlidingFitResult &slidingFitResult, const pandora::CartesianPointVector &splitPositionList) const
	Split cluster. More...

Private Attributes
unsigned int	m_slidingFitHalfWindow
std::string	m_inputClusterList

Detailed Description

TwoDTrackSplittingAlgorithm class.

Definition at line 21 of file TwoDSlidingFitMultiSplitAlgorithm.h.

Member Typedef Documentation

typedef std::unordered_map<const pandora::Cluster *, pandora::CartesianPointVector> lar_content::TwoDSlidingFitMultiSplitAlgorithm::ClusterPositionMap

protected

Definition at line 30 of file TwoDSlidingFitMultiSplitAlgorithm.h.

Constructor & Destructor Documentation

lar_content::TwoDSlidingFitMultiSplitAlgorithm::TwoDSlidingFitMultiSplitAlgorithm

(

)

Default constructor.

Definition at line 21 of file TwoDSlidingFitMultiSplitAlgorithm.cc.

                                                                     : m_slidingFitHalfWindow(15), m_inputClusterList("")
{
}

Member Function Documentation

void lar_content::TwoDSlidingFitMultiSplitAlgorithm::BuildSlidingFitResultMap ( const pandora::ClusterVector &  clusterVector, const unsigned int  halfWindowLayers, TwoDSlidingFitResultMap &  slidingFitResultMap  ) const

private

Build the map of sliding fit results.

Parameters

clusterVector	the vector of selected clusters
halfWindowLayers	the half-window to use for the sliding fits
slidingFitResultMap	the sliding fit result map

Definition at line 72 of file TwoDSlidingFitMultiSplitAlgorithm.cc.

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

    for (ClusterVector::const_iterator iter = clusterVector.begin(), iterEnd = clusterVector.end(); iter != iterEnd; ++iter)
    {
        if (slidingFitResultMap.end() == slidingFitResultMap.find(*iter))
        {
            try
            {
                const TwoDSlidingFitResult slidingFitResult(*iter, halfWindowLayers, slidingFitPitch);

                if (!slidingFitResultMap.insert(TwoDSlidingFitResultMap::value_type(*iter, slidingFitResult)).second)
                    throw StatusCodeException(STATUS_CODE_FAILURE);
            }
            catch (StatusCodeException &statusCodeException)
            {
                if (STATUS_CODE_FAILURE == statusCodeException.GetStatusCode())
                    throw statusCodeException;
            }
        }
    }
}

virtual void lar_content::TwoDSlidingFitMultiSplitAlgorithm::FindBestSplitPositions ( const TwoDSlidingFitResultMap &  slidingFitResultMap, ClusterPositionMap &  clusterSplittingMap  ) const

protectedpure virtual

Determine best split positions based on sliding fit result.

Parameters

slidingFitResultMap	mapping from clusters to sliding fit results
clusterSplittingMap	mapping from clusters to split positions

Implemented in lar_content::OvershootSplittingAlgorithm.

virtual void lar_content::TwoDSlidingFitMultiSplitAlgorithm::GetListOfCleanClusters ( const pandora::ClusterList *const  pClusterList, pandora::ClusterVector &  clusterVector  ) const

protectedpure virtual

Populate cluster vector with subset of cluster list, containing clusters judged to be clean.

Parameters

pClusterList	address of the cluster list
clusterVector	to receive the populated cluster vector

Implemented in lar_content::OvershootSplittingAlgorithm.

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

protected

Definition at line 209 of file TwoDSlidingFitMultiSplitAlgorithm.cc.

{
    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "InputClusterListName", m_inputClusterList));

    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SlidingFitHalfWindow", m_slidingFitHalfWindow));

    return STATUS_CODE_SUCCESS;
}

StatusCode lar_content::TwoDSlidingFitMultiSplitAlgorithm::Run ( )

private

Definition at line 27 of file TwoDSlidingFitMultiSplitAlgorithm.cc.

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

    if (!m_inputClusterList.empty())
    {
        const StatusCode statusCode(PandoraContentApi::ReplaceCurrentList<Cluster>(*this, m_inputClusterList));

        if (STATUS_CODE_NOT_FOUND == statusCode)
        {
            std::cout << "TwoDSlidingFitMultiSplitAlgorithm: cluster list not found " << m_inputClusterList << std::endl;
            return STATUS_CODE_SUCCESS;
        }

        if (STATUS_CODE_SUCCESS != statusCode)
            return statusCode;
    }

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

    // Get ordered list of candidate clusters
    ClusterVector clusterVector;
    this->GetListOfCleanClusters(pClusterList, clusterVector);

    // Build a set of sliding fit results for clean clusters
    TwoDSlidingFitResultMap slidingFitResultMap;
    this->BuildSlidingFitResultMap(clusterVector, m_slidingFitHalfWindow, slidingFitResultMap);

    // Find best split positions for each cluster
    ClusterPositionMap clusterSplittingMap;
    this->FindBestSplitPositions(slidingFitResultMap, clusterSplittingMap);

    // Perform splits
    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->SplitClusters(slidingFitResultMap, clusterSplittingMap));

    if (!m_inputClusterList.empty())
        PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<Cluster>(*this, originalListName));

    return STATUS_CODE_SUCCESS;
}

StatusCode lar_content::TwoDSlidingFitMultiSplitAlgorithm::SplitCluster ( const TwoDSlidingFitResult &  slidingFitResult, const pandora::CartesianPointVector &  splitPositionList  ) const

private

Split cluster.

Parameters

slidingFitResult	input sliding fit result
splitPositionList	vector of split positions

Definition at line 131 of file TwoDSlidingFitMultiSplitAlgorithm.cc.

{
    const Cluster *const pCluster = slidingFitResult.GetCluster();

    // Get split positions for this cluster
    FloatVector displacementVector;

    for (CartesianPointVector::const_iterator pIter = splitPositionVector.begin(), pIterEnd = splitPositionVector.end(); pIter != pIterEnd; ++pIter)
    {
        const CartesianVector &splitPosition = *pIter;

        float rL(0.f), rT(0.f);
        slidingFitResult.GetLocalPosition(splitPosition, rL, rT);
        displacementVector.push_back(rL);
    }

    const float bigL(2.f * slidingFitResult.GetL(slidingFitResult.GetMaxLayer()));
    displacementVector.push_back(-bigL);
    displacementVector.push_back(+bigL);

    std::sort(displacementVector.begin(), displacementVector.end());

    // Begin cluster fragmentation operations
    const ClusterList clusterList(1, pCluster);
    std::string clusterListToSave, clusterListToDelete;

    PANDORA_RETURN_RESULT_IF(
        STATUS_CODE_SUCCESS, !=, PandoraContentApi::InitializeFragmentation(*this, clusterList, clusterListToDelete, clusterListToSave));

    CaloHitList oldCaloHitList;
    pCluster->GetOrderedCaloHitList().FillCaloHitList(oldCaloHitList);

    bool foundPreviousL(false);
    float prevL(0.f);

    for (FloatVector::const_iterator fIter = displacementVector.begin(), fIterEnd = displacementVector.end(); fIter != fIterEnd; ++fIter)
    {
        const float nextL(*fIter);

        if (foundPreviousL)
        {
            // Select hits for new cluster
            CaloHitList newCaloHitList;

            for (CaloHitList::const_iterator hIter = oldCaloHitList.begin(), hIterEnd = oldCaloHitList.end(); hIter != hIterEnd; ++hIter)
            {
                const CaloHit *const pCaloHit = *hIter;

                float rL(0.f), rT(0.f);
                slidingFitResult.GetLocalPosition(pCaloHit->GetPositionVector(), rL, rT);

                if (rL >= prevL && rL < nextL)
                    newCaloHitList.push_back(pCaloHit);
            }

            if (newCaloHitList.empty())
                continue;

            // Create new cluster
            PandoraContentApi::Cluster::Parameters newParameters;
            newParameters.m_caloHitList = newCaloHitList;

            const Cluster *pNewCluster(NULL);
            PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Cluster::Create(*this, newParameters, pNewCluster));
        }

        prevL = nextL;
        foundPreviousL = true;
    }

    // End cluster fragmentation operations
    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::EndFragmentation(*this, clusterListToSave, clusterListToDelete));

    return STATUS_CODE_SUCCESS;
}

StatusCode lar_content::TwoDSlidingFitMultiSplitAlgorithm::SplitClusters ( const TwoDSlidingFitResultMap &  slidingFitResultMap, const ClusterPositionMap &  clusterSplittingMap  ) const

private

Split clusters.

Parameters

slidingFitResultMap	mapping from clusters to sliding fit results
clusterSplittingMap	mapping from clusters to split positions

Definition at line 99 of file TwoDSlidingFitMultiSplitAlgorithm.cc.

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

    for (const Cluster *const pCluster : clusterList)
    {
        const CartesianPointVector &splitPositionVector(clusterSplittingMap.at(pCluster));

        if (splitPositionVector.empty())
            continue;

        TwoDSlidingFitResultMap::const_iterator sIter = slidingFitResultMap.find(pCluster);
        if (slidingFitResultMap.end() == sIter)
            throw StatusCodeException(STATUS_CODE_FAILURE);

        const TwoDSlidingFitResult &slidingFitResult = sIter->second;

        StatusCode statusCode(this->SplitCluster(slidingFitResult, splitPositionVector));

        if (STATUS_CODE_SUCCESS != statusCode)
            return statusCode;
    }

    return STATUS_CODE_SUCCESS;
}

Member Data Documentation

std::string lar_content::TwoDSlidingFitMultiSplitAlgorithm::m_inputClusterList

private

Definition at line 80 of file TwoDSlidingFitMultiSplitAlgorithm.h.

unsigned int lar_content::TwoDSlidingFitMultiSplitAlgorithm::m_slidingFitHalfWindow

private

Definition at line 79 of file TwoDSlidingFitMultiSplitAlgorithm.h.

---

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

• TwoDSlidingFitMultiSplitAlgorithm.h
• TwoDSlidingFitMultiSplitAlgorithm.cc