MaCh3Modes.cpp

Go to the documentation of this file.

//MaCh3 includes
#include "MaCh3Modes.h"
 
// *******************
MaCh3Modes::MaCh3Modes(std::string const &filename) {
// *******************
  // Load config
  YAML::Node config = M3OpenConfig(filename);
  Initialise(config);
}
 
// *******************
MaCh3Modes::MaCh3Modes(const YAML::Node& config) {
// *******************
  Initialise(config);
}
 
// *******************
void MaCh3Modes::Initialise(const YAML::Node& config) {
// *******************
  NModes = 0;
  nCCModes = 0;
 
  Title = config["Title"].as<std::string>();
  Generator = config["GeneratorName"].as<std::string>();
 
  auto names = Get<std::vector<std::string>>(config["MaCh3Modes"], __FILE__, __LINE__);
 
  for(size_t i = 0; i < names.size(); i++)
  {
    DeclareNewMode(names[i],
                   Get<std::string>(config[names[i]]["Name"], __FILE__, __LINE__),
                   Get<int>(config[names[i]]["PlotColor"], __FILE__, __LINE__),
                   Get<std::vector<int>>(config[names[i]]["GeneratorMaping"], __FILE__, __LINE__),
                   Get<bool>(config[names[i]]["IsNC"], __FILE__, __LINE__),
                   Get<std::string>(config[names[i]]["SplineSuffix"], __FILE__, __LINE__));
 
    if (!Get<bool>(config[names[i]]["IsNC"], __FILE__, __LINE__)) {
      nCCModes += 1;
    }
  }
  // Add unknown category, it's better to have garbage category where all undefined modes will go rather than get random crashes
  DeclareNewMode("UNKNOWN_BAD",
                 "UNKNOWN_BAD",
                 kBlack,
                 {},
                 false,
                 "UNKNOWN_BAD");
  // This is hack to not have bad mode
  NModes--;
 
  PrepareMap();
 
  Print();
}
 
// *******************
void MaCh3Modes::Print() const {
// *******************
  MACH3LOG_INFO("Printing MaCh3 Modes Called: {}", Title);
 
  MACH3LOG_INFO("========================================================================");
  MACH3LOG_INFO("{:<5} {:2} {:<20} {:2} {:<20} {:2} {:<30}", "#", "|", "Name", "|", "FancyName", "|", Generator+" Modes");
  MACH3LOG_INFO("------------------------------------------------------------------------");
  for(int i = 0; i < NModes; ++i) {
    try {
      auto Name = fMode.at(i).Name;
      auto FancyName = fMode.at(i).FancyName;
      auto Values = fMode.at(i).GeneratorMaping;
      std::string generatorModes;
      for (const int& element : Values) {
        generatorModes += std::to_string(element) + " ";
      }
      MACH3LOG_INFO("{:<5} {:2} {:<20} {:2} {:<20} {:2} {:<30}", i, "|", Name, "|", FancyName, "|", generatorModes);
    } catch (const std::out_of_range& e) {
      MACH3LOG_ERROR("Index {} is out of bounds for fMode. Check NModes or fMode size.", i);
      throw MaCh3Exception(__FILE__ , __LINE__ );
    }
  }
  MACH3LOG_INFO("========================================================================");
  MACH3LOG_INFO("==========================");
  MACH3LOG_INFO("{:<10} {:2} {:<30}", Generator + " Modes", "|", "Name");
  MACH3LOG_INFO("--------------------------");
  for (size_t i = 0; i < ModeMap.size(); ++i) {
    try {
      MACH3LOG_INFO("{:<10} {:2} {:<30}", i, "|", fMode.at(ModeMap[i]).Name);
    } catch (const std::out_of_range& e) {
      MACH3LOG_ERROR("ModeMap[{}] = {} is out of bounds for fMode. Check ModeMap or fMode size.", i, ModeMap[i]);
      throw MaCh3Exception(__FILE__ , __LINE__ );
    }
  }
  MACH3LOG_INFO("==========================");
}
 
// *******************
MaCh3Modes_t MaCh3Modes::EnsureModeNameRegistered(std::string const &name) {
// *******************
  if (Mode.count(name)) {
    return Mode[name];
  }
  MaCh3Modes_t index = MaCh3Modes_t(Mode.size());
  Mode[name] = index;
  return index;
}
 
// *******************
void MaCh3Modes::DeclareNewMode(std::string const &name,
                std::string const &fancyname,
                int PlotColor,
                std::vector<int> const &GenMap,
                bool const IsNC,
                std::string const &SplineSuffix) {
// *******************
  MaCh3ModeInfo newinfo;
  newinfo.GeneratorMaping = GenMap;
  newinfo.FancyName = fancyname;
  newinfo.PlotColor = PlotColor;
  newinfo.Name = name;
  newinfo.IsNC = IsNC;
  newinfo.SplineSuffix = SplineSuffix;
 
  MaCh3Modes_t index = EnsureModeNameRegistered(name);
 
  fMode.emplace(index, newinfo);
  NModes++;
}
 
// *******************
void MaCh3Modes::PrepareMap() {
// *******************
  int maxElement = 0;
  for(int i = 0; i < NModes; ++i) {
    for(size_t j = 0; j < fMode[i].GeneratorMaping.size(); j++) {
      maxElement = std::max(maxElement, fMode[i].GeneratorMaping[j]);
    }
  }
  ModeMap.resize(maxElement+1, Mode["UNKNOWN_BAD"]);
 
  for(int m = 0; m < NModes; ++m) {
    for(size_t i = 0; i < fMode[m].GeneratorMaping.size(); ++i) {
      if(fMode[m].GeneratorMaping[i] < 0) {
        MACH3LOG_ERROR("Negative value of Mode {} for mode {}", fMode[m].GeneratorMaping[i], fMode[m].Name);
        throw MaCh3Exception(__FILE__ , __LINE__ );
      }
      if(ModeMap[fMode[m].GeneratorMaping[i]] != Mode["UNKNOWN_BAD"])
      {
        MACH3LOG_ERROR("Generator mode {} already defined in mode {} can't do this for mode {}", fMode[m].GeneratorMaping[i], fMode[ModeMap[fMode[m].GeneratorMaping[i]]].Name, fMode[m].Name);
        throw MaCh3Exception(__FILE__ , __LINE__ );
      }
      ModeMap[fMode[m].GeneratorMaping[i]] = m;
    }
  }
}
 
// *******************
std::string MaCh3Modes::GetMaCh3ModeName(const int Index) const {
// *******************
  if(Index < 0)
    MACH3LOG_CRITICAL("Mode you look for is smaller than 0 and equal to {}", Index);
 
  // return UNKNOWN_BAD if out of boundary
  if(Index > NModes)
  {
    MACH3LOG_DEBUG("Asking for mode {}, while I only have {}, returning {} mode", Index, NModes, fMode.at(NModes).Name);
    return fMode.at(NModes).Name;
  }
  return fMode.at(Index).Name;
}
 
// *******************
bool MaCh3Modes::IsMaCh3ModeNC(const int Index) const {
// *******************
  if(Index < 0)
    MACH3LOG_CRITICAL("Mode you look for is smaller than 0 and equal to {}", Index);
  
  // return UNKNOWN_BAD if out of boundary
  if(Index > NModes)
  {
    MACH3LOG_DEBUG("Asking for mode {}, while I only have {}, returning {} mode", Index, NModes, fMode.at(NModes).Name);
    return fMode.at(NModes).IsNC;
  }
  return fMode.at(Index).IsNC;
}
 
// *******************
std::string MaCh3Modes::GetMaCh3ModeFancyName(const int Index) const {
// *******************
  // return UNKNOWN_BAD if out of boundary
  if(Index < 0)
    MACH3LOG_CRITICAL("Mode you look for is smaller than 0 and equal to {}", Index);
 
  if(Index > NModes)
  {
    MACH3LOG_DEBUG("Asking for mode {}, while I only have {}, returning {} mode", Index, NModes, fMode.at(NModes).Name);
    return fMode.at(NModes).FancyName;
  }
  return fMode.at(Index).FancyName;
}
 
// *******************
MaCh3Modes_t MaCh3Modes::GetMode(const std::string& name) const {
// *******************
  if (Mode.count(name)) {
    return Mode.at(name);
  }
  MACH3LOG_DEBUG("Asking for mode {}, while I only have {}, returning {} mode", name, NModes, fMode.at(NModes).Name);
 
  // return UNKNOWN_BAD
  return NModes;
}
 
// *******************
MaCh3Modes_t MaCh3Modes::GetModeFromGenerator(const int Index) const {
// *******************
  if(Index < 0)
    MACH3LOG_CRITICAL("Mode you look for is smaller than 0 and equal to {}", Index);
 
  if(Index >= static_cast<int>(ModeMap.size()))
  {
    MACH3LOG_DEBUG("Asking for mode {}, while I only have {}, returning {} mode", Index, NModes, fMode.at(NModes).Name);
    return NModes;
  }
 
  return ModeMap[Index];
}
 
// *******************
int MaCh3Modes::GetMaCh3ModePlotColor(const int Index) const {
// *******************
  // return UNKNOWN_BAD if out of boundary
  if(Index < 0)
    MACH3LOG_CRITICAL("Mode you look for is smaller than 0 and equal to {}", Index);
 
  if(Index > NModes)
  {
    MACH3LOG_DEBUG("Asking for mode {}, while I only have {}, returning {} mode", Index, NModes, fMode.at(NModes).PlotColor);
    return fMode.at(NModes).PlotColor;
  }
  return fMode.at(Index).PlotColor;
}
 
// *******************
std::string MaCh3Modes::GetSplineSuffixFromMaCh3Mode(const int Index) {
  // *******************
  // return UNKNOWN_BAD if out of boundary
  if(Index < 0)
    MACH3LOG_CRITICAL("Mode you look for is smaller than 0 and equal to {}", Index);
 
  if(Index > NModes) {
    MACH3LOG_DEBUG("Asking for mode {}, while I only have {}, returning {} mode", Index, NModes, fMode[NModes].SplineSuffix);
    return fMode[NModes].SplineSuffix;
  }
 
  return fMode[Index].SplineSuffix;
}