#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

std::map< std::string, std::string >	getStringParamsFromBlockset (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 MoFEMErrorCode	addCanonicalAttributeNames (const std::vector< std::string > &names)

static MoFEMErrorCode	setMeshFileFromJson ()
	Set -file_name from JSON before Core is available.

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.

Static Public Attributes
static std::vector< std::string >	canonical_attributes_ordering

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

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

using	MeshsetStringParams = std::map< std::string, std::string >

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

std::map< MeshsetKey, MeshsetStringParams >	primaryMeshsetStringParamsByKey

Detailed Description

Examples: /home/lk58p/mofem_install/vanilla_dev_release/mofem-cephas/mofem/users_modules/eshelbian_plasticity/src/impl/EshelbianPlasticity.cpp.

Definition at line 12 of file JsonConfigManager.hpp.

Member Typedef Documentation

◆ MeshsetKey

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

private

Definition at line 53 of file JsonConfigManager.hpp.

◆ MeshsetParams

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

private

Definition at line 54 of file JsonConfigManager.hpp.

◆ MeshsetStringParams

using MoFEM::JsonConfigManager::MeshsetStringParams = std::map<std::string, std::string>

private

Definition at line 55 of file JsonConfigManager.hpp.

Constructor & Destructor Documentation

◆ JsonConfigManager()

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

Definition at line 448 of file JsonConfigManager.cpp.

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

MoFEM::Core

CoreTmp< 0 > Core

Definition Core.hpp:1154

MoFEM::JsonConfigManager::cOre

MoFEM::Core & cOre

Definition JsonConfigManager.hpp:57

◆ ~JsonConfigManager()

virtual MoFEM::JsonConfigManager::~JsonConfigManager ( )

virtualdefault

Member Function Documentation

◆ addCanonicalAttributeNames()

MoFEMErrorCode MoFEM::JsonConfigManager::addCanonicalAttributeNames ( const std::vector< std::string > & names )

static

Register additional numeric JSON attribute names.

Definition at line 419 of file JsonConfigManager.cpp.

                                       {
  MoFEMFunctionBeginHot;
  for (const auto &name : names) {
    if (name.empty()) {
      continue;
    }
 
    const auto lower_name = toLowerCopy(name);
    const auto it = std::find_if(
        canonical_attributes_ordering.begin(),
        canonical_attributes_ordering.end(), [&](const std::string &existing) {
          return toLowerCopy(existing) == lower_name;
        });
    if (it == canonical_attributes_ordering.end()) {
      canonical_attributes_ordering.push_back(lower_name);
    }
  }
 
  MoFEMFunctionReturnHot(0);
}

◆ applyMeshsets()

MoFEMErrorCode MoFEM::JsonConfigManager::applyMeshsets ( )

Definition at line 607 of file JsonConfigManager.cpp.

                                                {
  MoFEMFunctionBegin;
  if (configLoaded && hasMeshsets && !meshsetsApplied) {
    auto &meshsets_manager = cOre.getInterface<MeshsetsManager &>();
    primaryMeshsetParamsByKey.clear();
    primaryMeshsetStringParamsByKey.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,
                                         primaryMeshsetStringParamsByKey,
                                         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,
                                        primaryMeshsetStringParamsByKey);
    }
    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 573 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 667 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 675 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 659 of file JsonConfigManager.cpp.

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

◆ getStringParamsFromBlockset()

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

Definition at line 686 of file JsonConfigManager.cpp.

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

◆ getSubInterfaceOptions()

MoFEMErrorCode MoFEM::JsonConfigManager::getSubInterfaceOptions ( )

Definition at line 486 of file JsonConfigManager.cpp.

                                                         {
  return loadFromCommandLine();
}

◆ hasMeshsetsSection()

bool MoFEM::JsonConfigManager::hasMeshsetsSection ( ) const

inline

Definition at line 50 of file JsonConfigManager.hpp.

50{ return hasMeshsets; }

◆ loadFromCommandLine()

MoFEMErrorCode MoFEM::JsonConfigManager::loadFromCommandLine ( )

private

Definition at line 696 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 490 of file JsonConfigManager.cpp.

                                                                         {
  MoFEMFunctionBegin;
 
  boost::json::value selected_config;
  CHKERR loadSelectedConfigFromFile(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();
  primaryMeshsetStringParamsByKey.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 442 of file JsonConfigManager.cpp.

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

◆ setMeshFileFromJson()

MoFEMErrorCode MoFEM::JsonConfigManager::setMeshFileFromJson ( )

static

Set -file_name from JSON before Core is available.

Use only in programs that must read the mesh before MoFEM::Core and the JsonConfigManager interface are initialised.

Definition at line 451 of file JsonConfigManager.cpp.

                                                      {
  MoFEMFunctionBegin;
 
  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 || !std::strlen(json_file_name)) {
    MoFEMFunctionReturnHot(0);
  }
 
  bool has_file_name_arg = false;
  bool has_my_file_arg = false;
  CHKERR hasCommandLineOption("-file_name", has_file_name_arg);
  CHKERR hasCommandLineOption("-my_file", has_my_file_arg);
  if (has_file_name_arg || has_my_file_arg) {
    MoFEMFunctionReturnHot(0);
  }
 
  boost::json::value selected_config;
  CHKERR loadSelectedConfigFromFile(json_file_name, selected_config);
  const auto &config_object =
      requireObject(selected_config, json_file_name, "root");
 
  std::vector<ParsedMeshEntry> meshes;
  CHKERR collectMeshes(config_object, json_file_name, meshes);
  if (!meshes.empty()) {
    CHKERR PetscOptionsSetValue(PETSC_NULLPTR, "-file_name",
                                meshes.front().fileName.c_str());
  }
 
  MoFEMFunctionReturn(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

◆ canonical_attributes_ordering

std::vector<std::string> MoFEM::JsonConfigManager::canonical_attributes_ordering

inlinestatic

Initial value:

=

getDefaultJsonCanonicalAttributeNames()

MoFEM::getDefaultJsonCanonicalAttributeNames

std::vector< std::string > getDefaultJsonCanonicalAttributeNames()

Definition JsonConfigManagerCanonicalAttributes.hpp:13

Definition at line 14 of file JsonConfigManager.hpp.

◆ configFileName

std::string MoFEM::JsonConfigManager::configFileName

private

Definition at line 59 of file JsonConfigManager.hpp.

◆ configLoaded

bool MoFEM::JsonConfigManager::configLoaded = false

private

Definition at line 60 of file JsonConfigManager.hpp.

◆ configRoot

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

private

Definition at line 58 of file JsonConfigManager.hpp.

◆ cOre

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

private

Definition at line 57 of file JsonConfigManager.hpp.

◆ hasMeshsets

bool MoFEM::JsonConfigManager::hasMeshsets = false

private

Definition at line 61 of file JsonConfigManager.hpp.

◆ meshsetsApplied

bool MoFEM::JsonConfigManager::meshsetsApplied = false

private

Definition at line 62 of file JsonConfigManager.hpp.

◆ moabMeshesByKey

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

private

Definition at line 63 of file JsonConfigManager.hpp.

◆ primaryMeshsetParamsByKey

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

private

Definition at line 65 of file JsonConfigManager.hpp.

◆ primaryMeshsetStringParamsByKey

std::map<MeshsetKey, MeshsetStringParams> MoFEM::JsonConfigManager::primaryMeshsetStringParamsByKey

private

Definition at line 66 of file JsonConfigManager.hpp.

◆ pythonScriptsByKey

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

private

Definition at line 64 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

Static Public Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ MeshsetKey

◆ MeshsetParams

◆ MeshsetStringParams

Constructor & Destructor Documentation

◆ JsonConfigManager()

◆ ~JsonConfigManager()

Member Function Documentation

◆ addCanonicalAttributeNames()

◆ applyMeshsets()

◆ applyPetscOptions()

◆ getMoabMeshByKey()

◆ getParamsFromBlockset()

◆ getPythonScriptByKey()

◆ getStringParamsFromBlockset()

◆ getSubInterfaceOptions()

◆ hasMeshsetsSection()

◆ loadFromCommandLine()

◆ loadFromFile()

◆ query_interface()

◆ setMeshFileFromJson()

◆ supportedVersion()

Member Data Documentation

◆ canonical_attributes_ordering

◆ configFileName

◆ configLoaded

◆ configRoot

◆ cOre

◆ hasMeshsets

◆ meshsetsApplied

◆ moabMeshesByKey

◆ primaryMeshsetParamsByKey

◆ primaryMeshsetStringParamsByKey

◆ pythonScriptsByKey