Histogram2D.hpp

Go to the documentation of this file.

 
#ifndef H_HISTOGRAM2D
#define H_HISTOGRAM2D
 
#include <vector>
#include <string>
 
#include <iostream>
 
 
 
namespace pottu {
 
    template <class XBinner, class YBinner, class Cell>
    class Histogram2D {
    public:
 
    Histogram2D( typename XBinner::value_type xlow, typename XBinner::value_type xhigh, unsigned int xbinc,
             typename YBinner::value_type ylow, typename YBinner::value_type yhigh, unsigned int ybinc )
        : _xbinner( xlow, xhigh, xbinc ),
          _ybinner( ylow, yhigh, ybinc )
    {
        _data.resize( _xbinner.binCount()*_ybinner.binCount(), Cell() );
    }
 
    Histogram2D( const Histogram2D &o ) = default;
    Histogram2D( Histogram2D &&o ) = default;
    Histogram2D &operator=( const Histogram2D &o ) = default;
    Histogram2D &operator=( Histogram2D &&o ) = default;
    
    const std::string &title() const { return( _title ); }
    void setTitle( const std::string &newtitle ) { _title = newtitle; }
 
    const std::string &xlabel() const { return( _xlabel ); }
    void setXlabel( const std::string &newxlabel ) { _xlabel = newxlabel; }
 
    const std::string &ylabel() const { return( _ylabel ); }
    void setYlabel( const std::string &newylabel ) { _ylabel = newylabel; }
 
    const std::string &zlabel() const { return( _zlabel ); }
    void setZlabel( const std::string &newzlabel ) { _zlabel = newzlabel; }
 
    
    void fill( typename XBinner::value_type xvalue,
           typename YBinner::value_type yvalue ) {
        bool validX = false;
        bool validY = false;
 
        if( _xbinner.isUnderflow(xvalue) )
        ++_xunderflows;
        else if( _xbinner.isOverflow(xvalue) )
        ++_xoverflows;
        else
        validX = true;
 
        if( _ybinner.isUnderflow(yvalue) )
        ++_yunderflows;
        else if( _ybinner.isOverflow(yvalue) )
        ++_yoverflows;
        else
        validY = true;
 
        if( validX && validY )
        ++_data[ _ybinner(yvalue)*_xbinner.binCount()+_xbinner(xvalue) ];
    }
 
 
    void fill( typename XBinner::value_type xvalue,
           typename YBinner::value_type yvalue,
           Cell amount ) {
        bool validX = false;
        bool validY = false;
 
        if( _xbinner.isUnderflow(xvalue) )
        ++_xunderflows;
        else if( _xbinner.isOverflow(xvalue) )
        ++_xoverflows;
        else
        validX = true;
 
        if( _ybinner.isUnderflow(yvalue) )
        ++_yunderflows;
        else if( _ybinner.isOverflow(yvalue) )
        ++_yoverflows;
        else
        validY = true;
 
        if( validX && validY )
        _data[ _ybinner(yvalue)*_xbinner.binCount()+_xbinner(xvalue) ] += amount;
    }
 
 
        
    std::ostream &exportGnuplotBinary( std::ostream &os ) const {
        float f;
        // Writing number of x-values
        f = _xbinner.binCount();
        os.write( (const char *)&f, sizeof(float) );
        
        // Writing x-values
        for( unsigned int ix = 0; ix < _xbinner.binCount(); ++ix ) { 
        f = _xbinner.binCenter( ix );
        os.write( (const char *)&f, sizeof(float) );
        }
        
        // Writing y-values and data
        for( unsigned int iy = 0; iy < _ybinner.binCount(); ++iy ) {
        f = _ybinner.binCenter( iy );
        os.write( (const char *)&f, sizeof(float) );
        for( unsigned int ix = 0; ix < _xbinner.binCount(); ++ix ) { 
            f = _data[ iy*_xbinner.binCount()+ix ];
            os.write( (const char *)&f, sizeof(float) );
        }
        }
        return( os );
    }
 
    
        nlohmann::json getAsJSON() const {
        nlohmann::json j;
        j["type"]   = "Histogram2D";
        j["title"]  = _title;
        j["xlabel"] = _xlabel;
        j["ylabel"] = _ylabel;
        j["zlabel"] = _zlabel;
        {
        nlohmann::json b;
        b["low"] = _xbinner.low();
        b["high"] = _xbinner.high();
        b["bincount"] = _xbinner.binCount();
        b["binwidth"] = _xbinner.binWidth();
        j["xbinner"] = std::move(b);
        }
        {
        nlohmann::json b;
        b["low"] = _ybinner.low();
        b["high"] = _ybinner.high();
        b["bincount"] = _ybinner.binCount();
        b["binwidth"] = _ybinner.binWidth();
        j["ybinner"] = std::move(b);
        }
        j["data"]       = _data;
        return j;
    }
 
 
    XBinner             _xbinner;
    YBinner             _ybinner;
    std::vector<Cell>   _data;
    Cell                _xunderflows = 0;
    Cell                _xoverflows = 0;
    Cell                _yunderflows = 0;
    Cell                _yoverflows = 0;
 
    std::string         _title;
    std::string         _xlabel;
    std::string         _ylabel;
    std::string         _zlabel;
    };
 
 
}
 
#endif