LArTwoDSlidingFitResult.h

Go to the documentation of this file.

#ifndef LAR_TWO_D_SLIDING_FIT_RESULT_H
#define LAR_TWO_D_SLIDING_FIT_RESULT_H 1

#include "Api/PandoraApi.h"

#include "larpandoracontent/LArObjects/LArTwoDSlidingFitObjects.h"

#include <unordered_map>

namespace lar_content
{

class TwoDSlidingFitResult
{
public:
    template <typename T>
    TwoDSlidingFitResult(const T *const pT, const unsigned int layerFitHalfWindow, const float layerPitch,
        const float axisDeviationLimitForHitDivision = 0.95f);

    template <typename T>
    TwoDSlidingFitResult(const T *const pT, const unsigned int layerFitHalfWindow, const float layerPitch,
        const pandora::CartesianVector &axisIntercept, const pandora::CartesianVector &axisDirection,
        const pandora::CartesianVector &orthoDirection, const float axisDeviationLimitForHitDivision = 0.95f);

    TwoDSlidingFitResult(const unsigned int layerFitHalfWindow, const float layerPitch, const pandora::CartesianVector &axisIntercept,
        const pandora::CartesianVector &axisDirection, const pandora::CartesianVector &orthoDirection,
        const LayerFitContributionMap &layerFitContributionMap);

    const pandora::Cluster *GetCluster() const;

    unsigned int GetLayerFitHalfWindow() const;

    float GetLayerPitch() const;

    const pandora::CartesianVector &GetAxisIntercept() const;

    const pandora::CartesianVector &GetAxisDirection() const;

    const pandora::CartesianVector &GetOrthoDirection() const;

    const LayerFitResultMap &GetLayerFitResultMap() const;

    const LayerFitContributionMap &GetLayerFitContributionMap() const;

    const FitSegmentList &GetFitSegmentList() const;

    float GetLayerFitHalfWindowLength() const;

    int GetMinLayer() const;

    int GetMaxLayer() const;

    void GetMinAndMaxX(float &minX, float &maxX) const;

    void GetMinAndMaxZ(float &minZ, float &maxZ) const;

    int GetLayer(const float rL) const;

    float GetL(const int layer) const;

    void GetLocalPosition(const pandora::CartesianVector &position, float &rL, float &rT) const;

    void GetLocalDirection(const pandora::CartesianVector &direction, float &dTdL) const;

    void GetGlobalPosition(const float rL, const float rT, pandora::CartesianVector &position) const;

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

    pandora::CartesianVector GetGlobalMinLayerPosition() const;

    pandora::CartesianVector GetGlobalMaxLayerPosition() const;

    pandora::CartesianVector GetGlobalMinLayerDirection() const;

    pandora::CartesianVector GetGlobalMaxLayerDirection() const;

    float GetMinLayerRms() const;

    float GetMaxLayerRms() const;

    float GetFitRms(const float rL) const;

    float GetCosScatteringAngle(const float rL) const;

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

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

    pandora::StatusCode GetGlobalFitPositionAtX(const float x, pandora::CartesianVector &position) const;

    pandora::StatusCode GetGlobalFitDirectionAtX(const float x, pandora::CartesianVector &direction) const;

    pandora::StatusCode GetGlobalFitProjection(const pandora::CartesianVector &inputPosition, pandora::CartesianVector &projectedPosition) const;

    pandora::StatusCode GetGlobalFitPositionListAtX(const float x, pandora::CartesianPointVector &positionList) const;

    pandora::StatusCode GetTransverseProjection(const float x, const FitSegment &fitSegment, pandora::CartesianVector &position) const;

    pandora::StatusCode GetTransverseProjection(
        const float x, const FitSegment &fitSegment, pandora::CartesianVector &position, pandora::CartesianVector &direction) const;

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

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

    pandora::StatusCode GetExtrapolatedPositionAtX(const float x, pandora::CartesianVector &position) const;

    const FitSegment &GetFitSegment(const float rL) const;

private:
    void CalculateAxes(const pandora::CartesianPointVector &coordinateVector, const float layerPitch);

    void FillLayerFitContributionMap(const pandora::CartesianPointVector &coordinateVector);

    void PerformSlidingLinearFit();

    void FindSlidingFitSegments();

    void GetMinAndMaxCoordinate(const bool isX, float &min, float &max) const;

    pandora::CartesianVector GetGlobalFitPosition(const LayerInterpolation &layerInterpolation) const;

    pandora::CartesianVector GetGlobalFitDirection(const LayerInterpolation &layerInterpolation) const;

    float GetFitRms(const LayerInterpolation &layerInterpolation) const;

    pandora::StatusCode LongitudinalInterpolation(const float rL, LayerInterpolation &layerInterpolation) const;

    pandora::StatusCode TransverseInterpolation(const float x, const FitSegment &fitSegment, LayerInterpolation &layerInterpolation) const;

    pandora::StatusCode TransverseInterpolation(const float x, LayerInterpolationList &layerInterpolationList) const;

    pandora::StatusCode GetLongitudinalSurroundingLayers(
        const float rL, LayerFitResultMap::const_iterator &firstLayerIter, LayerFitResultMap::const_iterator &secondLayerIter) const;

    pandora::StatusCode GetTransverseSurroundingLayers(const float x, const int minLayer, const int maxLayer,
        LayerFitResultMap::const_iterator &firstLayerIter, LayerFitResultMap::const_iterator &secondLayerIter) const;

    void GetLongitudinalInterpolationWeights(const float rL, const LayerFitResultMap::const_iterator &firstLayerIter,
        const LayerFitResultMap::const_iterator &secondLayerIter, double &firstWeight, double &secondWeight) const;

    void GetTransverseInterpolationWeights(const float x, const LayerFitResultMap::const_iterator &firstLayerIter,
        const LayerFitResultMap::const_iterator &secondLayerIter, double &firstWeight, double &secondWeight) const;

    const pandora::Cluster *m_pCluster;                
    unsigned int m_layerFitHalfWindow;                 
    float m_layerPitch;                                
    pandora::CartesianVector m_axisIntercept;          
    pandora::CartesianVector m_axisDirection;          
    pandora::CartesianVector m_orthoDirection;         
    LayerFitResultMap m_layerFitResultMap;             
    LayerFitContributionMap m_layerFitContributionMap; 
    FitSegmentList m_fitSegmentList;                   
};

typedef std::vector<TwoDSlidingFitResult> TwoDSlidingFitResultList;
typedef std::unordered_map<const pandora::Cluster *, TwoDSlidingFitResult> TwoDSlidingFitResultMap;

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

inline unsigned int TwoDSlidingFitResult::GetLayerFitHalfWindow() const
{
    return m_layerFitHalfWindow;
}

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

inline float TwoDSlidingFitResult::GetLayerPitch() const
{
    return m_layerPitch;
}

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

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

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

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

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

inline const pandora::CartesianVector &TwoDSlidingFitResult::GetOrthoDirection() const
{
    return m_orthoDirection;
}

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

inline const LayerFitResultMap &TwoDSlidingFitResult::GetLayerFitResultMap() const
{
    return m_layerFitResultMap;
}

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

inline const LayerFitContributionMap &TwoDSlidingFitResult::GetLayerFitContributionMap() const
{
    return m_layerFitContributionMap;
}

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

inline const FitSegmentList &TwoDSlidingFitResult::GetFitSegmentList() const
{
    return m_fitSegmentList;
}

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

inline void TwoDSlidingFitResult::GetMinAndMaxX(float &minX, float &maxX) const
{
    return this->GetMinAndMaxCoordinate(true, minX, maxX);
}

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

inline void TwoDSlidingFitResult::GetMinAndMaxZ(float &minZ, float &maxZ) const
{
    return this->GetMinAndMaxCoordinate(false, minZ, maxZ);
}

} // namespace lar_content

#endif // #ifndef LAR_TWO_D_SLIDING_FIT_RESULT_H