lar_content::CosmicRayVertexBuildingAlgorithm Class Reference

CosmicRayVertexBuildingAlgorithm class. More...

#include "CosmicRayVertexBuildingAlgorithm.h"

Inheritance diagram for lar_content::CosmicRayVertexBuildingAlgorithm:

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

Private Member Functions
pandora::StatusCode	Run ()
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)
void	GetCosmicPfos (const pandora::PfoList *const pPfoList, pandora::PfoVector &pfoVector) const
	Get the list of input pfos to this algorithm. More...
void	BuildPointingClusterMap (const pandora::PfoVector &pfoVector, LArPointingClusterMap &pointingClusterMap) const
	Build a map of 3D sliding fits from the input Pfos. More...
void	BuildCosmicRayParticles (const LArPointingClusterMap &pointingClusterMap, const pandora::PfoVector &pfoVector) const
	Reconstruct the vertex and direction of a list of cosmic-ray Pfos. More...
void	BuildCosmicRayParent (const LArPointingClusterMap &pointingClusterMap, const pandora::ParticleFlowObject *const pPfo) const
	Reconstruct the vertex and direction of a parent cosmic-ray Pfo. More...
void	BuildCosmicRayDaughter (const pandora::ParticleFlowObject *const pPfo) const
	Reconstruct the vertex and direction of a daughter cosmic-ray Pfo. 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...
bool	m_isDualPhase
	type of geometry More...
unsigned int	m_halfWindowLayers
	number of layers to use for half-window of sliding fit More...
std::string	m_parentPfoListName
	The name of the input pfo list. More...
std::string	m_vertexListName
	The name of the output vertex list. More...
float	m_maxVertexDisplacementFromTrack
	The maximum separation of a close vertex from the cosmic ray track. More...

Detailed Description

CosmicRayVertexBuildingAlgorithm class.

Definition at line 21 of file CosmicRayVertexBuildingAlgorithm.h.

Constructor & Destructor Documentation

lar_content::CosmicRayVertexBuildingAlgorithm::CosmicRayVertexBuildingAlgorithm

(

)

Default constructor.

Definition at line 22 of file CosmicRayVertexBuildingAlgorithm.cc.

                                                                   :
    m_useParentShowerVertex(false),
    m_isDualPhase(false),
    m_halfWindowLayers(30),
    m_maxVertexDisplacementFromTrack(1.f)
{
}

Member Function Documentation

void lar_content::CosmicRayVertexBuildingAlgorithm::BuildCosmicRayDaughter ( const pandora::ParticleFlowObject *const  pPfo ) const

private

Reconstruct the vertex and direction of a daughter cosmic-ray Pfo.

Parameters

pPfo	the daughter Pfo

Definition at line 238 of file CosmicRayVertexBuildingAlgorithm.cc.

References f, lar_content::LArClusterHelper::GetClosestPosition(), lar_content::LArPfoHelper::GetClusters(), m_isDualPhase, m_maxVertexDisplacementFromTrack, m_useParentShowerVertex, and SetParticleParameters().

Referenced by BuildCosmicRayParticles().

{
    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 (daughterList.empty() || parentList.empty())
        return;

    bool found(false);
    float closestMaxVerticalCoordinate(-std::numeric_limits<float>::max()), maxVerticalCoordinate(-std::numeric_limits<float>::max());
    CartesianVector closestMaxVerticalVertex(0.f, 0.f, 0.f), maxVerticalVertex(0.f, 0.f, 0.f);

    for (const Cluster *const pDaughterCluster : daughterList)
    {
        CaloHitList daughterCaloHitList;
        pDaughterCluster->GetOrderedCaloHitList().FillCaloHitList(daughterCaloHitList);

        for (const Cluster *const pParentCluster : parentList)
        {
            CaloHitList parentCaloHitList;
            pParentCluster->GetOrderedCaloHitList().FillCaloHitList(parentCaloHitList);

            for (const CaloHit *const pDaughterCaloHit : daughterCaloHitList)
            {
                const CartesianVector &daughterPosition(pDaughterCaloHit->GetPositionVector());

                for (const CaloHit *const pParentCaloHit : parentCaloHitList)
                {
                    const CartesianVector &parentPosition(pParentCaloHit->GetPositionVector());
                    const float separationSquared((daughterPosition - parentPosition).GetMagnitudeSquared());
                    const float verticalCoordinate(m_isDualPhase ? daughterPosition.GetX() : daughterPosition.GetY());

                    if (verticalCoordinate > maxVerticalCoordinate)
                    {
                        maxVerticalCoordinate = verticalCoordinate;
                        maxVerticalVertex = daughterPosition;
                    }

                    if (separationSquared < (m_maxVertexDisplacementFromTrack * m_maxVertexDisplacementFromTrack))
                    {
                        if (verticalCoordinate > closestMaxVerticalCoordinate)
                        {
                            found = true;
                            closestMaxVerticalCoordinate = verticalCoordinate;
                            closestMaxVerticalVertex = daughterPosition;
                        }
                    }
                }
            }
        }
    }

    const CartesianVector &daughterVertex(found ? closestMaxVerticalVertex : maxVerticalVertex);
    const CartesianVector &vertexPosition(m_useParentShowerVertex ? LArClusterHelper::GetClosestPosition(daughterVertex, parentList) : daughterVertex);

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

void lar_content::CosmicRayVertexBuildingAlgorithm::BuildCosmicRayParent ( const LArPointingClusterMap &  pointingClusterMap, const pandora::ParticleFlowObject *const  pPfo  ) const

private

Reconstruct the vertex and direction of a parent cosmic-ray Pfo.

Parameters

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

Definition at line 142 of file CosmicRayVertexBuildingAlgorithm.cc.

References f, 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(), m_isDualPhase, and SetParticleParameters().

Referenced by BuildCosmicRayParticles().

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

    if (clusterList.empty())
        return;

    // Take highest point as vertex of parent Pfos (TODO: do something more sophisticated for horizontal events)
    bool foundVtx(false);
    CartesianVector vtxPosition(0.f, 0.f, 0.f);
    CartesianVector vtxDirection(0.f, 0.f, 0.f);

    bool foundEnd(false);
    CartesianVector endPosition(0.f, 0.f, 0.f);
    CartesianVector endDirection(0.f, 0.f, 0.f);

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

        try
        {
            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);

            LArPointingClusterMap::const_iterator cIter2 = pointingClusterMap.find(pCluster);

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

                minPosition = pointingCluster.GetInnerVertex().GetPosition();
                maxPosition = pointingCluster.GetOuterVertex().GetPosition();
                minDirection = pointingCluster.GetInnerVertex().GetDirection();
                maxDirection = pointingCluster.GetOuterVertex().GetDirection();
            }
            else
            {
                LArClusterHelper::GetExtremalCoordinates(pCluster, minPosition, maxPosition);
                minDirection = (maxPosition - minPosition).GetUnitVector();
                maxDirection = (minPosition - maxPosition).GetUnitVector();
            }

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

            // ATTN X is the vertical coordinate in Dual-Phase geometry
            const float minVerticalCoordinate(m_isDualPhase ? minPosition.GetX() : minPosition.GetY());
            const float maxVerticalCoordinate(m_isDualPhase ? maxPosition.GetX() : maxPosition.GetY());

            if (!foundVtx || (minVerticalCoordinate > std::max(maxVerticalCoordinate, m_isDualPhase ? vtxPosition.GetX() : vtxPosition.GetY())))
            {
                foundVtx = true;
                vtxPosition = minPosition;
                vtxDirection = minDirection;
            }

            if (!foundVtx || (maxVerticalCoordinate > std::max(minVerticalCoordinate, m_isDualPhase ? vtxPosition.GetX() : vtxPosition.GetY())))
            {
                foundVtx = true;
                vtxPosition = maxPosition;
                vtxDirection = maxDirection;
            }

            if (!foundEnd || (minVerticalCoordinate < std::min(maxVerticalCoordinate, m_isDualPhase ? endPosition.GetX() : endPosition.GetY())))
            {
                foundEnd = true;
                endPosition = minPosition;
                endDirection = minDirection;
            }

            if (!foundEnd || (maxVerticalCoordinate < std::min(minVerticalCoordinate, m_isDualPhase ? endPosition.GetX() : endPosition.GetY())))
            {
                foundEnd = true;
                endPosition = maxPosition;
                endDirection = maxDirection;
            }
        }
        catch (StatusCodeException &statusCodeException)
        {
            if (STATUS_CODE_FAILURE == statusCodeException.GetStatusCode())
                throw statusCodeException;

            continue;
        }
    }

    if (!(foundVtx && foundEnd))
        return;

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

void lar_content::CosmicRayVertexBuildingAlgorithm::BuildCosmicRayParticles ( const LArPointingClusterMap &  pointingClusterMap, const pandora::PfoVector &  pfoVector  ) const

private

Reconstruct the vertex and direction of a list of cosmic-ray Pfos.

Parameters

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

Definition at line 123 of file CosmicRayVertexBuildingAlgorithm.cc.

References BuildCosmicRayDaughter(), BuildCosmicRayParent(), and lar_content::LArPfoHelper::IsFinalState().

Referenced by Run().

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

        if (LArPfoHelper::IsFinalState(pPfo))
        {
            this->BuildCosmicRayParent(pointingClusterMap, pPfo);
        }
        else
        {
            this->BuildCosmicRayDaughter(pPfo);
        }
    }
}

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

private

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

Parameters

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

Definition at line 84 of file CosmicRayVertexBuildingAlgorithm.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 slidingFitPitch(std::max({pitchU, pitchV, pitchW}));

    for (PfoVector::const_iterator pIter = pfoVector.begin(), pIterEnd = pfoVector.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::CosmicRayVertexBuildingAlgorithm::GetCosmicPfos ( const pandora::PfoList *const  pPfoList, pandora::PfoVector &  pfoVector  ) const

private

Get the list of input pfos to this algorithm.

Parameters

pfoList

to receive the list of input pfos

Definition at line 58 of file CosmicRayVertexBuildingAlgorithm.cc.

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

Referenced by Run().

{
    PfoList outputList;

    for (PfoList::const_iterator pIter = pPfoList->begin(), pIterEnd = pPfoList->end(); pIter != pIterEnd; ++pIter)
    {
        if (!LArPfoHelper::IsFinalState(*pIter))
            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::CosmicRayVertexBuildingAlgorithm::ReadSettings ( const pandora::TiXmlHandle  xmlHandle )

private

Definition at line 335 of file CosmicRayVertexBuildingAlgorithm.cc.

References m_halfWindowLayers, m_isDualPhase, m_maxVertexDisplacementFromTrack, m_parentPfoListName, m_useParentShowerVertex, and m_vertexListName.

{
    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "InputPfoListName", m_parentPfoListName));

    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));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "IsDualPhase", m_isDualPhase));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
        XmlHelper::ReadValue(xmlHandle, "MaxVertexDisplacementFromTrack", m_maxVertexDisplacementFromTrack));

    return STATUS_CODE_SUCCESS;
}

StatusCode lar_content::CosmicRayVertexBuildingAlgorithm::Run ( )

private

Definition at line 32 of file CosmicRayVertexBuildingAlgorithm.cc.

References BuildCosmicRayParticles(), BuildPointingClusterMap(), GetCosmicPfos(), and m_parentPfoListName.

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

    if (NULL == pPfoList)
    {
        if (PandoraContentApi::GetSettings(*this)->ShouldDisplayAlgorithmInfo())
            std::cout << "CosmicRayVertexBuildingAlgorithm: pfo list unavailable." << std::endl;

        return STATUS_CODE_SUCCESS;
    }

    PfoVector pfoVector;
    LArPointingClusterMap pointingClusterMap;

    this->GetCosmicPfos(pPfoList, pfoVector);
    this->BuildPointingClusterMap(pfoVector, pointingClusterMap);
    this->BuildCosmicRayParticles(pointingClusterMap, pfoVector);

    return STATUS_CODE_SUCCESS;
}

void lar_content::CosmicRayVertexBuildingAlgorithm::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 304 of file CosmicRayVertexBuildingAlgorithm.cc.

References m_vertexListName.

Referenced by BuildCosmicRayDaughter(), and BuildCosmicRayParent().

{
    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_START;
    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::CosmicRayVertexBuildingAlgorithm::m_halfWindowLayers

private

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

Definition at line 83 of file CosmicRayVertexBuildingAlgorithm.h.

Referenced by BuildPointingClusterMap(), and ReadSettings().

bool lar_content::CosmicRayVertexBuildingAlgorithm::m_isDualPhase

private

type of geometry

Definition at line 82 of file CosmicRayVertexBuildingAlgorithm.h.

Referenced by BuildCosmicRayDaughter(), BuildCosmicRayParent(), and ReadSettings().

float lar_content::CosmicRayVertexBuildingAlgorithm::m_maxVertexDisplacementFromTrack

private

The maximum separation of a close vertex from the cosmic ray track.

Definition at line 86 of file CosmicRayVertexBuildingAlgorithm.h.

Referenced by BuildCosmicRayDaughter(), and ReadSettings().

std::string lar_content::CosmicRayVertexBuildingAlgorithm::m_parentPfoListName

private

The name of the input pfo list.

Definition at line 84 of file CosmicRayVertexBuildingAlgorithm.h.

Referenced by ReadSettings(), and Run().

bool lar_content::CosmicRayVertexBuildingAlgorithm::m_useParentShowerVertex

private

use the parent pfo for the shower vertices

Definition at line 81 of file CosmicRayVertexBuildingAlgorithm.h.

Referenced by BuildCosmicRayDaughter(), and ReadSettings().

std::string lar_content::CosmicRayVertexBuildingAlgorithm::m_vertexListName

private

The name of the output vertex list.

Definition at line 85 of file CosmicRayVertexBuildingAlgorithm.h.

Referenced by ReadSettings(), and SetParticleParameters().

---

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

• larpandoracontent/v04_08_01/source/larpandoracontent/LArThreeDReco/LArCosmicRay/CosmicRayVertexBuildingAlgorithm.h
• larpandoracontent/v04_08_01/source/larpandoracontent/LArThreeDReco/LArCosmicRay/CosmicRayVertexBuildingAlgorithm.cc