lar_content::LArHitWidthHelper Class Reference

LArHitWidthHelper class. More...

#include <LArHitWidthHelper.h>

Classes
class	ClusterParameters
	ClusterParameters class. More...
class	ConstituentHit
	ConstituentHit class. More...
class	SortByHigherXExtrema
	SortByHigherExtrema class. More...

Public Types
typedef std::vector < ConstituentHit >	ConstituentHitVector
typedef std::unordered_map < const pandora::Cluster *, const ClusterParameters >	ClusterToParametersMap

Static Public Member Functions
static const ClusterParameters &	GetClusterParameters (const pandora::Cluster *const pCluster, const ClusterToParametersMap &clusterToParametersMap)
	Return the cluster parameters of a given cluster, exception thrown if not found in map [cluster -> cluster parameter] or if map is empty. More...
static unsigned int	GetNProposedConstituentHits (const pandora::Cluster *const pCluster, const float maxConstituentHitWidth, const float hitWidthScalingFactor)
	Return the number of constituent hits that a given cluster would be broken into. More...
static ConstituentHitVector	GetConstituentHits (const pandora::Cluster *const pCluster, const float maxConstituentHitWidth, const float hitWidthScalingFactor, const bool isUniform)
	Break up the cluster hits into constituent hits. More...
static void	SplitHitIntoConstituents (const pandora::CaloHit *const pCaloHit, const pandora::Cluster *const pCluster, const unsigned int numberOfConstituentHits, const float constituentHitWidth, ConstituentHitVector &constituentHitVector)
	Break up the calo hit into constituent hits. More...
static pandora::CartesianPointVector	GetConstituentHitPositionVector (const ConstituentHitVector &constituentHitVector)
	Obtain a vector of the contituent hit central positions. More...
static float	GetTotalClusterWeight (const ConstituentHitVector &constituentHitVector)
	Sum the widths of constituent hits. More...
static float	GetOriginalTotalClusterWeight (const pandora::Cluster *const pCluster)
	Sum the widths of the original, unscaled hits contained within a cluster. More...
static pandora::CartesianVector	GetExtremalCoordinatesLowerX (const ConstituentHitVector &constituentHitVector)
	Return the lower x extremal point of the constituent hits. More...
static pandora::CartesianVector	GetExtremalCoordinatesHigherX (const ConstituentHitVector &constituentHitVector)
	Return the higher x extremal point of the constituent hits. More...
static void	GetExtremalCoordinatesX (const ConstituentHitVector &constituentHitVector, pandora::CartesianVector &lowerXCoordinate, pandora::CartesianVector &higherXCoordinate)
	Calculate the higher and lower x extremal points of the constituent hits. More...
static pandora::CartesianVector	GetClosestPointToLine2D (const pandora::CartesianVector &lineStart, const pandora::CartesianVector &lineDirection, const pandora::CaloHit *const pCaloHit)
	Consider the hit width to find the closest position of a calo hit to a specified line. More...
static float	GetClosestDistanceToPoint2D (const pandora::CaloHit *const pCaloHit, const pandora::CartesianVector &point2D)
	Consider the hit width to find the smallest distance between a calo hit and a given point. More...

Detailed Description

LArHitWidthHelper class.

Definition at line 19 of file LArHitWidthHelper.h.

Member Typedef Documentation

typedef std::unordered_map<const pandora::Cluster *, const ClusterParameters> lar_content::LArHitWidthHelper::ClusterToParametersMap

Definition at line 160 of file LArHitWidthHelper.h.

typedef std::vector<ConstituentHit> lar_content::LArHitWidthHelper::ConstituentHitVector

Definition at line 87 of file LArHitWidthHelper.h.

Member Function Documentation

float lar_content::LArHitWidthHelper::GetClosestDistanceToPoint2D ( const pandora::CaloHit *const  pCaloHit, const pandora::CartesianVector &  point2D  )

static

Consider the hit width to find the smallest distance between a calo hit and a given point.

Parameters

pCaloHit	the input calo hit
point2D	the position

Returns

the smallest distance

Definition at line 306 of file LArHitWidthHelper.cc.

{
    const CartesianVector &hitPosition(pCaloHit->GetPositionVector());
    const float hitWidth(pCaloHit->GetCellSize1());
    const float hitLowXEdge(hitPosition.GetX() - (hitWidth * 0.5f));
    const float hitHighXEdge(hitPosition.GetX() + (hitWidth * 0.5f));
    const float modDeltaZ(std::fabs(hitPosition.GetZ() - point2D.GetZ()));

    if ((hitLowXEdge < point2D.GetX()) && (hitHighXEdge > point2D.GetX()))
        return modDeltaZ;

    const float deltaX = hitLowXEdge > point2D.GetX() ? (point2D.GetX() - hitLowXEdge) : (point2D.GetX() - hitHighXEdge);

    return std::sqrt((deltaX * deltaX) + (modDeltaZ * modDeltaZ));
}

CartesianVector lar_content::LArHitWidthHelper::GetClosestPointToLine2D ( const pandora::CartesianVector &  lineStart, const pandora::CartesianVector &  lineDirection, const pandora::CaloHit *const  pCaloHit  )

static

Consider the hit width to find the closest position of a calo hit to a specified line.

Parameters

lineStart	the start position of the line
lineDirection	the direction of the line
pCaloHit	the input calo hit

Returns

the closest position

Definition at line 281 of file LArHitWidthHelper.cc.

{
    const CartesianVector &hitPosition(pCaloHit->GetPositionVector());

    if (std::fabs(lineDirection.GetZ()) < std::numeric_limits<float>::epsilon())
        return hitPosition;

    float xOnLine(lineStart.GetX());
    if (std::fabs(lineDirection.GetX()) > std::numeric_limits<float>::epsilon())
    {
        const float gradient(lineDirection.GetZ() / lineDirection.GetX());
        xOnLine += ((hitPosition.GetZ() - lineStart.GetZ()) / gradient);
    }

    const float &hitWidth(pCaloHit->GetCellSize1());
    const float hitLowXEdge(hitPosition.GetX() - (hitWidth * 0.5f));
    const float hitHighXEdge(hitPosition.GetX() + (hitWidth * 0.5f));
    const float closestPointX(xOnLine < hitLowXEdge ? hitLowXEdge : xOnLine > hitHighXEdge ? hitHighXEdge : xOnLine);

    return CartesianVector(closestPointX, 0.f, hitPosition.GetZ());
}

const LArHitWidthHelper::ClusterParameters & lar_content::LArHitWidthHelper::GetClusterParameters ( const pandora::Cluster *const  pCluster, const ClusterToParametersMap &  clusterToParametersMap  )

static

Return the cluster parameters of a given cluster, exception thrown if not found in map [cluster -> cluster parameter] or if map is empty.

Parameters

pCluster	the input cluster
clusterToParametersMap	the map [cluster -> cluster parameter]

Returns

the cluster parameters of the input cluster

Definition at line 74 of file LArHitWidthHelper.cc.

{
    if (clusterToParametersMap.empty())
        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);

    const auto clusterParametersIter(clusterToParametersMap.find(pCluster));

    if (clusterParametersIter == clusterToParametersMap.end())
        throw StatusCodeException(STATUS_CODE_NOT_FOUND);

    return clusterParametersIter->second;
}

CartesianPointVector lar_content::LArHitWidthHelper::GetConstituentHitPositionVector ( const ConstituentHitVector &  constituentHitVector )

static

Obtain a vector of the contituent hit central positions.

Parameters

constituentHitVector

the input vector of contituent hits

Returns

a vector of constituent hit central positions

Definition at line 223 of file LArHitWidthHelper.cc.

{
    CartesianPointVector constituentHitPositionVector;

    for (const ConstituentHit &constituentHit : constituentHitVector)
        constituentHitPositionVector.push_back(constituentHit.GetPositionVector());

    return constituentHitPositionVector;
}

LArHitWidthHelper::ConstituentHitVector lar_content::LArHitWidthHelper::GetConstituentHits ( const pandora::Cluster *const  pCluster, const float  maxConstituentHitWidth, const float  hitWidthScalingFactor, const bool  isUniform  )

static

Break up the cluster hits into constituent hits.

Parameters

pCluster	the input cluster
maxConstituentHitWidth	the maximum width of a constituent hit
hitWidthScalingFactor	the constituent hit width scaling factor
isUniform	whether to break up the hit into uniform constituent hits (and pad the hit) or not in the non-uniform case constituent hits from different hits may have different weights

Returns

the vector of constituent hits

Definition at line 120 of file LArHitWidthHelper.cc.

{
    if (maxConstituentHitWidth < std::numeric_limits<float>::epsilon())
    {
        std::cout << "LArHitWidthHelper::GetConstituentHits - Negative or equivalent to zero constitent hit width not allowed" << std::endl;
        throw StatusCodeException(STATUS_CODE_NOT_ALLOWED);
    }

    const OrderedCaloHitList &orderedCaloHitList(pCluster->GetOrderedCaloHitList());

    if (orderedCaloHitList.empty())
        throw StatusCodeException(STATUS_CODE_NOT_FOUND);

    ConstituentHitVector constituentHitVector;
    for (const OrderedCaloHitList::value_type &mapEntry : orderedCaloHitList)
    {
        for (const CaloHit *const pCaloHit : *mapEntry.second)
        {
            const float hitWidth = pCaloHit->GetCellSize1() * hitWidthScalingFactor;
            const unsigned int numberOfConstituentHits = std::ceil(hitWidth / maxConstituentHitWidth);
            if (isUniform)
            {
                LArHitWidthHelper::SplitHitIntoConstituents(pCaloHit, pCluster, numberOfConstituentHits, maxConstituentHitWidth, constituentHitVector);
            }
            else
            {
                const float constituentHitWidth = hitWidth / numberOfConstituentHits;
                LArHitWidthHelper::SplitHitIntoConstituents(pCaloHit, pCluster, numberOfConstituentHits, constituentHitWidth, constituentHitVector);
            }
        }
    }

    return constituentHitVector;
}

CartesianVector lar_content::LArHitWidthHelper::GetExtremalCoordinatesHigherX ( const ConstituentHitVector &  constituentHitVector )

static

Return the higher x extremal point of the constituent hits.

Parameters

constituentHitVector

the input vector of contituent hits

Returns

the higher x extremal point of the constituent hits

Definition at line 245 of file LArHitWidthHelper.cc.

{
    CartesianVector lowerXCoordinate(0.f, 0.f, 0.f), higherXCoordinate(0.f, 0.f, 0.f);
    LArHitWidthHelper::GetExtremalCoordinatesX(constituentHitVector, lowerXCoordinate, higherXCoordinate);

    return higherXCoordinate;
}

CartesianVector lar_content::LArHitWidthHelper::GetExtremalCoordinatesLowerX ( const ConstituentHitVector &  constituentHitVector )

static

Return the lower x extremal point of the constituent hits.

Parameters

constituentHitVector

the input vector of contituent hits

Returns

the lower x extremal point of the constituent hits

Definition at line 235 of file LArHitWidthHelper.cc.

{
    CartesianVector lowerXCoordinate(0.f, 0.f, 0.f), higherXCoordinate(0.f, 0.f, 0.f);
    LArHitWidthHelper::GetExtremalCoordinatesX(constituentHitVector, lowerXCoordinate, higherXCoordinate);

    return lowerXCoordinate;
}

void lar_content::LArHitWidthHelper::GetExtremalCoordinatesX ( const ConstituentHitVector &  constituentHitVector, pandora::CartesianVector &  lowerXCoordinate, pandora::CartesianVector &  higherXCoordinate  )

static

Calculate the higher and lower x extremal points of the constituent hits.

Parameters

constituentHitVector	the input vector of contituent hits
lowerXCoordinate	the lower x extremal point
higherXCoordinate	the higher x extremal point

Definition at line 255 of file LArHitWidthHelper.cc.

{
    const CartesianPointVector &constituentHitPositionVector(GetConstituentHitPositionVector(constituentHitVector));

    CartesianVector innerCoordinate(0.f, 0.f, 0.f), outerCoordinate(0.f, 0.f, 0.f);
    LArClusterHelper::GetExtremalCoordinates(constituentHitPositionVector, innerCoordinate, outerCoordinate);

    // set the lower/higher XCoordinate (in the event of a tie, use z)
    const float deltaX(outerCoordinate.GetX() - innerCoordinate.GetX());
    const float deltaZ(outerCoordinate.GetZ() - innerCoordinate.GetZ());

    if ((deltaX > 0.f) || ((std::fabs(deltaX) < std::numeric_limits<float>::epsilon()) && (deltaZ > 0.f)))
    {
        lowerXCoordinate = innerCoordinate;
        higherXCoordinate = outerCoordinate;
    }
    else
    {
        lowerXCoordinate = outerCoordinate;
        higherXCoordinate = innerCoordinate;
    }
}

unsigned int lar_content::LArHitWidthHelper::GetNProposedConstituentHits ( const pandora::Cluster *const  pCluster, const float  maxConstituentHitWidth, const float  hitWidthScalingFactor  )

static

Return the number of constituent hits that a given cluster would be broken into.

Parameters

pCluster	the input cluster
maxConstituentHitWidth	the maximum width of a constituent hit
hitWidthScalingFactor	the constituent hit width scaling factor

Returns

the number of constituent hits the cluster would be broken into

Definition at line 90 of file LArHitWidthHelper.cc.

{
    if (maxConstituentHitWidth < std::numeric_limits<float>::epsilon())
    {
        std::cout << "LArHitWidthHelper::GetConstituentHits - Negative or equivalent to zero constitent hit width not allowed" << std::endl;
        throw StatusCodeException(STATUS_CODE_NOT_ALLOWED);
    }

    const OrderedCaloHitList &orderedCaloHitList(pCluster->GetOrderedCaloHitList());

    if (orderedCaloHitList.empty())
        throw StatusCodeException(STATUS_CODE_NOT_FOUND);

    unsigned int totalConstituentHits(0);
    for (const OrderedCaloHitList::value_type &mapEntry : orderedCaloHitList)
    {
        for (const CaloHit *const pCaloHit : *mapEntry.second)
        {
            const float hitWidth = pCaloHit->GetCellSize1() * hitWidthScalingFactor;
            const unsigned int numberOfConstituentHits = std::ceil(hitWidth / maxConstituentHitWidth);

            totalConstituentHits += numberOfConstituentHits;
        }
    }

    return totalConstituentHits;
}

float lar_content::LArHitWidthHelper::GetOriginalTotalClusterWeight ( const pandora::Cluster *const  pCluster )

static

Sum the widths of the original, unscaled hits contained within a cluster.

Parameters

pCluster

the input cluster

Returns

the total weight sum

Definition at line 207 of file LArHitWidthHelper.cc.

{
    float clusterWeight(0.f);
    const OrderedCaloHitList &orderedCaloHitList(pCluster->GetOrderedCaloHitList());

    for (const OrderedCaloHitList::value_type &mapEntry : orderedCaloHitList)
    {
        for (const CaloHit *const pCaloHit : *mapEntry.second)
            clusterWeight += pCaloHit->GetCellSize1();
    }

    return clusterWeight;
}

float lar_content::LArHitWidthHelper::GetTotalClusterWeight ( const ConstituentHitVector &  constituentHitVector )

static

Sum the widths of constituent hits.

Parameters

constituentHitVector

the input vector of contituent hits

Returns

the total weight sum

Definition at line 196 of file LArHitWidthHelper.cc.

{
    float clusterWeight(0.f);
    for (const ConstituentHit &constituentHit : constituentHitVector)
        clusterWeight += constituentHit.GetHitWidth();

    return clusterWeight;
}

void lar_content::LArHitWidthHelper::SplitHitIntoConstituents ( const pandora::CaloHit *const  pCaloHit, const pandora::Cluster *const  pCluster, const unsigned int  numberOfConstituentHits, const float  constituentHitWidth, ConstituentHitVector &  constituentHitVector  )

static

Break up the calo hit into constituent hits.

Parameters

pCaloHit	the input calo hit
pCluster	the parent cluster
numberOfConstituentHits	the number of constituent hits the hit will be broken into
constituentHitWidth	the hit width of the constituent hits
constituentHitVector	the input vector to which to add the contituent hits

Definition at line 158 of file LArHitWidthHelper.cc.

{
    const CartesianVector &hitCenter(pCaloHit->GetPositionVector());
    const bool isOdd(numberOfConstituentHits % 2 == 1);
    float xDistanceFromCenter(0.f);

    // find constituent hit centers by moving out from the original hit center position
    unsigned int loopIterations(std::ceil(numberOfConstituentHits / 2.0));
    for (unsigned int i = 0; i < loopIterations; ++i)
    {
        if (i == 0)
        {
            if (isOdd)
            {
                constituentHitVector.push_back(ConstituentHit(hitCenter, constituentHitWidth, pCluster));
                continue;
            }
            else
            {
                xDistanceFromCenter += constituentHitWidth / 2;
            }
        }
        else
        {
            xDistanceFromCenter += constituentHitWidth;
        }

        CartesianVector positivePosition(hitCenter + CartesianVector(xDistanceFromCenter, 0.f, 0.f)),
            negativePosition(hitCenter - CartesianVector(xDistanceFromCenter, 0.f, 0.f));

        constituentHitVector.push_back(ConstituentHit(positivePosition, constituentHitWidth, pCluster));
        constituentHitVector.push_back(ConstituentHit(negativePosition, constituentHitWidth, pCluster));
    }
}

---

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

• LArHitWidthHelper.h
• LArHitWidthHelper.cc