OTObject.hpp

Go to the documentation of this file.

 
#ifndef H_OTOBJECT
#define H_OTOBJECT
 
#include <string>
#include <memory>
#include <fstream>
 
#include "Histogram1D.hpp"
#include "Histogram2D.hpp"
 
 
namespace pottu {
 
    /*
     * Simple structure controlling the export to disk. 
     * Possible values for h1dtype are: 
     *   "gzip_json", "ascii", "root"
     * Possible values for h2dtype are: 
     *   "gzip_json" and "gnuplot_binary"
     * 
     * Root support requires setting: #define POTTU_ROOT_SUPPORT 1 
     * before any include of pottu.
     */
    
    struct export_context_t {
    std::string h1dtype{"gzip_json"};
    std::string h2dtype{"gzip_json"};
    std::string tmp1, tmp2;
    };
    
    class OTObject {
    public:
    OTObject( const std::string &name_ ) : _name( name_ ) {}
    virtual ~OTObject() {}
 
    OTObject( const OTObject &o ) = delete;
    OTObject( OTObject &&o ) = delete;
 
    const std::string &name() const {return(_name);}
 
 
 
    virtual void exportToDisk( const std::string &prefix,
                   export_context_t &ectx ) const = 0;
 
 
    
    std::string _name;
 
 
    protected:
 
    
    };
 
 
 
 
    class OTOH1D_double_64 : public OTObject {
    public:
    OTOH1D_double_64( const std::string &name,
              double low, double high, double binc,
              const std::string &title = "",
              const std::string &xlabel = "",
              const std::string &ylabel = "" )
        : OTObject(name), _h( low, high, binc )
    {
        _h.setTitle(title); _h.setXlabel(xlabel); _h.setYlabel(ylabel);
    }
    
    virtual ~OTOH1D_double_64() = default;
 
    virtual void exportToDisk( const std::string &prefix, export_context_t &ectx ) const {
 
        if( ectx.h1dtype == "gzip_json" ) {
        nlohmann::json j = _h.getAsJSON();
        ectx.tmp1 = std::move(j.dump());
        gzFile f = gzopen( (prefix+name()+".h1d").c_str(), "wb" );
        gzwrite( f, ectx.tmp1.data(), ectx.tmp1.size() );
        gzclose( f );
        } else if( ectx.h1dtype == "ascii" ) {
        std::ofstream f( prefix+name() );
        if( !f.is_open() )
            throw std::runtime_error( std::string()+"Couldn\'t open file "+prefix+name()+"!" );
        _h.exportAscii( f );
        } else
        throw std::runtime_error( std::string()+"Unsupported h1dtype: "+ectx.h1dtype );
 
    }
 
 
    
    Histogram1D< BinnerFloat<double>, uint64_t > _h;
    };
 
 
 
    
    class OTOH1D_double_double : public OTObject {
    public:
    OTOH1D_double_double( const std::string &name,
              double low, double high, double binc,
              const std::string &title = "",
              const std::string &xlabel = "",
              const std::string &ylabel = "" )
        : OTObject(name), _h( low, high, binc )
    {
        _h.setTitle(title); _h.setXlabel(xlabel); _h.setYlabel(ylabel);
    }
    
    virtual ~OTOH1D_double_double() = default;
 
    virtual void exportToDisk( const std::string &prefix, export_context_t &ectx ) const {
 
        if( ectx.h1dtype == "gzip_json" ) {
        nlohmann::json j = _h.getAsJSON();
        ectx.tmp1 = std::move(j.dump());
        gzFile f = gzopen( (prefix+name()+".h1d").c_str(), "wb" );
        gzwrite( f, ectx.tmp1.data(), ectx.tmp1.size() );
        gzclose( f );
        } else if( ectx.h1dtype == "ascii" ) {
        std::ofstream f( prefix+name() );
        if( !f.is_open() )
            throw std::runtime_error( std::string()+"Couldn\'t open file "+prefix+name()+"!" );
        _h.exportAscii( f );
        } else
        throw std::runtime_error( std::string()+"Unsupported h1dtype: "+ectx.h1dtype );
 
    }
 
 
    
    Histogram1D< BinnerFloat<double>, double > _h;
    };
 
    
 
    class OTOH1D_pow2_64 : public OTObject {
    public:
    OTOH1D_pow2_64( const std::string &name,
            uint32_t high_bits, uint32_t bins_bits, 
            const std::string &title = "",
            const std::string &xlabel = "",
            const std::string &ylabel = "" )
        : OTObject(name), _h( BinnerPow2<uint32_t>(high_bits,bins_bits) )
    {
        _h.setTitle(title); _h.setXlabel(xlabel); _h.setYlabel(ylabel);
    }
    
    virtual ~OTOH1D_pow2_64() {};
 
    virtual void exportToDisk( const std::string &prefix, export_context_t &ectx ) const {
        if( ectx.h1dtype == "gzip_json" ) {
        nlohmann::json j = _h.getAsJSON();
        ectx.tmp1 = std::move(j.dump());
        gzFile f = gzopen( (prefix+name()+".h1d").c_str(), "wb" );
        gzwrite( f, ectx.tmp1.data(), ectx.tmp1.size() );
        gzclose( f );
        } else if( ectx.h1dtype == "ascii" ) {
        std::ofstream f( prefix+name() );
        if( !f.is_open() )
            throw std::runtime_error( std::string()+"Couldn\'t open file "+prefix+name()+"!" );
        _h.exportAscii( f );
        } else
        throw std::runtime_error( std::string()+"Unsupported h1dtype: "+ectx.h1dtype );
    }
 
    
    
    Histogram1D< BinnerPow2<uint32_t>, uint64_t > _h;
    };
 
 
 
    class OTOH2D_double_64 : public OTObject {
    public:
    OTOH2D_double_64( const std::string &name,
              double xlow, double xhigh, double xbinc,
              double ylow, double yhigh, double ybinc,
              const std::string &title = "",
              const std::string &xlabel = "",
              const std::string &ylabel = "",
              const std::string &zlabel = "" )
        : OTObject(name), _h( xlow, xhigh, xbinc, ylow, yhigh, ybinc ) 
    {
        _h.setTitle(title); _h.setXlabel(xlabel); _h.setYlabel(ylabel); _h.setZlabel(zlabel);
    }
    
    virtual ~OTOH2D_double_64() {}
 
    virtual void exportToDisk( const std::string &prefix, export_context_t &ectx ) const     {
        if( ectx.h1dtype == "gzip_json" ) {
        nlohmann::json j = _h.getAsJSON();
        ectx.tmp1 = std::move(j.dump());
        gzFile f = gzopen( (prefix+name()+".h2d").c_str(), "wb" );
        gzwrite( f, ectx.tmp1.data(), ectx.tmp1.size() );
        gzclose( f );
        } else if( ectx.h1dtype == "gnuplot_binary" ) {
        std::ofstream f( prefix+name() );
        if( !f.is_open() )
            throw std::runtime_error( std::string()+"Couldn\'t open file "+prefix+name()+"!" );
        _h.exportGnuplotBinary( f );
        } else
        throw std::runtime_error( std::string()+"Unsupported h1dtype: "+ectx.h1dtype );
 
    }
 
    
    Histogram2D< BinnerFloat<double>, BinnerFloat<double>, uint64_t > _h;
    };
 
    
    
    class OTOH2D_double_double : public OTObject {
    public:
    OTOH2D_double_double( const std::string &name,
                  double xlow, double xhigh, double xbinc,
                  double ylow, double yhigh, double ybinc,
                  const std::string &title = "",
                  const std::string &xlabel = "",
                  const std::string &ylabel = "",
                  const std::string &zlabel = "" )
        : OTObject(name), _h( xlow, xhigh, xbinc, ylow, yhigh, ybinc ) 
    {
        _h.setTitle(title); _h.setXlabel(xlabel); _h.setYlabel(ylabel); _h.setZlabel(zlabel);
    }
    
    virtual ~OTOH2D_double_double() {}
 
    virtual void exportToDisk( const std::string &prefix, export_context_t &ectx ) const     {
        if( ectx.h1dtype == "gzip_json" ) {
        nlohmann::json j = _h.getAsJSON();
        ectx.tmp1 = std::move(j.dump());
        gzFile f = gzopen( (prefix+name()+".h2d").c_str(), "wb" );
        gzwrite( f, ectx.tmp1.data(), ectx.tmp1.size() );
        gzclose( f );
        } else if( ectx.h1dtype == "gnuplot_binary" ) {
        std::ofstream f( prefix+name() );
        if( !f.is_open() )
            throw std::runtime_error( std::string()+"Couldn\'t open file "+prefix+name()+"!" );
        _h.exportGnuplotBinary( f );
        } else
        throw std::runtime_error( std::string()+"Unsupported h1dtype: "+ectx.h1dtype );
 
    }
 
    
    Histogram2D< BinnerFloat<double>, BinnerFloat<double>, double > _h;
    };
 
}
 
 
 
#endif