JBinsMap.hh

Go to the documentation of this file.

#ifndef __JROOT__JBINSMAP__
#define __JROOT__JBINSMAP__
 
#include <map>
#include <vector>
#include <string>
#include <memory>
#include <iostream>
#include <algorithm>
 
#include "TH1D.h"
#include "TH2D.h"
#include "TH3D.h"
 
#include "JLang/JException.hh"
#include "JLang/JStringStream.hh"
 
#include "JSystem/JStat.hh"
 
 
/**
 * \author bjung
 */
 
namespace JROOT {}
namespace JPP { using namespace JROOT; }
 
namespace JROOT {
 
  /**
   * Template declaration of auxiliary class for retrieving histograms corresponding to a given histogram name.
   */
  template<class T>
  class JBinsMapHelper;
 
 
  /**
   * Class for I/O of variable-width binning of multiple histograms.
   */
  class JBinsMap :
    public std::map<std::string, std::map<char, std::vector<double> > >
  {
  public:
    
    typedef std::map<std::string, std::map<char, std::vector<double> > >   map_type;
 
    typedef typename map_type::mapped_type                                 mapped_type; 
    typedef typename map_type::value_type                                  value_type;
 
    typedef typename map_type::iterator                                    iterator;
    typedef typename map_type::reverse_iterator                            reverse_iterator;
    
    typedef typename map_type::const_iterator                              const_iterator;
    typedef typename map_type::const_reverse_iterator                      const_reverse_iterator;
 
 
    /**
     * Get histogram with binning corresponding to a given histogram name.
     *
     * \param  name           histogram name
     * \return                pointer to 1D histogram
     */
    template<class T>
    std::unique_ptr<T> getHistogram(const std::string& name) const
    {
      static const JBinsMapHelper<T> getHistogram(*this);
 
      return getHistogram(name);
    }
 
 
    /**
     * Read binning from stream.
     *
     * \param  in            input stream
     * \return               input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JBinsMap& binning)
    {
      using namespace std;
      using namespace JPP;
 
      JStringStream is(in);
 
      if (getFileStatus(is.str().c_str())) {
        is.load();
      }
 
      for (string name; is >> name; ) {
 
        if (name.back() == SEPARATOR) { name.pop_back(); }
 
        mapped_type binsMap;
        
        for (char axis; is >> axis; ) {
 
          if (axis != 'x' &&
              axis != 'X' &&
              axis != 'y' &&
              axis != 'Y' &&
              axis != 'z' &&
              axis != 'Z') {
            is.clear();
            is.seekg(-1, ios::cur);         
            break;
          }
 
          axis = char(tolower(axis));
      
          if (is.peek() == (int) SEPARATOR) { is.ignore(); }
        
          vector<double> bins;
          
          for (double value; is >> value; ) {
            
            vector<double>::const_iterator i = std::lower_bound(bins.cbegin(), bins.cend(), value);
            
            if (i == bins.cend() || *i != value) {
              bins.insert(i, value);
            }
          }
 
          binsMap.insert(make_pair(axis, bins));
 
          is.clear();
        }
 
        binning.insert(make_pair(name, binsMap));
      }
 
      return in;
    }
 
 
    /**
     * Write binning to output
     *
     * \param  out                output stream
     * \return                    output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JBinsMap& binning)
    {
      using namespace std;
      
      for (const_iterator i = binning.begin(); i != binning.end(); ++i) {
 
        out << i->first << SEPARATOR << endl;
        
        for (typename mapped_type::const_iterator j = i->second.begin(); j != i->second.end(); ++j) {
 
          out << j->first << SEPARATOR;
 
          for (vector<double>::const_iterator k = j->second.begin(); k != j->second.end(); ++k) {
            out << ' ' << *k;
          }
 
          out << endl;
        }
 
        out << endl;
      }
 
      return out;
    }
 
 
  private:
    static const char SEPARATOR = ':'; //!< Separator for axis label
  };
 
 
  /**
   * Auxiliary class for retrieving 1D histograms corresponding to a given histogram name.
   */
  template<>
  struct JBinsMapHelper<TH1D>
  {
    /**
     * Constructor.
     *
     * \param  binsMap        bins map
     */
    JBinsMapHelper(const JBinsMap& binsMap) :
      binsMap(binsMap)
    {}
      
      
    /**
     * Get 1D histogram with binning corresponding to a given histogram name.
     *
     * \param  name           histogram name
     * \return                pointer to 1D histogram
     */
    std::unique_ptr<TH1D> operator()(const std::string& name) const
    {
      using namespace std;
      using namespace JPP;
 
      typename JBinsMap::const_iterator i = binsMap.find(name);
 
      if (i == binsMap.cend()) {
        THROW(JNoValue, "JBinsMapHelper<TH1D>::operator(): No bin configuration found for " << name);
      }
 
      const typename JBinsMap::mapped_type& bins = i->second;      
 
      typename JBinsMap::mapped_type::const_iterator p = bins.find('x');
 
      if (p != bins.cend()) {
 
        const vector<double>& Xbins = p->second;
 
        return std::make_unique<TH1D>(name.c_str(), "",
                                      Xbins.size()-1, Xbins.data());
      }
 
      THROW(JNoValue, "JBinsMapHelper<TH1D>::operator(): Missing x-axis binning for " << name);
    }
 
 
  private:
    const JBinsMap& binsMap; //!< Bins map
  };
 
 
  /**
   * Auxiliary class for retrieving 2D histograms corresponding to a given histogram name.
   */
  template<>
  struct JBinsMapHelper<TH2D>
  {
    /**
     * Constructor.
     *
     * \param  binsMap        bins map
     */
    JBinsMapHelper(const JBinsMap& binsMap) :
      binsMap(binsMap)
    {}
      
      
    /**
     * Get 2D histogram with binning corresponding to a given histogram name.
     *
     * \param  name           histogram name
     * \return                pointer to 2D histogram
     */
    std::unique_ptr<TH2D> operator()(const std::string& name) const
    {
      using namespace std;
      using namespace JPP;
      
      typename JBinsMap::const_iterator i = binsMap.find(name);
 
      if (i == binsMap.cend()) {
        THROW(JNoValue, "JBinsMapHelper<TH2D>::operator(): No bin configuration found for " << name);
      }
 
      const typename JBinsMap::mapped_type& bins = i->second;
 
      typename JBinsMap::mapped_type::const_iterator p = bins.find('x');
 
      if (p != bins.cend()) {
 
        const vector<double>& Xbins = p->second;
        
        typename JBinsMap::mapped_type::const_iterator q = bins.find('y');
 
        if (q != bins.cend()) {
 
          const vector<double>& Ybins = q->second;
 
          return std::make_unique<TH2D>(name.c_str(), "",
                                        Xbins.size()-1, Xbins.data(),
                                        Ybins.size()-1, Ybins.data());
        }
 
        THROW(JNoValue, "JBinsMapHelper<TH2D>::operator(): Missing y-axis binning for " << name);
      }
 
      THROW(JNoValue, "JBinsMapHelper<TH2D>::operator(): Missing x-axis binning for " << name);
    }
 
 
  private:
    const JBinsMap& binsMap; //!< Bins map
  };
 
 
  /**
   * Auxiliary class for retrieving 3D histograms corresponding to a given histogram name.
   */
  template<>
  struct JBinsMapHelper<TH3D>
  {
    /**
     * Constructor.
     *
     * \param  binsMap        bins map
     */
    JBinsMapHelper(const JBinsMap& binsMap) :
      binsMap(binsMap)
    {}
      
      
    /**
     * Get 3D histogram with binning corresponding to a given histogram name.
     *
     * \param  name           histogram name
     * \return                pointer to 3D histogram
     */
    std::unique_ptr<TH3D> operator()(const std::string& name) const
    {
      using namespace std;
      using namespace JPP;
 
      typename JBinsMap::const_iterator i = binsMap.find(name);
 
      if (i == binsMap.cend()) {
        THROW(JNoValue, "JBinsMapHelper<TH3D>::operator(): No bin configuration found for " << name);
      }
 
      const typename JBinsMap::mapped_type& bins = i->second;
 
      typename JBinsMap::mapped_type::const_iterator p = bins.find('x');
 
      if (p != bins.cend()) {
 
        const vector<double>& Xbins = p->second;
        
        typename JBinsMap::mapped_type::const_iterator q = bins.find('y');
 
        if (q != bins.cend()) {
 
          const vector<double>& Ybins = q->second;
 
          typename JBinsMap::mapped_type::const_iterator r = bins.find('z');
 
          if (r != bins.cend()) {
 
            const vector<double>& Zbins = r->second;
            
            return std::make_unique<TH3D>(name.c_str(), "",
                                          Xbins.size()-1, Xbins.data(),
                                          Ybins.size()-1, Ybins.data(),
                                          Zbins.size()-1, Zbins.data());
          }
 
          THROW(JNoValue, "JBinsMapHelper<TH3D>::operator(): Missing z-axis binning for " << name);
        }
 
        THROW(JNoValue, "JBinsMapHelper<TH3D>::operator(): Missing y-axis binning for " << name);
      }
 
      THROW(JNoValue, "JBinsMapHelper<TH3D>::operator(): Missing x-axis binning for " << name);
    }
 
 
  private:
    const JBinsMap& binsMap; //!< Bins map
  };
}
 
#endif