LArTrackOverlapResult.h

Go to the documentation of this file.

#ifndef LAR_TRACK_OVERLAP_RESULT_H
#define LAR_TRACK_OVERLAP_RESULT_H 1

#include "Pandora/PandoraInputTypes.h"
#include "Pandora/StatusCodes.h"

#include "larpandoracontent/LArObjects/LArXOverlap.h"

#include <cmath>
#include <vector>

namespace lar_content
{

class TrackOverlapResult
{
public:
    TrackOverlapResult();

    TrackOverlapResult(const unsigned int nMatchedSamplingPoints, const unsigned int nSamplingPoints, const float chi2);

    TrackOverlapResult(const TrackOverlapResult &rhs);

    virtual ~TrackOverlapResult();

    bool IsInitialized() const;

    unsigned int GetNMatchedSamplingPoints() const;

    unsigned int GetNSamplingPoints() const;

    float GetMatchedFraction() const;

    float GetChi2() const;

    float GetReducedChi2() const;

    bool operator<(const TrackOverlapResult &rhs) const;

    bool operator>(const TrackOverlapResult &rhs) const;

    TrackOverlapResult &operator=(const TrackOverlapResult &rhs);

protected:
    bool            m_isInitialized;                
    unsigned int    m_nMatchedSamplingPoints;       
    unsigned int    m_nSamplingPoints;              
    float           m_matchedFraction;              
    float           m_chi2;                         
    float           m_reducedChi2;                  
};

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

class TransverseOverlapResult : public TrackOverlapResult
{
public:
    TransverseOverlapResult();

    TransverseOverlapResult(const unsigned int nMatchedSamplingPoints, const unsigned int nSamplingPoints, const float chi2,
        const XOverlap &xOverlap);

    TransverseOverlapResult(const TransverseOverlapResult &rhs);

    ~TransverseOverlapResult();

    const XOverlap &GetXOverlap() const;

    TransverseOverlapResult &operator=(const TransverseOverlapResult &rhs);

private:
    XOverlap        m_xOverlap;                     
};

typedef std::vector<TransverseOverlapResult> TransverseOverlapResultVector;

TransverseOverlapResult operator+(const TransverseOverlapResult &lhs, const TransverseOverlapResult &rhs);

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

class LongitudinalOverlapResult : public TrackOverlapResult
{
public:
    LongitudinalOverlapResult();

    LongitudinalOverlapResult(const TrackOverlapResult trackOverlapResult, const float innerChi2, const float outerChi2);

    LongitudinalOverlapResult(const unsigned int nMatchedSamplingPoints, const unsigned int nSamplingPoints, const float chi2,
        const float innerChi2, const float outerChi2);

    LongitudinalOverlapResult(const LongitudinalOverlapResult &rhs);

    ~LongitudinalOverlapResult();

    float GetInnerChi2() const;

    float GetOuterChi2() const;

    LongitudinalOverlapResult &operator=(const LongitudinalOverlapResult &rhs);

private:
    float       m_innerChi2;                        
    float       m_outerChi2;                        
};

typedef std::vector<LongitudinalOverlapResult> LongitudinalOverlapResultVector;

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

class FragmentOverlapResult : public TrackOverlapResult
{
public:
    FragmentOverlapResult();

    FragmentOverlapResult(const TrackOverlapResult trackOverlapResult, const pandora::CaloHitList &caloHitList,
        const pandora::ClusterList &clusterList);

    FragmentOverlapResult(const unsigned int nMatchedSamplingPoints, const unsigned int nSamplingPoints, const float chi2,
        const pandora::CaloHitList &caloHitList, const pandora::ClusterList &clusterList);

    FragmentOverlapResult(const FragmentOverlapResult &rhs);

    ~FragmentOverlapResult();

    const pandora::CaloHitList &GetFragmentCaloHitList() const;

    const pandora::ClusterList &GetFragmentClusterList() const;

    pandora::HitType GetFragmentHitType() const;

    FragmentOverlapResult &operator=(const FragmentOverlapResult &rhs);

private:
    pandora::CaloHitList    m_caloHitList;      
    pandora::ClusterList    m_clusterList;      
};

typedef std::vector<FragmentOverlapResult> FragmentOverlapResultVector;

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

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

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

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

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

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

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

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

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

inline float TrackOverlapResult::GetMatchedFraction() const
{
    if (m_isInitialized)
        return m_matchedFraction;

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

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

inline float TrackOverlapResult::GetChi2() const
{
    if (m_isInitialized)
        return m_chi2;

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

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

inline float TrackOverlapResult::GetReducedChi2() const
{
    if (m_isInitialized)
        return m_reducedChi2;

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

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

inline const XOverlap &TransverseOverlapResult::GetXOverlap() const
{
    if (m_isInitialized)
        return m_xOverlap;

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

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

inline float LongitudinalOverlapResult::GetInnerChi2() const
{
    return m_innerChi2;
}

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

inline float LongitudinalOverlapResult::GetOuterChi2() const
{
    return m_outerChi2;
}

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

inline const pandora::CaloHitList &FragmentOverlapResult::GetFragmentCaloHitList() const
{
    return m_caloHitList;
}

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

inline const pandora::ClusterList &FragmentOverlapResult::GetFragmentClusterList() const
{
    return m_clusterList;
}

} // namespace lar_content

#endif // #ifndef LAR_TRACK_OVERLAP_RESULT_H