PlottingManager.cpp

Go to the documentation of this file.

#include <filesystem>
#include "PlottingManager.h"
 
namespace M3 {
namespace Plotting {
// this is the constructor using the default plotting config file
PlottingManager::PlottingManager() {
  // set config file name
  _configFileName = DEFAULT_PLOTTING_CONFIG;
}
 
// this is the constructor with user specified config
PlottingManager::PlottingManager(const std::string &PlottingConfigName) {
  // parse the config file
  _configFileName = PlottingConfigName;
}
 
void PlottingManager::initialise() {
  _plottingConfig = M3OpenConfig(_configFileName);
 
  MACH3LOG_DEBUG("Initialising PlottingManager with plotting congif {}", _configFileName);
  // read options from the config
  YAML::Node managerOptions = _plottingConfig["ManagerOptions"];
 
  std::string translationConfig = managerOptions["translationConfig"].as<std::string>();
  if (translationConfig == "")
  {
    translationConfig = DEFAULT_TRANSLATION_CONFIG;
    MACH3LOG_DEBUG("PlottingManager: Using default translation config file name");
  }
  
  MACH3LOG_DEBUG("PlottingManager: Using translation config file: {}", translationConfig);
 
  std::string styleConfig = managerOptions["styleConfig"].as<std::string>();
  if (styleConfig == "")
  {
    styleConfig = DEFAULT_STYLE_CONFIG;
    MACH3LOG_DEBUG("PlottingManager: Using default style config file name");
  }
 
  MACH3LOG_DEBUG("PlottingManager: Using style config file: {}", styleConfig);
 
  // create the StyleManager
  _styleMan = std::make_unique<StyleManager>(styleConfig);
 
  // create the InputManager and add all the files to it
  _inputMan = std::make_unique<InputManager>(translationConfig, _fileNames);
}
 
void PlottingManager::parseInputs(int argc, char * const *argv) {
  if (argc < 2)
  {
    usage();
    MACH3LOG_ERROR("no arguments were specified :(");
    throw MaCh3Exception(__FILE__, __LINE__);
  }
 
  // parse the inputs
  int c;
  while ((c = getopt(argc, argv, "o:l:d:c:srgh")) != -1)
  {
    if (c < 0)
      break;
    switch (c)
    {
    case 'o': {
      setOutFileName(optarg);
      break;
    }
    case 's': {
      _splitBySample = true;
      break;
    }
    case 'r': {
      _plotRatios = true;
      break;
    }
    case 'g': {
      _drawGrid = true;
      break;
    }
    case 'h': {
      usage();
      break;
    }
    case 'l': {
      parseFileLabels(optarg, _fileLabels);
      MACH3LOG_INFO("Specified file labels: ");
      for (std::string label : _fileLabels)
        MACH3LOG_INFO("  {}", label);
      break;
    }
    case 'c': {
      _configFileName = optarg;
      break;
    }
    case 'd': {
      _extraDrawOptions = optarg;
      break;
    }
    case '?':
    default:
    {
      MACH3LOG_ERROR("Unknown or malformed option");
      usage();
      throw MaCh3Exception(__FILE__, __LINE__);
    }
    }
  }
 
  MACH3LOG_INFO("Input files provided");
  // optind is for the extra arguments that are not parsed by the program
  for (; optind < argc; optind++)
  {
    _fileNames.push_back(argv[optind]);
    MACH3LOG_INFO(argv[optind]);
    _defaultFileLabels.push_back(argv[optind]);
  }
  
  if (_splitBySample)
    MACH3LOG_INFO("Splitting by sample");
 
  if (_plotRatios && _fileNames.size() == 0)
  {
    MACH3LOG_ERROR("you specified -r <_plotRatios> = true but didn't specify any files to compare against, was this a mistake?");
  }
 
  if (_fileLabels.size() == 0)
  {
    MACH3LOG_INFO("No file labels specified, will just use the file names");
    _fileLabels = _defaultFileLabels;
  }
 
  if ((_fileLabels.size() != 0) && (_fileLabels.size() != _fileNames.size()))
  {
    MACH3LOG_ERROR("hmmm, you gave me {} labels but {} files", _fileLabels.size(), _fileNames.size());
  }
 
  initialise();
}
 
void PlottingManager::addUserOption() {
}
 
std::string PlottingManager::getUserOption(const std::string& option) {
  (void) option;
  return "";
}
 
void PlottingManager::usage() const {
  MACH3LOG_INFO("========================================");
  MACH3LOG_INFO("PlottingManager usage:");
  MACH3LOG_INFO("========================================");
 
  MACH3LOG_INFO("Required:");
  MACH3LOG_INFO("  <input files>               One or more input files (positional args)");
 
  MACH3LOG_INFO("");
  MACH3LOG_INFO("Options:");
  MACH3LOG_INFO("  -o <file>                   Output file name");
  MACH3LOG_INFO("  -l <labels>                 Comma/space-separated file labels");
  MACH3LOG_INFO("  -c <config>                 Configuration file name");
  //MACH3LOG_INFO("  -d <options>                Extra draw options");
  //MACH3LOG_INFO("  -s                          Split by sample");
  //MACH3LOG_INFO("  -r                          Plot ratios (requires multiple input files)");
  MACH3LOG_INFO("  -g                          Draw grid");
  MACH3LOG_INFO("  -h                          Show this help message");
 
  MACH3LOG_INFO("");
  MACH3LOG_INFO("Examples:");
  MACH3LOG_INFO("  ./plot file1.root -f FancyName");
  MACH3LOG_INFO("========================================");
}
 
void PlottingManager::setOutFileName(const std::string& saveName) {
  std::filesystem::path path(saveName);
  if (!path.has_extension()) {
    path.replace_extension(".pdf");
    _outputName = path.string();
    return;
  }
 
  std::string ext = path.extension().string();
  if (ext == ".pdf" || ext == ".ps" || ext == ".eps") {
    _outputName = saveName;
    return;
  }
 
  MACH3LOG_WARN("file extension '{}' that you provided doesnt support multiple plots in one file", ext);
  MACH3LOG_WARN("should be one of .pdf, .eps .ps, will use pdf");
  _outputName = saveName + ".pdf";
}
 
const std::string PlottingManager::getOutputName(const std::string &suffix) {
  std::filesystem::path path(_outputName);
  // ".root", ".pdf", etc.
  std::string ext = path.extension().string();
  // filename without extension
  std::string stem = path.stem().string();
 
  return stem + suffix + ext;
}
 
void PlottingManager::setExec(const std::string& execName) {
  MACH3LOG_DEBUG("Setting internal exec name to {}", execName);
  _execOptions = _plottingConfig[execName];
  if (_outputName == "Plot.pdf")
    setOutFileName(getOption<std::string>("defaultOutputName"));
}
 
void PlottingManager::parseFileLabels(std::string labelString, std::vector<std::string> &labelVec) {
  // take in a string defining labels of the form "label1;label2;...;labelN" and parse it into a
  // vector containing the labels
 
  size_t end = labelString.find(";");
  while (end != std::string::npos)
  { // Loop until no delimiter is left in the string.
    labelVec.push_back(labelString.substr(0, end));
    labelString.erase(labelString.begin(), labelString.begin() + end + 1);
    end = labelString.find(";");
  }
  labelVec.push_back(labelString.substr(0, end));
}
} // namespace Plotting
} // namespace M3