JsonConfigManagerMeshsets.cpp

Go to the documentation of this file.

int centerAttributeSlot(const std::string &lower_key, const int first_slot) {
  if (lower_key == "center_x" || lower_key == "x0")
    return first_slot;
  if (lower_key == "center_y" || lower_key == "y0")
    return first_slot + 1;
  if (lower_key == "center_z" || lower_key == "z0")
    return first_slot + 2;
  return 0;
}
 
int positionalBlockAttributeSlot(const std::string &lower_type,
                                 const std::string &lower_key) {
  if (lower_type == "fix_x" && lower_key == "x")
    return 1;
  if (lower_type == "fix_y" && lower_key == "y")
    return 2;
  if (lower_type == "fix_z" && lower_key == "z")
    return 3;
  if (lower_type == "fix_all") {
    if (lower_key == "x")
      return 1;
    if (lower_key == "y")
      return 2;
    if (lower_key == "z")
      return 3;
  }
 
  if (lower_type == "rotate_x") {
    if (lower_key == "rx")
      return 1;
    return centerAttributeSlot(lower_key, 2);
  }
  if (lower_type == "rotate_y") {
    if (lower_key == "ry")
      return 1;
    return centerAttributeSlot(lower_key, 2);
  }
  if (lower_type == "rotate_z") {
    if (lower_key == "rz")
      return 1;
    return centerAttributeSlot(lower_key, 2);
  }
  if (lower_type == "rotate_all") {
    if (lower_key == "rx")
      return 1;
    if (lower_key == "ry")
      return 2;
    if (lower_key == "rz")
      return 3;
    return centerAttributeSlot(lower_key, 4);
  }
 
  if (lower_type.rfind("boundary_condition", 0) == 0 &&
      (lower_key == "value" || lower_key == "potential"))
    return 1;
  if (lower_type == "hencky" || lower_type.rfind("mat_elastic", 0) == 0) {
    if (lower_key == "young" || lower_key == "young_modulus")
      return 1;
    if (lower_key == "poisson" || lower_key == "poisson_ratio")
      return 2;
  }
 
  return 0;
}
 
int parseGenericBlockUserIndex(const std::string &lower_key) {
  if (lower_key.size() < 5 || lower_key.compare(0, 4, "user") != 0) {
    return 0;
  }
 
  try {
    return boost::lexical_cast<int>(lower_key.substr(4));
  } catch (...) {
    return 0;
  }
}
 
double requireBlockAttributeValue(const JsonValue &value,
                                  const std::string &file_name,
                                  const std::string &context) {
  if (value.is_bool())
    return value.as_bool() ? 1.0 : 0.0;
 
  return requireNumber(value, file_name, context);
}
 
MoFEMErrorCode applyBlockAttributes(MeshsetsManager &meshsets_manager, int id,
                                    const JsonObject &props,
                                    const std::string &file_name,
                                    const std::string &context,
                                    const std::string &type_name,
                                    const std::string &blockset_name) {
  MoFEMFunctionBegin;
  std::vector<double> values(MAX_MESHSET_ATTRIBUTES, 0);
  int max_index = 0;
  const auto lower_type = toLowerCopy(type_name);
  std::array<bool, MAX_MESHSET_ATTRIBUTES> used_indices{};
  std::vector<const JsonObject::value_type *> fallback_items;
 
  auto set_value = [&](const JsonObject::value_type &item, const int index) {
    const auto key = toStdString(item.key());
    if (index < 1 || index > MAX_MESHSET_ATTRIBUTES) {
      CHKERR failConfig(
          file_name, makeContext(context, key),
          "User index must be between 1 and " +
              boost::lexical_cast<std::string>(MAX_MESHSET_ATTRIBUTES));
    }
    values[index - 1] = requireBlockAttributeValue(
        item.value(), file_name, makeContext(context, key));
    used_indices[index - 1] = true;
    max_index = std::max(max_index, index);
    return 0;
  };
 
  for (const auto &item : props) {
    const auto key = toStdString(item.key());
    const auto lower_key = toLowerCopy(key);
    int index = positionalBlockAttributeSlot(lower_type, lower_key);
    if (!index) {
      index = parseGenericBlockUserIndex(lower_key);
    }
    if (!index) {
      fallback_items.push_back(&item);
      continue;
    }
    CHKERR set_value(item, index);
  }
 
  for (const auto *item_ptr : fallback_items) {
    int fallback_index = 0;
    for (int index = 1; index <= MAX_MESHSET_ATTRIBUTES; ++index) {
      if (!used_indices[index - 1]) {
        fallback_index = index;
        break;
      }
    }
    if (!fallback_index) {
      CHKERR failConfig(
          file_name, context,
          "generic BLOCKSET custom attributes exhausted available User slots");
    }
    CHKERR set_value(*item_ptr, fallback_index);
  }
 
  values.resize(max_index);
  CHKERR meshsets_manager.setAttributes(BLOCKSET, id, values, blockset_name);
  MoFEMFunctionReturn(0);
}
 
std::string meshsetContext(const std::string &mesh_context,
                           const size_t meshset_index) {
  return mesh_context + ".meshsets[" +
         boost::lexical_cast<std::string>(meshset_index) + "]";
}
 
struct ParsedMeshsetEntry {
  int meshsetId = -1;
  int appliedMeshsetId = -1;
  std::string meshsetName;
  std::string sourceMeshsetName;
  std::string typeName;
  JsonObject attributes;
  std::string context;
};
 
using BlocksetParamKey = std::pair<std::string, int>;
using BlocksetParams = std::map<std::string, double>;
using BlocksetParamsByKey = std::map<BlocksetParamKey, BlocksetParams>;
 
std::string meshsetAttributesContext(const ParsedMeshsetEntry &entry) {
  return makeContext(entry.context, "attributes");
}
 
std::string appliedBlocksetName(const ParsedMeshsetEntry &entry) {
  const auto &name = entry.meshsetName.empty() ? entry.sourceMeshsetName
                                               : entry.meshsetName;
  if (name.empty()) {
    return entry.typeName + "_" +
           boost::lexical_cast<std::string>(entry.appliedMeshsetId);
  }
 
  return entry.typeName + "_" + name + "_" +
         boost::lexical_cast<std::string>(entry.appliedMeshsetId);
}
 
MoFEMErrorCode getUniqueBlocksetByName(MeshsetsManager &meshsets_manager,
                                       const std::string &meshset_name,
                                       const std::string &file_name,
                                       const std::string &context,
                                       const CubitMeshSets **blockset_ptr) {
  MoFEMFunctionBegin;
  *blockset_ptr = nullptr;
  int number_of_meshsets = 0;
 
  for (auto it = meshsets_manager.getBegin(); it != meshsets_manager.getEnd();
       ++it) {
    if ((it->getBcType() & CubitBCType(BLOCKSET)).none() ||
        it->getName() != meshset_name) {
      continue;
    }
    *blockset_ptr = &*it;
    ++number_of_meshsets;
  }
 
  if (number_of_meshsets == 0) {
    CHKERR failConfig(file_name, makeContext(context, "meshset_name"),
                      "failed to resolve BLOCKSET meshset_name '" +
                          meshset_name + "'");
  }
  if (number_of_meshsets != 1) {
    CHKERR failConfig(file_name, makeContext(context, "meshset_name"),
                      "BLOCKSET meshset_name '" + meshset_name +
                          "' is not unique; resolve by explicit id");
  }
 
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode getBlocksetById(MeshsetsManager &meshsets_manager,
                               const int meshset_id,
                               const std::string &file_name,
                               const std::string &context,
                               const CubitMeshSets **blockset_ptr) {
  MoFEMFunctionBegin;
  if (!meshsets_manager.checkMeshset(meshset_id, BLOCKSET)) {
    CHKERR failConfig(file_name, makeContext(context, "id"),
                      "failed to resolve BLOCKSET id '" +
                          boost::lexical_cast<std::string>(meshset_id) + "'");
  }
  CHKERR meshsets_manager.getCubitMeshsetPtr(meshset_id, BLOCKSET,
                                             blockset_ptr);
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode resolveMeshsetIdAndName(MeshsetsManager &meshsets_manager,
                                       const bool has_meshset_id,
                                       const int requested_meshset_id,
                                       const std::string &lookup_meshset_name,
                                       const std::string &file_name,
                                       const std::string &context,
                                       int &meshset_id,
                                       std::string &meshset_name) {
  MoFEMFunctionBegin;
  const CubitMeshSets *blockset_by_id = nullptr;
 
  if (has_meshset_id) {
    CHKERR getBlocksetById(meshsets_manager, requested_meshset_id, file_name,
                           context, &blockset_by_id);
    meshset_id = blockset_by_id->getMeshsetId();
    meshset_name = blockset_by_id->getName();
    if (!lookup_meshset_name.empty() && meshset_name != lookup_meshset_name) {
      CHKERR failConfig(
          file_name, context,
          "meshset id '" + boost::lexical_cast<std::string>(meshset_id) +
              "' does not match meshset_name '" + lookup_meshset_name + "'");
    }
  } else if (!lookup_meshset_name.empty()) {
    const CubitMeshSets *blockset_by_name = nullptr;
    CHKERR getUniqueBlocksetByName(meshsets_manager, lookup_meshset_name,
                                   file_name, context, &blockset_by_name);
    meshset_id = blockset_by_name->getMeshsetId();
    meshset_name = blockset_by_name->getName();
  }
 
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode parseMeshsetEntry(const JsonObject &meshset_object,
                                 const std::string &file_name,
                                 const std::string &context,
                                 MeshsetsManager *meshsets_manager_ptr,
                                 ParsedMeshsetEntry &entry) {
  MoFEMFunctionBegin;
  entry = ParsedMeshsetEntry{};
  entry.context = context;
 
  bool has_meshset_id = false;
 
  for (const auto &item : meshset_object) {
    const auto key = toStdString(item.key());
    if (key == "id") {
      entry.meshsetId =
          requireInt(item.value(), file_name, makeContext(context, key));
      has_meshset_id = true;
      continue;
    }
    if (key == "meshset_name") {
      entry.meshsetName =
          requireString(item.value(), file_name, makeContext(context, key));
      continue;
    }
    if (key == "type") {
      entry.typeName =
          requireString(item.value(), file_name, makeContext(context, key));
      continue;
    }
    if (key == "attributes") {
      entry.attributes =
          requireObject(item.value(), file_name, makeContext(context, key));
      continue;
    }
    CHKERR failConfig(file_name, makeContext(context, key), "unknown meshset key");
  }
 
  if (entry.typeName.empty()) {
    CHKERR failConfig(file_name, makeContext(context, "type"),
                      "missing meshset type");
  }
  if (!has_meshset_id && entry.meshsetName.empty()) {
    CHKERR failConfig(file_name, context,
                      "meshset requires either 'id' or 'meshset_name'");
  }
 
  if (meshsets_manager_ptr) {
    int resolved_meshset_id = -1;
    std::string resolved_meshset_name;
    CHKERR resolveMeshsetIdAndName(
        *meshsets_manager_ptr, has_meshset_id, entry.meshsetId,
        entry.meshsetName, file_name, context, resolved_meshset_id,
        resolved_meshset_name);
    entry.meshsetId = resolved_meshset_id;
    entry.appliedMeshsetId = resolved_meshset_id;
    entry.sourceMeshsetName = resolved_meshset_name;
  }
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode parseMeshsets(const JsonArray &meshsets,
                             const std::string &mesh_context,
                             const std::string &file_name,
                             MeshsetsManager *meshsets_manager_ptr,
                             std::vector<ParsedMeshsetEntry> &parsed_meshsets) {
  MoFEMFunctionBegin;
  parsed_meshsets.clear();
  parsed_meshsets.reserve(meshsets.size());
 
  for (size_t meshset_index = 0; meshset_index != meshsets.size();
       ++meshset_index) {
    const auto current_meshset_context =
        meshsetContext(mesh_context, meshset_index);
    const auto &meshset_object =
        requireObject(meshsets[meshset_index], file_name, current_meshset_context);
 
    ParsedMeshsetEntry entry;
    CHKERR parseMeshsetEntry(meshset_object, file_name, current_meshset_context,
                             meshsets_manager_ptr, entry);
    parsed_meshsets.push_back(std::move(entry));
  }
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode validateMeshsets(const JsonArray &meshsets,
                                const std::string &mesh_context,
                                const std::string &file_name) {
  MoFEMFunctionBegin;
  std::vector<ParsedMeshsetEntry> ignored_meshsets;
  CHKERR parseMeshsets(meshsets, mesh_context, file_name, nullptr,
                       ignored_meshsets);
  MoFEMFunctionReturn(0);
}
 
BlocksetParams getBlocksetParams(const ParsedMeshsetEntry &entry,
                                 const std::string &file_name) {
  BlocksetParams params;
  for (const auto &item : entry.attributes) {
    const auto key = toStdString(item.key());
    params[toLowerCopy(key)] = requireBlockAttributeValue(
        item.value(), file_name, makeContext(meshsetAttributesContext(entry), key));
  }
  return params;
}
 
BlocksetParamKey getBlocksetParamKey(const ParsedMeshsetEntry &entry,
                                     const int meshset_id) {
  return {toLowerCopy(entry.typeName), meshset_id};
}
 
MoFEMErrorCode cacheResolvedBlocksetParams(
    const std::vector<ParsedMeshsetEntry> &parsed_meshsets,
    const std::string &file_name, BlocksetParamsByKey &params_by_key,
    std::set<int> &used_blockset_ids) {
  MoFEMFunctionBegin;
  params_by_key.clear();
  used_blockset_ids.clear();
 
  for (const auto &entry : parsed_meshsets) {
    used_blockset_ids.insert(entry.meshsetId);
 
    if (!params_by_key
             .emplace(getBlocksetParamKey(entry, entry.meshsetId),
                      getBlocksetParams(entry, file_name))
             .second) {
      CHKERR failConfig(
          file_name, entry.context,
          "duplicate JSON meshset entry for type '" + entry.typeName +
              "' and id '" +
              boost::lexical_cast<std::string>(entry.meshsetId) + "'");
    }
  }
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode cacheAppliedBlocksetParams(
    const std::vector<ParsedMeshsetEntry> &parsed_meshsets,
    const std::string &file_name, BlocksetParamsByKey &params_by_key) {
  MoFEMFunctionBegin;
  for (const auto &entry : parsed_meshsets) {
    if (entry.appliedMeshsetId != entry.meshsetId) {
      params_by_key[getBlocksetParamKey(entry, entry.appliedMeshsetId)] =
          getBlocksetParams(entry, file_name);
    }
  }
  MoFEMFunctionReturn(0);
}
 
int firstGeneratedBlocksetId(MeshsetsManager &meshsets_manager) {
  int next_id = 1;
  for (auto it = meshsets_manager.getBegin(); it != meshsets_manager.getEnd();
       ++it) {
    if ((it->getBcType() & CubitBCType(BLOCKSET)).any()) {
      next_id = std::max(next_id, it->getMeshsetId() + 1);
    }
  }
  return next_id;
}
 
int takeNextFreeBlocksetId(MeshsetsManager &meshsets_manager, int &next_id) {
  while (meshsets_manager.checkMeshset(next_id, BLOCKSET)) {
    ++next_id;
  }
  return next_id++;
}
 
MoFEMErrorCode createBlocksetCopy(MeshsetsManager &meshsets_manager,
                                  const int source_id, const int new_id,
                                  const std::string &name) {
  MoFEMFunctionBegin;
  const CubitMeshSets *source_meshset = nullptr;
  CHKERR meshsets_manager.getCubitMeshsetPtr(source_id, BLOCKSET,
                                             &source_meshset);
 
  Interface &m_field = meshsets_manager.cOre;
  Range entities;
  CHKERR m_field.get_moab().get_entities_by_handle(source_meshset->getMeshset(),
                                                   entities, true);
 
  CHKERR meshsets_manager.addMeshset(BLOCKSET, new_id, name);
  if (!entities.empty()) {
    CHKERR meshsets_manager.addEntitiesToMeshset(BLOCKSET, new_id, entities);
  }
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode applyParsedMeshsets(
    MeshsetsManager &meshsets_manager,
    std::vector<ParsedMeshsetEntry> &parsed_meshsets,
    const std::string &file_name) {
  MoFEMFunctionBegin;
 
  std::map<int, int> applied_entries_by_source_id;
  int next_blockset_id = firstGeneratedBlocksetId(meshsets_manager);
 
  for (auto &entry : parsed_meshsets) {
    CHKERR ensureBlocksetExists(meshsets_manager, entry.meshsetId, file_name,
                                entry.context);
 
    entry.appliedMeshsetId = entry.meshsetId;
    auto &applied_entries = applied_entries_by_source_id[entry.meshsetId];
    if (applied_entries > 0) {
      // Reuse the source entities, but do not overwrite the previous type/name.
      entry.appliedMeshsetId =
          takeNextFreeBlocksetId(meshsets_manager, next_blockset_id);
      CHKERR createBlocksetCopy(meshsets_manager, entry.meshsetId,
                                entry.appliedMeshsetId,
                                appliedBlocksetName(entry));
    }
    ++applied_entries;
 
    CHKERR applyBlockAttributes(meshsets_manager, entry.appliedMeshsetId,
                                entry.attributes, file_name,
                                meshsetAttributesContext(entry),
                                entry.typeName, appliedBlocksetName(entry));
  }
 
  MoFEMFunctionReturn(0);
}