LArThreeDSlidingFitResult.h

Go to the documentation of this file.

#ifndef LAR_THREE_D_SLIDING_FIT_RESULT_H
#define LAR_THREE_D_SLIDING_FIT_RESULT_H 1

#include "Api/PandoraApi.h"

#include "larpandoracontent/LArObjects/LArTwoDSlidingFitResult.h"

#include <unordered_map>

namespace lar_content
{

class ThreeDSlidingFitResult
{
public:
    template <typename T>
    ThreeDSlidingFitResult(const T *const pT, const unsigned int slidingFitWindow, const float slidingFitLayerPitch);

    const pandora::Cluster *GetCluster() const;

    const pandora::CartesianVector &GetAxisIntercept() const;

    const pandora::CartesianVector &GetAxisDirection() const;

    const TwoDSlidingFitResult &GetFirstFitResult() const;

    const TwoDSlidingFitResult &GetSecondFitResult() const;

    const pandora::CartesianVector &GetGlobalMinLayerPosition() const;

    const pandora::CartesianVector &GetGlobalMaxLayerPosition() const;

    const pandora::CartesianVector &GetGlobalMinLayerDirection() const;

    const pandora::CartesianVector &GetGlobalMaxLayerDirection() const;

    int GetMinLayer() const;

    int GetMaxLayer() const;

    float GetMinLayerRms() const;

    float GetMaxLayerRms() const;

    float GetFitRms(const float rL) const;

    float GetLongitudinalDisplacement(const pandora::CartesianVector &position) const;

    pandora::StatusCode GetGlobalFitPosition(const float rL, pandora::CartesianVector &position) const;

    pandora::StatusCode GetGlobalFitDirection(const float rL, pandora::CartesianVector &direction) const;

private:
    void GetGlobalPosition(const float rL, const float rT1, const float rT2, pandora::CartesianVector &position) const;

    void GetGlobalDirection(const float dTdL1, const float dTdL2, pandora::CartesianVector &direction) const;

    static pandora::TrackState GetPrimaryAxis(const pandora::Cluster *const pCluster, const float slidingFitLayerPitch);

    static pandora::TrackState GetPrimaryAxis(const pandora::CartesianPointVector *const pPointVector, const float slidingFitLayerPitch);

    static pandora::CartesianVector GetSeedDirection(const pandora::CartesianVector &axisDirection);

    const pandora::TrackState         m_primaryAxis;            
    const pandora::CartesianVector    m_axisIntercept;          
    const pandora::CartesianVector    m_axisDirection;          
    const pandora::CartesianVector    m_firstOrthoDirection;    
    const pandora::CartesianVector    m_secondOrthoDirection;   
    const TwoDSlidingFitResult        m_firstFitResult;         
    const TwoDSlidingFitResult        m_secondFitResult;        
    const int                         m_minLayer;               
    const int                         m_maxLayer;               

    pandora::CartesianVector          m_minLayerPosition;       
    pandora::CartesianVector          m_maxLayerPosition;       
    pandora::CartesianVector          m_minLayerDirection;      
    pandora::CartesianVector          m_maxLayerDirection;      
};

typedef std::vector<ThreeDSlidingFitResult> ThreeDSlidingFitResultList;
typedef std::unordered_map<const pandora::Cluster*, ThreeDSlidingFitResult> ThreeDSlidingFitResultMap;

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

inline const pandora::CartesianVector &ThreeDSlidingFitResult::GetAxisIntercept() const
{
    return m_axisIntercept;
}

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

inline const pandora::CartesianVector &ThreeDSlidingFitResult::GetAxisDirection() const
{
    return m_axisDirection;
}

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

inline const TwoDSlidingFitResult &ThreeDSlidingFitResult::GetFirstFitResult() const
{
    return m_firstFitResult;
}

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

inline const TwoDSlidingFitResult &ThreeDSlidingFitResult::GetSecondFitResult() const
{
    return m_secondFitResult;
}

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

inline const pandora::CartesianVector &ThreeDSlidingFitResult::GetGlobalMinLayerPosition() const
{
    return m_minLayerPosition;
}

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

inline const pandora::CartesianVector &ThreeDSlidingFitResult::GetGlobalMaxLayerPosition() const
{
    return m_maxLayerPosition;
}

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

inline const pandora::CartesianVector &ThreeDSlidingFitResult::GetGlobalMinLayerDirection() const
{
    return m_minLayerDirection;
}

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

inline const pandora::CartesianVector &ThreeDSlidingFitResult::GetGlobalMaxLayerDirection() const
{
    return m_maxLayerDirection;
}

} // namespace lar_content

#endif // #ifndef LAR_THREE_D_SLIDING_FIT_RESULT_H