void performNodalMeshReduction(
stk::mesh::Part &samplePart,
stk::mesh::BulkData& bulkData)
{
const stk::mesh::MetaData &metaData = stk::mesh::MetaData::get(bulkData);
std::vector<stk::mesh::Entity> sampleNodes;
stk::mesh::get_selected_entities(samplePart, bulkData.buckets(stk::topology::NODE_RANK), sampleNodes);
const stk::mesh::Selector locallyOwned = stk::mesh::MetaData::get(bulkData).locally_owned_part();
std::vector<stk::mesh::Entity> relatedEntities;
typedef std::vector<stk::mesh::Entity>::const_iterator EntityIterator;
for (EntityIterator it(sampleNodes.begin()), it_end(sampleNodes.end()); it != it_end; ++it) {
for (stk::mesh::EntityRank r = stk::topology::NODE_RANK; r < metaData.entity_rank_count(); ++r) {
stk::mesh::Entity const* relations = bulkData.begin(*it, r);
const int num_rels = bulkData.num_connectivity(*it, r);
for (int i = 0; i < num_rels; ++i) {
stk::mesh::Entity relatedEntity = relations[i];
if (bulkData.is_valid(relatedEntity) && locallyOwned(bulkData.bucket(relatedEntity))) {
relatedEntities.push_back(relatedEntity);
}
}
}
}
std::sort(relatedEntities.begin(), relatedEntities.end(), stk::mesh::EntityLess(bulkData));
relatedEntities.erase(
std::unique(relatedEntities.begin(), relatedEntities.end()),
relatedEntities.end());
std::vector<stk::mesh::Entity> sampleClosure;
stk::mesh::find_closure(bulkData, relatedEntities, sampleClosure);
// Keep only the closure, remove the rest, by decreasing entityRanks
{
const stk::mesh::Selector ownedOrShared = metaData.locally_owned_part() | metaData.globally_shared_part();
EntityIterator allKeepersEnd(sampleClosure.end());
const EntityIterator allKeepersBegin(sampleClosure.begin());
for (size_t candidateRankCount = metaData.entity_rank_count(); candidateRankCount > 0; --candidateRankCount) {
const stk::mesh::EntityRank candidateRank = static_cast<stk::mesh::EntityRank>(candidateRankCount - 1);
const EntityIterator keepersBegin = std::lower_bound(allKeepersBegin, allKeepersEnd,
stk::mesh::EntityKey(candidateRank, 0),
stk::mesh::EntityLess(bulkData));
const EntityIterator keepersEnd = allKeepersEnd;
std::vector<stk::mesh::Entity> candidates;
stk::mesh::get_selected_entities(ownedOrShared, bulkData.buckets(candidateRank), candidates);
{
BulkModification modification(bulkData);
std::set_difference(candidates.begin(), candidates.end(),
keepersBegin.base(), keepersEnd.base(),
EntityDestructor(modification),
stk::mesh::EntityLess(bulkData));
}
allKeepersEnd = keepersBegin;
}
}
}
stk::mesh::impl::ElementViaSidePair find_element_side_ord_for_side(const stk::mesh::BulkData& bulkData, unsigned num_elements, const stk::mesh::Entity* elements, stk::mesh::Entity side)
{
const stk::mesh::MetaData& meta = bulkData.mesh_meta_data();
for(unsigned i=0;i<num_elements;++i)
{
if(bulkData.bucket(elements[i]).owned())
{
const stk::mesh::Entity* sides = bulkData.begin(elements[i], meta.side_rank());
unsigned num_sides = bulkData.num_connectivity(elements[i], meta.side_rank());
for(unsigned j=0;j<num_sides;++j)
{
if(sides[j]==side)
{
const stk::mesh::ConnectivityOrdinal* ordinals = bulkData.begin_ordinals(elements[i], meta.side_rank());
return stk::mesh::impl::ElementViaSidePair{elements[i], static_cast<int>(ordinals[j])};
}
}
}
}
return stk::mesh::impl::ElementViaSidePair{stk::mesh::Entity(),0};
}
void fill_element_and_side_ids(Ioss::GroupingEntity & io,
stk::mesh::Part * const part,
const stk::mesh::BulkData & bulk_data,
stk::topology stk_element_topology,
const stk::mesh::Selector *subset_selector,
stk::mesh::EntityVector &sides,
std::vector<INT>& elem_side_ids)
{
if (bulk_data.has_sideset_data())
{
const stk::mesh::SideSet& sset = bulk_data.get_sideset_data(part->id());
size_t num_sides = sset.size();
elem_side_ids.reserve(num_sides*2);
stk::mesh::Selector selector = *part & ( bulk_data.mesh_meta_data().locally_owned_part() | bulk_data.mesh_meta_data().globally_shared_part() );
if(subset_selector)
selector &= *subset_selector;
for(size_t i=0;i<sset.size();++i)
{
stk::mesh::Entity element = sset[i].element;
stk::mesh::EntityId elemId = bulk_data.identifier(element);
int zero_based_side_ord = sset[i].side;
stk::mesh::Entity side = stk::mesh::get_side_entity_for_elem_id_side_pair_of_rank(bulk_data, elemId, zero_based_side_ord, bulk_data.mesh_meta_data().side_rank());
if(bulk_data.is_valid(side))
{
if(selector(bulk_data.bucket(side)))
{
if(bulk_data.bucket(element).topology() == stk_element_topology)
{
elem_side_ids.push_back(elemId);
elem_side_ids.push_back(zero_based_side_ord+1);
sides.push_back(side);
}
}
}
}
}
else
{
const stk::mesh::MetaData & meta_data = stk::mesh::MetaData::get(*part);
stk::mesh::EntityRank type = part_primary_entity_rank(*part);
size_t num_sides = get_entities(*part, type, bulk_data, sides, false, subset_selector);
elem_side_ids.reserve(num_sides * 2);
stk::mesh::EntityRank elem_rank = stk::topology::ELEMENT_RANK;
for(size_t i = 0; i < num_sides; ++i)
{
std::vector<stk::mesh::Entity> side;
side.push_back(sides[i]);
std::vector<stk::mesh::Entity> side_elements;
std::vector<stk::mesh::Entity> side_nodes(bulk_data.begin_nodes(sides[i]), bulk_data.end_nodes(sides[i]));
get_entities_through_relations(bulk_data, side_nodes, elem_rank, side_elements);
const size_t num_side_elem = side_elements.size();
std::sort(side_elements.begin(), side_elements.end(), stk::mesh::EntityLess(bulk_data));
stk::mesh::Entity suitable_elem = stk::mesh::Entity();
stk::mesh::ConnectivityOrdinal suitable_ordinal = stk::mesh::INVALID_CONNECTIVITY_ORDINAL;
for(size_t j = 0; j < num_side_elem; ++j)
{
const stk::mesh::Entity elem = side_elements[j];
const stk::mesh::Bucket &elemBucket = bulk_data.bucket(elem);
const bool isSelectingEverything = subset_selector == NULL;
const bool isElementBeingOutput = (isSelectingEverything || (*subset_selector)(elemBucket))
&& elemBucket.member(meta_data.locally_owned_part());
if(isElementBeingOutput)
{
const stk::mesh::Entity * elem_sides = bulk_data.begin(elem, type);
stk::mesh::ConnectivityOrdinal const * side_ordinal = bulk_data.begin_ordinals(elem, type);
const size_t num_elem_sides = bulk_data.num_connectivity(elem, type);
for(size_t k = 0; k < num_elem_sides; ++k)
{
if(elem_sides[k] == side[0])
{
suitable_elem = elem;
suitable_ordinal = side_ordinal[k];
break;
}
}
}
}
if(!bulk_data.is_valid(suitable_elem))
{
std::ostringstream oss;
oss << "ERROR, no suitable element found";
throw std::runtime_error(oss.str());
}
elem_side_ids.push_back(bulk_data.identifier(suitable_elem));
elem_side_ids.push_back(suitable_ordinal + 1); // Ioss is 1-based, mesh is 0-based.
}
}
}