Block::Block(const Ioss::ElementBlock &other)
{
id = other.get_property("id").get_int();
elementCount = other.get_property("entity_count").get_int();
nodesPerElement = other.get_property("topology_node_count").get_int();
attributeCount = other.get_property("attribute_count").get_int();
offset_ = other.get_offset();
std::string el_type = other.get_property("topology_type").get_string();
if (other.property_exists("original_topology_type")) {
el_type = other.get_property("original_topology_type").get_string();
}
std::strncpy(elType, el_type.c_str(), MAX_STR_LENGTH);
elType[MAX_STR_LENGTH] = 0;
// Fixup an exodusII kludge. For triangular elements, the same
// name is used for 2D elements and 3D shell elements. Convert
// to unambiguous names for the IO Subsystem. The 2D name
// stays the same, the 3D name becomes 'trishell#'
// Here, we need to map back to the 'triangle' name...
if (std::strncmp(elType, "trishell", 8) == 0)
std::strncpy(elType, "triangle", 8);
std::string io_name = other.name();
std::strncpy(name, io_name.c_str(), MAX_STR_LENGTH);
name[MAX_STR_LENGTH] = 0;
}
// ========================================================================
void process_elementblocks(Ioss::Region ®ion, stk::mesh::BulkData &bulk)
{
const Ioss::ElementBlockContainer& elem_blocks = region.get_element_blocks();
for(Ioss::ElementBlockContainer::const_iterator it = elem_blocks.begin();
it != elem_blocks.end(); ++it) {
Ioss::ElementBlock *entity = *it;
if (stk::io::include_entity(entity)) {
const std::string &name = entity->name();
const stk::mesh::MetaData& meta = stk::mesh::MetaData::get(bulk);
stk::mesh::Part* const part = meta.get_part(name);
STKIORequire(part != NULL);
const stk::topology topo = part->topology();
if (topo == stk::topology::INVALID_TOPOLOGY) {
std::ostringstream msg ;
msg << " INTERNAL_ERROR: Part " << part->name() << " returned INVALID from get_topology()";
throw std::runtime_error( msg.str() );
}
std::vector<int> elem_ids ;
std::vector<int> connectivity ;
entity->get_field_data("ids", elem_ids);
entity->get_field_data("connectivity", connectivity);
size_t element_count = elem_ids.size();
int nodes_per_elem = topo.num_nodes();
stk::mesh::EntityIdVector connectivity2(nodes_per_elem);
std::vector<int>::const_iterator connBegin = connectivity.begin();
std::vector<stk::mesh::Entity> elements(element_count);
for(size_t i=0; i<element_count; ++i, connBegin += nodes_per_elem) {
std::copy(connBegin, connBegin + nodes_per_elem, connectivity2.begin());
elements[i] = stk::mesh::declare_element(bulk, *part, elem_ids[i], connectivity2);
}
// For this example, we are just taking all attribute fields
// found on the io database and populating fields on the
// corresponding mesh part. In practice, would probably be
// selective about which attributes to use...
Ioss::NameList names;
entity->field_describe(Ioss::Field::ATTRIBUTE, &names);
for (Ioss::NameList::const_iterator I = names.begin(); I != names.end(); ++I) {
if (*I == "attribute" && names.size() > 1)
continue;
stk::mesh::FieldBase *field = meta.get_field<stk::mesh::FieldBase>(stk::topology::ELEMENT_RANK, *I);
stk::io::field_data_from_ioss(bulk, field, elements, entity, *I);
}
}
}
}
AxisAlignedBoundingBox DatabaseIO::get_bounding_box(const Ioss::ElementBlock *eb) const
{
if (elementBlockBoundingBoxes.empty()) {
// Calculate the bounding boxes for all element blocks...
std::vector<double> coordinates;
Ioss::NodeBlock * nb = get_region()->get_node_blocks()[0];
nb->get_field_data("mesh_model_coordinates", coordinates);
ssize_t nnode = nb->get_property("entity_count").get_int();
ssize_t ndim = nb->get_property("component_degree").get_int();
Ioss::ElementBlockContainer element_blocks = get_region()->get_element_blocks();
size_t nblock = element_blocks.size();
std::vector<double> minmax;
minmax.reserve(6 * nblock);
for (auto &block : element_blocks) {
double xmin, ymin, zmin, xmax, ymax, zmax;
if (block->get_database()->int_byte_size_api() == 8) {
std::vector<int64_t> connectivity;
block->get_field_data("connectivity_raw", connectivity);
calc_bounding_box(ndim, nnode, coordinates, connectivity, xmin, ymin, zmin, xmax, ymax,
zmax);
}
else {
std::vector<int> connectivity;
block->get_field_data("connectivity_raw", connectivity);
calc_bounding_box(ndim, nnode, coordinates, connectivity, xmin, ymin, zmin, xmax, ymax,
zmax);
}
minmax.push_back(xmin);
minmax.push_back(ymin);
minmax.push_back(zmin);
minmax.push_back(-xmax);
minmax.push_back(-ymax);
minmax.push_back(-zmax);
}
util().global_array_minmax(minmax, Ioss::ParallelUtils::DO_MIN);
for (size_t i = 0; i < element_blocks.size(); i++) {
Ioss::ElementBlock * block = element_blocks[i];
const std::string & name = block->name();
AxisAlignedBoundingBox bbox(minmax[6 * i + 0], minmax[6 * i + 1], minmax[6 * i + 2],
-minmax[6 * i + 3], -minmax[6 * i + 4], -minmax[6 * i + 5]);
elementBlockBoundingBoxes[name] = bbox;
}
}
return elementBlockBoundingBoxes[eb->name()];
}
// ========================================================================
void process_elementblocks(Ioss::Region ®ion, stk::mesh::MetaData &meta)
{
const stk::mesh::EntityRank element_rank = stk::topology::ELEMENT_RANK;
const Ioss::ElementBlockContainer& elem_blocks = region.get_element_blocks();
stk::io::default_part_processing(elem_blocks, meta, element_rank);
// Parts were created above, now handle element block specific
// information (topology, attributes, ...);
for(Ioss::ElementBlockContainer::const_iterator it = elem_blocks.begin();
it != elem_blocks.end(); ++it) {
Ioss::ElementBlock *entity = *it;
if (stk::io::include_entity(entity)) {
stk::mesh::Part* const part = meta.get_part(entity->name());
STKIORequire(part != NULL);
const stk::mesh::EntityRank part_rank = part->primary_entity_rank();
// Element Block attributes (if any)...
/** \todo IMPLEMENT truly handle attribute fields... For this
* case we are just defining a field for each attribute field
* that is present in the mesh...
*/
stk::io::define_io_fields(entity, Ioss::Field::ATTRIBUTE,
*part,
part_rank);
/** \todo IMPLEMENT truly handle fields... For this case we
* are just defining a field for each transient field that is
* present in the mesh...
*/
stk::io::define_io_fields(entity, Ioss::Field::TRANSIENT,
*part,
part_rank);
}
}
}