JsonConfigManagerMeshes.cpp

Go to the documentation of this file.

constexpr auto MOAB_MESH_TYPE = "MOAB_MESH";
constexpr auto PYTHON_SCRIPT_TYPE = "PYTHON_SCRIPT";
constexpr auto MESHES_KEY = "meshes";
constexpr auto INPUT_FILES_KEY = "input_files";
 
bool isPythonScriptMeshType(const std::string &type) {
  return type == PYTHON_SCRIPT_TYPE;
}
 
std::string meshContext(const size_t mesh_index,
                        const char *section_key = MESHES_KEY) {
  return "root." + std::string(section_key) + "[" +
         boost::lexical_cast<std::string>(mesh_index) + "]";
}
 
const char *getMeshSectionKey(const JsonObject &root_object,
                              const std::string &file_name) {
  const auto meshes_it = root_object.find(MESHES_KEY);
  const auto input_files_it = root_object.find(INPUT_FILES_KEY);
  if (meshes_it != root_object.end() && input_files_it != root_object.end()) {
    CHKERRABORT(PETSC_COMM_SELF,
                failConfig(file_name, "root.input_files",
                           "cannot be used together with root.meshes"));
  }
 
  if (meshes_it != root_object.end())
    return MESHES_KEY;
  if (input_files_it != root_object.end())
    return INPUT_FILES_KEY;
  return nullptr;
}
 
const JsonArray *getMeshesArray(const JsonObject &root_object,
                                const std::string &file_name,
                                const char **section_key = nullptr) {
  const auto *selected_key = getMeshSectionKey(root_object, file_name);
  if (section_key)
    *section_key = selected_key;
  if (!selected_key)
    return nullptr;
 
  const auto section_it = root_object.find(selected_key);
  return &requireArray(section_it->value(), file_name,
                       makeContext("root", selected_key));
}
 
const JsonArray *getMeshsetsArray(const JsonObject &root_object,
                                  const std::string &file_name,
                                  const size_t mesh_index) {
  const char *section_key = nullptr;
  const auto *meshes_array =
      getMeshesArray(root_object, file_name, &section_key);
  if (!meshes_array)
    return nullptr;
 
  if (mesh_index >= meshes_array->size()) {
    CHKERRABORT(PETSC_COMM_SELF,
                failConfig(file_name, meshContext(mesh_index, section_key),
                           "mesh index out of range"));
  }
 
  const auto context = meshContext(mesh_index, section_key);
  const auto &mesh_object =
      requireObject((*meshes_array)[mesh_index], file_name, context);
  if (const auto meshsets_it = mesh_object.find("meshsets");
      meshsets_it != mesh_object.end()) {
    return &requireArray(meshsets_it->value(), file_name,
                         makeContext(context, "meshsets"));
  }
 
  return nullptr;
}
 
MoFEMErrorCode parseMeshEntryField(const std::string &field_name,
                                   const JsonValue &value,
                                   const std::string &file_name,
                                   const std::string &context,
                                   ParsedMeshEntry &entry,
                                   bool &has_non_empty_meshsets) {
  MoFEMFunctionBegin;
  if (field_name == "key") {
    entry.key = requireString(value, file_name, makeContext(context, field_name));
  } else if (field_name == "type") {
    entry.type = requireString(value, file_name, makeContext(context, field_name));
  } else if (field_name == "file_name") {
    entry.fileName =
        requireString(value, file_name, makeContext(context, field_name));
  } else if (field_name == "meshsets") {
    const auto &meshsets =
        requireArray(value, file_name, makeContext(context, field_name));
    has_non_empty_meshsets = !meshsets.empty();
  } else {
    CHKERR failConfig(file_name, makeContext(context, field_name),
                      "unknown input file field");
  }
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode validateMeshEntry(const ParsedMeshEntry &entry,
                                 const std::string &file_name,
                                 const std::string &context,
                                 const size_t mesh_index) {
  MoFEMFunctionBegin;
  if (entry.type.empty()) {
    CHKERR failConfig(file_name, makeContext(context, "type"),
                      "missing required mesh type");
  }
  if (entry.fileName.empty()) {
    CHKERR failConfig(file_name, makeContext(context, "file_name"),
                      "missing required file_name");
  }
 
  if (entry.type != MOAB_MESH_TYPE && !isPythonScriptMeshType(entry.type)) {
    CHKERR failConfig(file_name, makeContext(context, "type"),
                      "unsupported mesh type '" + entry.type + "'");
  }
 
  if (mesh_index == 0 && entry.type != MOAB_MESH_TYPE) {
    CHKERR failConfig(file_name, makeContext(context, "type"),
                      "primary runtime mesh must be " +
                          std::string(MOAB_MESH_TYPE));
  }
 
  if (isPythonScriptMeshType(entry.type) && entry.key.empty()) {
    CHKERR failConfig(file_name, makeContext(context, "key"),
                      std::string(PYTHON_SCRIPT_TYPE) +
                          " requires a unique key");
  }
 
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode collectMeshes(const JsonObject &root_object,
                             const std::string &file_name,
                             std::vector<ParsedMeshEntry> &meshes,
                             bool *has_meshsets) {
  MoFEMFunctionBegin;
  meshes.clear();
  if (has_meshsets)
    *has_meshsets = false;
 
  const char *section_key = nullptr;
  if (const auto *meshes_array =
          getMeshesArray(root_object, file_name, &section_key);
      meshes_array) {
    meshes.reserve(meshes_array->size());
    for (size_t i = 0; i != meshes_array->size(); ++i) {
      const auto context = meshContext(i, section_key);
      const auto &mesh_object =
          requireObject((*meshes_array)[i], file_name, context);
 
      ParsedMeshEntry entry;
      bool has_non_empty_meshsets = false;
      for (const auto &item : mesh_object) {
        CHKERR parseMeshEntryField(toStdString(item.key()), item.value(),
                                   file_name, context, entry,
                                   has_non_empty_meshsets);
      }
 
      CHKERR validateMeshEntry(entry, file_name, context, i);
      if (has_meshsets && has_non_empty_meshsets) {
        *has_meshsets = true;
      }
      meshes.push_back(std::move(entry));
    }
  }
 
  std::set<std::string> moab_mesh_keys;
  std::set<std::string> python_script_keys;
  for (const auto &entry : meshes) {
    if (entry.type == MOAB_MESH_TYPE) {
      if (entry.key.empty()) {
        continue;
      }
      const auto inserted = moab_mesh_keys.insert(entry.key);
      if (!inserted.second) {
        CHKERR failConfig(file_name, makeContext("root", section_key),
                          "duplicate " + std::string(MOAB_MESH_TYPE) +
                              " key '" + entry.key + "'");
      }
      continue;
    }
    if (isPythonScriptMeshType(entry.type)) {
      const auto inserted = python_script_keys.insert(entry.key);
      if (!inserted.second) {
        CHKERR failConfig(file_name, makeContext("root", section_key),
                          "duplicate " + std::string(PYTHON_SCRIPT_TYPE) +
                              " key '" + entry.key + "'");
      }
    }
  }
 
  MoFEMFunctionReturn(0);
}