lar_content::LArVertexHelper Class Reference

LArVertexHelper class. More...

#include "LArVertexHelper.h"

Public Types
enum	ClusterDirection { DIRECTION_FORWARD_IN_Z, DIRECTION_BACKWARD_IN_Z, DIRECTION_UNKNOWN }

Static Public Member Functions
static ClusterDirection	GetClusterDirectionInZ (const pandora::Pandora &pandora, const pandora::Vertex *const pVertex, const pandora::Cluster *const pCluster, const float tanAngle, const float apexShift)
	Get the direction of the cluster in z, using a projection of the provided vertex. More...
static bool	IsInFiducialVolume (const pandora::Pandora &pandora, const pandora::CartesianVector &vertex, const std::string &detector)
	Determine if a vertex is within a detector's fiducial volume. This throws a STATUS_CODE_INVALID_PARAMETER exception if the detector is not recognised. More...

Detailed Description

LArVertexHelper class.

Definition at line 20 of file LArVertexHelper.h.

Member Enumeration Documentation

enum lar_content::LArVertexHelper::ClusterDirection

ClusterDirection enumeration

Enumerator
DIRECTION_FORWARD_IN_Z
DIRECTION_BACKWARD_IN_Z
DIRECTION_UNKNOWN

Definition at line 26 of file LArVertexHelper.h.

    {
        DIRECTION_FORWARD_IN_Z,
        DIRECTION_BACKWARD_IN_Z,
        DIRECTION_UNKNOWN
    };

Member Function Documentation

LArVertexHelper::ClusterDirection lar_content::LArVertexHelper::GetClusterDirectionInZ ( const pandora::Pandora &  pandora, const pandora::Vertex *const  pVertex, const pandora::Cluster *const  pCluster, const float  tanAngle, const float  apexShift  )

static

Get the direction of the cluster in z, using a projection of the provided vertex.

Parameters

pandora	the pandora instance
pVertex	the address of the vertex
pCluster	the address of the cluster
tanAngle	look for vertex inside triangle with apex shifted along the cluster length
apexShift	look for vertex inside triangle with apex shifted along the cluster length

Returns

the cluster direction in z

Definition at line 25 of file LArVertexHelper.cc.

References lar_content::LArPointingCluster::GetInnerVertex(), lar_content::LArPointingCluster::GetOuterVertex(), and lar_content::LArPointingCluster::Vertex::GetPosition().

Referenced by lar_content::ShowerGrowingAlgorithm::AreClustersAssociated(), and lar_content::VertexBasedPfoMopUpAlgorithm::GetClusterAssociation().

{
    if ((VERTEX_3D != pVertex->GetVertexType()) || (tanAngle < std::numeric_limits<float>::epsilon()))
        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);

    const HitType hitType(LArClusterHelper::GetClusterHitType(pCluster));
    const CartesianVector theVertex2D(LArGeometryHelper::ProjectPosition(pandora, pVertex->GetPosition(), hitType));

    try
    {
        const LArPointingCluster pointingCluster(pCluster);
        const float length((pointingCluster.GetInnerVertex().GetPosition() - pointingCluster.GetOuterVertex().GetPosition()).GetMagnitude());
        const bool innerIsAtLowerZ(pointingCluster.GetInnerVertex().GetPosition().GetZ() < pointingCluster.GetOuterVertex().GetPosition().GetZ());

        float rLInner(std::numeric_limits<float>::max()), rTInner(std::numeric_limits<float>::max());
        float rLOuter(std::numeric_limits<float>::max()), rTOuter(std::numeric_limits<float>::max());
        LArPointingClusterHelper::GetImpactParameters(pointingCluster.GetInnerVertex(), theVertex2D, rLInner, rTInner);
        LArPointingClusterHelper::GetImpactParameters(pointingCluster.GetOuterVertex(), theVertex2D, rLOuter, rTOuter);

        const bool innerIsVertexAssociated(rLInner > (rTInner / tanAngle) - (length * apexShift));
        const bool outerIsVertexAssociated(rLOuter > (rTInner / tanAngle) - (length * apexShift));

        if (innerIsVertexAssociated == outerIsVertexAssociated)
            return DIRECTION_UNKNOWN;

        if ((innerIsVertexAssociated && innerIsAtLowerZ) || (outerIsVertexAssociated && !innerIsAtLowerZ))
            return DIRECTION_FORWARD_IN_Z;

        if ((innerIsVertexAssociated && !innerIsAtLowerZ) || (outerIsVertexAssociated && innerIsAtLowerZ))
            return DIRECTION_BACKWARD_IN_Z;
    }
    catch (StatusCodeException &)
    {
        return DIRECTION_UNKNOWN;
    }

    throw StatusCodeException(STATUS_CODE_FAILURE);
}

bool lar_content::LArVertexHelper::IsInFiducialVolume ( const pandora::Pandora &  pandora, const pandora::CartesianVector &  vertex, const std::string &  detector  )

static

Determine if a vertex is within a detector's fiducial volume. This throws a STATUS_CODE_INVALID_PARAMETER exception if the detector is not recognised.

Parameters

pandora	The Pandora instance
vertex	The vertex to check
detector	The string describing the detector of interest DUNEFD HD: dune_fd_hd

Returns

true if in fiducial volume, false if not

Definition at line 67 of file LArVertexHelper.cc.

References f, x, y, and z.

Referenced by lar_content::VertexMonitoringAlgorithm::AssessVertices(), and lar_content::HierarchyValidationAlgorithm::Run().

{
    const LArTPCMap &larTPCMap(pandora.GetGeometry()->GetLArTPCMap());

    if (larTPCMap.empty())
    {
        std::cout << "LArVertexHelper::IsInFiducialVolume - LArTPC description not registered with Pandora as required " << std::endl;
        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);
    }

    float tpcMinX{std::numeric_limits<float>::max()}, tpcMaxX{-std::numeric_limits<float>::max()};
    float tpcMinY{std::numeric_limits<float>::max()}, tpcMaxY{-std::numeric_limits<float>::max()};
    float tpcMinZ{std::numeric_limits<float>::max()}, tpcMaxZ{-std::numeric_limits<float>::max()};

    for (const auto &[volumeId, pLArTPC] : larTPCMap)
    {
        (void)volumeId;
        const float centreX{pLArTPC->GetCenterX()}, halfWidthX{0.5f * pLArTPC->GetWidthX()};
        const float centreY{pLArTPC->GetCenterY()}, halfWidthY{0.5f * pLArTPC->GetWidthY()};
        const float centreZ{pLArTPC->GetCenterZ()}, halfWidthZ{0.5f * pLArTPC->GetWidthZ()};
        tpcMinX = std::min(tpcMinX, centreX - halfWidthX);
        tpcMaxX = std::max(tpcMaxX, centreX + halfWidthX);
        tpcMinY = std::min(tpcMinY, centreY - halfWidthY);
        tpcMaxY = std::max(tpcMaxY, centreY + halfWidthY);
        tpcMinZ = std::min(tpcMinZ, centreZ - halfWidthZ);
        tpcMaxZ = std::max(tpcMaxZ, centreZ + halfWidthZ);
    }

    if (detector == "dune_fd_hd")
    {
        const float x{vertex.GetX()};
        const float y{vertex.GetY()};
        const float z{vertex.GetZ()};
        return (tpcMinX + 50.f) < x && x < (tpcMaxX - 50.f) && (tpcMinY + 50.f) < y && y < (tpcMaxY - 50.f) && (tpcMinZ + 50.f) < z &&
            z < (tpcMaxZ - 150.f);
    }
    else if (detector == "dune_nd")
    {
        const float x{vertex.GetX()};
        const float y{vertex.GetY()};
        const float z{vertex.GetZ()};
        return tpcMinX < x && x < tpcMaxX && tpcMinY < y && y < tpcMaxY && tpcMinZ < z && z < tpcMaxZ;
    }
    else
    {
        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
    }
}

---

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

• larpandoracontent/v04_08_01/source/larpandoracontent/LArHelpers/LArVertexHelper.h
• larpandoracontent/v04_08_01/source/larpandoracontent/LArHelpers/LArVertexHelper.cc