PlottingManager.h

Go to the documentation of this file.

#pragma once
 
// C++ includes
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <vector>
 
// MaCh3 Includes
#include "Manager/MaCh3Logger.h"
#include "Manager/YamlHelper.h"
#include "Manager/MaCh3Exception.h"
 
// Other MaCh3Plotting stuff
#include "InputManager.h"
#include "StyleManager.h"
 
namespace M3 {
namespace Plotting {
class PlottingManager {
public:
  // EM: cant make these static as std::getenv("MACH3") not known at compile time
  const std::string DEFAULT_TRANSLATION_CONFIG =
      std::string(std::getenv("MACH3")) +
      "/plotting/universalTranslator.yaml"; 
  const std::string DEFAULT_STYLE_CONFIG =
      std::string(std::getenv("MACH3")) +
      "/plotting/StyleConfig.yaml"; 
  const std::string DEFAULT_PLOTTING_CONFIG =
      std::string(std::getenv("MACH3")) +
      "/plotting/PlottingConfig.yaml"; 
 
  PlottingManager();
 
  PlottingManager(const std::string &PlottingConfigName);
 
  void initialise();
 
  ~PlottingManager() {
    MACH3LOG_DEBUG("##### Deleting PlottingManager Instance #####");
  }
 
  void parseInputs(int argc, char* const *argv);
 
 
  inline void parseInputsVec(const std::vector<std::string>& argv) {
    std::vector<char *> charVec;
    MACH3LOG_DEBUG("Parsing Inputs :: was given vector:");
    for( const std::string &arg : argv ) 
    {
      charVec.push_back( const_cast<char *>(arg.c_str()) );
      MACH3LOG_DEBUG("  - {}", arg );
    }
    parseInputs(int(argv.size()), charVec.data());
  }
 
  void addUserOption();
 
  std::string getUserOption(const std::string& option);
 
  void usage() const;
 
  void parseFileLabels(std::string labelString, std::vector<std::string> &labelVec);
 
  void setOutFileName(const std::string& fileName);
 
  void setExec(const std::string& execName);
 
  template <typename T> T getOption(const std::string& option) { return _execOptions[option].as<T>(); }
  YAML::Node getOption(const std::string& option) const { return _execOptions[option]; }
 
  // ############# getters ##############
  const std::string getFileName(int i) const { return _fileNames[i]; }
 
  const std::string getFileLabel(int i) const { return _fileLabels[i]; }
 
  const std::string getDrawOptions() const { return _extraDrawOptions; }
 
  const std::string getOutputName() { return _outputName; }
 
  const std::string getOutputName(const std::string &suffix);
 
  const std::vector<std::string> getFileNames() const { return _fileNames; }
 
  const std::vector<std::string> getFileLabels() const { return _fileLabels; }
 
  size_t getNFiles() const { return _fileNames.size(); }
 
  bool getSplitBySample() const { return _splitBySample; }
 
  bool getPlotRatios() const { return _plotRatios; }
 
  bool getDrawGrid() const { return _drawGrid; }
 
 
  // for managers contained in this manager
  const StyleManager &style() const { return *_styleMan; }
 
  const InputManager &input() const { return *_inputMan; }
 
private:
  // name of the config file to read configs from
  std::string _configFileName = std::string(std::getenv("MACH3")) + "/plotting/PlottingConfig.yaml";
  // the parsed config
  YAML::Node _plottingConfig;
  // the config object holding the options for the current executable
  YAML::Node _execOptions;
 
  // input file names and labels
  std::vector<std::string> _fileNames;
  std::vector<std::string> _fileLabels;
  std::vector<std::string> _defaultFileLabels;
 
  // other string options
  std::string _outputName = "Plot.pdf";
  std::string _extraDrawOptions = "";
 
  // Generic plotting options
  bool _splitBySample = false;
  bool _plotRatios = false;
  bool _drawGrid = false;
 
  // other Manager objects
  std::unique_ptr<StyleManager> _styleMan;
  std::unique_ptr<InputManager> _inputMan;
};
} // namespace Plotting
} // namespace M3