LArPointingCluster.h

Go to the documentation of this file.

 
#ifndef LAR_POINTING_CLUSTER_H
#define LAR_POINTING_CLUSTER_H 1
 
#include "larpandoracontent/LArObjects/LArThreeDSlidingFitResult.h"
#include "larpandoracontent/LArObjects/LArTwoDSlidingFitResult.h"
 
namespace lar_content
{
 
class LArPointingCluster
{
public:
    class Vertex
    {
    public:
        Vertex();
 
        Vertex(const pandora::Cluster *const pCluster, const pandora::CartesianVector &position, const pandora::CartesianVector &direction,
            const float rms, const bool isInner);
 
        Vertex(const Vertex &rhs);
 
        ~Vertex();
 
        const pandora::Cluster *GetCluster() const;
 
        const pandora::CartesianVector &GetPosition() const;
 
        const pandora::CartesianVector &GetDirection() const;
 
        float GetRms() const;
 
        bool IsInnerVertex() const;
 
        bool IsInitialized() const;
 
        Vertex &operator=(const Vertex &rhs);
 
    private:
        const pandora::Cluster *m_pCluster;   
        pandora::CartesianVector m_position;  
        pandora::CartesianVector m_direction; 
        float m_rms;                          
        bool m_isInner;                       
        bool m_isInitialized;                 
    };
 
    LArPointingCluster(const pandora::Cluster *const pCluster, const unsigned int fitHalfLayerWindow = 10, const float fitLayerPitch = 0.3f);
 
    LArPointingCluster(const TwoDSlidingFitResult &slidingFitResult);
 
    LArPointingCluster(const ThreeDSlidingFitResult &slidingFitResult);
 
    const pandora::Cluster *GetCluster() const;
 
    const Vertex &GetInnerVertex() const;
 
    const Vertex &GetOuterVertex() const;
 
    float GetLengthSquared() const;
 
    float GetLength() const;
 
private:
    void BuildPointingCluster(const TwoDSlidingFitResult &slidingFitResult);
 
    void BuildPointingCluster(const ThreeDSlidingFitResult &slidingFitResult);
 
    const pandora::Cluster *m_pCluster; 
    Vertex m_innerVertex;               
    Vertex m_outerVertex;               
};
 
typedef std::vector<LArPointingCluster> LArPointingClusterList;
typedef std::vector<LArPointingCluster::Vertex> LArPointingClusterVertexList;
typedef std::unordered_map<const pandora::Cluster *, LArPointingCluster> LArPointingClusterMap;
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const pandora::Cluster *LArPointingCluster::GetCluster() const
{
    return m_pCluster;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const LArPointingCluster::Vertex &LArPointingCluster::GetInnerVertex() const
{
    return m_innerVertex;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const LArPointingCluster::Vertex &LArPointingCluster::GetOuterVertex() const
{
    return m_outerVertex;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float LArPointingCluster::GetLengthSquared() const
{
    return (m_outerVertex.GetPosition() - m_innerVertex.GetPosition()).GetMagnitudeSquared();
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float LArPointingCluster::GetLength() const
{
    return std::sqrt(this->GetLengthSquared());
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const pandora::Cluster *LArPointingCluster::Vertex::GetCluster() const
{
    if (!m_isInitialized)
        throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);
 
    return m_pCluster;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const pandora::CartesianVector &LArPointingCluster::Vertex::GetPosition() const
{
    if (!m_isInitialized)
        throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);
 
    return m_position;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const pandora::CartesianVector &LArPointingCluster::Vertex::GetDirection() const
{
    if (!m_isInitialized)
        throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);
 
    return m_direction;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float LArPointingCluster::Vertex::GetRms() const
{
    if (!m_isInitialized)
        throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);
 
    return m_rms;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline bool LArPointingCluster::Vertex::IsInnerVertex() const
{
    if (!m_isInitialized)
        throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);
 
    return m_isInner;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline bool LArPointingCluster::Vertex::IsInitialized() const
{
    return m_isInitialized;
}
 
} // namespace lar_content
 
#endif // #ifndef LAR_POINTING_CLUSTER_H