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