The Gaudi Framework  v36r0 (4abb4d13)
HistoParsers.cpp
Go to the documentation of this file.
1 /***********************************************************************************\
2 * (c) Copyright 1998-2019 CERN for the benefit of the LHCb and ATLAS collaborations *
3 * *
4 * This software is distributed under the terms of the Apache version 2 licence, *
5 * copied verbatim in the file "LICENSE". *
6 * *
7 * In applying this licence, CERN does not waive the privileges and immunities *
8 * granted to it by virtue of its status as an Intergovernmental Organization *
9 * or submit itself to any jurisdiction. *
10 \***********************************************************************************/
11 // =============================================================================
12 // Include files
13 // =============================================================================
14 // STD & STL
15 // =============================================================================
16 #include <map>
17 #include <memory>
18 // =============================================================================
19 // AIDA
20 // ============================================================================
21 #include "AIDA/IHistogram1D.h"
22 #include "AIDA/IHistogram2D.h"
23 #include "AIDA/IHistogram3D.h"
24 // ============================================================================
25 // ROOT
26 // ============================================================================
27 #include "TAxis.h"
28 #include "TH1D.h"
29 #include "TH1F.h"
30 #include "TH2D.h"
31 #include "TH2F.h"
32 #include "TH3D.h"
33 // ============================================================================
34 // GaudiKernel
35 // ============================================================================
36 #include <Gaudi/Parsers/Factory.h>
37 // ============================================================================
38 // local
39 // ============================================================================
40 #include "GaudiUtils/Aida2ROOT.h"
41 #include "GaudiUtils/HistoParsers.h"
42 #include "GaudiUtils/HistoXML.h"
43 // ============================================================================
44 // Local
45 // ============================================================================
46 #include "H1.h"
47 // ============================================================================
48 namespace Gaudi {
49  // ==========================================================================
50  namespace Parsers {
51  // ========================================================================
57  template <typename Iterator, typename Skipper>
58  class EdgeGrammar : public qi::grammar<Iterator, Edges(), qi::locals<char>, Skipper> {
59  // ======================================================================
60  public:
61  // ======================================================================
62  typedef Edges ResultT;
63  // ======================================================================
64  public:
65  // ======================================================================
66  EdgeGrammar() : EdgeGrammar::base_type( result ) {
67  inner = ( ( qi::lit( "edges" ) | "'edges'" | "\"edges\"" ) >> ":" >> edges[qi::_val *= qi::_1] ) |
68  inner_pairs[qi::_val = qi::_1];
69  inner_pairs = ( ( ( qi::lit( "nbins" ) | "'nbins'" | "\"nbins\"" ) >> ":" >> nbins[qi::_val /= qi::_1] ) |
70  ( ( qi::lit( "low" ) | "'low'" | "\"low\"" ) >> ":" >> low[qi::_val -= qi::_1] ) |
71  ( ( qi::lit( "high" ) | "'high'" | "\"high\"" ) >> ":" >> high[qi::_val += qi::_1] ) ) %
72  ',';
73 
74  begin =
75  enc::char_( '[' )[qi::_val = ']'] | enc::char_( '{' )[qi::_val = '}'] | enc::char_( '(' )[qi::_val = ')'];
76  end = enc::char_( qi::_r1 );
77  result = begin[qi::_a = qi::_1] >> inner[qi::_val = qi::_1] >> end( qi::_a );
78  }
79  VectorGrammar<Iterator, std::vector<double>, Skipper> edges;
80  RealGrammar<Iterator, double, Skipper> low, high;
81  IntGrammar<Iterator, unsigned int, Skipper> nbins;
82  qi::rule<Iterator, Edges(), qi::locals<char>, Skipper> result;
83  qi::rule<Iterator, Edges(), Skipper> inner, inner_pairs;
84  qi::rule<Iterator, char()> begin;
85  qi::rule<Iterator, void( char )> end;
86  // ======================================================================
87  };
88  REGISTER_GRAMMAR( Edges, EdgeGrammar );
89  // ========================================================================
90  template <typename Iterator, typename Skipper>
91  class H1Grammar : public qi::grammar<Iterator, H1(), qi::locals<char>, Skipper> {
92  // ======================================================================
93  public:
94  // ======================================================================
95  typedef H1 ResultT;
96  // ======================================================================
97  public:
98  // ======================================================================
99  H1Grammar() : H1Grammar::base_type( result ) {
100  inner = ( ( ( qi::lit( "name" ) | "'name'" | "\"name\"" ) >> ":" >> name[qi::_val *= qi::_1] ) |
101  ( ( qi::lit( "title" ) | "'title'" | "\"title\"" ) >> ":" >> title[qi::_val /= qi::_1] ) |
102  ( -( ( qi::lit( "X" ) | "'X'" | "\"X\"" | "x" | "'x'" | "\"x\"" ) >> ':' ) >>
103  edges[qi::_val &= qi::_1] ) |
104  ( ( qi::lit( "nbins" ) | "'nbins'" | "\"nbins\"" ) >> ":" >> nbins[qi::_val |= qi::_1] ) |
105  ( ( qi::lit( "low" ) | "'low'" | "\"low\"" ) >> ":" >> low[qi::_val -= qi::_1] ) |
106  ( ( qi::lit( "high" ) | "'high'" | "\"high\"" ) >> ":" >> high[qi::_val ^= qi::_1] ) |
107  ( ( qi::lit( "bins" ) | "'bins'" | "\"bins\"" ) >> ':' >> bins[qi::_val += qi::_1] ) ) %
108  ',';
109 
110  begin =
111  enc::char_( '[' )[qi::_val = ']'] | enc::char_( '{' )[qi::_val = '}'] | enc::char_( '(' )[qi::_val = ')'];
112  end = enc::char_( qi::_r1 );
113  result = ( begin[qi::_a = qi::_1] >> inner[qi::_val = qi::_1] >> end( qi::_a ) ) | inner;
114  }
115 
116  StringGrammar<Iterator, Skipper> name, title;
117  EdgeGrammar<Iterator, Skipper> edges;
118  RealGrammar<Iterator, double, Skipper> low, high;
119  IntGrammar<Iterator, unsigned int, Skipper> nbins;
120 
121  VectorGrammar<Iterator, std::vector<std::pair<double, double>>, Skipper> bins;
122  qi::rule<Iterator, H1(), qi::locals<char>, Skipper> result;
123  qi::rule<Iterator, H1(), Skipper> inner;
124  qi::rule<Iterator, char()> begin;
125  qi::rule<Iterator, void( char )> end;
126  };
127  REGISTER_GRAMMAR( H1, H1Grammar );
128  // ========================================================================
129  template <typename Iterator, typename Skipper>
130  class H2Grammar : public qi::grammar<Iterator, H2(), qi::locals<char>, Skipper> {
131  // ======================================================================
132  public:
133  // ======================================================================
134  typedef H2 ResultT;
135  // ======================================================================
136  public:
137  // ======================================================================
138  H2Grammar() : H2Grammar::base_type( result ) {
139  inner = ( ( ( qi::lit( "name" ) | "'name'" | "\"name\"" ) >> ":" >> name[qi::_val *= qi::_1] ) |
140  ( ( qi::lit( "title" ) | "'title'" | "\"title\"" ) >> ":" >> title[qi::_val /= qi::_1] ) |
141  ( ( qi::lit( "X" ) | "'X'" | "\"X\"" | "x" | "'x'" | "\"x\"" ) >> ':' >> edges[qi::_val &= qi::_1] ) |
142  ( ( qi::lit( "Y" ) | "'Y'" | "\"Y\"" | "y" | "'y'" | "\"y\"" ) >> ':' >> edges[qi::_val |= qi::_1] ) |
143  ( ( qi::lit( "bins" ) | "'bins'" | "\"bins\"" ) >> ':' >> bins[qi::_val += qi::_1] ) ) %
144  ',';
145 
146  begin =
147  enc::char_( '[' )[qi::_val = ']'] | enc::char_( '{' )[qi::_val = '}'] | enc::char_( '(' )[qi::_val = ')'];
148  end = enc::char_( qi::_r1 );
149  result = ( begin[qi::_a = qi::_1] >> inner[qi::_val = qi::_1] >> end( qi::_a ) ) | inner[qi::_val = qi::_1];
150  }
151 
152  StringGrammar<Iterator, Skipper> name, title;
153  EdgeGrammar<Iterator, Skipper> edges;
154  VectorGrammar<Iterator, std::vector<std::pair<double, double>>, Skipper> bins;
155  qi::rule<Iterator, H2(), qi::locals<char>, Skipper> result;
156  qi::rule<Iterator, H2(), Skipper> inner;
157  qi::rule<Iterator, char()> begin;
158  qi::rule<Iterator, void( char )> end;
159 
160  // ======================================================================
161  };
162  REGISTER_GRAMMAR( H2, H2Grammar );
163  // ========================================================================
164  } // namespace Parsers
165  // ==========================================================================
166 } // end of namespace Gaudi
167 // ============================================================================
168 namespace {
169  // ==========================================================================
171  StatusCode _parse( H1& h1, const std::string& input ) {
172  // check the parsing
173  StatusCode sc = Gaudi::Parsers::parse_( h1, input );
174  if ( sc.isFailure() ) { return sc; } // RETURN
175  return h1.ok() ? StatusCode::SUCCESS : StatusCode::FAILURE;
176  }
177  // ==========================================================================
179  StatusCode _parse( H2& h2, const std::string& input ) {
180  // check the parsing
181  StatusCode sc = Gaudi::Parsers::parse_( h2, input );
182  if ( sc.isFailure() ) { return sc; } // RETURN
183  return h2.ok() ? StatusCode::SUCCESS : StatusCode::FAILURE;
184  }
185  // ==========================================================================
186  template <class HISTO1>
187  std::unique_ptr<HISTO1> _parse_1D( const std::string& input, std::string& name ) {
188  //
189  typedef std::unique_ptr<HISTO1> H1P;
190  // ==========================================================================
191  // 1) parse the custom format
192  //
193  H1 h1;
194  StatusCode sc = _parse( h1, input );
195  if ( sc.isFailure() || !h1.ok() ) { return H1P(); } // RETURN
196  //
197  // 2) create the histogram
198  //
199  H1P histo( h1.m_edges.edges.empty() ? // FIXED binning?
200  new HISTO1( "", // h1.m_name.c_str () , // NAME
201  h1.m_title.c_str(), // TITLE
202  h1.m_edges.nbins, // #bins
203  h1.m_edges.low, // low edge
204  h1.m_edges.high )
205  : // high edge
206  new HISTO1( "", // h1.m_name .c_str () , // NAME
207  h1.m_title.c_str(), // TITLE
208  h1.m_edges.edges.size() - 1, // #bins
209  &h1.m_edges.edges.front() ) ); // vector of edges
210 
211  // fill the histogram
212  for ( unsigned int ibin = 0; ibin < h1.m_bins.size(); ++ibin ) {
213  histo->SetBinContent( ibin, h1.m_bins[ibin].first );
214  histo->SetBinError( ibin, h1.m_bins[ibin].second );
215  }
216  //
217  name = h1.m_name;
218  //
219  return histo;
220  }
221  // ==========================================================================
222  template <class HISTO2>
223  std::unique_ptr<HISTO2> _parse_2D( const std::string& input, std::string& name ) {
224  //
225  typedef std::unique_ptr<HISTO2> H2P;
226  // 1) parse the custom format
227  //
228  H2 h2;
229  StatusCode sc = _parse( h2, input );
230  if ( sc.isFailure() || !h2.ok() ) { return H2P(); } // RETURN
231  //
232  // 2) create the histogram
233  //
234  H2P histo( h2.m_xedges.edges.empty() && h2.m_yedges.edges.empty()
235  ? // FIXED binning?
236  new HISTO2( "", // h1.m_name.c_str () , // NAME
237  h2.m_title.c_str(), // TITLE
238  h2.m_xedges.nbins, // #bins
239  h2.m_xedges.low, // low edge
240  h2.m_xedges.high, // high edge
241  h2.m_yedges.nbins, // #bins
242  h2.m_yedges.low, // low edge
243  h2.m_yedges.high )
244  : h2.m_xedges.edges.empty() && !h2.m_xedges.edges.empty()
245  ? new HISTO2( "", // h1.m_name.c_str () , // NAME
246  h2.m_title.c_str(), // TITLE
247  h2.m_xedges.nbins, // #bins
248  h2.m_xedges.low, // low edge
249  h2.m_xedges.high, // high edge
250  h2.m_yedges.nBins(), // #bins
251  &h2.m_yedges.edges.front() )
252  : // vector of edges
253  !h2.m_xedges.edges.empty() && h2.m_xedges.edges.empty()
254  ? new HISTO2( "", // h1.m_name.c_str () , // NAME
255  h2.m_title.c_str(), // TITLE
256  h2.m_xedges.nBins(), // #bins
257  &h2.m_xedges.edges.front(), // vector of edges
258  h2.m_yedges.nbins, // #bins
259  h2.m_yedges.low, // low edge
260  h2.m_yedges.high )
261  : // high edge
262  new HISTO2( "", // h1.m_name.c_str () , // NAME
263  h2.m_title.c_str(), // TITLE
264  h2.m_xedges.nBins(), // #bins
265  &h2.m_xedges.edges.front(), // vector of edges
266  h2.m_yedges.nBins(), // #bins
267  &h2.m_yedges.edges.front() ) ); // vector of edges
268 
269  int ibin = 0;
270  const int xBins = h2.m_xedges.nBins();
271  const int yBins = h2.m_yedges.nBins();
272 
273  for ( int jBin = yBins + 1; jBin >= 0; --jBin ) {
274  for ( int iBin = 0; iBin <= xBins + 1; ++iBin ) {
275  histo->SetBinContent( iBin, jBin, h2.m_bins[ibin].first );
276  histo->SetBinError( iBin, jBin, h2.m_bins[ibin].second );
277  ++ibin;
278  }
279  }
280  //
281  name = h2.m_name;
282  //
283  return histo;
284  }
285  // ==========================================================================
286 } // end of anonymous namespace
287 // ============================================================================
288 /* parse ROOT histogram from text representation
289  * @param result (OUTPUT) the histogram
290  * @param input (INPUT) the input to be parsed
291  * @return status code
292  */
293 // ============================================================================
294 StatusCode Gaudi::Parsers::parse( TH1D& result, const std::string& input ) {
295  // 1) check the parsing
296  std::string name;
297  //
298  auto h1 = _parse_1D<TH1D>( input, name );
299  if ( h1 ) {
300  result.Reset();
301  h1->Copy( result ); // ASSIGN
302  result.SetName( name.c_str() );
303  return StatusCode::SUCCESS; // RETURN
304  }
305  //
306  // XML-like text?
307  return ( std::string::npos != input.find( '<' ) ) ? Gaudi::Utils::Histos::fromXml( result, input )
308  : StatusCode::FAILURE;
309 }
310 // ============================================================================
311 /* parse ROOT histogram from text representation
312  * @param result (OUTPUT) the histogram
313  * @param input (INPUT) the input to be parsed
314  * @return status code
315  */
316 // ============================================================================
317 StatusCode Gaudi::Parsers::parse( TH1F& result, const std::string& input ) {
318  // 1) check the parsing
319  std::string name;
320  //
321  auto h1 = _parse_1D<TH1F>( input, name );
322  if ( h1 ) {
323  result.Reset();
324  h1->Copy( result ); // ASSIGN
325  result.SetName( name.c_str() );
326  return StatusCode::SUCCESS; // RETURN
327  }
328  //
329  // XML-like text?
330  return ( std::string::npos != input.find( '<' ) ) ? Gaudi::Utils::Histos::fromXml( result, input )
331  : StatusCode::FAILURE;
332 }
333 // ============================================================================
334 /* parse ROOT histogram from text representation
335  * @param result (OUTPUT) the histogram
336  * @param input (INPUT) the input to be parsed
337  * @return status code
338  */
339 // ============================================================================
340 StatusCode Gaudi::Parsers::parse( TH2D& result, const std::string& input ) {
341  // 1) check the parsing
342  std::string name;
343  auto h2 = _parse_2D<TH2D>( input, name );
344  if ( h2 ) {
345  result.Reset();
346  h2->Copy( result ); // ASSIGN
347  result.SetName( name.c_str() );
348  return StatusCode::SUCCESS; // RETURN
349  }
350  //
351  // XML-like text?
352  return ( std::string::npos != input.find( '<' ) ) ? Gaudi::Utils::Histos::fromXml( result, input )
353  : StatusCode::FAILURE;
354 }
355 // ============================================================================
356 /* parse ROOT histogram from text representation
357  * @param result (OUTPUT) the histogram
358  * @param input (INPUT) the input to be parsed
359  * @return status code
360  */
361 // ============================================================================
362 StatusCode Gaudi::Parsers::parse( TH2F& result, const std::string& input ) {
363  // 1) check the parsing
364  std::string name;
365  auto h2 = _parse_2D<TH2F>( input, name );
366  if ( h2 ) {
367  result.Reset();
368  h2->Copy( result ); // ASSIGN
369  result.SetName( name.c_str() );
370  return StatusCode::SUCCESS; // RETURN
371  }
372  //
373  // XML-like text?
374  if ( std::string::npos != input.find( '<' ) ) { return Gaudi::Utils::Histos::fromXml( result, input ); }
375  //
376  return StatusCode::FAILURE;
377 }
378 // ============================================================================
379 /* parse ROOT histogram from text representation
380  * @param result (OUTPUT) the histogram
381  * @param input (INPUT) the input to be parsed
382  * @return status code
383  */
384 // ============================================================================
385 StatusCode Gaudi::Parsers::parse( TH1D*& result, const std::string& input ) {
386  if ( result ) { return parse( *result, input ); } // RETURN
387 
388  // 1) check the parsing
389  std::string name;
390  auto h1 = _parse_1D<TH1D>( input, name );
391  if ( h1 ) {
392  result = h1.release();
393  result->SetName( name.c_str() );
394  return StatusCode::SUCCESS; // RETURN
395  }
396  //
397  // XML-like text?
398  return ( std::string::npos != input.find( '<' ) ) ? Gaudi::Utils::Histos::fromXml( result, input )
399  : StatusCode::FAILURE;
400 }
401 // ============================================================================
402 /* parse ROOT histogram from text representation
403  * @param result (OUTPUT) the histogram
404  * @param input (INPUT) the input to be parsed
405  * @return status code
406  */
407 // ============================================================================
408 StatusCode Gaudi::Parsers::parse( TH2D*& result, const std::string& input ) {
409  if ( result ) { return parse( *result, input ); } // RETURN
410 
411  // 1) check the parsing
412  std::string name;
413  auto h2 = _parse_2D<TH2D>( input, name );
414  if ( h2 ) {
415  result = h2.release();
416  result->SetName( name.c_str() );
417  return StatusCode::SUCCESS; // RETURN
418  }
419  //
420  // XML-like text?
421  return ( std::string::npos != input.find( '<' ) ) ? Gaudi::Utils::Histos::fromXml( result, input )
422  : StatusCode::FAILURE;
423 }
424 // ============================================================================
425 /* parse AIDA histogram from text representation
426  * @param result (OUTPUT) the histogram
427  * @param input (INPUT) the input to be parsed
428  * @return status code
429  */
430 // ============================================================================
431 StatusCode Gaudi::Parsers::parse( AIDA::IHistogram1D& result, const std::string& input ) {
432  // 1) convert to ROOT
433  auto root = Gaudi::Utils::Aida2ROOT::aida2root( &result );
434  // 2) read ROOT histogram
435  return root ? parse( *root, input ) : StatusCode::FAILURE;
436 }
437 // ============================================================================
438 /* parse AIDA histogram from text representation
439  * @param result (OUTPUT) the histogram
440  * @param input (INPUT) the input to be parsed
441  * @return status code
442  */
443 // ============================================================================
444 StatusCode Gaudi::Parsers::parse( AIDA::IHistogram2D& result, const std::string& input ) {
445  // 1) convert to ROOT
446  auto root = Gaudi::Utils::Aida2ROOT::aida2root( &result );
447  // 2) read ROOT histogram
448  return root ? parse( *root, input ) : StatusCode::FAILURE;
449 }
450 // ============================================================================
451 // The END
452 // ============================================================================
H1.h
Gaudi::Parsers::H2Grammar::end
qi::rule< Iterator, void(char)> end
Definition: HistoParsers.cpp:158
Gaudi::Parsers::H1Grammar::ResultT
H1 ResultT
Definition: HistoParsers.cpp:95
Gaudi::Parsers::IntGrammar
Definition: Grammars.h:138
Gaudi::Parsers::H1Grammar
Definition: HistoParsers.cpp:91
Gaudi::Parsers::H2Grammar
Definition: HistoParsers.cpp:130
Gaudi::Parsers::EdgeGrammar::edges
VectorGrammar< Iterator, std::vector< double >, Skipper > edges
Definition: HistoParsers.cpp:79
Gaudi::Parsers::H1Grammar::result
qi::rule< Iterator, H1(), qi::locals< char >, Skipper > result
Definition: HistoParsers.cpp:122
std::string
STL class.
Gaudi::Parsers::EdgeGrammar::high
RealGrammar< Iterator, double, Skipper > high
Definition: HistoParsers.cpp:80
Aida2ROOT.h
Gaudi::Parsers::VectorGrammar
Definition: Grammars.h:264
HistoEx.histo
histo
Definition: HistoEx.py:103
Gaudi::Parsers::H1Grammar::end
qi::rule< Iterator, void(char)> end
Definition: HistoParsers.cpp:125
std::string::find
T find(T... args)
Gaudi::Parsers::EdgeGrammar::end
qi::rule< Iterator, void(char)> end
Definition: HistoParsers.cpp:85
Gaudi::Parsers::H2Grammar::begin
qi::rule< Iterator, char()> begin
Definition: HistoParsers.cpp:157
gaudiComponentHelp.root
root
Definition: gaudiComponentHelp.py:38
Gaudi::Parsers::H2Grammar::title
StringGrammar< Iterator, Skipper > title
Definition: HistoParsers.cpp:152
Gaudi::Utils::Aida2ROOT::aida2root
static TH1D * aida2root(AIDA::IHistogram1D *aida)
get the underlying pointer for 1D-histogram
Definition: Aida2ROOT.cpp:68
Gaudi::Parsers::EdgeGrammar
Definition: HistoParsers.cpp:58
Gaudi::Parsers::H2Grammar::bins
VectorGrammar< Iterator, std::vector< std::pair< double, double > >, Skipper > bins
Definition: HistoParsers.cpp:154
HistoParsers.h
TimingHistograms.name
name
Definition: TimingHistograms.py:23
StatusCode
Definition: StatusCode.h:65
Gaudi::Parsers::EdgeGrammar::ResultT
Edges ResultT
Definition: HistoParsers.cpp:62
Gaudi::Parsers::StringGrammar
Definition: Grammar.h:60
Gaudi::Parsers::H2Grammar::edges
EdgeGrammar< Iterator, Skipper > edges
Definition: HistoParsers.cpp:153
Gaudi::Parsers::parse_
StatusCode parse_(ResultT &result, const std::string &input)
Definition: Factory.h:39
Gaudi::Parsers::EdgeGrammar::inner_pairs
qi::rule< Iterator, Edges(), Skipper > inner_pairs
Definition: HistoParsers.cpp:83
Gaudi::Parsers::SkipperGrammar
Definition: Grammar.h:51
Gaudi
Header file for std:chrono::duration-based Counters.
Definition: __init__.py:1
Gaudi::Parsers::H2Grammar::inner
qi::rule< Iterator, H2(), Skipper > inner
Definition: HistoParsers.cpp:156
Gaudi::Parsers::H1Grammar::high
RealGrammar< Iterator, double, Skipper > high
Definition: HistoParsers.cpp:118
Factory.h
StatusCode::isFailure
bool isFailure() const
Definition: StatusCode.h:142
Gaudi::Parsers::REGISTER_GRAMMAR
REGISTER_GRAMMAR(std::string, StringGrammar)
Gaudi::Parsers::H1Grammar::low
RealGrammar< Iterator, double, Skipper > low
Definition: HistoParsers.cpp:118
StatusCode::SUCCESS
constexpr static const auto SUCCESS
Definition: StatusCode.h:100
Gaudi::Parsers::EdgeGrammar::begin
qi::rule< Iterator, char()> begin
Definition: HistoParsers.cpp:84
Gaudi::Parsers::EdgeGrammar::EdgeGrammar
EdgeGrammar()
Definition: HistoParsers.cpp:66
Gaudi::Edges
std::vector< double > Edges
Definition: GaudiPI.h:27
Gaudi::Parsers::H2Grammar::H2Grammar
H2Grammar()
Definition: HistoParsers.cpp:138
parse
StatusCode parse(DataObjID &dest, const std::string &src)
Definition: DataObjID.cpp:57
Gaudi::Parsers::EdgeGrammar::nbins
IntGrammar< Iterator, unsigned int, Skipper > nbins
Definition: HistoParsers.cpp:81
Gaudi::Parsers::EdgeGrammar::inner
qi::rule< Iterator, Edges(), Skipper > inner
Definition: HistoParsers.cpp:83
Gaudi::Parsers::parse
StatusCode parse(GaudiUtils::HashMap< K, V > &result, const std::string &input)
Basic parser for the types of HashMap used in DODBasicMapper.
Definition: DODBasicMapper.cpp:21
Gaudi::Parsers::H2Grammar::ResultT
H2 ResultT
Definition: HistoParsers.cpp:134
HistoDumpEx.h1
h1
Definition: HistoDumpEx.py:22
Gaudi::Parsers::H1Grammar::nbins
IntGrammar< Iterator, unsigned int, Skipper > nbins
Definition: HistoParsers.cpp:119
Gaudi::Parsers::H2Grammar::result
qi::rule< Iterator, H2(), qi::locals< char >, Skipper > result
Definition: HistoParsers.cpp:155
Gaudi::Parsers::H1Grammar::title
StringGrammar< Iterator, Skipper > title
Definition: HistoParsers.cpp:116
Gaudi::Parsers::EdgeGrammar::low
RealGrammar< Iterator, double, Skipper > low
Definition: HistoParsers.cpp:80
Gaudi::Parsers::H1Grammar::edges
EdgeGrammar< Iterator, Skipper > edges
Definition: HistoParsers.cpp:117
StatusCode::FAILURE
constexpr static const auto FAILURE
Definition: StatusCode.h:101
Gaudi::Parsers::H1Grammar::name
StringGrammar< Iterator, Skipper > name
Definition: HistoParsers.cpp:116
Gaudi::Parsers::H1Grammar::inner
qi::rule< Iterator, H1(), Skipper > inner
Definition: HistoParsers.cpp:123
Gaudi::Parsers::H1Grammar::H1Grammar
H1Grammar()
Definition: HistoParsers.cpp:99
std::unique_ptr
STL class.
Gaudi::Parsers::H2Grammar::name
StringGrammar< Iterator, Skipper > name
Definition: HistoParsers.cpp:152
HistoXML.h
Gaudi::Utils::Histos::fromXml
GAUDI_API StatusCode fromXml(TH1D &result, const std::string &input)
parse the histogram from standard ROOT XML
Definition: HistoXML.cpp:197
Gaudi::Parsers::H1Grammar::begin
qi::rule< Iterator, char()> begin
Definition: HistoParsers.cpp:124
Gaudi::Parsers::H1Grammar::bins
VectorGrammar< Iterator, std::vector< std::pair< double, double > >, Skipper > bins
Definition: HistoParsers.cpp:121
Gaudi::Parsers::RealGrammar
Definition: Grammar.h:112
Iterator
boost::spirit::classic::position_iterator2< ForwardIterator > Iterator
Definition: Iterator.h:28
Gaudi::Parsers::EdgeGrammar::result
qi::rule< Iterator, Edges(), qi::locals< char >, Skipper > result
Definition: HistoParsers.cpp:82