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;

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

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

    DeltaRayOverlapResult(const unsigned int nMatchedSamplingPoints, const unsigned int nSamplingPoints, const float chi2,
        const XOverlap &xOverlap, const pandora::PfoList &commonMuonPfoList);

    DeltaRayOverlapResult(const DeltaRayOverlapResult &rhs);

    virtual ~DeltaRayOverlapResult();

    const pandora::PfoList &GetCommonMuonPfoList() const;

    DeltaRayOverlapResult &operator=(const DeltaRayOverlapResult &rhs);

private:
    pandora::PfoList m_commonMuonPfoList; 
};

typedef std::vector<DeltaRayOverlapResult> DeltaRayOverlapResultVector;

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

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;
}

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

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

} // namespace lar_content

#endif // #ifndef LAR_TRACK_OVERLAP_RESULT_H