lar_content::CandidateVertexCreationAlgorithm Class Reference

CandidateVertexCreationAlgorithm::Algorithm class. More...

#include <CandidateVertexCreationAlgorithm.h>

Inheritance diagram for lar_content::CandidateVertexCreationAlgorithm:

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

Private Types
typedef std::unordered_map < const pandora::Cluster *, pandora::CartesianPointVector >	ClusterToSpacepointsMap

Private Member Functions
pandora::StatusCode	Run ()
void	SelectClusters (pandora::ClusterVector &clusterVectorU, pandora::ClusterVector &clusterVectorV, pandora::ClusterVector &clusterVectorW)
	Select a subset of input clusters (contained in the input list names) for processing in this algorithm. More...
void	CreateEndpointCandidates (const pandora::ClusterVector &clusterVector1, const pandora::ClusterVector &clusterVector2) const
	Create candidate vertex positions by comparing pairs of cluster end positions. More...
void	CreateEndpointVertex (const pandora::CartesianVector &position1, const pandora::HitType hitType1, const TwoDSlidingFitResult &fitResult2) const
	Create a candidate vertex position, using an end-point position from one cluster and sliding fit to a second cluster. More...
void	CreateCrossingCandidates (const pandora::ClusterVector &clusterVectorU, const pandora::ClusterVector &clusterVectorV, const pandora::ClusterVector &clusterVectorW) const
	Extrapolate 2D clusters, find where they cross, and match crossing points between views to create vertex candidates. More...
void	FindCrossingPoints (const pandora::ClusterVector &clusterVector, pandora::CartesianPointVector &crossingPoints) const
	Identify where (extrapolated) clusters plausibly cross in 2D. More...
void	GetSpacepoints (const pandora::Cluster *const pCluster, pandora::CartesianPointVector &spacePoints) const
	Get a list of spacepoints representing cluster 2D hit positions and extrapolated positions. More...
void	FindCrossingPoints (const pandora::CartesianPointVector &spacepoints1, const pandora::CartesianPointVector &spacepoints2, pandora::CartesianPointVector &crossingPoints) const
	Identify where (extrapolated) clusters plausibly cross in 2D. More...
void	CreateCrossingVertices (const pandora::CartesianPointVector &crossingPoints1, const pandora::CartesianPointVector &crossingPoints2, const pandora::HitType hitType1, const pandora::HitType hitType2, unsigned int &nCrossingCandidates) const
	Attempt to create candidate vertex positions, using 2D crossing points in 2 views. More...
void	AddInputVertices () const
	Add candidate vertices from any input vertices. More...
void	AddToSlidingFitCache (const pandora::Cluster *const pCluster)
	Creates a 2D sliding fit of a cluster and stores it for later use. More...
const TwoDSlidingFitResult &	GetCachedSlidingFitResult (const pandora::Cluster *const pCluster) const
	Get a sliding fit result from the algorithm cache. More...
void	TidyUp ()
	Clear relevant algorithm member variables between events. More...
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

Private Attributes
pandora::StringVector	m_inputClusterListNames
	The list of cluster list names. More...
std::string	m_inputVertexListName
	The list name for existing candidate vertices. More...
std::string	m_outputVertexListName
	The name under which to save the output vertex list. More...
bool	m_replaceCurrentVertexList
	Whether to replace the current vertex list with the output list. More...
unsigned int	m_slidingFitWindow
	The layer window for the sliding linear fits. More...
TwoDSlidingFitResultMap	m_slidingFitResultMap
	The sliding fit result map. More...
unsigned int	m_minClusterCaloHits
	The min number of hits in base cluster selection method. More...
float	m_minClusterLengthSquared
	The min length (squared) in base cluster selection method. More...
float	m_chiSquaredCut
	The chi squared cut (accept only 3D vertex positions with values below cut) More...
bool	m_enableEndpointCandidates
	Whether to create endpoint-based candidates. More...
float	m_maxEndpointXDiscrepancy
	The max cluster endpoint discrepancy. More...
bool	m_enableCrossingCandidates
	Whether to create crossing vertex candidates. More...
unsigned int	m_nMaxCrossingCandidates
	The max number of crossing candidates to create. More...
float	m_maxCrossingXDiscrepancy
	The max cluster endpoint discrepancy. More...
unsigned int	m_extrapolationNSteps
	Number of extrapolation steps, at each end of cluster, of specified size. More...
float	m_extrapolationStepSize
	The extrapolation step size in cm. More...
float	m_maxCrossingSeparationSquared
	The separation (squared) between spacepoints below which a crossing can be identified. More...
float	m_minNearbyCrossingDistanceSquared
	The minimum allowed distance between identified crossing positions. More...
bool	m_reducedCandidates
	Whether to reduce the number of candidates. More...
float	m_selectionCutFactorMax
	Maximum factor to multiply the base cluster selection cuts. More...
float	m_nClustersPassingMaxCutsPar
	Parameter for number of clusters passing the max base cluster selection cuts. More...

Detailed Description

CandidateVertexCreationAlgorithm::Algorithm class.

Definition at line 23 of file CandidateVertexCreationAlgorithm.h.

Member Typedef Documentation

typedef std::unordered_map<const pandora::Cluster *, pandora::CartesianPointVector> lar_content::CandidateVertexCreationAlgorithm::ClusterToSpacepointsMap

private

Definition at line 134 of file CandidateVertexCreationAlgorithm.h.

Constructor & Destructor Documentation

lar_content::CandidateVertexCreationAlgorithm::CandidateVertexCreationAlgorithm

(

)

Default constructor.

Definition at line 23 of file CandidateVertexCreationAlgorithm.cc.

                                                                   :
    m_replaceCurrentVertexList(true),
    m_slidingFitWindow(20),
    m_minClusterCaloHits(5),
    m_minClusterLengthSquared(3.f * 3.f),
    m_chiSquaredCut(2.f),
    m_enableEndpointCandidates(true),
    m_maxEndpointXDiscrepancy(4.f),
    m_enableCrossingCandidates(false),
    m_nMaxCrossingCandidates(500),
    m_maxCrossingXDiscrepancy(0.5f),
    m_extrapolationNSteps(200),
    m_extrapolationStepSize(0.1f),
    m_maxCrossingSeparationSquared(2.f * 2.f),
    m_minNearbyCrossingDistanceSquared(0.5f * 0.5f),
    m_reducedCandidates(false),
    m_selectionCutFactorMax(2.f),
    m_nClustersPassingMaxCutsPar(26.f)
{
}

Member Function Documentation

void lar_content::CandidateVertexCreationAlgorithm::AddInputVertices ( ) const

private

Add candidate vertices from any input vertices.

Definition at line 386 of file CandidateVertexCreationAlgorithm.cc.

{
    const VertexList *pInputVertexList{nullptr};
    try
    { // ATTN - No guarantee the list has been initialised, but silent failure here is ok
        PandoraContentApi::GetList(*this, m_inputVertexListName, pInputVertexList);
        if (!pInputVertexList)
            return;

        for (const Vertex *pInputVertex : *pInputVertexList)
        {
            PandoraContentApi::Vertex::Parameters parameters;
            parameters.m_position = pInputVertex->GetPosition();
            parameters.m_vertexLabel = VERTEX_INTERACTION;
            parameters.m_vertexType = VERTEX_3D;

            const Vertex *pVertex(nullptr);
            PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Vertex::Create(*this, parameters, pVertex));
        }
    }
    catch (const StatusCodeException &)
    {
        return;
    }
}

void lar_content::CandidateVertexCreationAlgorithm::AddToSlidingFitCache ( const pandora::Cluster *const  pCluster )

private

Creates a 2D sliding fit of a cluster and stores it for later use.

Parameters

pCluster

address of the relevant cluster

Definition at line 414 of file CandidateVertexCreationAlgorithm.cc.

{
    const float slidingFitPitch(LArGeometryHelper::GetWireZPitch(this->GetPandora()));
    const TwoDSlidingFitResult slidingFitResult(pCluster, m_slidingFitWindow, slidingFitPitch);

    if (!m_slidingFitResultMap.insert(TwoDSlidingFitResultMap::value_type(pCluster, slidingFitResult)).second)
        throw StatusCodeException(STATUS_CODE_FAILURE);
}

void lar_content::CandidateVertexCreationAlgorithm::CreateCrossingCandidates ( const pandora::ClusterVector &  clusterVectorU, const pandora::ClusterVector &  clusterVectorV, const pandora::ClusterVector &  clusterVectorW  ) const

private

Extrapolate 2D clusters, find where they cross, and match crossing points between views to create vertex candidates.

Parameters

clusterVectorU	the clusters in the u view
clusterVectorV	the clusters in the v view
clusterVectorW	the clusters in the w view

Definition at line 239 of file CandidateVertexCreationAlgorithm.cc.

{
    CartesianPointVector crossingsU, crossingsV, crossingsW;
    this->FindCrossingPoints(clusterVectorU, crossingsU);
    this->FindCrossingPoints(clusterVectorV, crossingsV);
    this->FindCrossingPoints(clusterVectorW, crossingsW);

    unsigned int nCrossingCandidates(0);
    this->CreateCrossingVertices(crossingsU, crossingsV, TPC_VIEW_U, TPC_VIEW_V, nCrossingCandidates);
    this->CreateCrossingVertices(crossingsU, crossingsW, TPC_VIEW_U, TPC_VIEW_W, nCrossingCandidates);
    this->CreateCrossingVertices(crossingsV, crossingsW, TPC_VIEW_V, TPC_VIEW_W, nCrossingCandidates);
}

void lar_content::CandidateVertexCreationAlgorithm::CreateCrossingVertices ( const pandora::CartesianPointVector &  crossingPoints1, const pandora::CartesianPointVector &  crossingPoints2, const pandora::HitType  hitType1, const pandora::HitType  hitType2, unsigned int &  nCrossingCandidates  ) const

private

Attempt to create candidate vertex positions, using 2D crossing points in 2 views.

Parameters

crossingPoints1	the crossing points in view 1
crossingPoints2	the crossing points in view 2
hitType1	the hit type of crossing points 1
hitType2	the hit type of crossing points 2
nCrossingCandidates	to count the number of crossing candidates created

Definition at line 351 of file CandidateVertexCreationAlgorithm.cc.

{

    for (const CartesianVector &position1 : crossingPoints1)
    {
        for (const CartesianVector &position2 : crossingPoints2)
        {
            if (nCrossingCandidates > m_nMaxCrossingCandidates)
                return;

            if (std::fabs(position1.GetX() - position2.GetX()) > m_maxCrossingXDiscrepancy)
                continue;

            float chiSquared(0.f);
            CartesianVector position3D(0.f, 0.f, 0.f);
            LArGeometryHelper::MergeTwoPositions3D(this->GetPandora(), hitType1, hitType2, position1, position2, position3D, chiSquared);

            if (chiSquared > m_chiSquaredCut)
                continue;

            PandoraContentApi::Vertex::Parameters parameters;
            parameters.m_position = position3D;
            parameters.m_vertexLabel = VERTEX_INTERACTION;
            parameters.m_vertexType = VERTEX_3D;

            const Vertex *pVertex(NULL);
            PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Vertex::Create(*this, parameters, pVertex));
            ++nCrossingCandidates;
        }
    }
}

void lar_content::CandidateVertexCreationAlgorithm::CreateEndpointCandidates ( const pandora::ClusterVector &  clusterVector1, const pandora::ClusterVector &  clusterVector2  ) const

private

Create candidate vertex positions by comparing pairs of cluster end positions.

Parameters

clusterVector1	the clusters in view 1
clusterVector1	the clusters in view 2

Definition at line 173 of file CandidateVertexCreationAlgorithm.cc.

{
    for (const Cluster *const pCluster1 : clusterVector1)
    {
        const HitType hitType1(LArClusterHelper::GetClusterHitType(pCluster1));

        const TwoDSlidingFitResult &fitResult1(this->GetCachedSlidingFitResult(pCluster1));
        const CartesianVector minLayerPosition1(fitResult1.GetGlobalMinLayerPosition());
        const CartesianVector maxLayerPosition1(fitResult1.GetGlobalMaxLayerPosition());

        for (const Cluster *const pCluster2 : clusterVector2)
        {
            const HitType hitType2(LArClusterHelper::GetClusterHitType(pCluster2));

            const TwoDSlidingFitResult &fitResult2(this->GetCachedSlidingFitResult(pCluster2));
            const CartesianVector minLayerPosition2(fitResult2.GetGlobalMinLayerPosition());
            const CartesianVector maxLayerPosition2(fitResult2.GetGlobalMaxLayerPosition());

            this->CreateEndpointVertex(maxLayerPosition1, hitType1, fitResult2);
            this->CreateEndpointVertex(minLayerPosition1, hitType1, fitResult2);
            this->CreateEndpointVertex(maxLayerPosition2, hitType2, fitResult1);
            this->CreateEndpointVertex(minLayerPosition2, hitType2, fitResult1);
        }
    }
}

void lar_content::CandidateVertexCreationAlgorithm::CreateEndpointVertex ( const pandora::CartesianVector &  position1, const pandora::HitType  hitType1, const TwoDSlidingFitResult &  fitResult2  ) const

private

Create a candidate vertex position, using an end-point position from one cluster and sliding fit to a second cluster.

Parameters

position1	an end-point position for the first cluster
hitType1	the hit type of the first cluster
fitResult2	the two dimensional sliding fit result for the second cluster

Definition at line 201 of file CandidateVertexCreationAlgorithm.cc.

{
    const CartesianVector minLayerPosition2(fitResult2.GetGlobalMinLayerPosition());
    const CartesianVector maxLayerPosition2(fitResult2.GetGlobalMaxLayerPosition());

    if ((((position1.GetX() < minLayerPosition2.GetX()) && (position1.GetX() < maxLayerPosition2.GetX())) ||
            ((position1.GetX() > minLayerPosition2.GetX()) && (position1.GetX() > maxLayerPosition2.GetX()))) &&
        (std::fabs(position1.GetX() - minLayerPosition2.GetX()) > m_maxEndpointXDiscrepancy) &&
        (std::fabs(position1.GetX() - maxLayerPosition2.GetX()) > m_maxEndpointXDiscrepancy))
    {
        return;
    }

    CartesianVector position2(0.f, 0.f, 0.f);
    if (STATUS_CODE_SUCCESS != fitResult2.GetExtrapolatedPositionAtX(position1.GetX(), position2))
        return;

    const HitType hitType2(LArClusterHelper::GetClusterHitType(fitResult2.GetCluster()));

    float chiSquared(0.f);
    CartesianVector position3D(0.f, 0.f, 0.f);
    LArGeometryHelper::MergeTwoPositions3D(this->GetPandora(), hitType1, hitType2, position1, position2, position3D, chiSquared);

    if (chiSquared > m_chiSquaredCut)
        return;

    PandoraContentApi::Vertex::Parameters parameters;
    parameters.m_position = position3D;
    parameters.m_vertexLabel = VERTEX_INTERACTION;
    parameters.m_vertexType = VERTEX_3D;

    const Vertex *pVertex(NULL);
    PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::Vertex::Create(*this, parameters, pVertex));
}

void lar_content::CandidateVertexCreationAlgorithm::FindCrossingPoints ( const pandora::ClusterVector &  clusterVector, pandora::CartesianPointVector &  crossingPoints  ) const

private

Identify where (extrapolated) clusters plausibly cross in 2D.

Parameters

clusterVector	the input clusters
crossingPoints	to receive the 2D crossing points

void lar_content::CandidateVertexCreationAlgorithm::FindCrossingPoints ( const pandora::CartesianPointVector &  spacepoints1, const pandora::CartesianPointVector &  spacepoints2, pandora::CartesianPointVector &  crossingPoints  ) const

private

Identify where (extrapolated) clusters plausibly cross in 2D.

Parameters

spacepoints1	space points for cluster 1
spacepoints2	space points for cluster 2
crossingPoints	to receive the list of plausible 2D crossing points

const TwoDSlidingFitResult & lar_content::CandidateVertexCreationAlgorithm::GetCachedSlidingFitResult ( const pandora::Cluster *const  pCluster ) const

private

Get a sliding fit result from the algorithm cache.

Parameters

pCluster

address of the relevant cluster

Definition at line 425 of file CandidateVertexCreationAlgorithm.cc.

{
    TwoDSlidingFitResultMap::const_iterator iter = m_slidingFitResultMap.find(pCluster);

    if (m_slidingFitResultMap.end() == iter)
        throw StatusCodeException(STATUS_CODE_NOT_FOUND);

    return iter->second;
}

void lar_content::CandidateVertexCreationAlgorithm::GetSpacepoints ( const pandora::Cluster *const  pCluster, pandora::CartesianPointVector &  spacePoints  ) const

private

Get a list of spacepoints representing cluster 2D hit positions and extrapolated positions.

Parameters

pCluster	address of the cluster
spacePoints	to receive the list of spacepoints

Definition at line 279 of file CandidateVertexCreationAlgorithm.cc.

{
    LArClusterHelper::GetCoordinateVector(pCluster, spacepoints);

    const TwoDSlidingFitResult &fitResult(this->GetCachedSlidingFitResult(pCluster));
    const float minLayerRL(fitResult.GetL(fitResult.GetMinLayer()));
    const float maxLayerRL(fitResult.GetL(fitResult.GetMaxLayer()));

    for (unsigned int iStep = 0; iStep < m_extrapolationNSteps; ++iStep)
    {
        const float deltaRL(static_cast<float>(iStep) * m_extrapolationStepSize);

        CartesianVector positionPositive(0.f, 0.f, 0.f), positionNegative(0.f, 0.f, 0.f);
        fitResult.GetExtrapolatedPosition(maxLayerRL + deltaRL, positionPositive);
        fitResult.GetExtrapolatedPosition(minLayerRL - deltaRL, positionNegative);

        spacepoints.push_back(positionPositive);
        spacepoints.push_back(positionNegative);
    }

    std::sort(spacepoints.begin(), spacepoints.end(), LArClusterHelper::SortCoordinatesByPosition);
}

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

private

Definition at line 444 of file CandidateVertexCreationAlgorithm.cc.

{
    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadVectorOfValues(xmlHandle, "InputClusterListNames", m_inputClusterListNames));

    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "InputVertexListName", m_inputVertexListName));

    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "OutputVertexListName", m_outputVertexListName));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "ReplaceCurrentVertexList", m_replaceCurrentVertexList));

    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, "MinClusterCaloHits", m_minClusterCaloHits));

    float minClusterLength = std::sqrt(m_minClusterLengthSquared);
    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinClusterLength", minClusterLength));
    m_minClusterLengthSquared = minClusterLength * minClusterLength;

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ChiSquaredCut", m_chiSquaredCut));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "EnableEndpointCandidates", m_enableEndpointCandidates));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MaxEndpointXDiscrepancy", m_maxEndpointXDiscrepancy));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "EnableCrossingCandidates", m_enableCrossingCandidates));

    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "NMaxCrossingCandidates", m_nMaxCrossingCandidates));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MaxCrossingXDiscrepancy", m_maxCrossingXDiscrepancy));

    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ExtrapolationNSteps", m_extrapolationNSteps));

    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ExtrapolationStepSize", m_extrapolationStepSize));

    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ReducedCandidates", m_reducedCandidates));

    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SelectionCutFactorMax", m_selectionCutFactorMax));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "NClustersPassingMaxCutsPar", m_nClustersPassingMaxCutsPar));

    float maxCrossingSeparation = std::sqrt(m_maxCrossingSeparationSquared);
    PANDORA_RETURN_RESULT_IF_AND_IF(
        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxCrossingSeparation", maxCrossingSeparation));
    m_maxCrossingSeparationSquared = maxCrossingSeparation * maxCrossingSeparation;

    float minNearbyCrossingDistance = std::sqrt(m_minNearbyCrossingDistanceSquared);
    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MinNearbyCrossingDistance", minNearbyCrossingDistance));
    m_minNearbyCrossingDistanceSquared = minNearbyCrossingDistance * minNearbyCrossingDistance;

    return STATUS_CODE_SUCCESS;
}

StatusCode lar_content::CandidateVertexCreationAlgorithm::Run ( )

private

Definition at line 46 of file CandidateVertexCreationAlgorithm.cc.

{
    try
    {
        ClusterVector clusterVectorU, clusterVectorV, clusterVectorW;
        this->SelectClusters(clusterVectorU, clusterVectorV, clusterVectorW);

        const VertexList *pVertexList(NULL);
        std::string temporaryListName;
        PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::CreateTemporaryListAndSetCurrent(*this, pVertexList, temporaryListName));

        if (m_enableEndpointCandidates)
        {
            this->CreateEndpointCandidates(clusterVectorU, clusterVectorV);
            this->CreateEndpointCandidates(clusterVectorU, clusterVectorW);
            this->CreateEndpointCandidates(clusterVectorV, clusterVectorW);
        }

        if (m_enableCrossingCandidates)
            this->CreateCrossingCandidates(clusterVectorU, clusterVectorV, clusterVectorW);

        if (!m_inputVertexListName.empty())
            this->AddInputVertices();

        if (!pVertexList->empty())
        {
            PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList<Vertex>(*this, m_outputVertexListName));

            if (m_replaceCurrentVertexList)
                PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ReplaceCurrentList<Vertex>(*this, m_outputVertexListName));
        }
    }
    catch (StatusCodeException &statusCodeException)
    {
        this->TidyUp();
        throw statusCodeException;
    }

    this->TidyUp();

    return STATUS_CODE_SUCCESS;
}

void lar_content::CandidateVertexCreationAlgorithm::SelectClusters ( pandora::ClusterVector &  clusterVectorU, pandora::ClusterVector &  clusterVectorV, pandora::ClusterVector &  clusterVectorW  )

private

Select a subset of input clusters (contained in the input list names) for processing in this algorithm.

Parameters

clusterVectorU	to receive the selected clusters in the u view
clusterVectorV	to receive the selected clusters in the v view
clusterVectorW	to receive the selected clusters in the w view

Definition at line 91 of file CandidateVertexCreationAlgorithm.cc.

{
    for (const std::string &clusterListName : m_inputClusterListNames)
    {
        const ClusterList *pClusterList(NULL);
        PANDORA_THROW_RESULT_IF_AND_IF(
            STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, clusterListName, pClusterList));

        if (!pClusterList || pClusterList->empty())
        {
            if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())
                std::cout << "CandidateVertexCreationAlgorithm: unable to find cluster list " << clusterListName << std::endl;

            continue;
        }

        const HitType hitType(LArClusterHelper::GetClusterHitType(*(pClusterList->begin())));

        if ((TPC_VIEW_U != hitType) && (TPC_VIEW_V != hitType) && (TPC_VIEW_W != hitType))
            throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);

        ClusterVector &selectedClusterVector((TPC_VIEW_U == hitType) ? clusterVectorU : (TPC_VIEW_V == hitType) ? clusterVectorV : clusterVectorW);

        if (!selectedClusterVector.empty())
            throw StatusCodeException(STATUS_CODE_FAILURE);

        ClusterVector sortedClusters(pClusterList->begin(), pClusterList->end());
        std::sort(sortedClusters.begin(), sortedClusters.end(), LArClusterHelper::SortByNHits);

        unsigned int nClustersPassingMaxCuts(0);
        if (m_reducedCandidates)
        {
            for (const Cluster *const pCluster : sortedClusters)
            {
                float selectionCutFactor(1.f);

                if (pCluster->GetParticleId() == E_MINUS)
                    selectionCutFactor = m_selectionCutFactorMax;

                if (pCluster->GetNCaloHits() < m_minClusterCaloHits * selectionCutFactor)
                    continue;

                if (LArClusterHelper::GetLengthSquared(pCluster) < m_minClusterLengthSquared * selectionCutFactor * selectionCutFactor)
                    continue;

                nClustersPassingMaxCuts++;
            }
        }

        for (const Cluster *const pCluster : sortedClusters)
        {
            float selectionCutFactor(1.f);

            if (pCluster->GetParticleId() == E_MINUS && m_reducedCandidates)
            {
                selectionCutFactor = (m_selectionCutFactorMax + 1.f) * 0.5f +
                                     (m_selectionCutFactorMax - 1.f) * 0.5f *
                                         std::tanh(static_cast<float>(nClustersPassingMaxCuts) - m_nClustersPassingMaxCutsPar);
            }

            if (pCluster->GetNCaloHits() < m_minClusterCaloHits * selectionCutFactor)
                continue;

            if (LArClusterHelper::GetLengthSquared(pCluster) < m_minClusterLengthSquared * selectionCutFactor * selectionCutFactor)
                continue;

            try
            {
                this->AddToSlidingFitCache(pCluster);
                selectedClusterVector.push_back(pCluster);
            }
            catch (StatusCodeException &statusCodeException)
            {
                if (STATUS_CODE_FAILURE == statusCodeException.GetStatusCode())
                    throw statusCodeException;
            }
        }
    }
}

void lar_content::CandidateVertexCreationAlgorithm::TidyUp ( )

private

Clear relevant algorithm member variables between events.

Definition at line 437 of file CandidateVertexCreationAlgorithm.cc.

{
    m_slidingFitResultMap.clear();
}

Member Data Documentation

float lar_content::CandidateVertexCreationAlgorithm::m_chiSquaredCut

private

The chi squared cut (accept only 3D vertex positions with values below cut)

Definition at line 146 of file CandidateVertexCreationAlgorithm.h.

bool lar_content::CandidateVertexCreationAlgorithm::m_enableCrossingCandidates

private

Whether to create crossing vertex candidates.

Definition at line 151 of file CandidateVertexCreationAlgorithm.h.

bool lar_content::CandidateVertexCreationAlgorithm::m_enableEndpointCandidates

private

Whether to create endpoint-based candidates.

Definition at line 148 of file CandidateVertexCreationAlgorithm.h.

unsigned int lar_content::CandidateVertexCreationAlgorithm::m_extrapolationNSteps

private

Number of extrapolation steps, at each end of cluster, of specified size.

Definition at line 154 of file CandidateVertexCreationAlgorithm.h.

float lar_content::CandidateVertexCreationAlgorithm::m_extrapolationStepSize

private

The extrapolation step size in cm.

Definition at line 155 of file CandidateVertexCreationAlgorithm.h.

pandora::StringVector lar_content::CandidateVertexCreationAlgorithm::m_inputClusterListNames

private

The list of cluster list names.

Definition at line 136 of file CandidateVertexCreationAlgorithm.h.

std::string lar_content::CandidateVertexCreationAlgorithm::m_inputVertexListName

private

The list name for existing candidate vertices.

Definition at line 137 of file CandidateVertexCreationAlgorithm.h.

float lar_content::CandidateVertexCreationAlgorithm::m_maxCrossingSeparationSquared

private

The separation (squared) between spacepoints below which a crossing can be identified.

Definition at line 156 of file CandidateVertexCreationAlgorithm.h.

float lar_content::CandidateVertexCreationAlgorithm::m_maxCrossingXDiscrepancy

private

The max cluster endpoint discrepancy.

Definition at line 153 of file CandidateVertexCreationAlgorithm.h.

float lar_content::CandidateVertexCreationAlgorithm::m_maxEndpointXDiscrepancy

private

The max cluster endpoint discrepancy.

Definition at line 149 of file CandidateVertexCreationAlgorithm.h.

unsigned int lar_content::CandidateVertexCreationAlgorithm::m_minClusterCaloHits

private

The min number of hits in base cluster selection method.

Definition at line 144 of file CandidateVertexCreationAlgorithm.h.

float lar_content::CandidateVertexCreationAlgorithm::m_minClusterLengthSquared

private

The min length (squared) in base cluster selection method.

Definition at line 145 of file CandidateVertexCreationAlgorithm.h.

float lar_content::CandidateVertexCreationAlgorithm::m_minNearbyCrossingDistanceSquared

private

The minimum allowed distance between identified crossing positions.

Definition at line 157 of file CandidateVertexCreationAlgorithm.h.

float lar_content::CandidateVertexCreationAlgorithm::m_nClustersPassingMaxCutsPar

private

Parameter for number of clusters passing the max base cluster selection cuts.

Definition at line 161 of file CandidateVertexCreationAlgorithm.h.

unsigned int lar_content::CandidateVertexCreationAlgorithm::m_nMaxCrossingCandidates

private

The max number of crossing candidates to create.

Definition at line 152 of file CandidateVertexCreationAlgorithm.h.

std::string lar_content::CandidateVertexCreationAlgorithm::m_outputVertexListName

private

The name under which to save the output vertex list.

Definition at line 138 of file CandidateVertexCreationAlgorithm.h.

bool lar_content::CandidateVertexCreationAlgorithm::m_reducedCandidates

private

Whether to reduce the number of candidates.

Definition at line 159 of file CandidateVertexCreationAlgorithm.h.

bool lar_content::CandidateVertexCreationAlgorithm::m_replaceCurrentVertexList

private

Whether to replace the current vertex list with the output list.

Definition at line 139 of file CandidateVertexCreationAlgorithm.h.

float lar_content::CandidateVertexCreationAlgorithm::m_selectionCutFactorMax

private

Maximum factor to multiply the base cluster selection cuts.

Definition at line 160 of file CandidateVertexCreationAlgorithm.h.

TwoDSlidingFitResultMap lar_content::CandidateVertexCreationAlgorithm::m_slidingFitResultMap

private

The sliding fit result map.

Definition at line 142 of file CandidateVertexCreationAlgorithm.h.

unsigned int lar_content::CandidateVertexCreationAlgorithm::m_slidingFitWindow

private

The layer window for the sliding linear fits.

Definition at line 141 of file CandidateVertexCreationAlgorithm.h.

---

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

• CandidateVertexCreationAlgorithm.h
• CandidateVertexCreationAlgorithm.cc