LArHierarchyPfo.h

Go to the documentation of this file.

#ifndef LAR_HIERARCHY_PFO_H
#define LAR_HIERARCHY_PFO_H 1

#include "Pandora/PandoraInternal.h"

#include "larpandoracontent/LArHelpers/LArPfoHelper.h"
#include "larpandoracontent/LArObjects/LArThreeDSlidingFitResult.h"

using namespace lar_content;

namespace lar_dl_content
{

class ExtremalPoint
{
public:
    ExtremalPoint();

    ExtremalPoint(const ExtremalPoint &extremalPoint);

    const pandora::CartesianVector &GetPosition() const;

    const pandora::CartesianVector &GetDirection() const;

    void Set(const pandora::CartesianVector &position, const pandora::CartesianVector &direction);

    bool IsSet() const;

    ExtremalPoint &operator=(const ExtremalPoint &rhs);

private:
    bool m_isSet;                         
    pandora::CartesianVector m_position;  
    pandora::CartesianVector m_direction; 
};

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

class HierarchyPfo
{
public:
    HierarchyPfo();

    HierarchyPfo(const pandora::ParticleFlowObject *pPfo, const ThreeDSlidingFitResult &threeDSlidingFitResult,
        const ExtremalPoint &upstreamPoint, const ExtremalPoint &downstreamPoint);

    const pandora::ParticleFlowObject *GetPfo() const;

    void SetPfo(const pandora::ParticleFlowObject *pPfo);

    const ThreeDSlidingFitResult &GetSlidingFitResult() const;

    const pandora::ParticleFlowObject *GetPredictedParentPfo() const;

    void SetPredictedParentPfo(const pandora::ParticleFlowObject *pPredictedParentPfo);

    const pandora::ParticleFlowObject *GetParentPfo() const;

    void SetParentPfo(const pandora::ParticleFlowObject *pParentPfo);

    const pandora::PfoVector &GetChildPfoVector() const;

    void AddChildPfo(const pandora::ParticleFlowObject *const pChildPfo);

    const ExtremalPoint &GetUpstreamPoint() const;

    void SetUpstreamPoint(const ExtremalPoint &upstreamPoint);

    const ExtremalPoint &GetDownstreamPoint() const;

    void SetDownstreamPoint(const ExtremalPoint &downstreamPoint);

    float GetPrimaryScore() const;

    void SetPrimaryScore(const float primaryScore);

    float GetLaterTierScore() const;

    void SetLaterTierScore(const float laterTierScore);

    bool GetIsInHierarchy() const;

    void SetIsInHierarchy(const bool isInHierarchy);

    bool operator==(const HierarchyPfo &rhs) const;

    bool operator==(const pandora::ParticleFlowObject *const rhs) const;

private:
    const pandora::ParticleFlowObject *m_pPfo;                
    ThreeDSlidingFitResult m_slidingFitResult;                
    const pandora::ParticleFlowObject *m_pPredictedParentPfo; 
    const pandora::ParticleFlowObject *m_pParentPfo;          
    pandora::PfoVector m_childPfoVector;                      
    ExtremalPoint m_upstreamPoint;                            
    ExtremalPoint m_downstreamPoint;                          
    float m_primaryScore;                                     
    float m_laterTierScore;                                   
    bool m_isInHierarchy;                                     
};

typedef std::vector<HierarchyPfo> HierarchyPfoVector;

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

inline ExtremalPoint::ExtremalPoint() :
    m_isSet(false),
    m_position(-999.f, -999.f, -999.f),
    m_direction(-999.f, -999.f, -999.f)
{
}

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

inline ExtremalPoint::ExtremalPoint(const ExtremalPoint &extremalPoint) :
    m_isSet(extremalPoint.m_isSet),
    m_position(extremalPoint.m_position),
    m_direction(extremalPoint.m_direction)
{
}

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

inline const pandora::CartesianVector &ExtremalPoint::GetPosition() const
{
    return m_position;
}

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

inline const pandora::CartesianVector &ExtremalPoint::GetDirection() const
{
    return m_direction;
}

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

inline void ExtremalPoint::Set(const pandora::CartesianVector &position, const pandora::CartesianVector &direction)
{
    m_isSet = true;
    m_position = position;
    m_direction = direction;
}

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

inline bool ExtremalPoint::IsSet() const
{
    return m_isSet;
}

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

inline ExtremalPoint &ExtremalPoint::operator=(const ExtremalPoint &rhs)
{
    this->m_isSet = rhs.m_isSet;
    this->m_position = rhs.m_position;
    this->m_direction = rhs.m_direction;

    return *this;
}

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

inline HierarchyPfo::HierarchyPfo(const pandora::ParticleFlowObject *pPfo, const ThreeDSlidingFitResult &slidingFitResult,
    const ExtremalPoint &upstreamPoint, const ExtremalPoint &downstreamPoint) :
    m_pPfo(pPfo),
    m_slidingFitResult(slidingFitResult),
    m_pPredictedParentPfo(nullptr),
    m_pParentPfo(nullptr),
    m_childPfoVector(pandora::PfoVector()),
    m_upstreamPoint(upstreamPoint),
    m_downstreamPoint(downstreamPoint),
    m_primaryScore(-std::numeric_limits<float>::max()),
    m_laterTierScore(-std::numeric_limits<float>::max()),
    m_isInHierarchy(false)
{
}

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

inline const pandora::ParticleFlowObject *HierarchyPfo::GetPfo() const
{
    return m_pPfo;
}

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

inline void HierarchyPfo::SetPfo(const pandora::ParticleFlowObject *pPfo)
{
    m_pPfo = pPfo;
}

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

inline const ThreeDSlidingFitResult &HierarchyPfo::GetSlidingFitResult() const
{
    return m_slidingFitResult;
}

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

inline const pandora::ParticleFlowObject *HierarchyPfo::GetPredictedParentPfo() const
{
    return m_pPredictedParentPfo;
}

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

inline void HierarchyPfo::SetPredictedParentPfo(const pandora::ParticleFlowObject *pPredictedParentPfo)
{
    m_pPredictedParentPfo = pPredictedParentPfo;
}

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

inline const pandora::ParticleFlowObject *HierarchyPfo::GetParentPfo() const
{
    return m_pParentPfo;
}

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

inline void HierarchyPfo::SetParentPfo(const pandora::ParticleFlowObject *pParentPfo)
{
    m_pParentPfo = pParentPfo;
}

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

inline const pandora::PfoVector &HierarchyPfo::GetChildPfoVector() const
{
    return m_childPfoVector;
}

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

inline void HierarchyPfo::AddChildPfo(const pandora::ParticleFlowObject *const pChildPfo)
{
    m_childPfoVector.emplace_back(pChildPfo);
}

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

inline const ExtremalPoint &HierarchyPfo::GetUpstreamPoint() const
{
    return m_upstreamPoint;
}

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

inline void HierarchyPfo::SetUpstreamPoint(const ExtremalPoint &upstreamPoint)
{
    m_upstreamPoint = upstreamPoint;
}

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

inline const ExtremalPoint &HierarchyPfo::GetDownstreamPoint() const
{
    return m_downstreamPoint;
}

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

inline void HierarchyPfo::SetDownstreamPoint(const ExtremalPoint &downstreamPoint)
{
    m_downstreamPoint = downstreamPoint;
}

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

inline float HierarchyPfo::GetPrimaryScore() const
{
    return m_primaryScore;
}

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

inline void HierarchyPfo::SetPrimaryScore(const float primaryScore)
{
    m_primaryScore = primaryScore;
}

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

inline float HierarchyPfo::GetLaterTierScore() const
{
    return m_laterTierScore;
}

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

inline void HierarchyPfo::SetLaterTierScore(const float laterTierScore)
{
    m_laterTierScore = laterTierScore;
}

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

inline bool HierarchyPfo::GetIsInHierarchy() const
{
    return m_isInHierarchy;
}

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

inline void HierarchyPfo::SetIsInHierarchy(const bool isInHierarchy)
{
    m_isInHierarchy = isInHierarchy;
}

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

inline bool HierarchyPfo::operator==(const HierarchyPfo &rhs) const
{
    return this->GetPfo() == rhs.GetPfo();
}

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

inline bool HierarchyPfo::operator==(const pandora::ParticleFlowObject *const rhs) const
{
    return this->GetPfo() == rhs;
}

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

} // namespace lar_dl_content

#endif // #ifndef LAR_HIERARCHY_PFO_H