JsonConfigManager.cpp

Go to the documentation of this file.

/** \file JsonConfigManager.cpp
 * \brief JSON configuration loader for PETSc options and meshsets
 */
 
#include <iomanip>
 
#if BOOST_VERSION < 107500
#error "JsonConfigManager requires Boost 1.75 or newer"
#endif
 
namespace MoFEM {
 
const std::string &JsonConfigManager::supportedVersion() {
  static const std::string version =
      std::to_string(MoFEM_VERSION_MAJOR) + "." +
      std::to_string(MoFEM_VERSION_MINOR);
  return version;
}
 
namespace {
 
using JsonArray = boost::json::array;
using JsonObject = boost::json::object;
using JsonValue = boost::json::value;
 
struct ParsedMeshEntry {
  std::string key;
  std::string type;
  std::string fileName;
};
 
constexpr int MAX_MESHSET_ATTRIBUTES = 10;
 
MoFEMErrorCode collectMeshes(const JsonObject &root_object,
                             const std::string &file_name,
                             std::vector<ParsedMeshEntry> &meshes,
                             bool *has_meshsets = nullptr);
 
std::string toStdString(const boost::json::string &value) {
  return std::string(value.data(), value.size());
}
 
std::string toLowerCopy(std::string value) {
  std::transform(value.begin(), value.end(), value.begin(),
                 [](unsigned char c) { return std::tolower(c); });
  return value;
}
 
std::string makeContext(const std::string &parent, const std::string &child) {
  if (parent.empty())
    return child;
  return parent + "." + child;
}
 
std::string jsonTypeName(const JsonValue &value) {
  if (value.is_null())
    return "null";
  if (value.is_object())
    return "object";
  if (value.is_array())
    return "array";
  if (value.is_string())
    return "string";
  if (value.is_bool())
    return "boolean";
  if (value.is_int64() || value.is_uint64())
    return "integer";
  if (value.is_double())
    return "number";
  return "unknown";
}
 
MoFEMErrorCode failConfig(const std::string &file_name,
                         const std::string &context,
                         const std::string &message) {
  MoFEMFunctionBeginHot;
  std::ostringstream oss;
  if (!file_name.empty())
    oss << file_name;
  if (!context.empty()) {
    if (!file_name.empty())
      oss << ": ";
    oss << context;
  }
  if (!message.empty()) {
    if (!file_name.empty() || !context.empty())
      oss << ": ";
    oss << message;
  }
  SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "%s", oss.str().c_str());
  MoFEMFunctionReturnHot(0);
}
 
const JsonObject &requireObject(const JsonValue &value,
                                const std::string &file_name,
                                const std::string &context) {
  if (!value.is_object()) {
    CHKERRABORT(PETSC_COMM_SELF,
                failConfig(file_name, context,
                           "expected object, got " + jsonTypeName(value)));
  }
  return value.as_object();
}
 
const JsonArray &requireArray(const JsonValue &value, const std::string &file_name,
                              const std::string &context) {
  if (!value.is_array()) {
    CHKERRABORT(PETSC_COMM_SELF,
                failConfig(file_name, context,
                           "expected array, got " + jsonTypeName(value)));
  }
  return value.as_array();
}
 
std::string requireString(const JsonValue &value, const std::string &file_name,
                          const std::string &context) {
  if (!value.is_string()) {
    CHKERRABORT(PETSC_COMM_SELF,
                failConfig(file_name, context,
                           "expected string, got " + jsonTypeName(value)));
  }
  return toStdString(value.as_string());
}
 
double requireNumber(const JsonValue &value, const std::string &file_name,
                     const std::string &context) {
  if (value.is_double())
    return value.as_double();
  if (value.is_int64())
    return static_cast<double>(value.as_int64());
  if (value.is_uint64())
    return static_cast<double>(value.as_uint64());
  CHKERRABORT(PETSC_COMM_SELF,
              failConfig(file_name, context,
                         "expected number, got " + jsonTypeName(value)));
  return 0;
}
 
int requireInt(const JsonValue &value, const std::string &file_name,
               const std::string &context) {
  if (value.is_int64()) {
    const auto val = value.as_int64();
    if (val < std::numeric_limits<int>::min() ||
        val > std::numeric_limits<int>::max()) {
      CHKERRABORT(
          PETSC_COMM_SELF,
          failConfig(file_name, context, "integer value out of int range"));
    }
    return static_cast<int>(val);
  }
  if (value.is_uint64()) {
    const auto val = value.as_uint64();
    if (val > static_cast<std::uint64_t>(std::numeric_limits<int>::max())) {
      CHKERRABORT(
          PETSC_COMM_SELF,
          failConfig(file_name, context, "integer value out of int range"));
    }
    return static_cast<int>(val);
  }
  CHKERRABORT(PETSC_COMM_SELF,
              failConfig(file_name, context,
                         "expected integer, got " + jsonTypeName(value)));
  return 0;
}
 
MoFEMErrorCode ensureBlocksetExists(MeshsetsManager &meshsets_manager, int id,
                                    const std::string &file_name,
                                    const std::string &context) {
  MoFEMFunctionBegin;
  if (!meshsets_manager.checkMeshset(id, BLOCKSET)) {
    std::ostringstream oss;
    oss << "target BLOCKSET id " << id << " does not exist";
    CHKERR failConfig(file_name, context, oss.str());
  }
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode discardResolvedBlocksetConfiguration(
    MeshsetsManager &meshsets_manager, const std::string &config_file,
    const std::set<int> &used_blockset_ids) {
  MoFEMFunctionBegin;
 
  std::vector<EntityHandle> handled_meshsets;
  std::vector<int> blockset_ids;
  std::vector<std::pair<int, std::string>> unused_blocksets;
 
  for (auto it = meshsets_manager.getBegin(); it != meshsets_manager.getEnd();
       ++it) {
    if ((it->getBcType() & CubitBCType(BLOCKSET)).none()) {
      continue;
    }
 
    const auto meshset = it->getMeshset();
    if (std::find(handled_meshsets.begin(), handled_meshsets.end(), meshset) !=
        handled_meshsets.end()) {
      continue;
    }
    handled_meshsets.push_back(meshset);
 
    const auto meshset_id = it->getMeshsetId();
    blockset_ids.push_back(meshset_id);
    const bool is_used = used_blockset_ids.count(it->getMeshsetId()) != 0;
    if (!is_used) {
      unused_blocksets.emplace_back(meshset_id, it->getName());
    }
  }
 
  for (const auto meshset_id : blockset_ids) {
    if (used_blockset_ids.count(meshset_id) == 0) {
      CHKERR meshsets_manager.setName(BLOCKSET, meshset_id, "");
    }
    CHKERR meshsets_manager.setAttributes(BLOCKSET, meshset_id, {});
  }
 
  if (!unused_blocksets.empty()) {
    std::ostringstream oss;
    oss << config_file
        << ": removing imported names/attributes from unused BLOCKSET meshsets:";
    for (const auto &entry : unused_blocksets) {
      oss << " [id=" << entry.first;
      if (!entry.second.empty()) {
        oss << ", name='" << entry.second << "'";
      }
      oss << "]";
    }
    MOFEM_LOG("WORLD", Sev::warning) << oss.str();
  }
 
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode clearPetscParamFileOptionsForJson(const std::string &config_file) {
  MoFEMFunctionBegin;
 
  char **argv = PETSC_NULLPTR;
  CHKERR PetscGetArguments(&argv);
 
  bool has_param_file_arg = false;
  std::vector<char *> filtered_argv;
  for (PetscInt i = 0; argv && argv[i]; ++i) {
    if (std::strcmp(argv[i], "-param_file") == 0) {
      has_param_file_arg = true;
      if (argv[i + 1])
        ++i;
      continue;
    }
    if (std::strcmp(argv[i], "-json_config") == 0) {
      if (argv[i + 1])
        ++i;
      continue;
    }
    filtered_argv.push_back(argv[i]);
  }
 
  const auto &petsc_options_file = Core::getPetscOptionsFile();
  if (has_param_file_arg) {
    MOFEM_LOG("WORLD", Sev::warning)
        << config_file
        << ": JSON config active, ignoring PETSc options loaded from -param_file";
  } else if (!petsc_options_file.empty()) {
    MOFEM_LOG("WORLD", Sev::warning)
        << config_file << ": JSON config active, ignoring PETSc options loaded "
        << "from default PETSc options file '" << petsc_options_file << "'";
  }
 
  CHKERR PetscOptionsClear(PETSC_NULLPTR);
  CHKERR PetscOptionsInsertArgs(PETSC_NULLPTR,
                                static_cast<int>(filtered_argv.size()),
                                filtered_argv.empty() ? PETSC_NULLPTR
                                                      : filtered_argv.data());
  MoFEMFunctionReturn(0);
}
 
std::string petscScalarToString(const JsonValue &value,
                                const std::string &file_name,
                                const std::string &context) {
  if (value.is_string())
    return toStdString(value.as_string());
  if (value.is_bool())
    return value.as_bool() ? "true" : "false";
  if (value.is_int64())
    return boost::lexical_cast<std::string>(value.as_int64());
  if (value.is_uint64())
    return boost::lexical_cast<std::string>(value.as_uint64());
  if (value.is_double()) {
    std::ostringstream oss;
    oss << std::setprecision(std::numeric_limits<double>::max_digits10)
        << value.as_double();
    return oss.str();
  }
  CHKERRABORT(PETSC_COMM_SELF,
              failConfig(file_name, context,
                         "PETSc option value must be scalar"));
  return "";
}
 
MoFEMErrorCode setPetscOptionIfUnset(const std::string &option_name,
                                     const char *option_value) {
  MoFEMFunctionBegin;
  PetscBool has_option = PETSC_FALSE;
  CHKERR PetscOptionsHasName(PETSC_NULLPTR, PETSC_NULLPTR, option_name.c_str(),
                             &has_option);
  if (!has_option)
    CHKERR PetscOptionsSetValue(PETSC_NULLPTR, option_name.c_str(),
                                option_value);
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode setPetscOptionIfUnset(const std::string &option_name,
                                     const std::string &option_value) {
  MoFEMFunctionBegin;
  CHKERR setPetscOptionIfUnset(option_name, option_value.c_str());
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode flattenPetscObject(const JsonObject &obj,
                                  const std::string &prefix,
                                  const std::string &file_name,
                                  const std::string &context,
                                  std::map<std::string, std::string>
                                      &seen_option_contexts) {
  MoFEMFunctionBegin;
  for (const auto &item : obj) {
    const auto key = toStdString(item.key());
    const auto item_context = makeContext(context, key);
    const auto option_name =
        prefix.empty() ? "-" + key : prefix + "_" + key;
 
    if (item.value().is_object()) {
      CHKERR flattenPetscObject(item.value().as_object(), option_name, file_name,
                                item_context, seen_option_contexts);
      continue;
    }
 
    if (item.value().is_array() || item.value().is_null()) {
      CHKERR failConfig(file_name, item_context,
                        "PETSc option value must be scalar or object");
    }
 
    if (const auto seen_it = seen_option_contexts.find(option_name);
        seen_it != seen_option_contexts.end()) {
      MOFEM_LOG("WORLD", Sev::warning)
          << file_name << ": duplicate PETSc option '" << option_name
          << "' in JSON config; keeping first value from "
          << seen_it->second << " and ignoring duplicate from " << item_context;
      continue;
    }
 
    seen_option_contexts.emplace(option_name, item_context);
 
    if (item.value().is_bool()) {
      if (item.value().as_bool()) {
        CHKERR setPetscOptionIfUnset(option_name, PETSC_NULLPTR);
      } else {
        CHKERR setPetscOptionIfUnset(option_name, "false");
      }
      continue;
    }
 
    CHKERR setPetscOptionIfUnset(
        option_name, petscScalarToString(item.value(), file_name, item_context));
  }
  MoFEMFunctionReturn(0);
}
 
// Per-executable program selection for shared JSON config files.
#include "JsonConfigManagerPrograms.cpp"
 
// Mesh-type parsing and validation are split out so new mesh sources can be
// added without growing this core manager file.
#include "JsonConfigManagerMeshes.cpp"
 
// JSON meshsets are generic BLOCKSET assignments. Type-specific Cubit
// material/BC data structures stay outside the JSON config layer.
#include "JsonConfigManagerMeshsets.cpp"
 
} // namespace
 
MoFEMErrorCode
JsonConfigManager::query_interface(boost::typeindex::type_index type_index,
                                   UnknownInterface **iface) const {
  *iface = const_cast<JsonConfigManager *>(this);
  return 0;
}
 
JsonConfigManager::JsonConfigManager(const MoFEM::Core &core)
    : cOre(const_cast<Core &>(core)) {}
 
MoFEMErrorCode JsonConfigManager::getSubInterfaceOptions() {
  return loadFromCommandLine();
}
 
MoFEMErrorCode JsonConfigManager::loadFromFile(const std::string &file_name) {
  MoFEMFunctionBegin;
 
  std::ifstream input(file_name.c_str(), std::ifstream::in);
  if (!input.good()) {
    CHKERR failConfig(file_name, "", "unable to open JSON config file");
  }
 
  std::ostringstream buffer;
  buffer << input.rdbuf();
 
  boost::system::error_code ec;
  auto root = boost::json::parse(buffer.str(), ec);
  if (ec) {
    CHKERR failConfig(file_name, "", "invalid JSON: " + ec.message());
  }
 
  const auto &root_object = requireObject(root, file_name, "root");
  boost::json::value selected_config;
  CHKERR selectProgramConfig(root_object, file_name, selected_config);
  const auto &config_object = requireObject(selected_config, file_name, "root");
 
  bool has_version = false;
  for (const auto &item : config_object) {
    const auto key = toStdString(item.key());
    if (key == "$schema")
      continue;
    if (key == "version") {
      has_version = true;
      const auto version =
          requireString(item.value(), file_name, makeContext("root", key));
      if (version != supportedVersion()) {
        CHKERR failConfig(file_name, makeContext("root", key),
                          "unsupported config version '" + version +
                              "', supported version is '" + supportedVersion() +
                              "'");
      }
      continue;
    }
    if (key == "petsc") {
      requireObject(item.value(), file_name, makeContext("root", key));
      continue;
    }
    if (key == "mofem") {
      requireObject(item.value(), file_name, makeContext("root", key));
      continue;
    }
    if (key == "meshes" || key == "input_files") {
      requireArray(item.value(), file_name, makeContext("root", key));
      continue;
    }
    if (key == "file_name") {
      CHKERR failConfig(
          file_name, makeContext("root", key),
          "legacy root-level file_name is not supported; use "
          "root.input_files[0].file_name or root.meshes[0].file_name");
    }
    if (key == "meshsets") {
      CHKERR failConfig(
          file_name, makeContext("root", key),
          "legacy root-level meshsets is not supported; use "
          "root.input_files[i].meshsets or root.meshes[i].meshsets");
    }
    CHKERR failConfig(file_name, makeContext("root", key),
                      "unknown top-level key");
  }
  if (!has_version) {
    CHKERR failConfig(file_name, "root.version",
                      "missing required version field");
  }
  hasMeshsets = false;
 
  std::vector<ParsedMeshEntry> new_meshes;
  bool config_has_meshsets = false;
  CHKERR collectMeshes(config_object, file_name, new_meshes,
                       &config_has_meshsets);
 
  configRoot = std::move(selected_config);
  configFileName = file_name;
  configLoaded = true;
  moabMeshesByKey.clear();
  pythonScriptsByKey.clear();
  for (const auto &entry : new_meshes) {
    if (entry.type == MOAB_MESH_TYPE && !entry.key.empty()) {
      moabMeshesByKey[entry.key] = entry.fileName;
    }
    if (isPythonScriptMeshType(entry.type)) {
      pythonScriptsByKey[entry.key] = entry.fileName;
    }
  }
  hasMeshsets = config_has_meshsets;
  meshsetsApplied = false;
  primaryMeshsetParamsByKey.clear();
 
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode JsonConfigManager::applyPetscOptions() {
  MoFEMFunctionBegin;
  if (configLoaded) {
    const auto &root_object = configRoot.as_object();
    std::map<std::string, std::string> seen_option_contexts;
    const char *section_key = nullptr;
    if (const auto *meshes_array =
            getMeshesArray(root_object, configFileName, &section_key);
        meshes_array && !meshes_array->empty()) {
      const auto primary_mesh_context = meshContext(0, section_key);
      const auto &primary_mesh = requireObject((*meshes_array)[0], configFileName,
                                               primary_mesh_context);
      CHKERR setPetscOptionIfUnset(
          "-file_name",
          requireString(primary_mesh.at("file_name"), configFileName,
                        makeContext(primary_mesh_context, "file_name")));
    }
 
    if (const auto petsc_it = root_object.find("petsc");
        petsc_it != root_object.end()) {
      CHKERR flattenPetscObject(petsc_it->value().as_object(), "",
                                configFileName, "petsc",
                                seen_option_contexts);
    }
    if (const auto mofem_it = root_object.find("mofem");
        mofem_it != root_object.end()) {
      CHKERR flattenPetscObject(mofem_it->value().as_object(), "",
                                configFileName, "mofem",
                                seen_option_contexts);
    }
  }
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode JsonConfigManager::applyMeshsets() {
  MoFEMFunctionBegin;
  if (configLoaded && hasMeshsets && !meshsetsApplied) {
    auto &meshsets_manager = cOre.getInterface<MeshsetsManager &>();
    primaryMeshsetParamsByKey.clear();
    if (const auto *primary_meshsets =
            getMeshsetsArray(configRoot.as_object(), configFileName, 0);
        primary_meshsets && !primary_meshsets->empty()) {
      const char *section_key =
          getMeshSectionKey(configRoot.as_object(), configFileName);
      const auto primary_mesh_context = meshContext(0, section_key);
      std::vector<ParsedMeshsetEntry> parsed_primary_meshsets;
      std::set<int> used_blockset_ids;
      CHKERR parseMeshsets(*primary_meshsets, primary_mesh_context, configFileName,
                           &meshsets_manager, parsed_primary_meshsets);
      CHKERR cacheResolvedBlocksetParams(parsed_primary_meshsets, configFileName,
                                         primaryMeshsetParamsByKey,
                                         used_blockset_ids);
 
      // JSON stays authoritative for block attributes. Imported blockset names
      // are kept only for meshsets that JSON actually refers to.
      CHKERR discardResolvedBlocksetConfiguration(
          meshsets_manager, configFileName, used_blockset_ids);
      CHKERR applyParsedMeshsets(meshsets_manager, parsed_primary_meshsets,
                                 configFileName);
      CHKERR cacheAppliedBlocksetParams(parsed_primary_meshsets, configFileName,
                                        primaryMeshsetParamsByKey);
    }
    const char *section_key = nullptr;
    if (const auto *meshes_array =
            getMeshesArray(configRoot.as_object(), configFileName, &section_key);
        meshes_array) {
      for (size_t mesh_index = 1; mesh_index != meshes_array->size();
           ++mesh_index) {
        if (const auto *meshsets =
                getMeshsetsArray(configRoot.as_object(), configFileName,
                                 mesh_index);
            meshsets && !meshsets->empty()) {
          CHKERR validateMeshsets(*meshsets, meshContext(mesh_index, section_key),
                                  configFileName);
        }
      }
    }
    meshsetsApplied = true;
  }
  MoFEMFunctionReturn(0);
}
 
std::string
JsonConfigManager::getPythonScriptByKey(const std::string &key) const {
  if (const auto it = pythonScriptsByKey.find(key);
      it != pythonScriptsByKey.end()) {
    return it->second;
  }
  return "";
}
 
std::string JsonConfigManager::getMoabMeshByKey(const std::string &key) const {
  if (const auto it = moabMeshesByKey.find(key); it != moabMeshesByKey.end()) {
    return it->second;
  }
  return "";
}
 
std::map<std::string, double>
JsonConfigManager::getParamsFromBlockset(const std::string &type_name,
                                         int meshset_id) const {
  const auto it =
      primaryMeshsetParamsByKey.find({toLowerCopy(type_name), meshset_id});
  if (it != primaryMeshsetParamsByKey.end()) {
    return it->second;
  }
  return {};
}
 
MoFEMErrorCode JsonConfigManager::loadFromCommandLine() {
  MoFEMFunctionBegin;
  if (!configLoaded) {
    char json_file_name[PETSC_MAX_PATH_LEN] = "";
    PetscBool has_json = PETSC_FALSE;
    CHKERR PetscOptionsGetString(PETSC_NULLPTR, PETSC_NULLPTR, "-json_config",
                                 json_file_name, sizeof(json_file_name),
                                 &has_json);
    if (has_json) {
      // IMPORTANT !!!
      // Clear any PETSc options that might have been set by param_file.petsc 
      CHKERR clearPetscParamFileOptionsForJson(json_file_name);
      CHKERR loadFromFile(json_file_name);
 
      if (hasMeshsets) {
        char meshsets_cfg_file[PETSC_MAX_PATH_LEN] = "";
        PetscBool has_meshsets_cfg = PETSC_FALSE;
        CHKERR PetscOptionsGetString(PETSC_NULLPTR, PETSC_NULLPTR,
                                     "-meshsets_config", meshsets_cfg_file,
                                     sizeof(meshsets_cfg_file),
                                     &has_meshsets_cfg);
        if (has_meshsets_cfg) {
          CHKERR failConfig(
              configFileName, "meshsets",
              "JSON meshsets cannot be used together with -meshsets_config");
        }
      }
 
      CHKERR applyPetscOptions();
      // Consume and apply any log_* options injected from JSON after PETSc
      // initialization so they do not remain as "unused database options".
      CHKERR LogManager::getOptions();
    }
  }
  MoFEMFunctionReturn(0);
}
 
} // namespace MoFEM