JsonPlotsDefReadTool.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/


#include "JsonPlotsDefReadTool.h"
#include "SinglePlotDefinition.h"

#include <nlohmann/json.hpp>
 

StatusCode IDTPM::JsonPlotsDefReadTool::initialize()
{
  ATH_MSG_DEBUG( "Initializing " << name() );
  ATH_CHECK( asg::AsgTool::initialize() );
  return StatusCode::SUCCESS;
}
 

std::vector< IDTPM::SinglePlotDefinition > 
IDTPM::JsonPlotsDefReadTool::getPlotsDefinitions() const
{
  using json = nlohmann::json;
  using cstr_t = const std::string&;
  using strVec_t = std::vector< std::string >;
 
  std::vector< SinglePlotDefinition > plotDefVec;

  for( cstr_t plotDefStr : m_plotsDefs ) {
 
    ATH_MSG_DEBUG( "Reading plot definition : " << plotDefStr );

    const json& plotDef = json::parse( plotDefStr );

    cstr_t name = plotDef.contains( "name" ) ?
        plotDef.at( "name" ).get_ref< cstr_t >() : "";

    cstr_t type = plotDef.contains( "type" ) ?
        plotDef.at( "type" ).get_ref< cstr_t >() : "";

    cstr_t folder = plotDef.contains( "folder" ) ?
        plotDef.at( "folder" ).get_ref< cstr_t >() : "";

    cstr_t title = plotDef.contains( "title" ) ?
        plotDef.at( "title" ).get_ref< cstr_t >() : "";

    unsigned int nBinsX = plotDef.contains( "xAxis_nBins" ) ?
        getInt( plotDef.at( "xAxis_nBins" ).get_ref< cstr_t >() ) : 0;

    unsigned int nBinsY = plotDef.contains( "yAxis_nBins" ) ?
        getInt( plotDef.at( "yAxis_nBins" ).get_ref< cstr_t >() ) : 0;

    unsigned int nBinsZ = plotDef.contains( "zAxis_nBins" ) ?
        getInt( plotDef.at( "zAxis_nBins" ).get_ref< cstr_t >() ) : 0;

    float xLow = plotDef.contains( "xAxis_low" ) ?
        getFloat( plotDef.at( "xAxis_low" ).get_ref< cstr_t >() ) : 0.;
    float xHigh = plotDef.contains( "xAxis_high" ) ?
        getFloat( plotDef.at( "xAxis_high" ).get_ref< cstr_t >() ) : 0.;

    float yLow = plotDef.contains( "yAxis_low" ) ?
        getFloat( plotDef.at( "yAxis_low" ).get_ref< cstr_t >() ) : 0.;
    float yHigh = plotDef.contains( "yAxis_high" ) ?
        getFloat( plotDef.at( "yAxis_high" ).get_ref< cstr_t >() ) : 0.;

    float zLow = plotDef.contains( "zAxis_low" ) ?
        getFloat( plotDef.at( "zAxis_low" ).get_ref< cstr_t >() ) : 0.;
    float zHigh = plotDef.contains( "zAxis_high" ) ?
        getFloat( plotDef.at( "zAxis_high" ).get_ref< cstr_t >() ) : 0.;

    bool xDoLogLinBins(false);
    if( plotDef.contains( "xAxis_doLogLinBins" ) ) {
      std::string xDoLogLinBinsStr = plotDef.at( "xAxis_doLogLinBins" ).get_ref< cstr_t >();
      if( xDoLogLinBinsStr == "true" ) xDoLogLinBins = true;
      else if( xDoLogLinBinsStr == "false" ) xDoLogLinBins = false;
      else ATH_MSG_WARNING( "xAxis_doLogLinBins not valid" );
    }

    bool yDoLogLinBins(false);
    if( plotDef.contains( "yAxis_doLogLinBins" ) ) {
      std::string yDoLogLinBinsStr = plotDef.at( "yAxis_doLogLinBins" ).get_ref< cstr_t >();
      if( yDoLogLinBinsStr == "true" ) yDoLogLinBins = true;
      else if( yDoLogLinBinsStr == "false" ) yDoLogLinBins = false;
      else ATH_MSG_WARNING( "yAxis_doLogLinBins not valid" );
    }

    bool zDoLogLinBins(false);
    if( plotDef.contains( "zAxis_doLogLinBins" ) ) {
      std::string zDoLogLinBinsStr = plotDef.at( "zAxis_doLogLinBins" ).get_ref< cstr_t >();
      if( zDoLogLinBinsStr == "true" ) zDoLogLinBins = true;
      else if( zDoLogLinBinsStr == "false" ) zDoLogLinBins = false;
      else ATH_MSG_WARNING( "zAxis_doLogLinBins not valid" );
    }

    strVec_t xBinsStrVec;
    if( plotDef.contains( "xAxis_bins" ) ) xBinsStrVec = plotDef.at( "xAxis_bins" ).get< strVec_t >();
    std::vector< float > xBinsVec;
    for( cstr_t thisBin : xBinsStrVec ) xBinsVec.push_back( getFloat( thisBin ) );
    if( not xBinsVec.empty() ) {
      xLow = xBinsVec.front();  xHigh = xBinsVec.back();  nBinsX = xBinsVec.size() - 1;
    }

    strVec_t yBinsStrVec;
    if( plotDef.contains( "yAxis_bins" ) ) yBinsStrVec = plotDef.at( "yAxis_bins" ).get< strVec_t >();
    std::vector< float > yBinsVec;
    for( cstr_t thisBin : yBinsStrVec ) yBinsVec.push_back( getFloat( thisBin ) );
    if( not yBinsVec.empty() ) {
      yLow = yBinsVec.front();  yHigh = yBinsVec.back();  nBinsY = yBinsVec.size() - 1;
    }

    strVec_t zBinsStrVec;
    if( plotDef.contains( "zAxis_bins" ) ) zBinsStrVec = plotDef.at( "zAxis_bins" ).get< strVec_t >();
    std::vector< float > zBinsVec;
    for( cstr_t thisBin : zBinsStrVec ) zBinsVec.push_back( getFloat( thisBin ) );
    if( not zBinsVec.empty() ) {
      zLow = zBinsVec.front();  zHigh = zBinsVec.back();  nBinsZ = zBinsVec.size() - 1;
    }

    cstr_t xTitle = plotDef.contains( "xAxis_title" ) ?
        plotDef.at( "xAxis_title" ).get_ref< cstr_t >() : "";

    cstr_t yTitle = plotDef.contains( "yAxis_title" ) ?
        plotDef.at( "yAxis_title" ).get_ref< cstr_t >() : "";

    cstr_t zTitle = plotDef.contains( "zAxis_title" ) ?
        plotDef.at( "zAxis_title" ).get_ref< cstr_t >() : "";

    strVec_t xBinLabelsVec;
    if( plotDef.contains( "xAxis_labels" ) ) xBinLabelsVec = plotDef.at( "xAxis_labels" ).get< strVec_t >();
    if( not xBinLabelsVec.empty() ) {
      nBinsX = xBinLabelsVec.size(); xLow = 0; xHigh = nBinsX;
    }

    strVec_t yBinLabelsVec;
    if( plotDef.contains( "yAxis_labels" ) ) yBinLabelsVec = plotDef.at( "yAxis_labels" ).get< strVec_t >();
    if( not yBinLabelsVec.empty() ) {
      nBinsY = yBinLabelsVec.size(); yLow = 0; yHigh = nBinsY;
    }

    strVec_t zBinLabelsVec;
    if( plotDef.contains( "zAxis_labels" ) ) zBinLabelsVec = plotDef.at( "zAxis_labels" ).get< strVec_t >();
    if( not zBinLabelsVec.empty() ) {
      nBinsZ = zBinLabelsVec.size(); zLow = 0; zHigh = nBinsZ;
    }

    plotDefVec.emplace_back(
        name, type, title,
        xTitle, nBinsX, xLow, xHigh, xDoLogLinBins, xBinsVec, xBinLabelsVec,
        yTitle, nBinsY, yLow, yHigh, yDoLogLinBins, yBinsVec, yBinLabelsVec,
        zTitle, nBinsZ, zLow, zHigh, zDoLogLinBins, zBinsVec, zBinLabelsVec,
        folder );

    if( not plotDefVec.back().isValid() ) {
      ATH_MSG_ERROR( "Removing invalid plot :" <<
                     "\n\t- string: " << plotDefStr <<
                     "\n\t- digest: " << plotDefVec.back().plotDigest() );
      plotDefVec.pop_back(); // removing from vector
    }
 
  } // close m_plotDefs loop
 
  return plotDefVec; 
}
 

float IDTPM::JsonPlotsDefReadTool::getFloat(
    const std::string& s, float defaultNum ) const
{
  try {
    float f = std::stof(s);
    return f;
  } catch(...) {
    return defaultNum;
  }
}
 
unsigned int IDTPM::JsonPlotsDefReadTool::getInt(
    const std::string& s, unsigned int defaultNum ) const
{
  return ( static_cast< unsigned int >( getFloat( s, defaultNum ) ) );
}