LArTrackOverlapResult.cc

Go to the documentation of this file.

 
#include "Objects/CaloHit.h"
 
#include "Pandora/PandoraInternal.h"
 
#include "larpandoracontent/LArObjects/LArTrackOverlapResult.h"
 
using namespace pandora;
 
namespace lar_content
{
 
TrackOverlapResult::TrackOverlapResult() :
    m_isInitialized(false),
    m_nMatchedSamplingPoints(0),
    m_nSamplingPoints(0),
    m_matchedFraction(0.f),
    m_chi2(0.f),
    m_reducedChi2(0.f)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
TrackOverlapResult::TrackOverlapResult(const unsigned int nMatchedSamplingPoints, const unsigned int nSamplingPoints, const float chi2) :
    m_isInitialized(true),
    m_nMatchedSamplingPoints(nMatchedSamplingPoints),
    m_nSamplingPoints(nSamplingPoints),
    m_matchedFraction(0.f),
    m_chi2(chi2),
    m_reducedChi2(0.f)
{
    if ((0 == m_nSamplingPoints) || (m_nMatchedSamplingPoints > m_nSamplingPoints))
        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
    m_matchedFraction = static_cast<float>(m_nMatchedSamplingPoints) / static_cast<float>(m_nSamplingPoints);
    m_reducedChi2 = m_chi2 / static_cast<float>(m_nSamplingPoints);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
TrackOverlapResult::TrackOverlapResult(const TrackOverlapResult &rhs) :
    m_isInitialized(rhs.m_isInitialized),
    m_nMatchedSamplingPoints(rhs.m_nMatchedSamplingPoints),
    m_nSamplingPoints(rhs.m_nSamplingPoints),
    m_matchedFraction(rhs.m_matchedFraction),
    m_chi2(rhs.m_chi2),
    m_reducedChi2(rhs.m_reducedChi2)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
TrackOverlapResult::~TrackOverlapResult()
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
bool TrackOverlapResult::operator<(const TrackOverlapResult &rhs) const
{
    if (this == &rhs)
        return false;
 
    if (!m_isInitialized && !rhs.IsInitialized())
        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);
 
    if (!m_isInitialized)
        return true;
 
    if (!rhs.IsInitialized())
        return false;
 
    if (m_nMatchedSamplingPoints != rhs.m_nMatchedSamplingPoints)
        return (m_nMatchedSamplingPoints < rhs.m_nMatchedSamplingPoints);
 
    if (std::fabs(m_reducedChi2 - rhs.m_reducedChi2) > std::numeric_limits<float>::epsilon())
        return (m_reducedChi2 > rhs.m_reducedChi2);
 
    return (m_matchedFraction < rhs.m_matchedFraction);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
bool TrackOverlapResult::operator>(const TrackOverlapResult &rhs) const
{
    if (this == &rhs)
        return false;
 
    return !(*this < rhs);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
TrackOverlapResult &TrackOverlapResult::operator=(const TrackOverlapResult &rhs)
{
    if (this == &rhs)
        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
    m_isInitialized = rhs.m_isInitialized;
    m_nMatchedSamplingPoints = rhs.m_nMatchedSamplingPoints;
    m_nSamplingPoints = rhs.m_nSamplingPoints;
    m_matchedFraction = rhs.m_matchedFraction;
    m_chi2 = rhs.m_chi2;
    m_reducedChi2 = rhs.m_reducedChi2;
 
    return *this;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
TransverseOverlapResult::TransverseOverlapResult() : TrackOverlapResult(), m_xOverlap(XOverlap(0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f))
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
TransverseOverlapResult::TransverseOverlapResult(
    const unsigned int nMatchedSamplingPoints, const unsigned int nSamplingPoints, const float chi2, const XOverlap &xOverlap) :
    TrackOverlapResult(nMatchedSamplingPoints, nSamplingPoints, chi2),
    m_xOverlap(xOverlap)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
TransverseOverlapResult::TransverseOverlapResult(const TransverseOverlapResult &rhs) :
    TrackOverlapResult(rhs),
    m_xOverlap(rhs.IsInitialized() ? rhs.GetXOverlap() : XOverlap(0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f))
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
TransverseOverlapResult::~TransverseOverlapResult()
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
TransverseOverlapResult &TransverseOverlapResult::operator=(const TransverseOverlapResult &rhs)
{
    this->TrackOverlapResult::operator=(rhs);
 
    if (rhs.IsInitialized())
    {
        m_xOverlap = rhs.GetXOverlap();
    }
    else
    {
        m_xOverlap = XOverlap(0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f);
    }
 
    return *this;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
TransverseOverlapResult operator+(const TransverseOverlapResult &lhs, const TransverseOverlapResult &rhs)
{
    if (!lhs.IsInitialized() && !rhs.IsInitialized())
        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);
 
    if (!lhs.IsInitialized())
        return rhs;
 
    if (!rhs.IsInitialized())
        return lhs;
 
    return TransverseOverlapResult(lhs.GetNMatchedSamplingPoints() + rhs.GetNMatchedSamplingPoints(),
        lhs.GetNSamplingPoints() + rhs.GetNSamplingPoints(), lhs.GetChi2() + rhs.GetChi2(), lhs.GetXOverlap() + rhs.GetXOverlap());
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
LongitudinalOverlapResult::LongitudinalOverlapResult() : TrackOverlapResult(), m_innerChi2(0.f), m_outerChi2(0.f)
{
}
//------------------------------------------------------------------------------------------------------------------------------------------
 
LongitudinalOverlapResult::LongitudinalOverlapResult(const TrackOverlapResult trackOverlapResult, const float innerChi2, const float outerChi2) :
    TrackOverlapResult(trackOverlapResult),
    m_innerChi2(innerChi2),
    m_outerChi2(outerChi2)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
LongitudinalOverlapResult::LongitudinalOverlapResult(const unsigned int nMatchedSamplingPoints, const unsigned int nSamplingPoints,
    const float chi2, const float innerChi2, const float outerChi2) :
    TrackOverlapResult(nMatchedSamplingPoints, nSamplingPoints, chi2),
    m_innerChi2(innerChi2),
    m_outerChi2(outerChi2)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
LongitudinalOverlapResult::LongitudinalOverlapResult(const LongitudinalOverlapResult &rhs) :
    TrackOverlapResult(rhs),
    m_innerChi2(rhs.IsInitialized() ? rhs.GetInnerChi2() : 0.f),
    m_outerChi2(rhs.IsInitialized() ? rhs.GetOuterChi2() : 0.f)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
LongitudinalOverlapResult::~LongitudinalOverlapResult()
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
LongitudinalOverlapResult &LongitudinalOverlapResult::operator=(const LongitudinalOverlapResult &rhs)
{
    this->TrackOverlapResult::operator=(rhs);
    m_innerChi2 = rhs.GetInnerChi2();
    m_outerChi2 = rhs.GetOuterChi2();
 
    return *this;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
FragmentOverlapResult::FragmentOverlapResult() : TrackOverlapResult(), m_caloHitList(), m_clusterList()
{
}
//------------------------------------------------------------------------------------------------------------------------------------------
 
FragmentOverlapResult::FragmentOverlapResult(
    const TrackOverlapResult trackOverlapResult, const pandora::CaloHitList &caloHitList, const pandora::ClusterList &clusterList) :
    TrackOverlapResult(trackOverlapResult),
    m_caloHitList(caloHitList),
    m_clusterList(clusterList)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
FragmentOverlapResult::FragmentOverlapResult(const unsigned int nMatchedSamplingPoints, const unsigned int nSamplingPoints,
    const float chi2, const pandora::CaloHitList &caloHitList, const pandora::ClusterList &clusterList) :
    TrackOverlapResult(nMatchedSamplingPoints, nSamplingPoints, chi2),
    m_caloHitList(caloHitList),
    m_clusterList(clusterList)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
FragmentOverlapResult::FragmentOverlapResult(const FragmentOverlapResult &rhs) :
    TrackOverlapResult(rhs),
    m_caloHitList(rhs.IsInitialized() ? rhs.GetFragmentCaloHitList() : CaloHitList()),
    m_clusterList(rhs.IsInitialized() ? rhs.GetFragmentClusterList() : ClusterList())
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
FragmentOverlapResult::~FragmentOverlapResult()
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
FragmentOverlapResult &FragmentOverlapResult::operator=(const FragmentOverlapResult &rhs)
{
    this->TrackOverlapResult::operator=(rhs);
    m_caloHitList = rhs.GetFragmentCaloHitList();
    m_clusterList = rhs.GetFragmentClusterList();
 
    return *this;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
pandora::HitType FragmentOverlapResult::GetFragmentHitType() const
{
    if (m_caloHitList.empty())
        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
    return (*(m_caloHitList.begin()))->GetHitType();
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
DeltaRayOverlapResult::DeltaRayOverlapResult() : TransverseOverlapResult(), m_commonMuonPfoList(PfoList())
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
DeltaRayOverlapResult::DeltaRayOverlapResult(const unsigned int nMatchedSamplingPoints, const unsigned int nSamplingPoints,
    const float chi2, const XOverlap &xOverlap, const PfoList &commonMuonPfoList) :
    TransverseOverlapResult(nMatchedSamplingPoints, nSamplingPoints, chi2, xOverlap),
    m_commonMuonPfoList(commonMuonPfoList)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
DeltaRayOverlapResult::DeltaRayOverlapResult(const DeltaRayOverlapResult &rhs) :
    TransverseOverlapResult(rhs),
    m_commonMuonPfoList(rhs.GetCommonMuonPfoList())
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
DeltaRayOverlapResult::~DeltaRayOverlapResult()
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
DeltaRayOverlapResult &DeltaRayOverlapResult::operator=(const DeltaRayOverlapResult &rhs)
{
    this->TransverseOverlapResult::operator=(rhs);
 
    m_commonMuonPfoList = rhs.GetCommonMuonPfoList();
 
    return *this;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
} // namespace lar_content