LArTrackTwoViewOverlapResult.h

Go to the documentation of this file.

#ifndef LAR_TRACK_TWO_VIEW_OVERLAP_RESULT_H
#define LAR_TRACK_TWO_VIEW_OVERLAP_RESULT_H 1

#include "Pandora/StatusCodes.h"

#include "larpandoracontent/LArObjects/LArTrackOverlapResult.h"
#include "larpandoracontent/LArObjects/LArTwoViewXOverlap.h"

#include <vector>

namespace lar_content
{
class TwoViewDeltaRayOverlapResult
{
public:
    TwoViewDeltaRayOverlapResult();

    TwoViewDeltaRayOverlapResult(const TwoViewXOverlap &xOverlap, const pandora::PfoList &commonMuonPfoList,
        const pandora::Cluster *const pBestMatchedCluster, const pandora::ClusterList &matchedClusterList, const float reducedChiSquared);

    TwoViewDeltaRayOverlapResult(const TwoViewDeltaRayOverlapResult &rhs);

    virtual ~TwoViewDeltaRayOverlapResult();

    bool IsInitialized() const;

    const TwoViewXOverlap &GetXOverlap() const;

    const pandora::Cluster *GetBestMatchedCluster() const;

    const pandora::PfoList &GetCommonMuonPfoList() const;

    const pandora::ClusterList &GetMatchedClusterList() const;

    float GetReducedChiSquared() const;

    const pandora::Cluster *GetBestMatchedAvailableCluster() const;

    TwoViewDeltaRayOverlapResult &operator=(const TwoViewDeltaRayOverlapResult &rhs);

    bool operator<(const TwoViewDeltaRayOverlapResult &rhs) const;

private:
    bool m_isInitialized;                          
    TwoViewXOverlap m_xOverlap;                    
    pandora::PfoList m_commonMuonPfoList;          
    const pandora::Cluster *m_pBestMatchedCluster; 
    pandora::ClusterList m_matchedClusterList;     
    float m_reducedChiSquared;                     
};

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

class TrackTwoViewOverlapResult
{
public:
    TrackTwoViewOverlapResult();

    TrackTwoViewOverlapResult(const float matchingScore);

    TrackTwoViewOverlapResult(const TrackTwoViewOverlapResult &rhs);

    virtual ~TrackTwoViewOverlapResult();

    bool IsInitialized() const;

    float GetMatchingScore() const;

    bool operator<(const TrackTwoViewOverlapResult &rhs) const;

    bool operator>(const TrackTwoViewOverlapResult &rhs) const;

    TrackTwoViewOverlapResult &operator=(const TrackTwoViewOverlapResult &rhs);

protected:
    bool m_isInitialized;  
    float m_matchingScore; 
};

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

class TwoViewTransverseOverlapResult : public TrackTwoViewOverlapResult
{
public:
    TwoViewTransverseOverlapResult();

    TwoViewTransverseOverlapResult(const float matchingScore, const float downsamplingFactor, const unsigned int nSamplingPoints,
        const unsigned int nMatchedSamplingPoints, const float correlationCoefficient, const TwoViewXOverlap &twoViewXOverlap);

    TwoViewTransverseOverlapResult(const TwoViewTransverseOverlapResult &rhs);

    ~TwoViewTransverseOverlapResult();

    unsigned int GetNSamplingPoints() const;

    unsigned int GetNMatchedSamplingPoints() const;

    unsigned int GetNReUpsampledSamplingPoints() const;

    unsigned int GetNMatchedReUpsampledSamplingPoints() const;

    float GetCorrelationCoefficient() const;

    float GetLocallyMatchedFraction() const;

    const TwoViewXOverlap &GetTwoViewXOverlap() const;

    bool operator<(const TwoViewTransverseOverlapResult &rhs) const;

    TwoViewTransverseOverlapResult &operator=(const TwoViewTransverseOverlapResult &rhs);

private:
    float m_downsamplingFactor;            
    unsigned int m_nSamplingPoints;        
    unsigned int m_nMatchedSamplingPoints; 
    float m_correlationCoefficient;        
    TwoViewXOverlap m_twoViewXOverlap;     
};

typedef std::vector<TwoViewTransverseOverlapResult> TwoViewTransverseOverlapResultVector;

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

inline bool TwoViewDeltaRayOverlapResult::IsInitialized() const
{
    return m_isInitialized;
}

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

inline const TwoViewXOverlap &TwoViewDeltaRayOverlapResult::GetXOverlap() const
{
    return m_xOverlap;
}

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

inline const pandora::Cluster *TwoViewDeltaRayOverlapResult::GetBestMatchedCluster() const
{
    return m_pBestMatchedCluster;
}

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

inline const pandora::PfoList &TwoViewDeltaRayOverlapResult::GetCommonMuonPfoList() const
{
    return m_commonMuonPfoList;
}

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

inline const pandora::ClusterList &TwoViewDeltaRayOverlapResult::GetMatchedClusterList() const
{
    return m_matchedClusterList;
}

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

inline float TwoViewDeltaRayOverlapResult::GetReducedChiSquared() const
{
    return m_reducedChiSquared;
}

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

inline bool TrackTwoViewOverlapResult::IsInitialized() const
{
    return m_isInitialized;
}

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

inline float TrackTwoViewOverlapResult::GetMatchingScore() const
{
    if (m_isInitialized)
        return m_matchingScore;

    throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);
}

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

inline unsigned int TwoViewTransverseOverlapResult::GetNSamplingPoints() const
{
    if (m_isInitialized)
        return m_nSamplingPoints;

    throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);
}

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

inline unsigned int TwoViewTransverseOverlapResult::GetNMatchedSamplingPoints() const
{
    if (m_isInitialized)
        return m_nMatchedSamplingPoints;

    throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);
}

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

inline unsigned int TwoViewTransverseOverlapResult::GetNReUpsampledSamplingPoints() const
{
    if (m_isInitialized)
        return static_cast<unsigned int>(m_downsamplingFactor * static_cast<float>(m_nSamplingPoints));

    throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);
}

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

inline unsigned int TwoViewTransverseOverlapResult::GetNMatchedReUpsampledSamplingPoints() const
{
    if (m_isInitialized)
        return static_cast<unsigned int>(m_downsamplingFactor * static_cast<float>(m_nMatchedSamplingPoints));

    throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);
}

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

inline float TwoViewTransverseOverlapResult::GetCorrelationCoefficient() const
{
    if (m_isInitialized)
        return m_correlationCoefficient;

    throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);
}

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

inline float TwoViewTransverseOverlapResult::GetLocallyMatchedFraction() const
{
    if (m_isInitialized)
        return (m_nSamplingPoints > 0 ? static_cast<float>(m_nMatchedSamplingPoints) / static_cast<float>(m_nSamplingPoints) : 0.f);

    throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);
}

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

inline const TwoViewXOverlap &TwoViewTransverseOverlapResult::GetTwoViewXOverlap() const
{
    if (m_isInitialized)
        return m_twoViewXOverlap;

    throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);
}

} // namespace lar_content

#endif // #ifndef LAR_TRACK_TWO_VIEW_OVERLAP_RESULT_H