JsonConfigManagerMeshsets.cpp

Go to the documentation of this file.

int canonicalAttributeOrder(const std::string &lower_key) {
  const auto &ordering = JsonConfigManager::canonical_attributes_ordering;
  const auto it = std::find_if(
      ordering.begin(), ordering.end(), [&](const std::string &name) {
        return toLowerCopy(name) == lower_key;
      });
  if (it == ordering.end()) {
    return -1;
  }
  return static_cast<int>(std::distance(ordering.begin(), it));
}
 
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 &blockset_name) {
  MoFEMFunctionBegin;
  std::map<int, double> ordered_values;
 
  for (const auto &item : props) {
    if (item.value().is_string()) {
      continue;
    }
 
    const auto key = toStdString(item.key());
    const auto lower_key = toLowerCopy(key);
    const auto order = canonicalAttributeOrder(lower_key);
    if (order < 0) {
      continue;
    }
    ordered_values[order] = requireBlockAttributeValue(
        item.value(), file_name, makeContext(context, key));
  }
 
  if (ordered_values.size() > MAX_MESHSET_ATTRIBUTES) {
    CHKERR failConfig(
        file_name, context,
        "BLOCKSET attributes exceed maximum supported direct attribute count " +
            boost::lexical_cast<std::string>(MAX_MESHSET_ATTRIBUTES));
  }
 
  std::vector<double> values;
  values.reserve(ordered_values.size());
  for (const auto &attribute : ordered_values) {
    values.push_back(attribute.second);
  }
 
  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>;
using BlocksetStringParams = std::map<std::string, std::string>;
using BlocksetStringParamsByKey =
    std::map<BlocksetParamKey, BlocksetStringParams>;
 
std::string meshsetAttributesContext(const ParsedMeshsetEntry &entry) {
  return makeContext(entry.context, "attributes");
}
 
std::string appliedBlocksetName(const ParsedMeshsetEntry &entry) {
  const auto id = boost::lexical_cast<std::string>(entry.appliedMeshsetId);
  const auto max_name_size = NAME_TAG_SIZE - 1;
  const auto type_id_name = entry.typeName + "_" + id;
 
  if (type_id_name.size() > max_name_size) {
    std::ostringstream ss;
    ss << "JSON " << entry.context << ": generated BLOCKSET name '"
       << type_id_name << "' is too long (" << type_id_name.size()
       << " characters); cannot fit type and id into " << max_name_size
       << " characters";
    CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY, ss.str());
  }
 
  const auto &meshset_name = entry.meshsetName.empty() ? entry.sourceMeshsetName
                                                       : entry.meshsetName;
  if (meshset_name.empty() || meshset_name == entry.typeName) {
    return type_id_name;
  }
 
  const auto full_name = entry.typeName + "_" + meshset_name + "_" + id;
  if (full_name.size() <= max_name_size) {
    return full_name;
  }
 
  MOFEM_LOG("WORLD", Sev::warning)
      << "JSON " << entry.context << ": generated BLOCKSET name '"
      << full_name << "' is too long (" << full_name.size()
      << " characters); removed meshset_name and using '" << type_id_name
      << "'";
  return type_id_name;
}
 
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) {
    if (item.value().is_string()) {
      continue;
    }
 
    const auto key = toStdString(item.key());
    params[toLowerCopy(key)] = requireBlockAttributeValue(
        item.value(), file_name, makeContext(meshsetAttributesContext(entry), key));
  }
  return params;
}
 
BlocksetStringParams getBlocksetStringParams(const ParsedMeshsetEntry &entry,
                                             const std::string &file_name) {
  BlocksetStringParams params;
  for (const auto &item : entry.attributes) {
    if (!item.value().is_string()) {
      continue;
    }
 
    const auto key = toStdString(item.key());
    params[toLowerCopy(key)] = requireString(
        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,
    BlocksetStringParamsByKey &string_params_by_key,
    std::set<int> &used_blockset_ids) {
  MoFEMFunctionBegin;
  params_by_key.clear();
  string_params_by_key.clear();
  used_blockset_ids.clear();
 
  for (const auto &entry : parsed_meshsets) {
    used_blockset_ids.insert(entry.meshsetId);
 
    const auto param_key = getBlocksetParamKey(entry, entry.meshsetId);
    if (params_by_key.count(param_key) || string_params_by_key.count(param_key)) {
      CHKERR failConfig(
          file_name, entry.context,
          "duplicate JSON meshset entry for type '" + entry.typeName +
              "' and id '" +
              boost::lexical_cast<std::string>(entry.meshsetId) + "'");
    }
    params_by_key[param_key] = getBlocksetParams(entry, file_name);
    string_params_by_key[param_key] = getBlocksetStringParams(entry, file_name);
  }
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode cacheAppliedBlocksetParams(
    const std::vector<ParsedMeshsetEntry> &parsed_meshsets,
    const std::string &file_name, BlocksetParamsByKey &params_by_key,
    BlocksetStringParamsByKey &string_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);
      string_params_by_key[getBlocksetParamKey(entry, entry.appliedMeshsetId)] =
          getBlocksetStringParams(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];
    const bool make_copy = applied_entries > 0;
    if (make_copy) {
      entry.appliedMeshsetId =
          takeNextFreeBlocksetId(meshsets_manager, next_blockset_id);
    }
 
    const auto blockset_name = appliedBlocksetName(entry);
 
    if (make_copy) {
      // Reuse the source entities, but do not overwrite the previous type/name.
      CHKERR createBlocksetCopy(meshsets_manager, entry.meshsetId,
                                entry.appliedMeshsetId, blockset_name);
    }
    ++applied_entries;
 
    CHKERR applyBlockAttributes(meshsets_manager, entry.appliedMeshsetId,
                                entry.attributes, file_name,
                                meshsetAttributesContext(entry), blockset_name);
  }
 
  MoFEMFunctionReturn(0);
}