HistoParsers.cpp

Go to the documentation of this file.

// =============================================================================
// Include files
// =============================================================================
// STD & STL
// =============================================================================
#include <map>
#include <memory>
// =============================================================================
// AIDA
// ============================================================================
#include "AIDA/IHistogram1D.h"
#include "AIDA/IHistogram2D.h"
#include "AIDA/IHistogram3D.h"
// ============================================================================
// ROOT
// ============================================================================
#include "TAxis.h"
#include "TH1D.h"
#include "TH1F.h"
#include "TH2D.h"
#include "TH2F.h"
#include "TH3D.h"
// ============================================================================
// GaudiKernel
// ============================================================================
#include <Gaudi/Parsers/Factory.h>
// ============================================================================
// local
// ============================================================================
#include "GaudiUtils/Aida2ROOT.h"
#include "GaudiUtils/HistoParsers.h"
#include "GaudiUtils/HistoXML.h"
// ============================================================================
// Local
// ============================================================================
#include "H1.h"
// ============================================================================
namespace Gaudi {
  // ==========================================================================
  namespace Parsers {
    // ========================================================================
    template <typename Iterator, typename Skipper>
    class EdgeGrammar : public qi::grammar<Iterator, Edges(), qi::locals<char>, Skipper> {
      // ======================================================================
    public:
      // ======================================================================
      typedef Edges ResultT;
      // ======================================================================
    public:
      // ======================================================================
      EdgeGrammar() : EdgeGrammar::base_type( result ) {
        inner = ( ( qi::lit( "edges" ) | "'edges'" | "\"edges\"" ) >> ":" >> edges[qi::_val *= qi::_1] ) |
                inner_pairs[qi::_val = qi::_1];
        inner_pairs = ( ( ( qi::lit( "nbins" ) | "'nbins'" | "\"nbins\"" ) >> ":" >> nbins[qi::_val /= qi::_1] ) |
                        ( ( qi::lit( "low" ) | "'low'" | "\"low\"" ) >> ":" >> low[qi::_val -= qi::_1] ) |
                        ( ( qi::lit( "high" ) | "'high'" | "\"high\"" ) >> ":" >> high[qi::_val += qi::_1] ) ) %
                      ',';

        begin =
            enc::char_( '[' )[qi::_val = ']'] | enc::char_( '{' )[qi::_val = '}'] | enc::char_( '(' )[qi::_val = ')'];
        end    = enc::char_( qi::_r1 );
        result = begin[qi::_a = qi::_1] >> inner[qi::_val = qi::_1] >> end( qi::_a );
      }
      VectorGrammar<Iterator, std::vector<double>, Skipper>  edges;
      RealGrammar<Iterator, double, Skipper>                 low, high;
      IntGrammar<Iterator, unsigned int, Skipper>            nbins;
      qi::rule<Iterator, Edges(), qi::locals<char>, Skipper> result;
      qi::rule<Iterator, Edges(), Skipper>                   inner, inner_pairs;
      qi::rule<Iterator, char()>                             begin;
      qi::rule<Iterator, void( char )>                       end;
      // ======================================================================
    };
    REGISTER_GRAMMAR( Edges, EdgeGrammar );
    // ========================================================================
    template <typename Iterator, typename Skipper>
    class H1Grammar : public qi::grammar<Iterator, H1(), qi::locals<char>, Skipper> {
      // ======================================================================
    public:
      // ======================================================================
      typedef H1 ResultT;
      // ======================================================================
    public:
      // ======================================================================
      H1Grammar() : H1Grammar::base_type( result ) {
        inner = ( ( ( qi::lit( "name" ) | "'name'" | "\"name\"" ) >> ":" >> name[qi::_val *= qi::_1] ) |
                  ( ( qi::lit( "title" ) | "'title'" | "\"title\"" ) >> ":" >> title[qi::_val /= qi::_1] ) |
                  ( -( ( qi::lit( "X" ) | "'X'" | "\"X\"" | "x" | "'x'" | "\"x\"" ) >> ':' ) >>
                    edges[qi::_val &= qi::_1] ) |
                  ( ( qi::lit( "nbins" ) | "'nbins'" | "\"nbins\"" ) >> ":" >> nbins[qi::_val |= qi::_1] ) |
                  ( ( qi::lit( "low" ) | "'low'" | "\"low\"" ) >> ":" >> low[qi::_val -= qi::_1] ) |
                  ( ( qi::lit( "high" ) | "'high'" | "\"high\"" ) >> ":" >> high[qi::_val ^= qi::_1] ) |
                  ( ( qi::lit( "bins" ) | "'bins'" | "\"bins\"" ) >> ':' >> bins[qi::_val += qi::_1] ) ) %
                ',';

        begin =
            enc::char_( '[' )[qi::_val = ']'] | enc::char_( '{' )[qi::_val = '}'] | enc::char_( '(' )[qi::_val = ')'];
        end    = enc::char_( qi::_r1 );
        result = ( begin[qi::_a = qi::_1] >> inner[qi::_val = qi::_1] >> end( qi::_a ) ) | inner;
      }

      StringGrammar<Iterator, Skipper>            name, title;
      EdgeGrammar<Iterator, Skipper>              edges;
      RealGrammar<Iterator, double, Skipper>      low, high;
      IntGrammar<Iterator, unsigned int, Skipper> nbins;

      VectorGrammar<Iterator, std::vector<std::pair<double, double>>, Skipper> bins;
      qi::rule<Iterator, H1(), qi::locals<char>, Skipper>                      result;
      qi::rule<Iterator, H1(), Skipper>                                        inner;
      qi::rule<Iterator, char()>                                               begin;
      qi::rule<Iterator, void( char )>                                         end;
    };
    REGISTER_GRAMMAR( H1, H1Grammar );
    // ========================================================================
    template <typename Iterator, typename Skipper>
    class H2Grammar : public qi::grammar<Iterator, H2(), qi::locals<char>, Skipper> {
      // ======================================================================
    public:
      // ======================================================================
      typedef H2 ResultT;
      // ======================================================================
    public:
      // ======================================================================
      H2Grammar() : H2Grammar::base_type( result ) {
        inner = ( ( ( qi::lit( "name" ) | "'name'" | "\"name\"" ) >> ":" >> name[qi::_val *= qi::_1] ) |
                  ( ( qi::lit( "title" ) | "'title'" | "\"title\"" ) >> ":" >> title[qi::_val /= qi::_1] ) |
                  ( ( qi::lit( "X" ) | "'X'" | "\"X\"" | "x" | "'x'" | "\"x\"" ) >> ':' >> edges[qi::_val &= qi::_1] ) |
                  ( ( qi::lit( "Y" ) | "'Y'" | "\"Y\"" | "y" | "'y'" | "\"y\"" ) >> ':' >> edges[qi::_val |= qi::_1] ) |
                  ( ( qi::lit( "bins" ) | "'bins'" | "\"bins\"" ) >> ':' >> bins[qi::_val += qi::_1] ) ) %
                ',';

        begin =
            enc::char_( '[' )[qi::_val = ']'] | enc::char_( '{' )[qi::_val = '}'] | enc::char_( '(' )[qi::_val = ')'];
        end    = enc::char_( qi::_r1 );
        result = ( begin[qi::_a = qi::_1] >> inner[qi::_val = qi::_1] >> end( qi::_a ) ) | inner[qi::_val = qi::_1];
      }

      StringGrammar<Iterator, Skipper>                                         name, title;
      EdgeGrammar<Iterator, Skipper>                                           edges;
      VectorGrammar<Iterator, std::vector<std::pair<double, double>>, Skipper> bins;
      qi::rule<Iterator, H2(), qi::locals<char>, Skipper>                      result;
      qi::rule<Iterator, H2(), Skipper>                                        inner;
      qi::rule<Iterator, char()>                                               begin;
      qi::rule<Iterator, void( char )>                                         end;

      // ======================================================================
    };
    REGISTER_GRAMMAR( H2, H2Grammar );
    // ========================================================================
  } // namespace Parsers
  // ==========================================================================
} //                                                     end of namespace Gaudi
// ============================================================================
namespace {
  // ==========================================================================
  StatusCode _parse( H1& h1, const std::string& input ) {
    // check the parsing
    StatusCode sc = Gaudi::Parsers::parse_( h1, input );
    if ( sc.isFailure() ) { return sc; } // RETURN
    return h1.ok() ? StatusCode::SUCCESS : StatusCode::FAILURE;
  }
  // ==========================================================================
  StatusCode _parse( H2& h2, const std::string& input ) {
    // check the parsing
    StatusCode sc = Gaudi::Parsers::parse_( h2, input );
    if ( sc.isFailure() ) { return sc; } // RETURN
    return h2.ok() ? StatusCode::SUCCESS : StatusCode::FAILURE;
  }
  // ==========================================================================
  template <class HISTO1>
  std::unique_ptr<HISTO1> _parse_1D( const std::string& input, std::string& name ) {
    //
    typedef std::unique_ptr<HISTO1> H1P;
    // ==========================================================================
    // 1) parse the custom format
    //
    H1         h1;
    StatusCode sc = _parse( h1, input );
    if ( sc.isFailure() || !h1.ok() ) { return H1P(); } // RETURN
    //
    // 2) create the histogram
    //
    H1P histo( h1.m_edges.edges.empty() ?          // FIXED binning?
                   new HISTO1( "",                 // h1.m_name.c_str   ()         ,           // NAME
                               h1.m_title.c_str(), // TITLE
                               h1.m_edges.nbins,   // #bins
                               h1.m_edges.low,     // low edge
                               h1.m_edges.high )
                                        :                     // high  edge
                   new HISTO1( "",                            // h1.m_name .c_str ()          ,     // NAME
                               h1.m_title.c_str(),            // TITLE
                               h1.m_edges.edges.size() - 1,   // #bins
                               &h1.m_edges.edges.front() ) ); // vector of edges

    // fill the histogram
    for ( unsigned int ibin = 0; ibin < h1.m_bins.size(); ++ibin ) {
      histo->SetBinContent( ibin, h1.m_bins[ibin].first );
      histo->SetBinError( ibin, h1.m_bins[ibin].second );
    }
    //
    name = h1.m_name;
    //
    return histo;
  }
  // ==========================================================================
  template <class HISTO2>
  std::unique_ptr<HISTO2> _parse_2D( const std::string& input, std::string& name ) {
    //
    typedef std::unique_ptr<HISTO2> H2P;
    // 1) parse the custom format
    //
    H2         h2;
    StatusCode sc = _parse( h2, input );
    if ( sc.isFailure() || !h2.ok() ) { return H2P(); } // RETURN
    //
    // 2) create the histogram
    //
    H2P histo( h2.m_xedges.edges.empty() && h2.m_yedges.edges.empty()
                   ?                               // FIXED binning?
                   new HISTO2( "",                 // h1.m_name.c_str   ()         ,           // NAME
                               h2.m_title.c_str(), // TITLE
                               h2.m_xedges.nbins,  // #bins
                               h2.m_xedges.low,    // low edge
                               h2.m_xedges.high,   // high edge
                               h2.m_yedges.nbins,  // #bins
                               h2.m_yedges.low,    // low edge
                               h2.m_yedges.high )
                   : h2.m_xedges.edges.empty() && !h2.m_xedges.edges.empty()
                         ? new HISTO2( "",                  // h1.m_name.c_str   ()         ,           // NAME
                                       h2.m_title.c_str(),  // TITLE
                                       h2.m_xedges.nbins,   // #bins
                                       h2.m_xedges.low,     // low edge
                                       h2.m_xedges.high,    // high edge
                                       h2.m_yedges.nBins(), // #bins
                                       &h2.m_yedges.edges.front() )
                         : // vector of edges
                         !h2.m_xedges.edges.empty() && h2.m_xedges.edges.empty()
                             ? new HISTO2( "",                  // h1.m_name.c_str   ()         ,           // NAME
                                           h2.m_title.c_str(),  // TITLE
                                           h2.m_xedges.nBins(), // #bins
                                           &h2.m_xedges.edges.front(), // vector of edges
                                           h2.m_yedges.nbins,          // #bins
                                           h2.m_yedges.low,            // low edge
                                           h2.m_yedges.high )
                             :                                       // high edge
                             new HISTO2( "",                         // h1.m_name.c_str   ()         ,           // NAME
                                         h2.m_title.c_str(),         // TITLE
                                         h2.m_xedges.nBins(),        // #bins
                                         &h2.m_xedges.edges.front(), // vector of edges
                                         h2.m_yedges.nBins(),        // #bins
                                         &h2.m_yedges.edges.front() ) ); // vector of edges

    int       ibin  = 0;
    const int xBins = h2.m_xedges.nBins();
    const int yBins = h2.m_yedges.nBins();

    for ( int jBin = yBins + 1; jBin >= 0; --jBin ) {
      for ( int iBin = 0; iBin <= xBins + 1; ++iBin ) {
        histo->SetBinContent( iBin, jBin, h2.m_bins[ibin].first );
        histo->SetBinError( iBin, jBin, h2.m_bins[ibin].second );
        ++ibin;
      }
    }
    //
    name = h2.m_name;
    //
    return histo;
  }
  // ==========================================================================
} //                                                 end of anonymous namespace
// ============================================================================
/*  parse ROOT histogram from text representation
 *  @param result (OUTPUT) the histogram
 *  @param input  (INPUT)  the input to be parsed
 *  @return status code
 */
// ============================================================================
StatusCode Gaudi::Parsers::parse( TH1D& result, const std::string& input ) {
  // 1) check the parsing
  std::string name;
  //
  auto h1 = _parse_1D<TH1D>( input, name );
  if ( h1 ) {
    result.Reset();
    h1->Copy( result ); // ASSIGN
    result.SetName( name.c_str() );
    return StatusCode::SUCCESS; // RETURN
  }
  //
  // XML-like text?
  return ( std::string::npos != input.find( '<' ) ) ? Gaudi::Utils::Histos::fromXml( result, input )
                                                    : StatusCode::FAILURE;
}
// ============================================================================
/*  parse ROOT histogram from text representation
 *  @param result (OUTPUT) the histogram
 *  @param input  (INPUT)  the input to be parsed
 *  @return status code
 */
// ============================================================================
StatusCode Gaudi::Parsers::parse( TH1F& result, const std::string& input ) {
  // 1) check the parsing
  std::string name;
  //
  auto h1 = _parse_1D<TH1F>( input, name );
  if ( h1 ) {
    result.Reset();
    h1->Copy( result ); // ASSIGN
    result.SetName( name.c_str() );
    return StatusCode::SUCCESS; // RETURN
  }
  //
  // XML-like text?
  return ( std::string::npos != input.find( '<' ) ) ? Gaudi::Utils::Histos::fromXml( result, input )
                                                    : StatusCode::FAILURE;
}
// ============================================================================
/*  parse ROOT histogram from text representation
 *  @param result (OUTPUT) the histogram
 *  @param input  (INPUT)  the input to be parsed
 *  @return status code
 */
// ============================================================================
StatusCode Gaudi::Parsers::parse( TH2D& result, const std::string& input ) {
  // 1) check the parsing
  std::string name;
  auto        h2 = _parse_2D<TH2D>( input, name );
  if ( h2 ) {
    result.Reset();
    h2->Copy( result ); // ASSIGN
    result.SetName( name.c_str() );
    return StatusCode::SUCCESS; // RETURN
  }
  //
  // XML-like text?
  return ( std::string::npos != input.find( '<' ) ) ? Gaudi::Utils::Histos::fromXml( result, input )
                                                    : StatusCode::FAILURE;
}
// ============================================================================
/*  parse ROOT histogram from text representation
 *  @param result (OUTPUT) the histogram
 *  @param input  (INPUT)  the input to be parsed
 *  @return status code
 */
// ============================================================================
StatusCode Gaudi::Parsers::parse( TH2F& result, const std::string& input ) {
  // 1) check the parsing
  std::string name;
  auto        h2 = _parse_2D<TH2F>( input, name );
  if ( h2 ) {
    result.Reset();
    h2->Copy( result ); // ASSIGN
    result.SetName( name.c_str() );
    return StatusCode::SUCCESS; // RETURN
  }
  //
  // XML-like text?
  if ( std::string::npos != input.find( '<' ) ) { return Gaudi::Utils::Histos::fromXml( result, input ); }
  //
  return StatusCode::FAILURE;
}
// ============================================================================
/*  parse ROOT histogram from text representation
 *  @param result (OUTPUT) the histogram
 *  @param input  (INPUT)  the input to be parsed
 *  @return status code
 */
// ============================================================================
StatusCode Gaudi::Parsers::parse( TH1D*& result, const std::string& input ) {
  if ( result ) { return parse( *result, input ); } // RETURN

  // 1) check the parsing
  std::string name;
  auto        h1 = _parse_1D<TH1D>( input, name );
  if ( h1 ) {
    result = h1.release();
    result->SetName( name.c_str() );
    return StatusCode::SUCCESS; // RETURN
  }
  //
  // XML-like text?
  return ( std::string::npos != input.find( '<' ) ) ? Gaudi::Utils::Histos::fromXml( result, input )
                                                    : StatusCode::FAILURE;
}
// ============================================================================
/*  parse ROOT histogram from text representation
 *  @param result (OUTPUT) the histogram
 *  @param input  (INPUT)  the input to be parsed
 *  @return status code
 */
// ============================================================================
StatusCode Gaudi::Parsers::parse( TH2D*& result, const std::string& input ) {
  if ( result ) { return parse( *result, input ); } // RETURN

  // 1) check the parsing
  std::string name;
  auto        h2 = _parse_2D<TH2D>( input, name );
  if ( h2 ) {
    result = h2.release();
    result->SetName( name.c_str() );
    return StatusCode::SUCCESS; // RETURN
  }
  //
  // XML-like text?
  return ( std::string::npos != input.find( '<' ) ) ? Gaudi::Utils::Histos::fromXml( result, input )
                                                    : StatusCode::FAILURE;
}
// ============================================================================
/*  parse AIDA histogram from text representation
 *  @param result (OUTPUT) the histogram
 *  @param input  (INPUT)  the input to be parsed
 *  @return status code
 */
// ============================================================================
StatusCode Gaudi::Parsers::parse( AIDA::IHistogram1D& result, const std::string& input ) {
  // 1) convert to ROOT
  auto root = Gaudi::Utils::Aida2ROOT::aida2root( &result );
  // 2) read ROOT histogram
  return root ? parse( *root, input ) : StatusCode::FAILURE;
}
// ============================================================================
/*  parse AIDA histogram from text representation
 *  @param result (OUTPUT) the histogram
 *  @param input  (INPUT)  the input to be parsed
 *  @return status code
 */
// ============================================================================
StatusCode Gaudi::Parsers::parse( AIDA::IHistogram2D& result, const std::string& input ) {
  // 1) convert to ROOT
  auto root = Gaudi::Utils::Aida2ROOT::aida2root( &result );
  // 2) read ROOT histogram
  return root ? parse( *root, input ) : StatusCode::FAILURE;
}
// ============================================================================
// The END
// ============================================================================