lar_content::NeutrinoDaughterVerticesAlgorithm Class Reference

NeutrinoDaughterVerticesAlgorithm class. More...

#include "NeutrinoDaughterVerticesAlgorithm.h"

Inheritance diagram for lar_content::NeutrinoDaughterVerticesAlgorithm:

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

Private Member Functions
pandora::StatusCode	Run ()
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)
void	GetDaughterPfos (const pandora::PfoList *const pfoList, pandora::PfoVector &pfoVector) const
	Get the vector of daughter pfos. More...
void	BuildPointingClusterMap (const pandora::PfoVector &pfoVector, LArPointingClusterMap &pointingClusterMap) const
	Build a map of 3D sliding fits from the input Pfos. More...
void	BuildDaughterParticles (const LArPointingClusterMap &pointingClusterMap, const pandora::PfoVector &pfoVector) const
	Reconstruct the vertex and direction of daughter Pfos. More...
void	BuildDaughterTrack (const LArPointingClusterMap &pointingClusterMap, const pandora::ParticleFlowObject *const pDaughterPfo) const
	Reconstruct the vertex and direction of a track-like Pfos. More...
void	BuildDaughterShower (const pandora::ParticleFlowObject *const pDaughterPfo) const
	Reconstruct the vertex and direction of a shower-like Pfos. More...
void	SetParticleParameters (const pandora::CartesianVector &vtxPosition, const pandora::CartesianVector &vtxDirection, const pandora::ParticleFlowObject *const pPfo) const
	Set the vertex and direction of the Pfos. More...

Private Attributes
bool	m_useParentShowerVertex
	use the parent pfo for the shower vertices More...
unsigned int	m_halfWindowLayers
	number of layers to use for half-window of sliding fit More...
std::string	m_neutrinoListName
	The input list of pfo list names. More...
std::string	m_vertexListName
	The name of the output cosmic-ray vertex list. More...

Detailed Description

NeutrinoDaughterVerticesAlgorithm class.

Definition at line 21 of file NeutrinoDaughterVerticesAlgorithm.h.

Constructor & Destructor Documentation

lar_content::NeutrinoDaughterVerticesAlgorithm::NeutrinoDaughterVerticesAlgorithm

(

)

Default constructor.

Definition at line 22 of file NeutrinoDaughterVerticesAlgorithm.cc.

                                                                     :
    m_useParentShowerVertex(false),
    m_halfWindowLayers(20)
{
}

Member Function Documentation

void lar_content::NeutrinoDaughterVerticesAlgorithm::BuildDaughterParticles ( const LArPointingClusterMap &  pointingClusterMap, const pandora::PfoVector &  pfoVector  ) const

private

Reconstruct the vertex and direction of daughter Pfos.

Parameters

pointingClusterMap	the input map of 3D pointing clusters
pfoVector	the input list of Pfos

Definition at line 121 of file NeutrinoDaughterVerticesAlgorithm.cc.

References BuildDaughterShower(), BuildDaughterTrack(), and lar_content::LArPfoHelper::IsTrack().

Referenced by Run().

{
    for (PfoVector::const_iterator iter = pfoVector.begin(), iterEnd = pfoVector.end(); iter != iterEnd; ++iter)
    {
        const ParticleFlowObject *const pPfo = *iter;

        if (LArPfoHelper::IsTrack(pPfo))
        {
            this->BuildDaughterTrack(pointingClusterMap, pPfo);
        }
        else
        {
            this->BuildDaughterShower(pPfo);
        }
    }
}

void lar_content::NeutrinoDaughterVerticesAlgorithm::BuildDaughterShower ( const pandora::ParticleFlowObject *const  pDaughterPfo ) const

private

Reconstruct the vertex and direction of a shower-like Pfos.

Parameters

pPfo	the input Pfo

Definition at line 235 of file NeutrinoDaughterVerticesAlgorithm.cc.

References f, lar_content::LArClusterHelper::GetClosestPosition(), lar_content::LArClusterHelper::GetClosestPositions(), lar_content::LArPfoHelper::GetClusters(), lar_content::LArPfoHelper::IsNeutrino(), m_useParentShowerVertex, and SetParticleParameters().

Referenced by BuildDaughterParticles().

{
    if (pDaughterPfo->GetParentPfoList().size() != 1)
        throw StatusCodeException(STATUS_CODE_FAILURE);

    const ParticleFlowObject *const pParentPfo = *(pDaughterPfo->GetParentPfoList().begin());

    if (LArPfoHelper::IsNeutrino(pParentPfo) && pParentPfo->GetVertexList().size() != 1)
        throw StatusCodeException(STATUS_CODE_FAILURE);

    ClusterList parentList, daughterList;
    LArPfoHelper::GetClusters(pParentPfo, TPC_3D, parentList);
    LArPfoHelper::GetClusters(pDaughterPfo, TPC_3D, daughterList);

    if (daughterList.empty())
        return;

    if (LArPfoHelper::IsNeutrino(pParentPfo))
    {
        const Vertex *const pVertex = *(pParentPfo->GetVertexList().begin());
        const CartesianVector vtxPosition(
            m_useParentShowerVertex ? pVertex->GetPosition() : LArClusterHelper::GetClosestPosition(pVertex->GetPosition(), daughterList));

        return this->SetParticleParameters(vtxPosition, CartesianVector(0.f, 0.f, 0.f), pDaughterPfo);
    }

    if (parentList.empty())
        return;

    bool foundVtx(false);
    float vtxDistanceSquared(0.f);
    CartesianVector vtxPosition(0.f, 0.f, 0.f);

    for (ClusterList::const_iterator dIter = daughterList.begin(), dIterEnd = daughterList.end(); dIter != dIterEnd; ++dIter)
    {
        const Cluster *const pDaughterCluster = *dIter;

        for (ClusterList::const_iterator pIter = parentList.begin(), pIterEnd = parentList.end(); pIter != pIterEnd; ++pIter)
        {
            const Cluster *const pParentCluster = *pIter;

            CartesianVector closestDaughterPosition(0.f, 0.f, 0.f), closestParentPosition(0.f, 0.f, 0.f);
            LArClusterHelper::GetClosestPositions(pDaughterCluster, pParentCluster, closestDaughterPosition, closestParentPosition);

            const float closestDistanceSquared((closestDaughterPosition - closestParentPosition).GetMagnitudeSquared());

            if (!foundVtx || closestDistanceSquared < vtxDistanceSquared)
            {
                foundVtx = true;
                vtxDistanceSquared = closestDistanceSquared;
                vtxPosition = (m_useParentShowerVertex ? closestParentPosition : closestDaughterPosition);
            }
        }
    }

    if (!foundVtx)
        return;

    this->SetParticleParameters(vtxPosition, CartesianVector(0.f, 0.f, 0.f), pDaughterPfo);
}

void lar_content::NeutrinoDaughterVerticesAlgorithm::BuildDaughterTrack ( const LArPointingClusterMap &  pointingClusterMap, const pandora::ParticleFlowObject *const  pDaughterPfo  ) const

private

Reconstruct the vertex and direction of a track-like Pfos.

Parameters

pointingClusterMap	the input map of 3D pointing clusters
pPfo	the input Pfo

Definition at line 140 of file NeutrinoDaughterVerticesAlgorithm.cc.

References f, lar_content::LArClusterHelper::GetClosestDistance(), lar_content::LArPfoHelper::GetClusters(), lar_content::LArPointingCluster::Vertex::GetDirection(), lar_content::LArClusterHelper::GetExtremalCoordinates(), lar_content::LArPointingCluster::GetInnerVertex(), lar_content::LArPointingCluster::GetOuterVertex(), lar_content::LArPointingCluster::Vertex::GetPosition(), lar_content::LArPfoHelper::IsNeutrino(), and SetParticleParameters().

Referenced by BuildDaughterParticles().

{
    if (pDaughterPfo->GetParentPfoList().size() != 1)
        throw StatusCodeException(STATUS_CODE_FAILURE);

    const ParticleFlowObject *const pParentPfo = *(pDaughterPfo->GetParentPfoList().begin());

    ClusterList parentList, daughterList;
    LArPfoHelper::GetClusters(pParentPfo, TPC_3D, parentList);
    LArPfoHelper::GetClusters(pDaughterPfo, TPC_3D, daughterList);

    if (parentList.empty() && pParentPfo->GetVertexList().empty())
        return;

    bool foundVtx(false);
    float vtxDistance(0.f);
    CartesianVector vtxPosition(0.f, 0.f, 0.f);
    CartesianVector vtxDirection(0.f, 0.f, 0.f);

    for (ClusterList::const_iterator dIter = daughterList.begin(), dIterEnd = daughterList.end(); dIter != dIterEnd; ++dIter)
    {
        const Cluster *const pDaughterCluster = *dIter;

        CartesianVector minPosition(0.f, 0.f, 0.f), maxPosition(0.f, 0.f, 0.f);
        CartesianVector minDirection(0.f, 0.f, 0.f), maxDirection(0.f, 0.f, 0.f);
        bool foundDirection(false);

        LArPointingClusterMap::const_iterator cIter = pointingClusterMap.find(pDaughterCluster);

        if (pointingClusterMap.end() != cIter)
        {
            const LArPointingCluster &pointingCluster(cIter->second);

            minPosition = pointingCluster.GetInnerVertex().GetPosition();
            maxPosition = pointingCluster.GetOuterVertex().GetPosition();
            minDirection = pointingCluster.GetInnerVertex().GetDirection();
            maxDirection = pointingCluster.GetOuterVertex().GetDirection();
            foundDirection = true;
        }
        else
        {
            LArClusterHelper::GetExtremalCoordinates(pDaughterCluster, minPosition, maxPosition);
        }

        if ((maxPosition - minPosition).GetMagnitudeSquared() < std::numeric_limits<float>::epsilon())
            continue;

        if (!foundDirection)
        {
            minDirection = (maxPosition - minPosition).GetUnitVector();
            maxDirection = (minPosition - maxPosition).GetUnitVector();
        }

        float minDistance(std::numeric_limits<float>::max());
        float maxDistance(std::numeric_limits<float>::max());

        for (ClusterList::const_iterator pIter = parentList.begin(), pIterEnd = parentList.end(); pIter != pIterEnd; ++pIter)
        {
            const Cluster *const pParentCluster = *pIter;
            minDistance = std::min(minDistance, (LArClusterHelper::GetClosestDistance(minPosition, pParentCluster)));
            maxDistance = std::min(maxDistance, (LArClusterHelper::GetClosestDistance(maxPosition, pParentCluster)));
        }

        if (LArPfoHelper::IsNeutrino(pParentPfo) && !pParentPfo->GetVertexList().empty())
        {
            const Vertex *const pVertex = *(pParentPfo->GetVertexList().begin());
            minDistance = std::min(minDistance, (pVertex->GetPosition() - minPosition).GetMagnitude());
            maxDistance = std::min(maxDistance, (pVertex->GetPosition() - maxPosition).GetMagnitude());
        }

        if (!foundVtx || (minDistance < vtxDistance))
        {
            foundVtx = true;
            vtxDistance = minDistance;
            vtxPosition = minPosition;
            vtxDirection = minDirection;
        }

        if (!foundVtx || (maxDistance < vtxDistance))
        {
            foundVtx = true;
            vtxDistance = maxDistance;
            vtxPosition = maxPosition;
            vtxDirection = maxDirection;
        }
    }

    if (!foundVtx)
        return;

    this->SetParticleParameters(vtxPosition, vtxDirection, pDaughterPfo);
}

void lar_content::NeutrinoDaughterVerticesAlgorithm::BuildPointingClusterMap ( const pandora::PfoVector &  pfoVector, LArPointingClusterMap &  pointingClusterMap  ) const

private

Build a map of 3D sliding fits from the input Pfos.

Parameters

pfoVector	the input particle flow objects
pointingClusterMap	the output map of 3D pointing clusters

Definition at line 81 of file NeutrinoDaughterVerticesAlgorithm.cc.

References lar_content::LArPfoHelper::GetClusters(), lar_content::LArGeometryHelper::GetWirePitch(), lar_content::LArPfoHelper::IsTrack(), and m_halfWindowLayers.

Referenced by Run().

{
    const float pitchU{LArGeometryHelper::GetWirePitch(this->GetPandora(), TPC_VIEW_U)};
    const float pitchV{LArGeometryHelper::GetWirePitch(this->GetPandora(), TPC_VIEW_V)};
    const float pitchW{LArGeometryHelper::GetWirePitch(this->GetPandora(), TPC_VIEW_W)};
    const float pitchMax{std::max({pitchU, pitchV, pitchW})};
    const float slidingFitPitch(pitchMax);

    for (PfoVector::const_iterator pIter = pfoList.begin(), pIterEnd = pfoList.end(); pIter != pIterEnd; ++pIter)
    {
        const ParticleFlowObject *const pPfo = *pIter;

        if (!LArPfoHelper::IsTrack(pPfo))
            continue;

        ClusterList clusterList;
        LArPfoHelper::GetClusters(pPfo, TPC_3D, clusterList);

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

            try
            {
                const LArPointingCluster pointingCluster(pCluster, m_halfWindowLayers, slidingFitPitch);

                if (!pointingClusterMap.insert(LArPointingClusterMap::value_type(pCluster, pointingCluster)).second)
                    throw StatusCodeException(STATUS_CODE_FAILURE);
            }
            catch (StatusCodeException &statusCodeException)
            {
                if (STATUS_CODE_FAILURE == statusCodeException.GetStatusCode())
                    throw statusCodeException;
            }
        }
    }
}

void lar_content::NeutrinoDaughterVerticesAlgorithm::GetDaughterPfos ( const pandora::PfoList *const  pfoList, pandora::PfoVector &  pfoVector  ) const

private

Get the vector of daughter pfos.

Parameters

pfoList	the input list of neutrino pfos
pfoVector	to receive the vector of daughter pfos

Definition at line 55 of file NeutrinoDaughterVerticesAlgorithm.cc.

References lar_content::LArPfoHelper::GetAllDownstreamPfos(), lar_content::LArPfoHelper::GetClusters(), and lar_content::LArPfoHelper::IsNeutrino().

Referenced by Run().

{
    PfoList outputList;

    for (PfoList::const_iterator pIter = pPfoList->begin(), pIterEnd = pPfoList->end(); pIter != pIterEnd; ++pIter)
    {
        if (!LArPfoHelper::IsNeutrino(*pIter) && (*pIter)->GetVertexList().size() != 1)
            throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);

        LArPfoHelper::GetAllDownstreamPfos(*pIter, outputList);
    }

    for (PfoList::const_iterator pIter = outputList.begin(), pIterEnd = outputList.end(); pIter != pIterEnd; ++pIter)
    {
        ClusterList clusterList;
        LArPfoHelper::GetClusters(*pIter, TPC_3D, clusterList);

        if (clusterList.empty())
            continue;

        pfoVector.push_back(*pIter);
    }
}

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

private

Definition at line 329 of file NeutrinoDaughterVerticesAlgorithm.cc.

References m_halfWindowLayers, m_neutrinoListName, m_useParentShowerVertex, and m_vertexListName.

{
    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "NeutrinoPfoListName", m_neutrinoListName));

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

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "UseParentForShowerVertex", m_useParentShowerVertex));

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

    return STATUS_CODE_SUCCESS;
}

StatusCode lar_content::NeutrinoDaughterVerticesAlgorithm::Run ( )

private

Definition at line 30 of file NeutrinoDaughterVerticesAlgorithm.cc.

References BuildDaughterParticles(), BuildPointingClusterMap(), GetDaughterPfos(), and m_neutrinoListName.

{
    const PfoList *pPfoList = NULL;
    PANDORA_THROW_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*this, m_neutrinoListName, pPfoList));

    if (!pPfoList || pPfoList->empty())
    {
        if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())
            std::cout << "NeutrinoDaughterVerticesAlgorithm: unable to find pfo list " << m_neutrinoListName << std::endl;

        return STATUS_CODE_SUCCESS;
    }

    PfoVector pfoVector;
    LArPointingClusterMap pointingClusterMap;

    this->GetDaughterPfos(pPfoList, pfoVector);
    this->BuildPointingClusterMap(pfoVector, pointingClusterMap);
    this->BuildDaughterParticles(pointingClusterMap, pfoVector);

    return STATUS_CODE_SUCCESS;
}

void lar_content::NeutrinoDaughterVerticesAlgorithm::SetParticleParameters ( const pandora::CartesianVector &  vtxPosition, const pandora::CartesianVector &  vtxDirection, const pandora::ParticleFlowObject *const  pPfo  ) const

private

Set the vertex and direction of the Pfos.

Parameters

vtxPosition	the input vertex position
vtxDirection	the input vertex direction
pPfo	the input Pfo

Definition at line 298 of file NeutrinoDaughterVerticesAlgorithm.cc.

References m_vertexListName.

Referenced by BuildDaughterShower(), and BuildDaughterTrack().

{
    if (!pPfo->GetVertexList().empty())
        throw StatusCodeException(STATUS_CODE_FAILURE);

    PandoraContentApi::ParticleFlowObject::Metadata metadata;
    metadata.m_momentum = vtxDirection;
    PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::ParticleFlowObject::AlterMetadata(*this, pPfo, metadata));

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

    PandoraContentApi::Vertex::Parameters parameters;
    parameters.m_position = vtxPosition;
    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));

    if (!pVertexList->empty())
    {
        PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::SaveList<Vertex>(*this, m_vertexListName));
        PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::AddToPfo<Vertex>(*this, pPfo, pVertex));
    }
}

Member Data Documentation

unsigned int lar_content::NeutrinoDaughterVerticesAlgorithm::m_halfWindowLayers

private

number of layers to use for half-window of sliding fit

Definition at line 83 of file NeutrinoDaughterVerticesAlgorithm.h.

Referenced by BuildPointingClusterMap(), and ReadSettings().

std::string lar_content::NeutrinoDaughterVerticesAlgorithm::m_neutrinoListName

private

The input list of pfo list names.

Definition at line 84 of file NeutrinoDaughterVerticesAlgorithm.h.

Referenced by ReadSettings(), and Run().

bool lar_content::NeutrinoDaughterVerticesAlgorithm::m_useParentShowerVertex

private

use the parent pfo for the shower vertices

Definition at line 82 of file NeutrinoDaughterVerticesAlgorithm.h.

Referenced by BuildDaughterShower(), and ReadSettings().

std::string lar_content::NeutrinoDaughterVerticesAlgorithm::m_vertexListName

private

The name of the output cosmic-ray vertex list.

Definition at line 85 of file NeutrinoDaughterVerticesAlgorithm.h.

Referenced by ReadSettings(), and SetParticleParameters().

---

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

• larpandoracontent/v04_08_01/source/larpandoracontent/LArThreeDReco/LArEventBuilding/NeutrinoDaughterVerticesAlgorithm.h
• larpandoracontent/v04_08_01/source/larpandoracontent/LArThreeDReco/LArEventBuilding/NeutrinoDaughterVerticesAlgorithm.cc