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