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