v0.16.3
Loading...
Searching...
No Matches
Public Member Functions | Static Public Member Functions | Static Public Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
MoFEM::JsonConfigManager Struct Reference

#include "src/interfaces/JsonConfigManager.hpp"

Inheritance diagram for MoFEM::JsonConfigManager:
[legend]
Collaboration diagram for MoFEM::JsonConfigManager:
[legend]

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, double > getParamsFromBlocksetByTypePrefix (const std::string &type_prefix, int meshset_id) const
 Numeric attributes of the entry with this id whose type starts with type_prefix.
 
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 MoFEMErrorCode getMofemBoolFromJson (const std::string &key, PetscBool &value, PetscBool &found)
 Read a boolean of the JSON "mofem" section 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
mesh_reconstruction.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 81 of file JsonConfigManager.hpp.

◆ MeshsetParams

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

Definition at line 82 of file JsonConfigManager.hpp.

◆ MeshsetStringParams

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

Definition at line 83 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)) {}
CoreTmp< 0 > Core
Definition Core.hpp:1161

◆ ~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.

420 {
422 for (const auto &name : names) {
423 if (name.empty()) {
424 continue;
425 }
426
427 const auto lower_name = toLowerCopy(name);
428 const auto it = std::find_if(
430 canonical_attributes_ordering.end(), [&](const std::string &existing) {
431 return toLowerCopy(existing) == lower_name;
432 });
433 if (it == canonical_attributes_ordering.end()) {
434 canonical_attributes_ordering.push_back(lower_name);
435 }
436 }
437
439}
It it
Definition Schur.cpp:2568
std::string name
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
static std::vector< std::string > canonical_attributes_ordering

◆ applyMeshsets()

MoFEMErrorCode MoFEM::JsonConfigManager::applyMeshsets ( )

Definition at line 650 of file JsonConfigManager.cpp.

650 {
653 auto &meshsets_manager = cOre.getInterface<MeshsetsManager &>();
656 if (const auto *primary_meshsets =
658 primary_meshsets && !primary_meshsets->empty()) {
659 const char *section_key =
661 const auto primary_mesh_context = meshContext(0, section_key);
662 std::vector<ParsedMeshsetEntry> parsed_primary_meshsets;
663 std::set<int> used_blockset_ids;
664 CHKERR parseMeshsets(*primary_meshsets, primary_mesh_context, configFileName,
665 &meshsets_manager, parsed_primary_meshsets);
666 CHKERR cacheResolvedBlocksetParams(parsed_primary_meshsets, configFileName,
669 used_blockset_ids);
670
671 // JSON stays authoritative for block attributes. Imported blockset names
672 // are kept only for meshsets that JSON actually refers to.
673 CHKERR discardResolvedBlocksetConfiguration(
674 meshsets_manager, configFileName, used_blockset_ids);
675 CHKERR applyParsedMeshsets(meshsets_manager, parsed_primary_meshsets,
677 CHKERR cacheAppliedBlocksetParams(parsed_primary_meshsets, configFileName,
680 }
681 const char *section_key = nullptr;
682 if (const auto *meshes_array =
683 getMeshesArray(configRoot.as_object(), configFileName, &section_key);
684 meshes_array) {
685 for (size_t mesh_index = 1; mesh_index != meshes_array->size();
686 ++mesh_index) {
687 if (const auto *meshsets =
689 mesh_index);
690 meshsets && !meshsets->empty()) {
691 CHKERR validateMeshsets(*meshsets, meshContext(mesh_index, section_key),
693 }
694 }
695 }
696 meshsetsApplied = true;
697 }
699}
std::string meshContext(const size_t mesh_index, const char *section_key=MESHES_KEY)
const JsonArray * getMeshsetsArray(const JsonObject &root_object, const std::string &file_name, const size_t mesh_index)
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)
MoFEMErrorCode validateMeshsets(const JsonArray &meshsets, const std::string &mesh_context, const std::string &file_name)
MoFEMErrorCode cacheAppliedBlocksetParams(const std::vector< ParsedMeshsetEntry > &parsed_meshsets, const std::string &file_name, BlocksetParamsByKey &params_by_key, BlocksetStringParamsByKey &string_params_by_key)
MoFEMErrorCode applyParsedMeshsets(MeshsetsManager &meshsets_manager, std::vector< ParsedMeshsetEntry > &parsed_meshsets, const std::string &file_name)
MoFEMErrorCode cacheResolvedBlocksetParams(const std::vector< ParsedMeshsetEntry > &parsed_meshsets, const std::string &file_name, BlocksetParamsByKey &params_by_key, BlocksetStringParamsByKey &string_params_by_key, std::set< int > &used_blockset_ids)
MoFEMErrorCode parseMeshsets(const JsonArray &meshsets, const std::string &mesh_context, const std::string &file_name, MeshsetsManager *meshsets_manager_ptr, std::vector< ParsedMeshsetEntry > &parsed_meshsets)
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define CHKERR
Inline error check.
std::map< MeshsetKey, MeshsetParams > primaryMeshsetParamsByKey
std::map< MeshsetKey, MeshsetStringParams > primaryMeshsetStringParamsByKey
boost::json::value configRoot
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.

◆ applyPetscOptions()

MoFEMErrorCode MoFEM::JsonConfigManager::applyPetscOptions ( )
private

Definition at line 616 of file JsonConfigManager.cpp.

616 {
618 if (configLoaded) {
619 const auto &root_object = configRoot.as_object();
620 std::map<std::string, std::string> seen_option_contexts;
621 const char *section_key = nullptr;
622 if (const auto *meshes_array =
623 getMeshesArray(root_object, configFileName, &section_key);
624 meshes_array && !meshes_array->empty()) {
625 const auto primary_mesh_context = meshContext(0, section_key);
626 const auto &primary_mesh = requireObject((*meshes_array)[0], configFileName,
627 primary_mesh_context);
628 CHKERR setPetscOptionIfUnset(
629 "-file_name",
630 requireString(primary_mesh.at("file_name"), configFileName,
631 makeContext(primary_mesh_context, "file_name")));
632 }
633
634 if (const auto petsc_it = root_object.find("petsc");
635 petsc_it != root_object.end()) {
636 CHKERR flattenPetscObject(petsc_it->value().as_object(), "",
637 configFileName, "petsc",
638 seen_option_contexts);
639 }
640 if (const auto mofem_it = root_object.find("mofem");
641 mofem_it != root_object.end()) {
642 CHKERR flattenPetscObject(mofem_it->value().as_object(), "",
643 configFileName, "mofem",
644 seen_option_contexts);
645 }
646 }
648}

◆ getMoabMeshByKey()

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

Definition at line 710 of file JsonConfigManager.cpp.

710 {
711 if (const auto it = moabMeshesByKey.find(key); it != moabMeshesByKey.end()) {
712 return it->second;
713 }
714 return "";
715}
ParentChildKey key
std::map< std::string, std::string > moabMeshesByKey

◆ getMofemBoolFromJson()

MoFEMErrorCode MoFEM::JsonConfigManager::getMofemBoolFromJson ( const std::string &  key,
PetscBool &  value,
PetscBool &  found 
)
static

Read a boolean of the JSON "mofem" section before Core is available.

Use only in programs that must branch before MoFEM::Core and the JsonConfigManager interface are initialised, as the choice of mesh loader does. The command line is not consulted; callers that honour it read the option themselves and fall back to this.

Parameters
keyname of the entry in the "mofem" section, without the leading -
valueset only when the entry is present
foundwhether the entry was present

Definition at line 486 of file JsonConfigManager.cpp.

488 {
490 found = PETSC_FALSE;
491
492 char json_file_name[PETSC_MAX_PATH_LEN] = "";
493 PetscBool has_json = PETSC_FALSE;
494 CHKERR PetscOptionsGetString(PETSC_NULLPTR, PETSC_NULLPTR, "-json_config",
495 json_file_name, sizeof(json_file_name),
496 &has_json);
497 if (!has_json || !std::strlen(json_file_name)) {
499 }
500
501 boost::json::value selected_config;
502 CHKERR loadSelectedConfigFromFile(json_file_name, selected_config);
503 const auto &config_object =
504 requireObject(selected_config, json_file_name, "root");
505
506 const auto mofem_it = config_object.find("mofem");
507 if (mofem_it == config_object.end()) {
509 }
510 const auto &mofem_object =
511 requireObject(mofem_it->value(), json_file_name, "mofem");
512
513 const auto key_it = mofem_object.find(key);
514 if (key_it == mofem_object.end()) {
516 }
517 if (!key_it->value().is_bool()) {
518 CHKERR failConfig(json_file_name, makeContext("mofem", key),
519 "expected boolean, got " +
520 jsonTypeName(key_it->value()));
521 }
522
523 value = key_it->value().as_bool() ? PETSC_TRUE : PETSC_FALSE;
524 found = PETSC_TRUE;
525
527}
PetscErrorCode PetscOptionsGetString(PetscOptions *, const char pre[], const char name[], char str[], size_t size, PetscBool *set)

◆ getParamsFromBlockset()

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

Definition at line 718 of file JsonConfigManager.cpp.

719 {
720 const auto it =
721 primaryMeshsetParamsByKey.find({toLowerCopy(type_name), meshset_id});
722 if (it != primaryMeshsetParamsByKey.end()) {
723 return it->second;
724 }
725 return {};
726}

◆ getParamsFromBlocksetByTypePrefix()

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

Numeric attributes of the entry with this id whose type starts with type_prefix.

Generated BLOCKSET names embed the type, so a consumer finding blocks by a regex such as CRACK(.*) knows the prefix and the id, but not whether the JSON type was CRACK, CRACK_1 or CRACK_2. Returns an empty map when nothing matches.

Definition at line 729 of file JsonConfigManager.cpp.

730 {
731 const auto prefix = toLowerCopy(type_prefix);
732 for (auto it = primaryMeshsetParamsByKey.lower_bound({prefix, meshset_id});
733 it != primaryMeshsetParamsByKey.end(); ++it) {
734 if (it->first.first.compare(0, prefix.size(), prefix) != 0) {
735 break;
736 }
737 if (it->first.second == meshset_id) {
738 return it->second;
739 }
740 }
741 return {};
742}

◆ getPythonScriptByKey()

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

Definition at line 702 of file JsonConfigManager.cpp.

702 {
703 if (const auto it = pythonScriptsByKey.find(key);
704 it != pythonScriptsByKey.end()) {
705 return it->second;
706 }
707 return "";
708}
std::map< std::string, std::string > pythonScriptsByKey

◆ getStringParamsFromBlockset()

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

Definition at line 745 of file JsonConfigManager.cpp.

746 {
747 const auto it = primaryMeshsetStringParamsByKey.find(
748 {toLowerCopy(type_name), meshset_id});
749 if (it != primaryMeshsetStringParamsByKey.end()) {
750 return it->second;
751 }
752 return {};
753}

◆ getSubInterfaceOptions()

MoFEMErrorCode MoFEM::JsonConfigManager::getSubInterfaceOptions ( )

Definition at line 529 of file JsonConfigManager.cpp.

529 {
530 return loadFromCommandLine();
531}
MoFEMErrorCode loadFromCommandLine()

◆ hasMeshsetsSection()

bool MoFEM::JsonConfigManager::hasMeshsetsSection ( ) const
inline

Definition at line 78 of file JsonConfigManager.hpp.

78{ return hasMeshsets; }

◆ loadFromCommandLine()

MoFEMErrorCode MoFEM::JsonConfigManager::loadFromCommandLine ( )
private

Definition at line 755 of file JsonConfigManager.cpp.

755 {
757 if (!configLoaded) {
758 char json_file_name[PETSC_MAX_PATH_LEN] = "";
759 PetscBool has_json = PETSC_FALSE;
760 CHKERR PetscOptionsGetString(PETSC_NULLPTR, PETSC_NULLPTR, "-json_config",
761 json_file_name, sizeof(json_file_name),
762 &has_json);
763 if (has_json) {
764 // IMPORTANT !!!
765 // Clear any PETSc options that might have been set by param_file.petsc
766 CHKERR clearPetscParamFileOptionsForJson(json_file_name);
767 CHKERR loadFromFile(json_file_name);
768
769 if (hasMeshsets) {
770 char meshsets_cfg_file[PETSC_MAX_PATH_LEN] = "";
771 PetscBool has_meshsets_cfg = PETSC_FALSE;
772 CHKERR PetscOptionsGetString(PETSC_NULLPTR, PETSC_NULLPTR,
773 "-meshsets_config", meshsets_cfg_file,
774 sizeof(meshsets_cfg_file),
775 &has_meshsets_cfg);
776 if (has_meshsets_cfg) {
777 CHKERR failConfig(
778 configFileName, "meshsets",
779 "JSON meshsets cannot be used together with -meshsets_config");
780 }
781 }
782
784 // Consume and apply any log_* options injected from JSON after PETSc
785 // initialization so they do not remain as "unused database options".
787 }
788 }
790}
MoFEMErrorCode loadFromFile(const std::string &file_name)
static MoFEMErrorCode getOptions()
Get logger option.

◆ loadFromFile()

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

Definition at line 533 of file JsonConfigManager.cpp.

533 {
535
536 boost::json::value selected_config;
537 CHKERR loadSelectedConfigFromFile(file_name, selected_config);
538 const auto &config_object = requireObject(selected_config, file_name, "root");
539
540 bool has_version = false;
541 for (const auto &item : config_object) {
542 const auto key = toStdString(item.key());
543 if (key == "$schema")
544 continue;
545 if (key == "version") {
546 has_version = true;
547 const auto version =
548 requireString(item.value(), file_name, makeContext("root", key));
549 if (version != supportedVersion()) {
550 CHKERR failConfig(file_name, makeContext("root", key),
551 "unsupported config version '" + version +
552 "', supported version is '" + supportedVersion() +
553 "'");
554 }
555 continue;
556 }
557 if (key == "petsc") {
558 requireObject(item.value(), file_name, makeContext("root", key));
559 continue;
560 }
561 if (key == "mofem") {
562 requireObject(item.value(), file_name, makeContext("root", key));
563 continue;
564 }
565 if (key == "meshes" || key == "input_files") {
566 requireArray(item.value(), file_name, makeContext("root", key));
567 continue;
568 }
569 if (key == "file_name") {
570 CHKERR failConfig(
571 file_name, makeContext("root", key),
572 "legacy root-level file_name is not supported; use "
573 "root.input_files[0].file_name or root.meshes[0].file_name");
574 }
575 if (key == "meshsets") {
576 CHKERR failConfig(
577 file_name, makeContext("root", key),
578 "legacy root-level meshsets is not supported; use "
579 "root.input_files[i].meshsets or root.meshes[i].meshsets");
580 }
581 CHKERR failConfig(file_name, makeContext("root", key),
582 "unknown top-level key");
583 }
584 if (!has_version) {
585 CHKERR failConfig(file_name, "root.version",
586 "missing required version field");
587 }
588 hasMeshsets = false;
589
590 std::vector<ParsedMeshEntry> new_meshes;
591 bool config_has_meshsets = false;
592 CHKERR collectMeshes(config_object, file_name, new_meshes,
593 &config_has_meshsets);
594
595 configRoot = std::move(selected_config);
596 configFileName = file_name;
597 configLoaded = true;
598 moabMeshesByKey.clear();
599 pythonScriptsByKey.clear();
600 for (const auto &entry : new_meshes) {
601 if (entry.type == MOAB_MESH_TYPE && !entry.key.empty()) {
602 moabMeshesByKey[entry.key] = entry.fileName;
603 }
604 if (isPythonScriptMeshType(entry.type)) {
605 pythonScriptsByKey[entry.key] = entry.fileName;
606 }
607 }
608 hasMeshsets = config_has_meshsets;
609 meshsetsApplied = false;
612
614}
MoFEMErrorCode collectMeshes(const JsonObject &root_object, const std::string &file_name, std::vector< ParsedMeshEntry > &meshes, bool *has_meshsets)
bool isPythonScriptMeshType(const std::string &type)
constexpr auto MOAB_MESH_TYPE
static const std::string & supportedVersion()

◆ 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.

443 {
444 *iface = const_cast<JsonConfigManager *>(this);
445 return 0;
446}
JsonConfigManager(const MoFEM::Core &core)

◆ 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.

451 {
453
454 char json_file_name[PETSC_MAX_PATH_LEN] = "";
455 PetscBool has_json = PETSC_FALSE;
456 CHKERR PetscOptionsGetString(PETSC_NULLPTR, PETSC_NULLPTR, "-json_config",
457 json_file_name, sizeof(json_file_name),
458 &has_json);
459 if (!has_json || !std::strlen(json_file_name)) {
461 }
462
463 bool has_file_name_arg = false;
464 bool has_my_file_arg = false;
465 CHKERR hasCommandLineOption("-file_name", has_file_name_arg);
466 CHKERR hasCommandLineOption("-my_file", has_my_file_arg);
467 if (has_file_name_arg || has_my_file_arg) {
469 }
470
471 boost::json::value selected_config;
472 CHKERR loadSelectedConfigFromFile(json_file_name, selected_config);
473 const auto &config_object =
474 requireObject(selected_config, json_file_name, "root");
475
476 std::vector<ParsedMeshEntry> meshes;
477 CHKERR collectMeshes(config_object, json_file_name, meshes);
478 if (!meshes.empty()) {
479 CHKERR PetscOptionsSetValue(PETSC_NULLPTR, "-file_name",
480 meshes.front().fileName.c_str());
481 }
482
484}
std::map< unsigned long long, std::unique_ptr< ManagedMesh > > meshes

◆ supportedVersion()

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

Definition at line 13 of file JsonConfigManager.cpp.

13 {
14 static const std::string version =
15 std::to_string(MoFEM_VERSION_MAJOR) + "." +
16 std::to_string(MoFEM_VERSION_MINOR);
17 return version;
18}

Member Data Documentation

◆ canonical_attributes_ordering

std::vector<std::string> MoFEM::JsonConfigManager::canonical_attributes_ordering
inlinestatic
Initial value:
=
std::vector< std::string > getDefaultJsonCanonicalAttributeNames()

Definition at line 14 of file JsonConfigManager.hpp.

◆ configFileName

std::string MoFEM::JsonConfigManager::configFileName
private

Definition at line 87 of file JsonConfigManager.hpp.

◆ configLoaded

bool MoFEM::JsonConfigManager::configLoaded = false
private

Definition at line 88 of file JsonConfigManager.hpp.

◆ configRoot

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

Definition at line 86 of file JsonConfigManager.hpp.

◆ cOre

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

Definition at line 85 of file JsonConfigManager.hpp.

◆ hasMeshsets

bool MoFEM::JsonConfigManager::hasMeshsets = false
private

Definition at line 89 of file JsonConfigManager.hpp.

◆ meshsetsApplied

bool MoFEM::JsonConfigManager::meshsetsApplied = false
private

Definition at line 90 of file JsonConfigManager.hpp.

◆ moabMeshesByKey

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

Definition at line 91 of file JsonConfigManager.hpp.

◆ primaryMeshsetParamsByKey

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

Definition at line 93 of file JsonConfigManager.hpp.

◆ primaryMeshsetStringParamsByKey

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

Definition at line 94 of file JsonConfigManager.hpp.

◆ pythonScriptsByKey

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

Definition at line 92 of file JsonConfigManager.hpp.


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