#include "src/interfaces/JsonConfigManager.hpp"

Inheritance diagram for MoFEM::JsonConfigManager:

Collaboration diagram for MoFEM::JsonConfigManager:

Public Member Functions
MoFEMErrorCode	query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const

	JsonConfigManager (const MoFEM::Core &core)

virtual	~JsonConfigManager ()=default

MoFEMErrorCode	getSubInterfaceOptions ()

MoFEMErrorCode	loadFromFile (const std::string &file_name)

MoFEMErrorCode	applyMeshsets ()

std::string	getPythonScriptByKey (const std::string &key) const

std::string	getMoabMeshByKey (const std::string &key) const

std::map< std::string, double >	getParamsFromBlockset (const std::string &type_name, int meshset_id) const

bool	hasMeshsetsSection () const

Public Member Functions inherited from MoFEM::UnknownInterface
template<class IFACE >
MoFEMErrorCode	registerInterface (bool error_if_registration_failed=true)
	Register interface.

template<class IFACE >
MoFEMErrorCode	getInterface (IFACE *&iface) const
	Get interface reference to pointer of interface.

template<class IFACE >
MoFEMErrorCode	getInterface (IFACE **const iface) const
	Get interface pointer to pointer of interface.

template<class IFACE , typename boost::enable_if< boost::is_pointer< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get interface pointer to pointer of interface.

template<class IFACE , typename boost::enable_if< boost::is_reference< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get reference to interface.

template<class IFACE >
IFACE *	getInterface () const
	Function returning pointer to interface.

virtual	~UnknownInterface ()=default

Static Public Member Functions
static const std::string &	supportedVersion ()

Static Public Member Functions inherited from MoFEM::UnknownInterface
static MoFEMErrorCode	getLibVersion (Version &version)
	Get library version.

static MoFEMErrorCode	getFileVersion (moab::Interface &moab, Version &version)
	Get database major version.

static MoFEMErrorCode	setFileVersion (moab::Interface &moab, Version version=Version(MoFEM_VERSION_MAJOR, MoFEM_VERSION_MINOR, MoFEM_VERSION_BUILD))
	Get database major version.

static MoFEMErrorCode	getInterfaceVersion (Version &version)
	Get database major version.

Private Types
using	MeshsetKey = std::pair< std::string, int >

using	MeshsetParams = std::map< std::string, double >

Private Member Functions
MoFEMErrorCode	loadFromCommandLine ()

MoFEMErrorCode	applyPetscOptions ()

Private Attributes
MoFEM::Core &	cOre

boost::json::value	configRoot

std::string	configFileName

bool	configLoaded = false

bool	hasMeshsets = false

bool	meshsetsApplied = false

std::map< std::string, std::string >	moabMeshesByKey

std::map< std::string, std::string >	pythonScriptsByKey

std::map< MeshsetKey, MeshsetParams >	primaryMeshsetParamsByKey

Detailed Description

Definition at line 10 of file JsonConfigManager.hpp.

Member Typedef Documentation

◆ MeshsetKey

using MoFEM::JsonConfigManager::MeshsetKey = std::pair<std::string, int>

private

Definition at line 32 of file JsonConfigManager.hpp.

◆ MeshsetParams

using MoFEM::JsonConfigManager::MeshsetParams = std::map<std::string, double>

private

Definition at line 33 of file JsonConfigManager.hpp.

Constructor & Destructor Documentation

◆ JsonConfigManager()

MoFEM::JsonConfigManager::JsonConfigManager ( const MoFEM::Core & core )

Definition at line 386 of file JsonConfigManager.cpp.

387 : cOre(const_cast<Core &>(core)) {}

MoFEM::Core

CoreTmp< 0 > Core

Definition Core.hpp:1154

MoFEM::JsonConfigManager::cOre

MoFEM::Core & cOre

Definition JsonConfigManager.hpp:35

◆ ~JsonConfigManager()

virtual MoFEM::JsonConfigManager::~JsonConfigManager ( )

virtualdefault

Member Function Documentation

◆ applyMeshsets()

MoFEMErrorCode MoFEM::JsonConfigManager::applyMeshsets ( )

Definition at line 524 of file JsonConfigManager.cpp.

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

◆ applyPetscOptions()

MoFEMErrorCode MoFEM::JsonConfigManager::applyPetscOptions ( )

private

Definition at line 490 of file JsonConfigManager.cpp.

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

◆ getMoabMeshByKey()

std::string MoFEM::JsonConfigManager::getMoabMeshByKey ( const std::string & key ) const

Definition at line 581 of file JsonConfigManager.cpp.

                                                                        {
  if (const auto it = moabMeshesByKey.find(key); it != moabMeshesByKey.end()) {
    return it->second;
  }
  return "";
}

◆ getParamsFromBlockset()

std::map< std::string, double > MoFEM::JsonConfigManager::getParamsFromBlockset	(	const std::string &	type_name,
		int	meshset_id
	)		const

Definition at line 589 of file JsonConfigManager.cpp.

                                                               {
  const auto it =
      primaryMeshsetParamsByKey.find({toLowerCopy(type_name), meshset_id});
  if (it != primaryMeshsetParamsByKey.end()) {
    return it->second;
  }
  return {};
}

◆ getPythonScriptByKey()

std::string MoFEM::JsonConfigManager::getPythonScriptByKey ( const std::string & key ) const

Definition at line 573 of file JsonConfigManager.cpp.

                                                                  {
  if (const auto it = pythonScriptsByKey.find(key);
      it != pythonScriptsByKey.end()) {
    return it->second;
  }
  return "";
}

◆ getSubInterfaceOptions()

MoFEMErrorCode MoFEM::JsonConfigManager::getSubInterfaceOptions ( )

Definition at line 389 of file JsonConfigManager.cpp.

                                                         {
  return loadFromCommandLine();
}

◆ hasMeshsetsSection()

bool MoFEM::JsonConfigManager::hasMeshsetsSection ( ) const

inline

Definition at line 29 of file JsonConfigManager.hpp.

29{ return hasMeshsets; }

◆ loadFromCommandLine()

MoFEMErrorCode MoFEM::JsonConfigManager::loadFromCommandLine ( )

private

Definition at line 599 of file JsonConfigManager.cpp.

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

◆ loadFromFile()

MoFEMErrorCode MoFEM::JsonConfigManager::loadFromFile ( const std::string & file_name )

Definition at line 393 of file JsonConfigManager.cpp.

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

◆ query_interface()

MoFEMErrorCode MoFEM::JsonConfigManager::query_interface	(	boost::typeindex::type_index	type_index,
		UnknownInterface **	iface
	)		const

virtual

Implements MoFEM::UnknownInterface.

Definition at line 380 of file JsonConfigManager.cpp.

                                                                   {
  *iface = const_cast<JsonConfigManager *>(this);
  return 0;
}

◆ supportedVersion()

const std::string & MoFEM::JsonConfigManager::supportedVersion ( )

static

Definition at line 13 of file JsonConfigManager.cpp.

                                                     {
  static const std::string version =
      std::to_string(MoFEM_VERSION_MAJOR) + "." +
      std::to_string(MoFEM_VERSION_MINOR);
  return version;
}

Member Data Documentation

◆ configFileName

std::string MoFEM::JsonConfigManager::configFileName

private

Definition at line 37 of file JsonConfigManager.hpp.

◆ configLoaded

bool MoFEM::JsonConfigManager::configLoaded = false

private

Definition at line 38 of file JsonConfigManager.hpp.

◆ configRoot

boost::json::value MoFEM::JsonConfigManager::configRoot

private

Definition at line 36 of file JsonConfigManager.hpp.

◆ cOre

MoFEM::Core& MoFEM::JsonConfigManager::cOre

private

Definition at line 35 of file JsonConfigManager.hpp.

◆ hasMeshsets

bool MoFEM::JsonConfigManager::hasMeshsets = false

private

Definition at line 39 of file JsonConfigManager.hpp.

◆ meshsetsApplied

bool MoFEM::JsonConfigManager::meshsetsApplied = false

private

Definition at line 40 of file JsonConfigManager.hpp.

◆ moabMeshesByKey

std::map<std::string, std::string> MoFEM::JsonConfigManager::moabMeshesByKey

private

Definition at line 41 of file JsonConfigManager.hpp.

◆ primaryMeshsetParamsByKey

std::map<MeshsetKey, MeshsetParams> MoFEM::JsonConfigManager::primaryMeshsetParamsByKey

private

Definition at line 43 of file JsonConfigManager.hpp.

◆ pythonScriptsByKey

std::map<std::string, std::string> MoFEM::JsonConfigManager::pythonScriptsByKey

private

Definition at line 42 of file JsonConfigManager.hpp.

The documentation for this struct was generated from the following files:

src/interfaces/JsonConfigManager.hpp
src/interfaces/impl/JsonConfigManager.cpp

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ MeshsetKey

◆ MeshsetParams

Constructor & Destructor Documentation

◆ JsonConfigManager()

◆ ~JsonConfigManager()

Member Function Documentation

◆ applyMeshsets()

◆ applyPetscOptions()

◆ getMoabMeshByKey()

◆ getParamsFromBlockset()

◆ getPythonScriptByKey()

◆ getSubInterfaceOptions()

◆ hasMeshsetsSection()

◆ loadFromCommandLine()

◆ loadFromFile()

◆ query_interface()

◆ supportedVersion()

Member Data Documentation

◆ configFileName

◆ configLoaded

◆ configRoot

◆ cOre

◆ hasMeshsets

◆ meshsetsApplied

◆ moabMeshesByKey

◆ primaryMeshsetParamsByKey

◆ pythonScriptsByKey