plottingManager.cpp

Go to the documentation of this file.

#include "plottingManager.h"
 
namespace MaCh3Plotting {
// 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);
  for (std::string fileName : _fileNames)
  {
    _inputMan->addFile(fileName);
  }
}
 
void PlottingManager::parseInputs(int argc, char * const *argv) {
  // 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();
      throw MaCh3Exception(__FILE__ , __LINE__ );
    }
    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;
    }
    }
  }
 
  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 didnt 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(std::string option) {
  (void) option;
  return "";
}
 
void PlottingManager::usage() {
}
 
void PlottingManager::setOutFileName(const std::string& saveName) {
  if (saveName.find(".") == std::string::npos)
  {
    _outputName = saveName + ".pdf";
    return;
  }
 
  std::string ext = saveName;
  // if there are .'s then remove everything before them until we only have the file extension left
  while (ext.find(".") != std::string::npos)
    ext.erase(0, ext.find(".") + 1);
  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::string ext = _outputName;
  std::string name = _outputName;
 
  size_t dotPos = 0;
  while (ext.find(".") != std::string::npos)
  {
    dotPos += ext.find(".");
    ext.erase(0, ext.find(".") + 1);
  }
 
  name.erase(dotPos, ext.size() + 1);
  return name + 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 MaCh3Plotting