LArTwoDSlidingFitObjects.h

Go to the documentation of this file.

#ifndef LAR_TWO_D_SLIDING_FIT_OBJECTS_H
#define LAR_TWO_D_SLIDING_FIT_OBJECTS_H 1

#include "Pandora/StatusCodes.h"

#include <cmath>
#include <map>
#include <vector>

namespace lar_content
{

enum TransverseDirection
{
    POSITIVE_IN_X,
    NEGATIVE_IN_X,
    UNCHANGED_IN_X,
    UNKNOWN
};

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

class LayerFitResult
{
public:
    LayerFitResult(const double l, const double fitT, const double gradient, const double rms);

    double GetL() const;

    double GetFitT() const;

    double GetGradient() const;

    double GetRms() const;

private:
    double m_l;        
    double m_fitT;     
    double m_gradient; 
    double m_rms;      
};

typedef std::map<int, LayerFitResult> LayerFitResultMap;

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

class LayerFitContribution
{
public:
    LayerFitContribution();

    void AddPoint(const float l, const float t);

    double GetSumT() const;

    double GetSumL() const;

    double GetSumTT() const;

    double GetSumLT() const;

    double GetSumLL() const;

    unsigned int GetNPoints() const;

private:
    double m_sumT;          
    double m_sumL;          
    double m_sumTT;         
    double m_sumLT;         
    double m_sumLL;         
    unsigned int m_nPoints; 
};

typedef std::map<int, LayerFitContribution> LayerFitContributionMap;

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

class LayerInterpolation
{
public:
    LayerInterpolation();

    LayerInterpolation(const LayerFitResultMap::const_iterator &firstLayerIter, const LayerFitResultMap::const_iterator &secondLayerIter,
        const double firstWeight, const double secondWeight);

    bool IsInitialized() const;

    LayerFitResultMap::const_iterator GetStartLayerIter() const;

    LayerFitResultMap::const_iterator GetEndLayerIter() const;

    double GetStartLayerWeight() const;

    double GetEndLayerWeight() const;

private:
    bool m_isInitialized;                               
    LayerFitResultMap::const_iterator m_startLayerIter; 
    LayerFitResultMap::const_iterator m_endLayerIter;   
    double m_startLayerWeight;                          
    double m_endLayerWeight;                            
};

typedef std::vector<LayerInterpolation> LayerInterpolationList;

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

class FitSegment
{
public:
    FitSegment(const int startLayer, const int endLayer, const double startX, const double endX);

    int GetStartLayer() const;

    int GetEndLayer() const;

    double GetMinX() const;

    double GetMaxX() const;

    bool IsIncreasingX() const;

private:
    int m_startLayer;     
    int m_endLayer;       
    double m_minX;        
    double m_maxX;        
    bool m_isIncreasingX; 
};

typedef std::vector<FitSegment> FitSegmentList;

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

inline LayerFitResult::LayerFitResult(const double l, const double fitT, const double gradient, const double rms) :
    m_l(l),
    m_fitT(fitT),
    m_gradient(gradient),
    m_rms(rms)
{
}

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

inline double LayerFitResult::GetL() const
{
    return m_l;
}

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

inline double LayerFitResult::GetFitT() const
{
    return m_fitT;
}

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

inline double LayerFitResult::GetGradient() const
{
    return m_gradient;
}

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

inline double LayerFitResult::GetRms() const
{
    return m_rms;
}

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

inline LayerFitContribution::LayerFitContribution() :
    m_sumT(0.),
    m_sumL(0.),
    m_sumTT(0.),
    m_sumLT(0.),
    m_sumLL(0.),
    m_nPoints(0)
{
}

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

inline void LayerFitContribution::AddPoint(const float l, const float t)
{
    const double T = static_cast<double>(t);
    const double L = static_cast<double>(l);

    m_sumT += T;
    m_sumL += L;
    m_sumTT += T * T;
    m_sumLT += L * T;
    m_sumLL += L * L;
    ++m_nPoints;
}

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

inline double LayerFitContribution::GetSumT() const
{
    return m_sumT;
}

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

inline double LayerFitContribution::GetSumL() const
{
    return m_sumL;
}

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

inline double LayerFitContribution::GetSumLT() const
{
    return m_sumLT;
}

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

inline double LayerFitContribution::GetSumLL() const
{
    return m_sumLL;
}

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

inline double LayerFitContribution::GetSumTT() const
{
    return m_sumTT;
}

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

inline unsigned int LayerFitContribution::GetNPoints() const
{
    return m_nPoints;
}

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

inline LayerInterpolation::LayerInterpolation() :
    m_isInitialized(false),
    m_startLayerWeight(0.f),
    m_endLayerWeight(0.f)
{
}

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

inline LayerInterpolation::LayerInterpolation(const LayerFitResultMap::const_iterator &startLayerIter,
    const LayerFitResultMap::const_iterator &endLayerIter, const double startLayerWeight, const double endLayerWeight) :
    m_isInitialized(true),
    m_startLayerIter(startLayerIter),
    m_endLayerIter(endLayerIter),
    m_startLayerWeight(startLayerWeight),
    m_endLayerWeight(endLayerWeight)
{
}

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

inline bool LayerInterpolation::IsInitialized() const
{
    return m_isInitialized;
}

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

inline LayerFitResultMap::const_iterator LayerInterpolation::GetStartLayerIter() const
{
    if (!m_isInitialized)
        throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);

    return m_startLayerIter;
}

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

inline LayerFitResultMap::const_iterator LayerInterpolation::GetEndLayerIter() const
{
    if (!m_isInitialized)
        throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);

    return m_endLayerIter;
}

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

inline double LayerInterpolation::GetStartLayerWeight() const
{
    if (!m_isInitialized)
        throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);

    return m_startLayerWeight;
}

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

inline double LayerInterpolation::GetEndLayerWeight() const
{
    if (!m_isInitialized)
        throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);

    return m_endLayerWeight;
}

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

inline FitSegment::FitSegment(const int startLayer, const int endLayer, const double startX, const double endX) :
    m_startLayer(startLayer),
    m_endLayer(endLayer)
{
    m_minX = std::min(startX, endX);
    m_maxX = std::max(startX, endX);
    m_isIncreasingX = (endX > startX);
}

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

inline int FitSegment::GetStartLayer() const
{
    return m_startLayer;
}

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

inline int FitSegment::GetEndLayer() const
{
    return m_endLayer;
}

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

inline double FitSegment::GetMinX() const
{
    return m_minX;
}

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

inline double FitSegment::GetMaxX() const
{
    return m_maxX;
}

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

inline bool FitSegment::IsIncreasingX() const
{
    return m_isIncreasingX;
}

} // namespace lar_content

#endif // #ifndef LAR_TWO_D_SLIDING_FIT_OBJECTS_H