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