Histograms.h

Go to the documentation of this file.

 
#ifndef PANDORA_HISTOGRAMS_H
#define PANDORA_HISTOGRAMS_H 1
 
#include <map>
 
namespace pandora
{
 
class TiXmlDocument;
class TiXmlHandle;
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class Histogram
{
public:
    Histogram(const unsigned int nBinsX, const float xLow, const float xHigh);
 
    Histogram(const TiXmlHandle *const pXmlHandle, const std::string &xmlElementName);
 
    Histogram(const Histogram &rhs);
 
    int GetNBinsX() const;
 
    float GetXLow() const;
 
    float GetXHigh() const;
 
    float GetXBinWidth() const;
 
    float GetBinContent(const int binX) const;
 
    int GetBinNumber(const float valueX) const;
 
    int GetMinBinNumber() const;
 
    int GetMaxBinNumber() const;
 
    int GetUnderflowBinNumber() const;
 
    int GetOverflowBinNumber() const;
 
    float GetCumulativeSum() const;
 
    float GetCumulativeSum(const int xLowBin, const int xHighBin) const;
 
    void GetMaximum(float &maximumValue, int &maximumBinX) const;
 
    void GetMaximum(const int xLowBin, const int xHighBin, float &maximumValue, int &maximumBinX) const;
 
    float GetMeanX() const;
 
    float GetMeanX(const int xLowBin, const int xHighBin) const;
 
    float GetStandardDeviationX() const;
 
    float GetStandardDeviationX(const int xLowBin, const int xHighBin) const;
 
    void SetBinContent(const int binX, const float value);
 
    void Fill(const float valueX, const float weight = 1.f);
 
    void Scale(const float scaleFactor);
 
    void WriteToXml(TiXmlDocument *const pTiXmlDocument, const std::string &xmlElementName) const;
 
private:
    typedef std::map<int, float> HistogramMap;
 
    HistogramMap        m_histogramMap;         
 
    int                 m_nBinsX;               
    float               m_xLow;                 
    float               m_xHigh;                
    float               m_xBinWidth;            
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
class TwoDHistogram
{
public:
    TwoDHistogram(const unsigned int nBinsX, const float xLow, const float xHigh, const unsigned int nBinsY, const float yLow,
        const float yHigh);
 
    TwoDHistogram(const TiXmlHandle *const pXmlHandle, const std::string &xmlElementName);
 
    TwoDHistogram(const TwoDHistogram &rhs);
 
    int GetNBinsX() const;
 
    float GetXLow() const;
 
    float GetXHigh() const;
 
    float GetXBinWidth() const;
 
    int GetNBinsY() const;
 
    float GetYLow() const;
 
    float GetYHigh() const;
 
    float GetYBinWidth() const;
 
    float GetBinContent(const int binX, const int binY) const;
 
    int GetBinNumberX(const float valueX) const;
 
    int GetMinBinNumberX() const;
 
    int GetMaxBinNumberX() const;
 
    int GetUnderflowBinNumberX() const;
 
    int GetOverflowBinNumberX() const;
 
    int GetBinNumberY(const float valueY) const;
 
    int GetMinBinNumberY() const;
 
    int GetMaxBinNumberY() const;
 
    int GetUnderflowBinNumberY() const;
 
    int GetOverflowBinNumberY() const;
 
    float GetCumulativeSum() const;
 
    float GetCumulativeSum(const int xLowBin, const int xHighBin, const int yLowBin, const int yHighBin) const;
 
    void GetMaximum(float &maximumValue, int &maximumBinX, int &maximumBinY) const;
 
    void GetMaximum(const int xLowBin, const int xHighBin, const int yLowBin, const int yHighBin, float &maximumValue, int &maximumBinX,
        int &maximumBinY) const;
 
    float GetMeanX() const;
 
    float GetMeanX(const int xLowBin, const int xHighBin, const int yLowBin, const int yHighBin) const;
 
    float GetStandardDeviationX() const;
 
    float GetStandardDeviationX(const int xLowBin, const int xHighBin, const int yLowBin, const int yHighBin) const;
 
    float GetMeanY() const;
 
    float GetMeanY(const int xLowBin, const int xHighBin, const int yLowBin, const int yHighBin) const;
 
    float GetStandardDeviationY() const;
 
    float GetStandardDeviationY(const int xLowBin, const int xHighBin, const int yLowBin, const int yHighBin) const;
 
    void SetBinContent(const int binX, const int binY, const float value);
 
    void Fill(const float valueX, const float valueY, const float weight = 1.f);
 
    void Scale(const float scaleFactor);
 
    void WriteToXml(TiXmlDocument *const pTiXmlDocument, const std::string &xmlElementName) const;
 
private:
    typedef std::map<int, float> HistogramMap;
    typedef std::map<int, HistogramMap> TwoDHistogramMap;
 
    TwoDHistogramMap    m_xyHistogramMap;       
    TwoDHistogramMap    m_yxHistogramMap;       
 
    int                 m_nBinsX;               
    float               m_xLow;                 
    float               m_xHigh;                
    float               m_xBinWidth;            
 
    int                 m_nBinsY;               
    float               m_yLow;                 
    float               m_yHigh;                
    float               m_yBinWidth;            
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int Histogram::GetNBinsX() const
{
    return m_nBinsX;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float Histogram::GetXLow() const
{
    return m_xLow;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float Histogram::GetXHigh() const
{
    return m_xHigh;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float Histogram::GetXBinWidth() const
{
    return m_xBinWidth;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int Histogram::GetMinBinNumber() const
{
    return 0;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int Histogram::GetMaxBinNumber() const
{
    return (m_nBinsX - 1);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int Histogram::GetUnderflowBinNumber() const
{
    return (this->GetMinBinNumber() - 1);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int Histogram::GetOverflowBinNumber() const
{
    return (this->GetMaxBinNumber() + 1);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float Histogram::GetCumulativeSum() const
{
    return this->GetCumulativeSum(this->GetMinBinNumber(), this->GetMaxBinNumber());
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline void Histogram::GetMaximum(float &maximumValue, int &maximumBinX) const
{
    return this->GetMaximum(this->GetMinBinNumber(), this->GetMaxBinNumber(), maximumValue, maximumBinX);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float Histogram::GetMeanX() const
{
    return this->GetMeanX(this->GetMinBinNumber(), this->GetMaxBinNumber());
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float Histogram::GetStandardDeviationX() const
{
    return this->GetStandardDeviationX(this->GetMinBinNumber(), this->GetMaxBinNumber());
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int TwoDHistogram::GetNBinsX() const
{
    return m_nBinsX;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoDHistogram::GetXLow() const
{
    return m_xLow;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoDHistogram::GetXHigh() const
{
    return m_xHigh;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoDHistogram::GetXBinWidth() const
{
    return m_xBinWidth;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int TwoDHistogram::GetNBinsY() const
{
    return m_nBinsY;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoDHistogram::GetYLow() const
{
    return m_yLow;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoDHistogram::GetYHigh() const
{
    return m_yHigh;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoDHistogram::GetYBinWidth() const
{
    return m_yBinWidth;
}
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int TwoDHistogram::GetMinBinNumberX() const
{
    return 0;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int TwoDHistogram::GetMaxBinNumberX() const
{
    return (m_nBinsX - 1);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int TwoDHistogram::GetUnderflowBinNumberX() const
{
    return (this->GetMinBinNumberX() - 1);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int TwoDHistogram::GetOverflowBinNumberX() const
{
    return (this->GetMaxBinNumberX() + 1);
}
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int TwoDHistogram::GetMinBinNumberY() const
{
    return 0;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int TwoDHistogram::GetMaxBinNumberY() const
{
    return (m_nBinsY - 1);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int TwoDHistogram::GetUnderflowBinNumberY() const
{
    return (this->GetMinBinNumberY() - 1);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int TwoDHistogram::GetOverflowBinNumberY() const
{
    return (this->GetMaxBinNumberY() + 1);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoDHistogram::GetCumulativeSum() const
{
    return this->GetCumulativeSum(this->GetMinBinNumberX(), this->GetMaxBinNumberX(), this->GetMinBinNumberY(), this->GetMaxBinNumberY());
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline void TwoDHistogram::GetMaximum(float &maximumValue, int &maximumBinX, int &maximumBinY) const
{
    return this->GetMaximum(this->GetMinBinNumberX(), this->GetMaxBinNumberX(), this->GetMinBinNumberY(), this->GetMaxBinNumberY(), maximumValue, maximumBinX, maximumBinY);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoDHistogram::GetMeanX() const
{
    return this->GetMeanX(this->GetMinBinNumberX(), this->GetMaxBinNumberX(), this->GetMinBinNumberY(), this->GetMaxBinNumberY());
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoDHistogram::GetStandardDeviationX() const
{
    return this->GetStandardDeviationX(this->GetMinBinNumberX(), this->GetMaxBinNumberX(), this->GetMinBinNumberY(), this->GetMaxBinNumberY());
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoDHistogram::GetMeanY() const
{
    return this->GetMeanY(this->GetMinBinNumberX(), this->GetMaxBinNumberX(), this->GetMinBinNumberY(), this->GetMaxBinNumberY());
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoDHistogram::GetStandardDeviationY() const
{
    return this->GetStandardDeviationY(this->GetMinBinNumberX(), this->GetMaxBinNumberX(), this->GetMinBinNumberY(), this->GetMaxBinNumberY());
}
 
} // namespace pandora
 
#endif // #ifndef PANDORA_HISTOGRAMS_H