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

Classes
struct	Axis
	Small helper struct representing the Axis of an Histogram. More...
struct	ProfileWrapper
	helper Wrapper around TProfileX to be able to fill it More...
struct	TraitsBase
	Common base for Traits dealing with Histogram conversions to Root Provides generic implementation for creating the histogram and filling meta data The filling (method fill) is not implemented. More...

Functions
Axis	jsonToAxis (nlohmann::json &jAxis)
	extract an Axis from json data More...
template<typename Traits , std::size_t... index>
std::tuple< typename Traits::Histo, std::string >	jsonToRootHistogramInternal (std::string &dir, std::string &name, nlohmann::json const &j, std::index_sequence< index... >)
	generic function to convert json to a ROOT Histogram - internal implementation More...
TDirectory *	changeDir (TFile &file, std::string dir)
	changes to the ROOT directory given in the current ROOT file and returns the current directory before the change More...
template<typename Histo >
nlohmann::json	allAxisTojson (Histo const &h)
template<typename Histo >
nlohmann::json	binsTojson (Histo const &h)
template<typename Histo >
nlohmann::json	rootHistogramToJson (Histo const &h)
	automatic translation of Root Histograms to json More...

Function Documentation

allAxisTojson()

template<typename Histo >

nlohmann::json Gaudi::Histograming::Sink::details::allAxisTojson

(

Histo const &

h

)

Definition at line 252 of file Utils.h.

                                                 {
      if constexpr ( std::is_base_of_v<TH3D, Histo> ) {
        return { *h.GetXaxis(), *h.GetYaxis(), *h.GetZaxis() };
      } else if constexpr ( std::is_base_of_v<TProfile2D, Histo> || std::is_base_of_v<TH2D, Histo> ) {
        return { *h.GetXaxis(), *h.GetYaxis() };
      } else {
        return { *h.GetXaxis() };
      }
    }

binsTojson()

template<typename Histo >

nlohmann::json Gaudi::Histograming::Sink::details::binsTojson

(

Histo const &

h

)

Definition at line 263 of file Utils.h.

                                              {
      if constexpr ( std::is_base_of_v<TProfile, Histo> || std::is_base_of_v<TProfile2D, Histo> ) {
        nlohmann::json j;
        // ROOT TProfile interface being completely inconsistent, we have to play
        // with different ways to access values of the histogram... one per value !
        auto* sums  = h.GetArray();
        auto* sums2 = h.GetSumw2();
        for ( unsigned long n = 0; n < (unsigned long)h.GetSize(); n++ ) {
          j.push_back( nlohmann::json{ { h.GetBinEntries( n ), sums[n] }, sums2->At( n ) } );
        }
        return j;
      } else {
        return gsl::span{ h.GetArray(), (unsigned long)h.GetSize() };
      }
    }

changeDir()

TDirectory* Gaudi::Histograming::Sink::details::changeDir ( TFile &  file, std::string  dir  )

inline

changes to the ROOT directory given in the current ROOT file and returns the current directory before the change

Definition at line 225 of file Utils.h.

                                                               {
      // 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();
      return previousDir;
    }

jsonToAxis()

Axis Gaudi::Histograming::Sink::details::jsonToAxis ( nlohmann::json &  jAxis )

inline

extract an Axis from json data

Definition at line 101 of file Utils.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
    }

jsonToRootHistogramInternal()

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

std::tuple<typename Traits::Histo, std::string> Gaudi::Histograming::Sink::details::jsonToRootHistogramInternal	(	std::string &	dir,
		std::string &	name,
		nlohmann::json const &	j,
		std::index_sequence< index... >
	)

generic function to convert json to a ROOT Histogram - internal implementation

Definition at line 111 of file Utils.h.

                                                                                                               {
      // extract data from json
      auto jsonAxis = j.at( "axis" );
      auto axis     = std::array{ jsonToAxis( 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 );
      }
 
      // 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 );
 
      return { histo, dir };
    }

rootHistogramToJson()

template<typename Histo >

nlohmann::json Gaudi::Histograming::Sink::details::rootHistogramToJson

(

Histo const &

h

)

automatic translation of Root Histograms to json

Definition at line 281 of file Utils.h.

                                                       {
      std::string type = std::is_base_of_v<TProfile, Histo> || std::is_base_of_v<TProfile2D, Histo>
                             ? "histogram:ProfileHistogram:double"
                             : "histogram:Histogram:double";
      return nlohmann::json{ { "type", type },
                             { "title", h.GetTitle() },
                             { "dimension", h.GetDimension() },
                             { "empty", (int)h.GetEntries() == 0 },
                             { "nEntries", (int)h.GetEntries() },
                             { "axis", allAxisTojson( h ) },
                             { "bins", binsTojson( h ) } };
    }