JsonConfigManagerMeshes.cpp File Reference

Go to the source code of this file.

Functions
bool	isPythonScriptMeshType (const std::string &type)
std::string	meshContext (const size_t mesh_index, const char *section_key=MESHES_KEY)
const char *	getMeshSectionKey (const JsonObject &root_object, const std::string &file_name)
const JsonArray *	getMeshesArray (const JsonObject &root_object, const std::string &file_name, const char **section_key=nullptr)
const JsonArray *	getMeshsetsArray (const JsonObject &root_object, const std::string &file_name, const size_t mesh_index)
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)
MoFEMErrorCode	validateMeshEntry (const ParsedMeshEntry &entry, const std::string &file_name, const std::string &context, const size_t mesh_index)
MoFEMErrorCode	collectMeshes (const JsonObject &root_object, const std::string &file_name, std::vector< ParsedMeshEntry > &meshes, bool *has_meshsets)

Variables
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"

Function Documentation

collectMeshes()

MoFEMErrorCode collectMeshes	(	const JsonObject &	root_object,
		const std::string &	file_name,
		std::vector< ParsedMeshEntry > &	meshes,
		bool *	has_meshsets
	)

Definition at line 133 of file JsonConfigManagerMeshes.cpp.

                                                 {
  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);
}

getMeshesArray()

const JsonArray * getMeshesArray	(	const JsonObject &	root_object,
		const std::string &	file_name,
		const char **	section_key = nullptr
	)

Definition at line 33 of file JsonConfigManagerMeshes.cpp.

                                                                    {
  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));
}

getMeshSectionKey()

const char * getMeshSectionKey	(	const JsonObject &	root_object,
		const std::string &	file_name
	)

Definition at line 16 of file JsonConfigManagerMeshes.cpp.

                                                          {
  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;
}

getMeshsetsArray()

const JsonArray * getMeshsetsArray	(	const JsonObject &	root_object,
		const std::string &	file_name,
		const size_t	mesh_index
	)

Definition at line 47 of file JsonConfigManagerMeshes.cpp.

                                                           {
  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;
}

isPythonScriptMeshType()

bool isPythonScriptMeshType

(

const std::string &

type

)

Definition at line 6 of file JsonConfigManagerMeshes.cpp.

                                                   {
  return type == PYTHON_SCRIPT_TYPE;
}

meshContext()

std::string meshContext	(	const size_t	mesh_index,
		const char *	section_key = MESHES_KEY
	)

Definition at line 10 of file JsonConfigManagerMeshes.cpp.

                                                              {
  return "root." + std::string(section_key) + "[" +
         boost::lexical_cast<std::string>(mesh_index) + "]";
}

parseMeshEntryField()

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
	)

Definition at line 74 of file JsonConfigManagerMeshes.cpp.

                                                                 {
  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);
}

validateMeshEntry()

MoFEMErrorCode validateMeshEntry	(	const ParsedMeshEntry &	entry,
		const std::string &	file_name,
		const std::string &	context,
		const size_t	mesh_index
	)

Definition at line 99 of file JsonConfigManagerMeshes.cpp.

                                                          {
  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);
}

Variable Documentation

INPUT_FILES_KEY

constexpr auto INPUT_FILES_KEY = "input_files"

constexpr

Definition at line 4 of file JsonConfigManagerMeshes.cpp.

MESHES_KEY

constexpr auto MESHES_KEY = "meshes"

constexpr

Definition at line 3 of file JsonConfigManagerMeshes.cpp.

MOAB_MESH_TYPE

constexpr auto MOAB_MESH_TYPE = "MOAB_MESH"

constexpr

Definition at line 1 of file JsonConfigManagerMeshes.cpp.

PYTHON_SCRIPT_TYPE

constexpr auto PYTHON_SCRIPT_TYPE = "PYTHON_SCRIPT"

constexpr

Definition at line 2 of file JsonConfigManagerMeshes.cpp.