result_collection_support.hpp

Go to the documentation of this file.

 
#ifndef H_POTTU_RESULT_COLLECTION_SUPPORT
#define H_POTTU_RESULT_COLLECTION_SUPPORT
 
 
#ifdef POTTU_ROOT_SUPPORT
//  #include <TFile.h>
  #include <TDirectory.h>
  #include <TH1I.h>
  #include <TH2I.h>
#else
// Including legacy ObjectTree only if no root support requested
  #include "ObjectTree.hpp"
#endif
 
#include <fmt/base.h>
 
#include <fstream>
#include <exception>
#include <cstdint>
 
 
namespace pottu {
 
    struct histogram_param_binning_t {
    double low{0};
    double high{16384};
    uint32_t bins{256};
    };
    
    
#ifdef POTTU_ROOT_SUPPORT
    typedef TDirectory * _result_tree_type;
    typedef TH1I         _histogram_1d_pow2_type;
    typedef TH1I         _histogram_1d_type;
    typedef TH2I         _histogram_2d_type;
    
    static inline TDirectory *createSubTree( TDirectory *tree, const std::string &name ) {
    return tree->mkdir( name.c_str() );
    }
 
    static inline TH1I *
    createHistogram1DPow2( TDirectory *tree, const char *name, uint32_t highbits, uint32_t binbits ) {
    tree->cd();
    auto h = new TH1I( name, name, 1<<binbits, 0, 1<<highbits );
    return h;
    }
 
    static inline TH1I *
    createHistogram1D( TDirectory *tree, const char *name, double low, double high, uint32_t bincount ) {
    tree->cd();
    auto h = new TH1I( name, name, bincount, low, high );
    return h;
    }
 
    static inline TH2I *
    createHistogram2D( TDirectory *tree, const char *name,
            double xlow, double xhigh, uint32_t xbincount,
            double ylow, double yhigh, uint32_t ybincount ) {
    tree->cd();
    auto h = new TH2I( name, name, xbincount, xlow, xhigh, ybincount, ylow, yhigh );
    return h;
    }
 
    static inline void fillInteger( TH1I *h, int value ) {
    h->Fill( value );
    }
 
    static inline void fill( TH1I *h, double value ) {
    h->Fill( value );
    }
    
    static inline void fillAmount( TH1I *h, double value, int amount ) {
    h->Fill( value, amount );
    }
 
    static inline void fill( TH2I *h, double xvalue, double yvalue ) {
    h->Fill( xvalue, yvalue );
    }
 
    static inline void fillAmount( TH2I *h, double xvalue, double yvalue, int amount ) {
    h->Fill( xvalue, yvalue, amount );
    }
 
#else
    typedef ObjectTree                  * _result_tree_type;
    typedef ObjectTree::pow2_h1_type      _histogram_1d_pow2_type;
    typedef ObjectTree::default_h1_type   _histogram_1d_type;
    typedef ObjectTree::default_h2_type   _histogram_2d_type;
    
    static inline ObjectTree *createSubTree( ObjectTree *tree, const char *name ) {
    return tree->createSubTree( name );
    }
 
    static inline ObjectTree::pow2_h1_type *
    createHistogram1DPow2( ObjectTree *tree, const char *name, uint32_t highbits, uint32_t binbits ) {
    return tree->createHistogram1D_pow2( name, highbits, binbits );
    }
 
    static inline ObjectTree::default_h1_type *
    createHistogram1D( ObjectTree *tree, const char *name, double low, double high, uint32_t bincount ) {
    return tree->createHistogram1D( name, low, high, bincount );
    }
 
    static inline ObjectTree::default_h2_type *
    createHistogram2D( ObjectTree *tree, const char *name,
            double xlow, double xhigh, uint32_t xbincount,
            double ylow, double yhigh, uint32_t ybincount ) {
    return tree->createHistogram2D( name, xlow, xhigh, xbincount, ylow, yhigh, ybincount );
    }
 
    static inline void fillInteger( ObjectTree::pow2_h1_type *h, int value ) {
    h->fill( value );
    }
 
    static inline void fill( ObjectTree::default_h1_type *h, double value ) {
    h->fill( value );
    }
 
    static inline void fillAmount( ObjectTree::default_h1_type *h, double value, int amount ) {
    h->fill( value, amount );
    }
 
    static inline void fill( ObjectTree::default_h2_type *h, double xvalue, double yvalue ) {
    h->fill( xvalue, yvalue );
    }
 
    static inline void fillAmount( ObjectTree::default_h2_type *h, double xvalue, double yvalue, int amount ) {
    h->fill( xvalue, yvalue, amount );
    }
 
 
 
#endif
 
 
    static inline pottu::_histogram_1d_type *createHistogram1D( pottu::_result_tree_type tree,
                                const std::string &name,
                                const histogram_param_binning_t &binning ) {
    return pottu::createHistogram1D( tree,
                     name.c_str(),
                     binning.low, binning.high, binning.bins );
    }
 
 
    static inline pottu::_histogram_2d_type *createHistogram2D( pottu::_result_tree_type tree,
                                const std::string &name,
                                const histogram_param_binning_t &xbinning,
                                const histogram_param_binning_t &ybinning ) {
    return pottu::createHistogram2D( tree,
                     name.c_str(),
                     xbinning.low, xbinning.high, xbinning.bins,
                     ybinning.low, ybinning.high, ybinning.bins );                    
    }
 
 
    
#ifdef POTTU_ROOT_SUPPORT
    static inline void exportHistogramToAscii( const pottu::_histogram_1d_type *h, const std::string &prefix ) {
    std::string name = fmt::format( "{}{}.dat", prefix, h->GetName() );
    std::ofstream f( name );
    if( !f.is_open() ) {
        throw std::runtime_error( fmt::format( "Couldn't open file \'{}\' to export histogram.\n", name ) );
    }
    uint32_t n = h->GetNbinsX();
    
    for( uint32_t i=1; i<=n; i++ ) {
        f << h->GetBinLowEdge(i)+h->GetBinWidth(i)/2 << "\t"
          << h->GetBinContent(i) << "\n";
    }
    }
#else
    static inline void exportHistogramToAscii( const pottu::_histogram_1d_type *h, const std::string &prefix ) {
    throw std::runtime_error( "exportHistogramToAscii() is not implemented for built-in histograms" );
    // TODO
    }
#endif
    
 
    static inline void throwIfNotValidName( const std::string &name ) {
    if( name.size() == 0 )
        throw std::runtime_error( "Name cannot be empty for an object." );
 
    for( const auto c : name ) {
        if( !( isalnum(c) || c=='_' || c=='-' || c=='.' ) )
        throw std::runtime_error( fmt::format( "Name \'{}\' is not valid name for an object.", name ) );
    }
    }
 
    
}
 
 
 
 
 
 
#endif