// ======================================================================== 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); } } } }
int get_entity_subcell_id(const BulkData& mesh, const Entity entity, const EntityRank subcell_rank, stk::topology subcell_topology, const std::vector<Entity>& subcell_nodes) { ThrowAssert(subcell_rank <= stk::topology::ELEMENT_RANK); const int INVALID_SIDE = -1; stk::topology entity_topology = mesh.bucket(entity).topology(); ThrowAssert(entity_topology.num_nodes() == mesh.num_nodes(entity)); const Entity* entity_nodes = mesh.begin_nodes(entity); std::vector<Entity> topology_sub_nodes(subcell_nodes.size()); for(size_t i = 0; i < entity_topology.num_sub_topology(subcell_rank); ++i) { entity_topology.sub_topology_nodes(entity_nodes, subcell_rank, i, topology_sub_nodes.begin()); if(subcell_topology.equivalent(topology_sub_nodes, subcell_nodes).first) { return i; } } return INVALID_SIDE; }
stk::mesh::Permutation get_permutation_of_side_nodes(stk::topology sideTopology, const stk::mesh::Entity *sideNodes, const stk::mesh::Entity *elemSideNodes) { std::pair<bool, unsigned> result = sideTopology.equivalent(sideNodes, elemSideNodes); return static_cast<stk::mesh::Permutation>(result.second); }
ScratchViews::ScratchViews(const TeamHandleType& team, const stk::mesh::BulkData& bulkData, stk::topology topo, ElemDataRequests& dataNeeded) : elemNodes(nullptr), scs_areav(), dndx(), dndx_shifted(), deriv(), det_j(), scv_volume(), gijUpper(), gijLower() { /* master elements are allowed to be null if they are not required */ MasterElement *meSCS = dataNeeded.get_cvfem_surface_me(); MasterElement *meSCV = dataNeeded.get_cvfem_volume_me(); int nDim = bulkData.mesh_meta_data().spatial_dimension(); int nodesPerElem = topo.num_nodes(); int numScsIp = meSCS != nullptr ? meSCS->numIntPoints_ : 0; int numScvIp = meSCV != nullptr ? meSCV->numIntPoints_ : 0; create_needed_field_views(team, dataNeeded, bulkData, nodesPerElem); create_needed_master_element_views(team, dataNeeded, nDim, nodesPerElem, numScsIp, numScvIp); }
Entity declare_element_to_entity(BulkData & mesh, Entity elem, Entity entity, const unsigned relationOrdinal, const PartVector& parts, stk::topology entity_top) { stk::topology elem_top = mesh.bucket(elem).topology(); std::vector<unsigned> entity_node_ordinals(entity_top.num_nodes()); elem_top.sub_topology_node_ordinals(mesh.entity_rank(entity), relationOrdinal, entity_node_ordinals.begin()); const stk::mesh::Entity *elem_nodes = mesh.begin_nodes(elem); EntityVector entity_top_nodes(entity_top.num_nodes()); elem_top.sub_topology_nodes(elem_nodes, mesh.entity_rank(entity), relationOrdinal, entity_top_nodes.begin()); Permutation perm = mesh.find_permutation(elem_top, elem_nodes, entity_top, &entity_top_nodes[0], relationOrdinal); OrdinalVector ordinal_scratch; ordinal_scratch.reserve(64); PartVector part_scratch; part_scratch.reserve(64); if(!parts.empty()) { mesh.change_entity_parts(entity, parts); } const stk::mesh::ConnectivityOrdinal *side_ordinals = mesh.begin_ordinals(elem, mesh.entity_rank(entity)); unsigned num_sides = mesh.count_valid_connectivity(elem, mesh.entity_rank(entity)); bool elem_to_side_exists = false; for(unsigned i = 0; i < num_sides; ++i) { if(side_ordinals[i] == relationOrdinal) { elem_to_side_exists = true; break; } } if(!elem_to_side_exists) { mesh.declare_relation(elem, entity, relationOrdinal, perm, ordinal_scratch, part_scratch); } const unsigned num_side_nodes = mesh.count_valid_connectivity(entity, stk::topology::NODE_RANK); if(0 == num_side_nodes) { Permutation node_perm = stk::mesh::Permutation::INVALID_PERMUTATION; Entity const *elem_nodes_local = mesh.begin_nodes(elem); for(unsigned i = 0; i < entity_top.num_nodes(); ++i) { Entity node = elem_nodes_local[entity_node_ordinals[i]]; mesh.declare_relation(entity, node, i, node_perm, ordinal_scratch, part_scratch); } } else { ThrowAssertMsg(num_side_nodes == entity_top.num_nodes(), "declare_element_to_entity: " << mesh.entity_key(entity) << " already exists with different number of nodes."); } return entity; }
std::string get_topology(stk::topology topology) { if(topology==stk::topology::INVALID_TOPOLOGY) return " "; return " (" + topology.name() + ") "; }
void verify_unbuildable_element(stk::mesh::BulkData &bulk, const stk::topology topo, const stk::mesh::EntityIdVector & elem_node_ids, const stk::mesh::EntityIdVector & side_ids, const std::vector < std::vector < unsigned > > &gold_side_node_ids, bool *sides_connectibility_check, const stk::mesh::EntityIdVector & edge_ids, const std::vector < std::vector < unsigned > > &gold_edge_node_ids, bool *edges_connectibility_check) { stk::mesh::EntityId element_id[1] = {1}; stk::mesh::MetaData &meta = bulk.mesh_meta_data(); stk::mesh::Part &elem_part = meta.declare_part_with_topology("elem_part", topo); meta.commit(); bulk.modification_begin(); stk::mesh::Entity elem = stk::mesh::declare_element(bulk, elem_part, element_id[0], elem_node_ids); stk::mesh::EntityVector side_nodes; uint num_sides = topo.num_sides(); stk::topology::rank_t sub_topo_rank = topo.side_rank(); for(uint i = 0; i < num_sides; ++i) { stk::topology sub_topo = topo.side_topology(i); side_nodes.clear(); stk::mesh::Entity side = bulk.declare_entity(sub_topo_rank, side_ids[i], meta.get_topology_root_part(sub_topo)); for (uint j = 0; j < sub_topo.num_nodes(); ++j) { stk::mesh::Entity side_node = bulk.get_entity(stk::topology::NODE_RANK, gold_side_node_ids[i][j]); side_nodes.push_back(side_node); bulk.declare_relation(side, side_node, j); } std::pair<stk::mesh::ConnectivityOrdinal, stk::mesh::Permutation> ordinalAndPermutation = stk::mesh::get_ordinal_and_permutation(bulk, elem, sub_topo_rank, side_nodes); if (sides_connectibility_check[i]) { EXPECT_NE(ordinalAndPermutation.first, stk::mesh::ConnectivityOrdinal::INVALID_CONNECTIVITY_ORDINAL); EXPECT_NE(ordinalAndPermutation.second, stk::mesh::Permutation::INVALID_PERMUTATION); } else { EXPECT_EQ(ordinalAndPermutation.first, stk::mesh::ConnectivityOrdinal::INVALID_CONNECTIVITY_ORDINAL); EXPECT_EQ(ordinalAndPermutation.second, stk::mesh::Permutation::INVALID_PERMUTATION); } } if (edge_ids.empty()) { bulk.modification_end(); return; } stk::mesh::EntityVector edge_nodes; uint num_edges = topo.num_edges(); for(uint i = 0; i < num_edges; ++i) { edge_nodes.clear(); stk::mesh::Entity edge = bulk.declare_entity(stk::topology::EDGE_RANK, edge_ids[i], meta.get_topology_root_part(topo.edge_topology())); for (uint j = 0; j < topo.edge_topology().num_nodes(); ++j) { stk::mesh::Entity edge_node = bulk.get_entity(stk::topology::NODE_RANK, gold_edge_node_ids[i][j]); edge_nodes.push_back(edge_node); bulk.declare_relation(edge, edge_node, j); } std::pair<stk::mesh::ConnectivityOrdinal, stk::mesh::Permutation> ordinalAndPermutation = stk::mesh::get_ordinal_and_permutation(bulk, elem, stk::topology::EDGE_RANK, edge_nodes); if (edges_connectibility_check[i]) { EXPECT_NE(ordinalAndPermutation.first, stk::mesh::ConnectivityOrdinal::INVALID_CONNECTIVITY_ORDINAL); EXPECT_NE(ordinalAndPermutation.second, stk::mesh::Permutation::INVALID_PERMUTATION); } else { EXPECT_EQ(ordinalAndPermutation.first, stk::mesh::ConnectivityOrdinal::INVALID_CONNECTIVITY_ORDINAL); EXPECT_EQ(ordinalAndPermutation.second, stk::mesh::Permutation::INVALID_PERMUTATION); } } bulk.modification_end(); }
void build_element_from_topology_verify_ordinals_and_permutations(stk::mesh::BulkData &bulk, const stk::topology topo, const stk::mesh::EntityIdVector & elem_node_ids, const stk::mesh::EntityIdVector & edge_ids, const std::vector < std::vector < unsigned > > &gold_side_node_ids, const unsigned * gold_side_permutations, const std::vector < std::vector < unsigned > > &gold_edge_node_ids, const unsigned * gold_edge_permutations) { stk::mesh::EntityId element_id[1] = {1}; stk::mesh::MetaData &meta = bulk.mesh_meta_data(); stk::mesh::Part &elem_part = meta.declare_part_with_topology("elem_part", topo); meta.commit(); bulk.modification_begin(); stk::mesh::Entity elem = stk::mesh::declare_element(bulk, elem_part, element_id[0], elem_node_ids); stk::mesh::EntityVector side_nodes; uint num_sides = topo.num_sides(); stk::topology::rank_t sub_topo_rank = topo.side_rank(); for(uint i = 0; i < num_sides; ++i) { stk::topology sub_topo = topo.side_topology(i); bulk.declare_element_side(elem, i, {&meta.get_topology_root_part(sub_topo)}); side_nodes.clear(); for (uint j = 0; j < sub_topo.num_nodes(); ++j) { stk::mesh::Entity side_node = bulk.get_entity(stk::topology::NODE_RANK, gold_side_node_ids[i][j]); side_nodes.push_back(side_node); } stk::mesh::OrdinalAndPermutation ordinalAndPermutation = stk::mesh::get_ordinal_and_permutation(bulk, elem, sub_topo_rank, side_nodes); EXPECT_EQ(ordinalAndPermutation.second, gold_side_permutations[i]) << topo; EXPECT_EQ(ordinalAndPermutation.first, i) << topo; } if (edge_ids.empty()) { bulk.modification_end(); return; } stk::mesh::EntityVector edge_nodes; uint num_edges = topo.num_edges(); for(uint i = 0; i < num_edges; ++i) { edge_nodes.clear(); stk::mesh::Entity edge = bulk.declare_entity(stk::topology::EDGE_RANK, edge_ids[i], meta.get_topology_root_part(topo.edge_topology())); for (uint j = 0; j < topo.edge_topology().num_nodes(); ++j) { stk::mesh::Entity edge_node = bulk.get_entity(stk::topology::NODE_RANK, gold_edge_node_ids[i][j]); edge_nodes.push_back(edge_node); bulk.declare_relation(edge, edge_node, j); } std::pair<stk::mesh::ConnectivityOrdinal, stk::mesh::Permutation> ordinalAndPermutation = stk::mesh::get_ordinal_and_permutation(bulk, elem, stk::topology::EDGE_RANK, edge_nodes); EXPECT_EQ(ordinalAndPermutation.second, gold_edge_permutations[i]) << topo; EXPECT_EQ(ordinalAndPermutation.first, i) << topo; } bulk.modification_end(); }
void fill_pre_req_data( ElemDataRequests& dataNeeded, const stk::mesh::BulkData& bulkData, stk::topology topo, stk::mesh::Entity elem, const stk::mesh::FieldBase* coordField, ScratchViews& prereqData) { int nodesPerElem = topo.num_nodes(); MasterElement *meSCS = dataNeeded.get_cvfem_surface_me(); MasterElement *meSCV = dataNeeded.get_cvfem_volume_me(); prereqData.elemNodes = bulkData.begin_nodes(elem); const FieldSet& neededFields = dataNeeded.get_fields(); for(const FieldInfo& fieldInfo : neededFields) { stk::mesh::EntityRank fieldEntityRank = fieldInfo.field->entity_rank(); unsigned scalarsDim1 = fieldInfo.scalarsDim1; bool isTensorField = fieldInfo.scalarsDim2 > 1; if (fieldEntityRank==stk::topology::ELEM_RANK) { if (isTensorField) { SharedMemView<double**>& shmemView = prereqData.get_scratch_view_2D(*fieldInfo.field); gather_elem_tensor_field(*fieldInfo.field, elem, scalarsDim1, fieldInfo.scalarsDim2, shmemView); } else { SharedMemView<double*>& shmemView = prereqData.get_scratch_view_1D(*fieldInfo.field); unsigned len = shmemView.dimension(0); double* fieldDataPtr = static_cast<double*>(stk::mesh::field_data(*fieldInfo.field, elem)); for(unsigned i=0; i<len; ++i) { shmemView(i) = fieldDataPtr[i]; } } } else if (fieldEntityRank == stk::topology::NODE_RANK) { if (isTensorField) { SharedMemView<double***>& shmemView3D = prereqData.get_scratch_view_3D(*fieldInfo.field); gather_elem_node_tensor_field(*fieldInfo.field, nodesPerElem, scalarsDim1, fieldInfo.scalarsDim2, bulkData.begin_nodes(elem), shmemView3D); } else { if (scalarsDim1 == 1) { SharedMemView<double*>& shmemView1D = prereqData.get_scratch_view_1D(*fieldInfo.field); gather_elem_node_field(*fieldInfo.field, nodesPerElem, prereqData.elemNodes, shmemView1D); } else { SharedMemView<double**>& shmemView2D = prereqData.get_scratch_view_2D(*fieldInfo.field); if (scalarsDim1 == 3) { gather_elem_node_field_3D(*fieldInfo.field, nodesPerElem, prereqData.elemNodes, shmemView2D); } else { gather_elem_node_field(*fieldInfo.field, nodesPerElem, scalarsDim1, prereqData.elemNodes, shmemView2D); } } } } else { ThrowRequireMsg(false, "Only node and element fields supported currently."); } } SharedMemView<double**>* coordsView = nullptr; if (coordField != nullptr) { coordsView = &prereqData.get_scratch_view_2D(*coordField); } const std::set<ELEM_DATA_NEEDED>& dataEnums = dataNeeded.get_data_enums(); double error = 0; for(ELEM_DATA_NEEDED data : dataEnums) { switch(data) { case SCS_AREAV: ThrowRequireMsg(meSCS != nullptr, "ERROR, meSCS needs to be non-null if SCS_AREAV is requested."); ThrowRequireMsg(coordsView != nullptr, "ERROR, coords null but SCS_AREAV requested."); meSCS->determinant(1, &((*coordsView)(0,0)), &prereqData.scs_areav(0,0), &error); break; case SCS_GRAD_OP: ThrowRequireMsg(meSCS != nullptr, "ERROR, meSCS needs to be non-null if SCS_GRAD_OP is requested."); ThrowRequireMsg(coordsView != nullptr, "ERROR, coords null but SCS_GRAD_OP requested."); meSCS->grad_op(1, &((*coordsView)(0,0)), &prereqData.dndx(0,0,0), &prereqData.deriv(0), &prereqData.det_j(0), &error); break; case SCS_SHIFTED_GRAD_OP: ThrowRequireMsg(meSCS != nullptr, "ERROR, meSCS needs to be non-null if SCS_GRAD_OP is requested."); ThrowRequireMsg(coordsView != nullptr, "ERROR, coords null but SCS_GRAD_OP requested."); meSCS->shifted_grad_op(1, &((*coordsView)(0,0)), &prereqData.dndx_shifted(0,0,0), &prereqData.deriv(0), &prereqData.det_j(0), &error); break; case SCS_GIJ: ThrowRequireMsg(meSCS != nullptr, "ERROR, meSCS needs to be non-null if SCS_GIJ is requested."); ThrowRequireMsg(coordsView != nullptr, "ERROR, coords null but SCS_GIJ requested."); meSCS->gij(&((*coordsView)(0,0)), &prereqData.gijUpper(0,0,0), &prereqData.gijLower(0,0,0), &prereqData.deriv(0)); break; case SCV_VOLUME: ThrowRequireMsg(meSCV != nullptr, "ERROR, meSCV needs to be non-null if SCV_VOLUME is requested."); ThrowRequireMsg(coordsView != nullptr, "ERROR, coords null but SCV_VOLUME requested."); meSCV->determinant(1, &((*coordsView)(0,0)), &prereqData.scv_volume(0), &error); break; default: break; } } }