ClusterFitHelper.h

Go to the documentation of this file.

 
#ifndef PANDORA_CLUSTER_FIT_HELPER_H
#define PANDORA_CLUSTER_FIT_HELPER_H 1
 
#include "Pandora/PandoraInputTypes.h"
#include "Pandora/PandoraInternal.h"
 
namespace pandora
{
 
class ClusterFitPoint
{
public:
    ClusterFitPoint(const CaloHit *const pCaloHit);
 
    ClusterFitPoint(const CartesianVector &position, const CartesianVector &cellNormalVector, const float cellSize,
        const float energy, const unsigned int pseudoLayer);
 
    const CartesianVector &GetPosition() const;
 
    const CartesianVector &GetCellNormalVector() const;
 
    float GetCellSize() const;
 
    float GetEnergy() const;
 
    unsigned int GetPseudoLayer() const;
 
    bool operator<(const ClusterFitPoint &rhs) const;
 
private:
    CartesianVector         m_position;              
    CartesianVector         m_cellNormalVector;      
    float                   m_cellSize;              
    float                   m_energy;                
    unsigned int            m_pseudoLayer;           
};
 
typedef std::vector<ClusterFitPoint> ClusterFitPointList;
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class ClusterFitResult
{
public:
    ClusterFitResult();
 
    bool IsFitSuccessful() const;
 
    const CartesianVector &GetDirection() const;
 
    const CartesianVector &GetIntercept() const;
 
    float GetChi2() const;
 
    float GetRms() const;
 
    float GetRadialDirectionCosine() const;
 
    void SetSuccessFlag(const bool successFlag);
 
    void SetDirection(const CartesianVector &direction);
 
    void SetIntercept(const CartesianVector &intercept);
 
    void SetChi2(const float chi2);
 
    void SetRms(const float rms);
 
    void SetRadialDirectionCosine(const float radialDirectionCosine);
 
    void Reset();
 
private:
    bool                    m_isFitSuccessful;       
    CartesianVector         m_direction;             
    CartesianVector         m_intercept;             
    InputFloat              m_chi2;                  
    InputFloat              m_rms;                   
    InputFloat              m_dirCosR;               
};
 
typedef std::vector<ClusterFitResult> ClusterFitResultList;
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class ClusterFitHelper
{
public:
    static StatusCode FitStart(const Cluster *const pCluster, const unsigned int maxOccupiedLayers, ClusterFitResult &clusterFitResult);
 
    static StatusCode FitEnd(const Cluster *const pCluster, const unsigned int maxOccupiedLayers, ClusterFitResult &clusterFitResult);
 
    static StatusCode FitFullCluster(const Cluster *const pCluster, ClusterFitResult &clusterFitResult);
 
    static StatusCode FitLayers(const Cluster *const pCluster, const unsigned int startLayer, const unsigned int endLayer,
        ClusterFitResult &clusterFitResult);
 
    static StatusCode FitLayerCentroids(const Cluster *const pCluster, const unsigned int startLayer, const unsigned int endLayer,
        ClusterFitResult &clusterFitResult);
 
    static StatusCode FitPoints(ClusterFitPointList &clusterFitPointList, ClusterFitResult &clusterFitResult);
 
private:
    static StatusCode PerformLinearFit(const CartesianVector &centralPosition, const CartesianVector &centralDirection,
        ClusterFitPointList &clusterFitPointList, ClusterFitResult &clusterFitResult);
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const CartesianVector &ClusterFitPoint::GetPosition() const
{
    return m_position;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const CartesianVector &ClusterFitPoint::GetCellNormalVector() const
{
    return m_cellNormalVector;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float ClusterFitPoint::GetCellSize() const
{
    return m_cellSize;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float ClusterFitPoint::GetEnergy() const
{
    return m_energy;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline unsigned int ClusterFitPoint::GetPseudoLayer() const
{
    return m_pseudoLayer;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline ClusterFitResult::ClusterFitResult() :
    m_isFitSuccessful(false),
    m_direction(0.f, 0.f, 0.f),
    m_intercept(0.f, 0.f, 0.f)
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline bool ClusterFitResult::IsFitSuccessful() const
{
    return m_isFitSuccessful;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const CartesianVector &ClusterFitResult::GetDirection() const
{
    if (!m_isFitSuccessful)
        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);
 
    return m_direction;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const CartesianVector &ClusterFitResult::GetIntercept() const
{
    if (!m_isFitSuccessful)
        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);
 
    return m_intercept;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float ClusterFitResult::GetChi2() const
{
    if (!m_isFitSuccessful)
        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);
 
    return m_chi2.Get();
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float ClusterFitResult::GetRms() const
{
    if (!m_isFitSuccessful)
        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);
 
    return m_rms.Get();
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float ClusterFitResult::GetRadialDirectionCosine() const
{
    if (!m_isFitSuccessful)
        throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);
 
    return m_dirCosR.Get();
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline void ClusterFitResult::SetSuccessFlag(bool successFlag)
{
    m_isFitSuccessful = successFlag;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline void ClusterFitResult::SetDirection(const CartesianVector &direction)
{
    m_direction = direction;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline void ClusterFitResult::SetIntercept(const CartesianVector &intercept)
{
    m_intercept = intercept;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline void ClusterFitResult::SetChi2(const float chi2)
{
    if (!(m_chi2 = chi2))
        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline void ClusterFitResult::SetRms(const float rms)
{
    if (!(m_rms = rms))
        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline void ClusterFitResult::SetRadialDirectionCosine(const float radialDirectionCosine)
{
    if (!(m_dirCosR = radialDirectionCosine))
        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline void ClusterFitResult::Reset()
{
    m_isFitSuccessful = false;
    m_direction.SetValues(0.f, 0.f, 0.f);
    m_intercept.SetValues(0.f, 0.f, 0.f);
    m_chi2.Reset();
    m_rms.Reset();
    m_dirCosR.Reset();
}
 
} // namespace pandora
 
#endif // #ifndef PANDORA_CLUSTER_FIT_HELPER_H