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