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