LArTrackTwoViewOverlapResult.cc

Go to the documentation of this file.

#include "larpandoracontent/LArObjects/LArTrackTwoViewOverlapResult.h"
#include "Objects/Cluster.h"

using namespace pandora;

namespace lar_content
{

TwoViewDeltaRayOverlapResult::TwoViewDeltaRayOverlapResult() :
    m_isInitialized(false),
    m_xOverlap(TwoViewXOverlap(0.f, 0.f, 0.f, 0.f)),
    m_commonMuonPfoList(),
    m_pBestMatchedCluster(nullptr),
    m_matchedClusterList(),
    m_reducedChiSquared(std::numeric_limits<float>::max())
{
}

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

TwoViewDeltaRayOverlapResult::TwoViewDeltaRayOverlapResult(const TwoViewXOverlap &xOverlap, const PfoList &commonMuonPfoList,
    const Cluster *const pBestMatchedCluster, const ClusterList &matchedClusterList, const float reducedChiSquared) :
    m_isInitialized(true),
    m_xOverlap(xOverlap),
    m_commonMuonPfoList(commonMuonPfoList),
    m_pBestMatchedCluster(pBestMatchedCluster),
    m_matchedClusterList(matchedClusterList),
    m_reducedChiSquared(reducedChiSquared)
{
}

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

TwoViewDeltaRayOverlapResult::TwoViewDeltaRayOverlapResult(const TwoViewDeltaRayOverlapResult &rhs) :
    m_isInitialized(rhs.m_isInitialized),
    m_xOverlap(rhs.GetXOverlap()),
    m_commonMuonPfoList(rhs.GetCommonMuonPfoList()),
    m_pBestMatchedCluster(rhs.GetBestMatchedCluster()),
    m_matchedClusterList(rhs.GetMatchedClusterList()),
    m_reducedChiSquared(rhs.GetReducedChiSquared())
{
}

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

TwoViewDeltaRayOverlapResult::~TwoViewDeltaRayOverlapResult()
{
}

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

const Cluster *TwoViewDeltaRayOverlapResult::GetBestMatchedAvailableCluster() const
{
    unsigned int highestNHits(0);
    const Cluster *pBestMatchedCluster(nullptr);

    for (const Cluster *const pMatchedCluster : m_matchedClusterList)
    {
        if (!pMatchedCluster->IsAvailable())
            continue;

        if (pMatchedCluster->GetNCaloHits() > highestNHits)
        {
            highestNHits = pMatchedCluster->GetNCaloHits();
            pBestMatchedCluster = pMatchedCluster;
        }
    }

    return pBestMatchedCluster;
}

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

TwoViewDeltaRayOverlapResult &TwoViewDeltaRayOverlapResult::operator=(const TwoViewDeltaRayOverlapResult &rhs)
{
    m_isInitialized = rhs.m_isInitialized;
    m_xOverlap = rhs.GetXOverlap();
    m_commonMuonPfoList = rhs.GetCommonMuonPfoList();
    m_pBestMatchedCluster = rhs.GetBestMatchedCluster();
    m_matchedClusterList = rhs.GetMatchedClusterList();
    m_reducedChiSquared = rhs.GetReducedChiSquared();

    return *this;
}

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

bool TwoViewDeltaRayOverlapResult::operator<(const TwoViewDeltaRayOverlapResult &rhs) const
{
    if (this == &rhs)
        return false;

    if (!m_isInitialized && !rhs.m_isInitialized)
        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);

    if (!m_isInitialized)
        return true;

    if (!rhs.m_isInitialized)
        return false;

    return (m_xOverlap.GetTwoViewXOverlapSpan() < rhs.m_xOverlap.GetTwoViewXOverlapSpan());
}

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

TrackTwoViewOverlapResult::TrackTwoViewOverlapResult() :
    m_isInitialized(false),
    m_matchingScore(0)
{
}

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

TrackTwoViewOverlapResult::TrackTwoViewOverlapResult(const float matchingScore) :
    m_isInitialized(true),
    m_matchingScore(matchingScore)
{
}

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

TrackTwoViewOverlapResult::TrackTwoViewOverlapResult(const TrackTwoViewOverlapResult &rhs) :
    m_isInitialized(rhs.m_isInitialized),
    m_matchingScore(rhs.m_matchingScore)
{
}

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

TrackTwoViewOverlapResult::~TrackTwoViewOverlapResult()
{
}

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

bool TrackTwoViewOverlapResult::operator<(const TrackTwoViewOverlapResult &rhs) const
{
    if (this == &rhs)
        return false;

    if (!m_isInitialized && !rhs.m_isInitialized)
        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);

    if (!m_isInitialized)
        return true;

    if (!rhs.m_isInitialized)
        return false;

    return (m_matchingScore < rhs.m_matchingScore);
}

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

bool TrackTwoViewOverlapResult::operator>(const TrackTwoViewOverlapResult &rhs) const
{
    if (this == &rhs)
        return false;

    return !(*this < rhs);
}

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

TrackTwoViewOverlapResult &TrackTwoViewOverlapResult::operator=(const TrackTwoViewOverlapResult &rhs)
{
    if (this == &rhs)
        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);

    m_isInitialized = rhs.m_isInitialized;
    m_matchingScore = rhs.m_matchingScore;

    return *this;
}

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

TwoViewTransverseOverlapResult::TwoViewTransverseOverlapResult() :
    TrackTwoViewOverlapResult(),
    m_downsamplingFactor(0.f),
    m_nSamplingPoints(0),
    m_nMatchedSamplingPoints(0),
    m_correlationCoefficient(0.f),
    m_twoViewXOverlap(TwoViewXOverlap(0.f, 0.f, 0.f, 0.f))
{
}

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

TwoViewTransverseOverlapResult::TwoViewTransverseOverlapResult(const float matchingScore, const float downsamplingFactor, const unsigned int nSamplingPoints,
    const unsigned int nMatchedSamplingPoints, const float correlationCoefficient, const TwoViewXOverlap &twoViewXOverlap) :
    TrackTwoViewOverlapResult(matchingScore),
    m_downsamplingFactor(downsamplingFactor),
    m_nSamplingPoints(nSamplingPoints),
    m_nMatchedSamplingPoints(nMatchedSamplingPoints),
    m_correlationCoefficient(correlationCoefficient),
    m_twoViewXOverlap(twoViewXOverlap)
{
}

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

TwoViewTransverseOverlapResult::TwoViewTransverseOverlapResult(const TwoViewTransverseOverlapResult &rhs) :
    TrackTwoViewOverlapResult(rhs),
    m_downsamplingFactor(rhs.m_downsamplingFactor),
    m_nSamplingPoints(rhs.m_nSamplingPoints),
    m_nMatchedSamplingPoints(rhs.m_nMatchedSamplingPoints),
    m_correlationCoefficient(rhs.m_correlationCoefficient),
    m_twoViewXOverlap(rhs.m_isInitialized ? rhs.m_twoViewXOverlap : TwoViewXOverlap(0.f, 0.f, 0.f, 0.f))
{
}

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

TwoViewTransverseOverlapResult::~TwoViewTransverseOverlapResult()
{
}

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

bool TwoViewTransverseOverlapResult::operator<(const TwoViewTransverseOverlapResult &rhs) const
{
    if (this == &rhs)
        return false;

    if (!m_isInitialized && !rhs.m_isInitialized)
        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);

    if (!m_isInitialized)
        return true;

    if (!rhs.m_isInitialized)
        return false;

    if (std::fabs(m_matchingScore - rhs.m_matchingScore) > std::numeric_limits<float>::epsilon())
        return (m_matchingScore < rhs.m_matchingScore);

    if (std::fabs(m_correlationCoefficient - rhs.m_correlationCoefficient) > std::numeric_limits<float>::epsilon())
        return (m_correlationCoefficient < rhs.m_correlationCoefficient);

    if (m_nMatchedSamplingPoints != rhs.m_nMatchedSamplingPoints)
        return (m_nMatchedSamplingPoints < rhs.m_nMatchedSamplingPoints);

    if (m_nSamplingPoints != rhs.m_nSamplingPoints)
        return (m_nSamplingPoints < rhs.m_nSamplingPoints);

    if (std::fabs(this->GetLocallyMatchedFraction() - rhs.GetLocallyMatchedFraction()) > std::numeric_limits<float>::epsilon())
        return (this->GetLocallyMatchedFraction() < rhs.GetLocallyMatchedFraction());

    if (std::fabs(m_twoViewXOverlap.GetTwoViewXOverlapSpan() - rhs.m_twoViewXOverlap.GetTwoViewXOverlapSpan()) > std::numeric_limits<float>::epsilon())
        return (m_twoViewXOverlap.GetTwoViewXOverlapSpan() < rhs.m_twoViewXOverlap.GetTwoViewXOverlapSpan());

    if (std::fabs(m_twoViewXOverlap.GetXSpan0() - rhs.m_twoViewXOverlap.GetXSpan0()) > std::numeric_limits<float>::epsilon())
        return (m_twoViewXOverlap.GetXSpan0() < rhs.m_twoViewXOverlap.GetXSpan0());

    return (m_twoViewXOverlap.GetXSpan1() < rhs.m_twoViewXOverlap.GetXSpan1());
}

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

TwoViewTransverseOverlapResult &TwoViewTransverseOverlapResult::operator=(const TwoViewTransverseOverlapResult &rhs)
{
    this->TrackTwoViewOverlapResult::operator=(rhs);

    if (rhs.m_isInitialized)
    {
        m_isInitialized = rhs.m_isInitialized;
        m_matchingScore = rhs.m_matchingScore;
        m_downsamplingFactor = rhs.m_downsamplingFactor;
        m_nSamplingPoints = rhs.m_nSamplingPoints;
        m_nMatchedSamplingPoints = rhs.m_nMatchedSamplingPoints;
        m_correlationCoefficient = rhs.m_correlationCoefficient;
        m_twoViewXOverlap = rhs.m_twoViewXOverlap;
    }
    else
    {
        m_isInitialized = false;
        m_matchingScore = 0.f;
        m_downsamplingFactor = 0.f;
        m_nSamplingPoints = 0;
        m_nMatchedSamplingPoints = 0;
        m_correlationCoefficient = 0.f;
        m_twoViewXOverlap = TwoViewXOverlap(0.f, 0.f, 0.f, 0.f);
    }

    return *this;
}

} // namespace lar_content