json_config_manager.cpp

Go to the documentation of this file.

/**
 * @file json_config_manager.cpp
 * @brief Atom test for JsonConfigManager
 */
 
#include <MoFEM.hpp>
 
using namespace MoFEM;
 
static char help[] = "JSON config manager atom test\n";
 
namespace {
 
double readRealOption(const char *name) {
  double value = 0;
  PetscBool found = PETSC_FALSE;
  CHKERRABORT(
      PETSC_COMM_WORLD,
      PetscOptionsGetReal(PETSC_NULLPTR, PETSC_NULLPTR, name, &value, &found));
  if (!found) {
    throw std::runtime_error("Expected PETSc real option to be set: " +
                             std::string(name));
  }
  return value;
}
 
int readIntOption(const char *name) {
  int value = 0;
  PetscBool found = PETSC_FALSE;
  CHKERRABORT(PETSC_COMM_WORLD, PetscOptionsGetInt(PETSC_NULLPTR, PETSC_NULLPTR,
                                                   name, &value, &found));
  if (!found) {
    throw std::runtime_error("Expected integer option to be set: " +
                             std::string(name));
  }
  return value;
}
 
std::string readStringOption(const char *name) {
  char value[256] = "";
  PetscBool found = PETSC_FALSE;
  CHKERRABORT(PETSC_COMM_WORLD,
              PetscOptionsGetString(PETSC_NULLPTR, PETSC_NULLPTR, name, value,
                                    sizeof(value), &found));
  if (!found) {
    throw std::runtime_error("Expected PETSc string option to be set: " +
                             std::string(name));
  }
  return value;
}
 
bool readOptionalStringOption(const char *name, std::string &value) {
  char buffer[PETSC_MAX_PATH_LEN] = "";
  PetscBool found = PETSC_FALSE;
  CHKERRABORT(PETSC_COMM_WORLD,
              PetscOptionsGetString(PETSC_NULLPTR, PETSC_NULLPTR, name, buffer,
                                    sizeof(buffer), &found));
  if (!found)
    return false;
  value.assign(buffer);
  return true;
}
 
bool hasOption(const char *name) {
  PetscBool found = PETSC_FALSE;
  CHKERRABORT(PETSC_COMM_WORLD,
              PetscOptionsHasName(PETSC_NULLPTR, PETSC_NULLPTR, name, &found));
  return found == PETSC_TRUE;
}
 
void assertNear(const double actual, const double expected, const double tol,
                const char *message) {
  if (std::abs(actual - expected) > tol) {
    std::ostringstream oss;
    oss << message << " expected=" << std::setprecision(16) << expected
        << " actual=" << actual;
    throw std::runtime_error(oss.str());
  }
}
 
void assertAttributeValues(const std::vector<double> &attrs,
                           std::initializer_list<double> expected,
                           const char *label) {
  if (attrs.size() != expected.size()) {
    std::ostringstream oss;
    oss << label << " attributes size mismatch expected=" << expected.size()
        << " actual=" << attrs.size();
    throw std::runtime_error(oss.str());
  }
 
  size_t index = 0;
  for (const auto value : expected) {
    std::ostringstream oss;
    oss << label << " User" << index + 1;
    assertNear(attrs[index], value, 1e-12, oss.str().c_str());
    ++index;
  }
}
 
void assertBlockAttributes(MoFEM::Interface &m_field, const int meshset_id,
                           std::initializer_list<double> expected,
                           const char *label) {
  for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(m_field, BLOCKSET, it)) {
    if (it->getMeshsetId() != meshset_id) {
      continue;
    }
 
    std::vector<double> attrs;
    CHKERRABORT(PETSC_COMM_WORLD, it->getAttributes(attrs));
    assertAttributeValues(attrs, expected, label);
    return;
  }
 
  throw std::runtime_error(std::string(label) + " BLOCKSET not found");
}
 
int assertBlockAttributesByName(MoFEM::Interface &m_field,
                                const std::string &meshset_name,
                                std::initializer_list<double> expected,
                                const char *label) {
  for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(m_field, BLOCKSET, it)) {
    if (it->getName() != meshset_name) {
      continue;
    }
 
    std::vector<double> attrs;
    CHKERRABORT(PETSC_COMM_WORLD, it->getAttributes(attrs));
    assertAttributeValues(attrs, expected, label);
    return it->getMeshsetId();
  }
 
  throw std::runtime_error(std::string(label) + " BLOCKSET not found by name");
}
 
} // namespace
 
int main(int argc, char *argv[]) {
 
  MoFEM::Core::Initialize(&argc, &argv, (char *)0, help);
 
  try {
    moab::Core mb_instance;
    moab::Interface &moab = mb_instance;
 
    MoFEM::Core core(moab);
    MoFEM::Interface &m_field = core;
    auto *json_config = m_field.getInterface<JsonConfigManager>();
 
    CHKERR json_config->getSubInterfaceOptions();
 
    const std::string expected_ksp_type =
        readStringOption("-expected_ksp_type");
    const std::string expected_pc_type = readStringOption("-expected_pc_type");
    std::string expected_file_name;
 
    if (readStringOption("-ksp_type") != expected_ksp_type) {
      SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
              "Unexpected -ksp_type value");
    }
    if (readStringOption("-pc_type") != expected_pc_type) {
      SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
              "Unexpected -pc_type value");
    }
    assertNear(readRealOption("-ksp_rtol"), 1e-8, 1e-14,
               "Unexpected -ksp_rtol");
    if (readIntOption("-order") != 2) {
      SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
              "Unexpected -order value");
    }
    if (readIntOption("-atom_test") != 1) {
      SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
              "Unexpected -atom_test value");
    }
    if (!hasOption("-log_no_color")) {
      SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
              "Expected -log_no_color option to be set");
    }
    if (readOptionalStringOption("-expected_file_name", expected_file_name)) {
      if (readStringOption("-file_name") != expected_file_name) {
        SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                "Unexpected -file_name value");
      }
    }
 
    MeshsetsManager *meshsets_manager_ptr;
    CHKERR m_field.getInterface(meshsets_manager_ptr);
 
    CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 1001, "elastic_domain");
    CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 1002, "trans_iso_domain");
    CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 1003, "thermal_domain");
    CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 1004, "moisture_domain");
    CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 1005, "interface_domain");
    CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 1006,
                                            "bodyforces_domain");
    CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 1007, "generic_block");
    CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 1008,
                                            "int_electric_custom");
    CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 2001, "displacement");
    CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 2002, "force");
    CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 2003, "temperature");
    CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 3001, "pressure");
    CHKERR meshsets_manager_ptr->addMeshset(BLOCKSET, 3002, "heatflux");
 
    CHKERR JsonConfigManager::addCanonicalAttributeNames(
        {"charge_density", "mobility", "scale"});
    CHKERR meshsets_manager_ptr->setMeshsetFromFile();
    CHKERR json_config->applyMeshsets();
 
    const bool shared_types_same_blockset_test =
        hasOption("-shared_types_same_blockset_test");
    if (shared_types_same_blockset_test) {
      const auto elastic_params =
          json_config->getParamsFromBlockset("MAT_ELASTIC", 1001);
      if (elastic_params.at("young") != 1000.0 ||
          elastic_params.at("poisson") != 0.3) {
        SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                "Unexpected shared-block MAT_ELASTIC params from JSON");
      }
      const auto elastic_string_params =
          json_config->getStringParamsFromBlockset("MAT_ELASTIC", 1001);
      if (elastic_string_params.at("model_spec") != "incompressible") {
        SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                "Unexpected shared-block MAT_ELASTIC string params from JSON");
      }
 
      const auto thermal_params =
          json_config->getParamsFromBlockset("MAT_THERMAL", 1001);
      if (thermal_params.at("conductivity") != 11.0 ||
          thermal_params.at("heatcapacity") != 22.0) {
        SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                "Unexpected shared-block MAT_THERMAL params from JSON");
      }
      const auto thermal_string_params =
          json_config->getStringParamsFromBlockset("MAT_THERMAL", 1001);
      if (thermal_string_params.at("load_history") !=
          "~/thermal_load_case.txt") {
        SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                "Unexpected shared-block MAT_THERMAL string params from JSON");
      }
 
      const int elastic_id = assertBlockAttributesByName(
          m_field, "MAT_ELASTIC_elastic_domain_1001", {1000.0, 0.3},
          "MAT_ELASTIC");
      const int thermal_id = assertBlockAttributesByName(
          m_field, "MAT_THERMAL_elastic_domain_3003", {11.0, 22.0},
          "MAT_THERMAL");
      if (elastic_id == thermal_id) {
        SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                "Expected distinct blocksets for shared source meshset name");
      }
 
      const auto thermal_target_params =
          json_config->getParamsFromBlockset("MAT_THERMAL", thermal_id);
      if (thermal_target_params.at("conductivity") != 11.0 ||
          thermal_target_params.at("heatcapacity") != 22.0) {
        SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                "Unexpected shared-block MAT_THERMAL params for target id");
      }
      const auto thermal_target_string_params =
          json_config->getStringParamsFromBlockset("MAT_THERMAL", thermal_id);
      if (thermal_target_string_params.at("load_history") !=
          "~/thermal_load_case.txt") {
        SETERRQ(
            PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
            "Unexpected shared-block MAT_THERMAL string params for target id");
      }
    }
 
    if (!shared_types_same_blockset_test) {
      const bool expect_multiple_python_scripts =
          hasOption("-expect_multiple_python_scripts");
      if (json_config->getMoabMeshByKey("primary") != "json_primary_mesh.h5m") {
        SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                "Unexpected keyed MOAB mesh lookup result");
      }
      if (!json_config->getMoabMeshByKey("missing_mesh").empty()) {
        SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                "Unexpected missing keyed MOAB mesh lookup result");
      }
      if (expect_multiple_python_scripts) {
        if (json_config->getMoabMeshByKey("background_mesh") !=
            "rectangle_quad.h5m") {
          SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                  "Unexpected auxiliary keyed MOAB mesh lookup result");
        }
        if (json_config->getPythonScriptByKey("python_script_1") !=
                "./sdf_files/sdf_hertz_2d_plane.py" ||
            json_config->getPythonScriptByKey("python_script_2") !=
                "./sdf_files/sdf_hertz_2d_plane_2.py") {
          SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                  "Unexpected keyed Python script lookup result");
        }
      } else {
        if (json_config->getPythonScriptByKey("python_script") !=
            "./sdf_files/sdf_hertz_2d_plane.py") {
          SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                  "Unexpected keyed Python script lookup result");
        }
      }
      if (!json_config->getPythonScriptByKey("missing_script").empty()) {
        SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                "Unexpected missing keyed Python script lookup result");
      }
 
      const auto elastic_params =
          json_config->getParamsFromBlockset("hencky", 1001);
      if (elastic_params.at("young") != 1000.0 ||
          elastic_params.at("poisson") != 0.3) {
        SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                "Unexpected hencky params from JSON");
      }
      if (hasOption("-expect_string_params")) {
        const auto elastic_string_params =
            json_config->getStringParamsFromBlockset("hencky", 1001);
        if (elastic_string_params.at("model_spec") != "incompressible" ||
            elastic_string_params.at("load_history") != "~/load_case1.txt") {
          SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                  "Unexpected hencky string params from JSON");
        }
      }
 
      const auto generic_params =
          json_config->getParamsFromBlockset("GENERIC_BLOCK", 1007);
      if (generic_params.at("user1") != 9.0 ||
          generic_params.at("user1b") != 8.0) {
        SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                "Unexpected GENERIC_BLOCK params from JSON");
      }
 
      const auto int_electric_custom_params =
          json_config->getParamsFromBlockset("INT_ELECTRIC_CUSTOM", 1008);
      if (int_electric_custom_params.at("charge_density") != 12.0 ||
          int_electric_custom_params.at("mobility") != 13.0 ||
          int_electric_custom_params.at("scale") != 14.0) {
        SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                "Unexpected INT_ELECTRIC_CUSTOM params from JSON");
      }
 
      const auto mooney_rivlin_params =
          json_config->getParamsFromBlockset("MAT_MOONEY_RIVLIN", 1004);
      const bool has_mooney_rivlin_params = !mooney_rivlin_params.empty();
 
      const auto displacement_params =
          json_config->getParamsFromBlockset("DISPLACEMENT", 2001);
      if (displacement_params.at("flag1") != 1.0 ||
          displacement_params.at("flag2") != 1.0 ||
          displacement_params.at("flag3") != 0.0 ||
          displacement_params.at("value3") != 3.0) {
        SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                "Unexpected DISPLACEMENT params from JSON");
      }
 
      const auto force_params =
          json_config->getParamsFromBlockset("FORCE", 2002);
      if (force_params.at("force_magnitude") != 10.0 ||
          force_params.at("moment_magnitude") != 11.0 ||
          force_params.at("moment_my") != 1.0) {
        SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                "Unexpected FORCE params from JSON");
      }
 
      const auto temperature_params =
          json_config->getParamsFromBlockset("TEMPERATURE", 2003);
      if (temperature_params.at("flag1") != 1.0 ||
          temperature_params.at("value1") != 123.0) {
        SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                "Unexpected TEMPERATURE params from JSON");
      }
 
      const auto pressure_params =
          json_config->getParamsFromBlockset("PRESSURE", 3001);
      if (pressure_params.at("flag2") != 1.0 ||
          pressure_params.at("value1") != 12.5) {
        SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                "Unexpected PRESSURE params from JSON");
      }
 
      const auto heatflux_params =
          json_config->getParamsFromBlockset("HEATFLUX", 3002);
      if (heatflux_params.at("flag1") != 1.0 ||
          heatflux_params.at("value1") != 99.0) {
        SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                "Unexpected HEATFLUX params from JSON");
      }
 
      if (!json_config->getParamsFromBlockset("UNKNOWN_TYPE", 1007).empty()) {
        SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                "Unexpected params returned for unknown blockset type");
      }
      if (!json_config->getStringParamsFromBlockset("UNKNOWN_TYPE", 1007)
               .empty()) {
        SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                "Unexpected string params returned for unknown blockset type");
      }
 
      assertBlockAttributes(m_field, 1001, {1000.0, 0.3, 1e-5, 7.0}, "hencky");
      assertBlockAttributes(m_field, 1002, {1.0, 2.0, 3.0, 4.0, 5.0},
                            "MAT_ELASTIC_TRANSISO");
      assertBlockAttributes(m_field, 1003, {11.0, 22.0}, "MAT_THERMAL");
      if (has_mooney_rivlin_params) {
        assertBlockAttributes(m_field, 1004, {2.0, 3.0, 4.0, 0.5},
                              "MAT_MOONEY_RIVLIN");
      }
      assertBlockAttributes(m_field, 1005, {10.0, 20.0, 30.0, 40.0},
                            "MAT_INTERF");
      assertBlockAttributes(m_field, 1006, {100.0, 1.0, 2.0, 3.0},
                            "BODYFORCES");
      assertBlockAttributes(m_field, 1007, {9.0}, "GENERIC_BLOCK");
      assertBlockAttributes(m_field, 1008, {12.0, 13.0, 14.0},
                            "INT_ELECTRIC_CUSTOM");
      assertBlockAttributes(m_field, 2001, {1.0, 1.0, 0.0, 1.0, 2.0, 3.0},
                            "DISPLACEMENT");
      assertBlockAttributes(
          m_field, 2002, {10.0, 11.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0}, "FORCE");
      assertBlockAttributes(m_field, 2003, {1.0, 123.0}, "TEMPERATURE");
      assertBlockAttributes(m_field, 3001, {1.0, 12.5}, "PRESSURE");
      assertBlockAttributes(m_field, 3002, {1.0, 99.0}, "HEATFLUX");
    }
  }
  CATCH_ERRORS;
 
  MoFEM::Core::Finalize();
}