JsonConfigManagerMeshsets.cpp File Reference

Go to the source code of this file.

Classes
struct	ParsedMeshsetEntry

Typedefs
using	BlocksetParamKey = std::pair< std::string, int >
using	BlocksetParams = std::map< std::string, double >
using	BlocksetParamsByKey = std::map< BlocksetParamKey, BlocksetParams >

Functions
int	centerAttributeSlot (const std::string &lower_key, const int first_slot)
int	positionalBlockAttributeSlot (const std::string &lower_type, const std::string &lower_key)
int	parseGenericBlockUserIndex (const std::string &lower_key)
double	requireBlockAttributeValue (const JsonValue &value, const std::string &file_name, const std::string &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)
std::string	meshsetContext (const std::string &mesh_context, const size_t meshset_index)
std::string	meshsetAttributesContext (const ParsedMeshsetEntry &entry)
std::string	appliedBlocksetName (const ParsedMeshsetEntry &entry)
MoFEMErrorCode	getUniqueBlocksetByName (MeshsetsManager &meshsets_manager, const std::string &meshset_name, const std::string &file_name, const std::string &context, const CubitMeshSets **blockset_ptr)
MoFEMErrorCode	getBlocksetById (MeshsetsManager &meshsets_manager, const int meshset_id, const std::string &file_name, const std::string &context, const CubitMeshSets **blockset_ptr)
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)
MoFEMErrorCode	parseMeshsetEntry (const JsonObject &meshset_object, const std::string &file_name, const std::string &context, MeshsetsManager *meshsets_manager_ptr, ParsedMeshsetEntry &entry)
MoFEMErrorCode	parseMeshsets (const JsonArray &meshsets, const std::string &mesh_context, const std::string &file_name, MeshsetsManager *meshsets_manager_ptr, std::vector< ParsedMeshsetEntry > &parsed_meshsets)
MoFEMErrorCode	validateMeshsets (const JsonArray &meshsets, const std::string &mesh_context, const std::string &file_name)
BlocksetParams	getBlocksetParams (const ParsedMeshsetEntry &entry, const std::string &file_name)
BlocksetParamKey	getBlocksetParamKey (const ParsedMeshsetEntry &entry, const int 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)
MoFEMErrorCode	cacheAppliedBlocksetParams (const std::vector< ParsedMeshsetEntry > &parsed_meshsets, const std::string &file_name, BlocksetParamsByKey &params_by_key)
int	firstGeneratedBlocksetId (MeshsetsManager &meshsets_manager)
int	takeNextFreeBlocksetId (MeshsetsManager &meshsets_manager, int &next_id)
MoFEMErrorCode	createBlocksetCopy (MeshsetsManager &meshsets_manager, const int source_id, const int new_id, const std::string &name)
MoFEMErrorCode	applyParsedMeshsets (MeshsetsManager &meshsets_manager, std::vector< ParsedMeshsetEntry > &parsed_meshsets, const std::string &file_name)

Typedef Documentation

BlocksetParamKey

using BlocksetParamKey = std::pair<std::string, int>

Definition at line 166 of file JsonConfigManagerMeshsets.cpp.

BlocksetParams

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

Definition at line 167 of file JsonConfigManagerMeshsets.cpp.

BlocksetParamsByKey

using BlocksetParamsByKey = std::map<BlocksetParamKey, BlocksetParams>

Definition at line 168 of file JsonConfigManagerMeshsets.cpp.

Function Documentation

appliedBlocksetName()

std::string appliedBlocksetName

(

const ParsedMeshsetEntry &

entry

)

Definition at line 174 of file JsonConfigManagerMeshsets.cpp.

                                                               {
  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);
}

applyBlockAttributes()

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
	)

Definition at line 87 of file JsonConfigManagerMeshsets.cpp.

                                                                    {
  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);
}

applyParsedMeshsets()

MoFEMErrorCode applyParsedMeshsets	(	MeshsetsManager &	meshsets_manager,
		std::vector< ParsedMeshsetEntry > &	parsed_meshsets,
		const std::string &	file_name
	)

Definition at line 454 of file JsonConfigManagerMeshsets.cpp.

                                {
  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);
}

cacheAppliedBlocksetParams()

MoFEMErrorCode cacheAppliedBlocksetParams	(	const std::vector< ParsedMeshsetEntry > &	parsed_meshsets,
		const std::string &	file_name,
		BlocksetParamsByKey &	params_by_key
	)

Definition at line 403 of file JsonConfigManagerMeshsets.cpp.

                                                                    {
  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);
}

cacheResolvedBlocksetParams()

MoFEMErrorCode cacheResolvedBlocksetParams	(	const std::vector< ParsedMeshsetEntry > &	parsed_meshsets,
		const std::string &	file_name,
		BlocksetParamsByKey &	params_by_key,
		std::set< int > &	used_blockset_ids
	)

Definition at line 378 of file JsonConfigManagerMeshsets.cpp.

                                    {
  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);
}

centerAttributeSlot()

int centerAttributeSlot	(	const std::string &	lower_key,
		const int	first_slot
	)

Definition at line 1 of file JsonConfigManagerMeshsets.cpp.

                                                                          {
  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;
}

createBlocksetCopy()

MoFEMErrorCode createBlocksetCopy	(	MeshsetsManager &	meshsets_manager,
		const int	source_id,
		const int	new_id,
		const std::string &	name
	)

Definition at line 434 of file JsonConfigManagerMeshsets.cpp.

                                                         {
  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);
}

firstGeneratedBlocksetId()

int firstGeneratedBlocksetId

(

MeshsetsManager &

meshsets_manager

)

Definition at line 416 of file JsonConfigManagerMeshsets.cpp.

                                                                {
  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;
}

getBlocksetById()

MoFEMErrorCode getBlocksetById	(	MeshsetsManager &	meshsets_manager,
		const int	meshset_id,
		const std::string &	file_name,
		const std::string &	context,
		const CubitMeshSets **	blockset_ptr
	)

Definition at line 219 of file JsonConfigManagerMeshsets.cpp.

                                                                   {
  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);
}

getBlocksetParamKey()

BlocksetParamKey getBlocksetParamKey	(	const ParsedMeshsetEntry &	entry,
		const int	meshset_id
	)

Definition at line 373 of file JsonConfigManagerMeshsets.cpp.

                                                           {
  return {toLowerCopy(entry.typeName), meshset_id};
}

getBlocksetParams()

BlocksetParams getBlocksetParams	(	const ParsedMeshsetEntry &	entry,
		const std::string &	file_name
	)

Definition at line 362 of file JsonConfigManagerMeshsets.cpp.

                                                             {
  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;
}

getUniqueBlocksetByName()

MoFEMErrorCode getUniqueBlocksetByName	(	MeshsetsManager &	meshsets_manager,
		const std::string &	meshset_name,
		const std::string &	file_name,
		const std::string &	context,
		const CubitMeshSets **	blockset_ptr
	)

Definition at line 186 of file JsonConfigManagerMeshsets.cpp.

                                                                           {
  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);
}

meshsetAttributesContext()

std::string meshsetAttributesContext

(

const ParsedMeshsetEntry &

entry

)

Definition at line 170 of file JsonConfigManagerMeshsets.cpp.

                                                                    {
  return makeContext(entry.context, "attributes");
}

meshsetContext()

std::string meshsetContext	(	const std::string &	mesh_context,
		const size_t	meshset_index
	)

Definition at line 150 of file JsonConfigManagerMeshsets.cpp.

                                                       {
  return mesh_context + ".meshsets[" +
         boost::lexical_cast<std::string>(meshset_index) + "]";
}

parseGenericBlockUserIndex()

int parseGenericBlockUserIndex

(

const std::string &

lower_key

)

Definition at line 66 of file JsonConfigManagerMeshsets.cpp.

                                                           {
  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;
  }
}

parseMeshsetEntry()

MoFEMErrorCode parseMeshsetEntry	(	const JsonObject &	meshset_object,
		const std::string &	file_name,
		const std::string &	context,
		MeshsetsManager *	meshsets_manager_ptr,
		ParsedMeshsetEntry &	entry
	)

Definition at line 268 of file JsonConfigManagerMeshsets.cpp.

                                                            {
  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);
}

parseMeshsets()

MoFEMErrorCode parseMeshsets	(	const JsonArray &	meshsets,
		const std::string &	mesh_context,
		const std::string &	file_name,
		MeshsetsManager *	meshsets_manager_ptr,
		std::vector< ParsedMeshsetEntry > &	parsed_meshsets
	)

Definition at line 328 of file JsonConfigManagerMeshsets.cpp.

                                                                             {
  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);
}

positionalBlockAttributeSlot()

int positionalBlockAttributeSlot	(	const std::string &	lower_type,
		const std::string &	lower_key
	)

Definition at line 11 of file JsonConfigManagerMeshsets.cpp.

                                                             {
  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;
}

requireBlockAttributeValue()

double requireBlockAttributeValue	(	const JsonValue &	value,
		const std::string &	file_name,
		const std::string &	context
	)

Definition at line 78 of file JsonConfigManagerMeshsets.cpp.

                                                            {
  if (value.is_bool())
    return value.as_bool() ? 1.0 : 0.0;
 
  return requireNumber(value, file_name, context);
}

resolveMeshsetIdAndName()

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
	)

Definition at line 235 of file JsonConfigManagerMeshsets.cpp.

                                                                {
  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);
}

takeNextFreeBlocksetId()

int takeNextFreeBlocksetId	(	MeshsetsManager &	meshsets_manager,
		int &	next_id
	)

Definition at line 427 of file JsonConfigManagerMeshsets.cpp.

                                                                            {
  while (meshsets_manager.checkMeshset(next_id, BLOCKSET)) {
    ++next_id;
  }
  return next_id++;
}

validateMeshsets()

MoFEMErrorCode validateMeshsets	(	const JsonArray &	meshsets,
		const std::string &	mesh_context,
		const std::string &	file_name
	)

Definition at line 352 of file JsonConfigManagerMeshsets.cpp.

                                                            {
  MoFEMFunctionBegin;
  std::vector<ParsedMeshsetEntry> ignored_meshsets;
  CHKERR parseMeshsets(meshsets, mesh_context, file_name, nullptr,
                       ignored_meshsets);
  MoFEMFunctionReturn(0);
}