LArHitWidthHelper.h

Go to the documentation of this file.

#ifndef LAR_HIT_WIDTH_HELPER_H
#define LAR_HIT_WIDTH_HELPER_H 1

#include "Objects/Cluster.h"

namespace lar_content
{

class LArHitWidthHelper
{
public:
    class ConstituentHit
    {
    public:
        ConstituentHit(const pandora::CartesianVector &positionVector, const float hitWidth, const pandora::Cluster *const pParentClusterAddress);

        const pandora::CartesianVector &GetPositionVector() const;

        float GetHitWidth() const;

        const pandora::Cluster *GetParentClusterAddress() const;

        class SortByDistanceToPoint
        {
        public:
            SortByDistanceToPoint(const pandora::CartesianVector referencePoint) :
                m_referencePoint(referencePoint)
            {
            }

            bool operator()(const ConstituentHit &lhs, const ConstituentHit &rhs);

        private:
            const pandora::CartesianVector m_referencePoint; 
        };

    private:
        pandora::CartesianVector m_positionVector;       
        float m_hitWidth;                                
        const pandora::Cluster *m_pParentClusterAddress; 
    };

    typedef std::vector<ConstituentHit> ConstituentHitVector;

    class ClusterParameters
    {
    public:
        ClusterParameters(const pandora::Cluster *const pCluster, const float maxConsituentHitWidth, const bool isUniformHits,
            const float hitWidthScalingFactor);

        ClusterParameters(const pandora::Cluster *const pCluster, const unsigned int numCaloHits, const float totalWeight,
            const ConstituentHitVector &constituentHitVector, const pandora::CartesianVector &lowerXExtrema,
            const pandora::CartesianVector &higherXExtrema);

        const pandora::Cluster *GetClusterAddress() const;

        unsigned int GetNumCaloHits() const;

        float GetTotalWeight() const;

        const ConstituentHitVector &GetConstituentHitVector() const;

        const pandora::CartesianVector &GetLowerXExtrema() const;

        const pandora::CartesianVector &GetHigherXExtrema() const;

    private:
        const pandora::Cluster *m_pCluster;                
        const unsigned int m_numCaloHits;                  
        const ConstituentHitVector m_constituentHitVector; 
        const float m_totalWeight;                         
        const pandora::CartesianVector m_lowerXExtrema;    
        const pandora::CartesianVector m_higherXExtrema;   
    };

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

    class SortByHigherXExtrema
    {
    public:
        SortByHigherXExtrema(const ClusterToParametersMap &clusterToParametersMap);

        bool operator()(const pandora::Cluster *const pLhs, const pandora::Cluster *const pRhs);

    private:
        const ClusterToParametersMap &m_clusterToParametersMap; 
    };

    static const ClusterParameters &GetClusterParameters(const pandora::Cluster *const pCluster, const ClusterToParametersMap &clusterToParametersMap);

    static unsigned int GetNProposedConstituentHits(
        const pandora::Cluster *const pCluster, const float maxConstituentHitWidth, const float hitWidthScalingFactor);

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

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

    static pandora::CartesianPointVector GetConstituentHitPositionVector(const ConstituentHitVector &constituentHitVector);

    static float GetTotalClusterWeight(const ConstituentHitVector &constituentHitVector);

    static float GetOriginalTotalClusterWeight(const pandora::Cluster *const pCluster);

    static pandora::CartesianVector GetExtremalCoordinatesLowerX(const ConstituentHitVector &constituentHitVector);

    static pandora::CartesianVector GetExtremalCoordinatesHigherX(const ConstituentHitVector &constituentHitVector);

    static void GetExtremalCoordinatesX(const ConstituentHitVector &constituentHitVector, pandora::CartesianVector &lowerXCoordinate,
        pandora::CartesianVector &higherXCoordinate);

    static pandora::CartesianVector GetClosestPointToLine2D(
        const pandora::CartesianVector &lineStart, const pandora::CartesianVector &lineDirection, const pandora::CaloHit *const pCaloHit);

    static float GetClosestDistanceToPoint2D(const pandora::CaloHit *const pCaloHit, const pandora::CartesianVector &point2D);

    static float GetClosestDistance(const pandora::CaloHit *const pThisCaloHit, const pandora::CaloHitList &caloHitList);

    static float GetClosestDistance(const pandora::CaloHit *const pCaloHit1, const pandora::CaloHit *const pCaloHit2);
};

//------------------------------------------------------------------------------------------------------------------------------------------

inline const pandora::CartesianVector &LArHitWidthHelper::ConstituentHit::GetPositionVector() const
{
    return m_positionVector;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline float LArHitWidthHelper::ConstituentHit::GetHitWidth() const
{
    return m_hitWidth;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline const pandora::Cluster *LArHitWidthHelper::ConstituentHit::GetParentClusterAddress() const
{
    return m_pParentClusterAddress;
}

//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------

inline const pandora::Cluster *LArHitWidthHelper::ClusterParameters::GetClusterAddress() const
{
    return m_pCluster;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline unsigned int LArHitWidthHelper::ClusterParameters::GetNumCaloHits() const
{
    return m_numCaloHits;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline float LArHitWidthHelper::ClusterParameters::GetTotalWeight() const
{
    return m_totalWeight;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline const LArHitWidthHelper::ConstituentHitVector &LArHitWidthHelper::ClusterParameters::GetConstituentHitVector() const
{
    return m_constituentHitVector;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline const pandora::CartesianVector &LArHitWidthHelper::ClusterParameters::GetLowerXExtrema() const
{
    return m_lowerXExtrema;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline const pandora::CartesianVector &LArHitWidthHelper::ClusterParameters::GetHigherXExtrema() const
{
    return m_higherXExtrema;
}

//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------

inline LArHitWidthHelper::SortByHigherXExtrema::SortByHigherXExtrema(const ClusterToParametersMap &clusterToParametersMap) :
    m_clusterToParametersMap(clusterToParametersMap)
{
}

} // namespace lar_content

#endif // #ifndef LAR_HIT_WIDTH_HELPER_H