Gaudi::Histograming::Sink::details Namespace Reference

Classes
struct	Axis

Functions
Axis	toAxis (nlohmann::json &jAxis)
template<typename Traits , std::size_t... index>
void	saveRootHistoInternal (TFile &file, std::string dir, std::string name, nlohmann::json const &j, std::index_sequence< index... >)
	generic function to handle histograms - internal implemenatation More...
template<typename Traits >
void	saveRootHisto (TFile &file, std::string dir, std::string name, nlohmann::json &j)
	generic method to save histograms to files More...

Function Documentation

saveRootHisto()

template<typename Traits >

void Gaudi::Histograming::Sink::details::saveRootHisto	(	TFile &	file,
		std::string	dir,
		std::string	name,
		nlohmann::json &	j
	)

generic method to save histograms to files

Can be used in most cases as the handler function to register into Sink::Base contains all the boiler plate code and redirects specific code to the Traits template

The Traits type must provide the following static functions :

• Histo create( std::string& name, std::string& title, Axis& axis... ) it should intanciate a new ROOT histogram instance and return it
• void fillMetaData( Histo& histo, nlohmann::json const& jsonAxis, unsigned int nentries) it should fill metadata in the ROOT histo histogram provides from the list of axis number of entries
• void fill( Histo& histo, unsigned int i, const WeightType& weight ) it should fill the given bin with the given value Last point, it should have a static constexpr unsigned int Dimension

Definition at line 152 of file RootHistogramSinkBase.h.

                                                                                      {
      details::saveRootHistoInternal<Traits>( file, std::move( dir ), std::move( name ), j,
                                              std::make_index_sequence<Traits::Dimension>() );
    }

saveRootHistoInternal()

template<typename Traits , std::size_t... index>

void Gaudi::Histograming::Sink::details::saveRootHistoInternal	(	TFile &	file,
		std::string	dir,
		std::string	name,
		nlohmann::json const &	j,
		std::index_sequence< index... >
	)

generic function to handle histograms - internal implemenatation

Definition at line 68 of file RootHistogramSinkBase.h.

                                                              {
      // extract data from json
      auto jsonAxis = j.at( "axis" );
      auto axis     = std::array{ toAxis( jsonAxis[index] )... };
      auto weights  = j.at( "bins" ).get<std::vector<typename Traits::WeightType>>();
      auto title    = j.at( "title" ).get<std::string>();
      auto nentries = j.at( "nEntries" ).get<unsigned int>();
      // weird way ROOT has to give titles to axis
      title += ( axis[index].title + ... );
      // compute total number of bins, multiplying bins per axis
      auto totNBins = ( ( axis[index].nBins + 2 ) * ... );
      assert( weights.size() == totNBins );
 
      if ( name[0] == '/' ) {
        dir  = "";
        name = name.substr( 1 );
      }
 
      // take into account the case where name contains '/'s (e.g. "Group/Name") by
      // moving the prefix into dir
      if ( auto pos = name.rfind( '/' ); pos != std::string::npos ) {
        dir += '/' + name.substr( 0, pos );
        name = name.substr( pos + 1 );
      }
 
      // remember the current directory
      auto previousDir = gDirectory;
 
      // find or create the directory for the histogram
      {
        using namespace ranges;
        auto is_delimiter        = []( auto c ) { return c == '/' || c == '.'; };
        auto transform_to_string = views::transform( []( auto&& rng ) { return rng | to<std::string>; } );
 
        auto currentDir = accumulate( dir | views::split_when( is_delimiter ) | transform_to_string,
                                      file.GetDirectory( "" ), []( auto current, auto&& dir_level ) {
                                        if ( current ) {
                                          // try to get next level
                                          auto nextDir = current->GetDirectory( dir_level.c_str() );
                                          // if it does not exist, create it
                                          if ( !nextDir ) nextDir = current->mkdir( dir_level.c_str() );
                                          // move to next level
                                          current = nextDir;
                                        }
                                        return current;
                                      } );
 
        if ( !currentDir )
          throw GaudiException( "Could not create directory " + dir, "Histogram::Sink::Root", StatusCode::FAILURE );
        // switch to the directory
        currentDir->cd();
      }
 
      // Create Root histogram calling constructors with the args tuple
      auto histo = Traits::create( name, title, axis[index]... );
 
      // fill Histo
      for ( unsigned int i = 0; i < totNBins; i++ ) Traits::fill( histo, i, weights[i] );
      // fill histo metadata, e.g. bins and number of entries
      Traits::fillMetaData( histo, jsonAxis, nentries );
      // write to file
      histo.Write();
 
      // switch back to the previous directory
      previousDir->cd();
    }

toAxis()

Axis Gaudi::Histograming::Sink::details::toAxis

(

nlohmann::json &

jAxis

)

Definition at line 58 of file RootHistogramSinkBase.h.

                                       {
      return { jAxis.at( "nBins" ).get<unsigned int>(), jAxis.at( "minValue" ).get<double>(),
               jAxis.at( "maxValue" ).get<double>(),
               ";" + jAxis.at( "title" ).get<std::string>() }; // ";" to prepare concatenations of titles
    }