void get_selected_entities( const Selector & selector ,
const BucketVector & input_buckets ,
std::vector< Entity> & entities )
{
size_t count = count_selected_entities(selector,input_buckets);
entities.resize(count);
const BucketVector::const_iterator ie = input_buckets.end();
BucketVector::const_iterator ik = input_buckets.begin();
for ( size_t j = 0 ; ik != ie ; ++ik ) {
const Bucket & k = ** ik ;
if ( selector( k ) ) {
const size_t n = k.size();
for ( size_t i = 0; i < n; ++i, ++j ) {
entities[j] = k[i] ;
}
}
}
if (input_buckets.size() > 0) {
std::sort(entities.begin(), entities.end(), EntityLess(input_buckets[0]->mesh()));
}
}
unsigned count_selected_entities(
const Selector & selector ,
const BucketVector & input_buckets )
{
size_t count = 0;
const BucketVector::const_iterator ie = input_buckets.end();
BucketVector::const_iterator ik = input_buckets.begin();
for ( ; ik != ie ; ++ik ) {
const Bucket & k = ** ik ;
if ( selector( k ) ) { count += k.size(); }
}
return count ;
}
void UnitTestStkMeshBulkModification::test_all_local_elements()
{
BulkData& bulk_data = initialize_ring_fixture();
{
const stk::mesh::Part& universal = m_ring_mesh.m_meta_data.universal_part();
stk::mesh::Selector universal_selector(universal);
BucketVector buckets = bulk_data.get_buckets(stk::topology::NODE_RANK, universal_selector);
// get all the nodes that this process knows about
std::vector< Entity> universal_entities;
for (BucketVector::iterator itr = buckets.begin();
itr != buckets.end(); ++itr) {
Bucket& b = **itr;
for (BucketIterator bitr = b.begin(); bitr != b.end(); ++bitr) {
universal_entities.push_back(*bitr);
}
}
buckets.clear();
buckets = bulk_data.get_buckets(stk::topology::ELEMENT_RANK, universal_selector);
// get all the elements that this process knows about
for (BucketVector::iterator itr = buckets.begin();
itr != buckets.end(); ++itr) {
Bucket& b = **itr;
for (BucketIterator bitr = b.begin(); bitr != b.end(); ++bitr) {
universal_entities.push_back(*bitr);
}
}
buckets.clear();
// universal entities should now have all the universal nodes and elements
stk::util::sort_and_unique(universal_entities, stk::mesh::EntityLess(bulk_data));
// get the buckets that we need to traverse to get the locally used elements
stk::mesh::Selector locally_used_selector =
m_ring_mesh.m_meta_data.locally_owned_part() |
m_ring_mesh.m_meta_data.globally_shared_part();
buckets = bulk_data.get_buckets(stk::topology::ELEMENT_RANK, locally_used_selector);
// get the locally used elements and store them in entities
std::vector< Entity> entities;
for (BucketVector::iterator itr = buckets.begin();
itr != buckets.end(); ++itr) {
Bucket& b = **itr;
for (BucketIterator bitr = b.begin(); bitr != b.end(); ++bitr) {
entities.push_back(*bitr);
}
}
// call find_closure, passing in the locally used elements
std::vector< Entity> entities_closure;
stk::mesh::find_closure(bulk_data, entities, entities_closure);
// The ghosted entities on this proc (element or node) should be contained
// in the closure of the locally-used element on some other proc, so we
// expect that they will be part of the closure. In other
// words, the set of entities returned by find_closure should exactly match
// the set of universal entities (nodes and elements).
ASSERT_TRUE(universal_entities.size() == entities_closure.size());
for (size_t i = 0; i < entities_closure.size(); ++i) {
EXPECT_TRUE(universal_entities[i] == entities_closure[i]);
}
}
}
void UnitTestStkMeshBulkModification::test_all_local_nodes()
{
BulkData& bulk_data = initialize_ring_fixture();
{
std::vector< Entity> entities;
std::vector< Entity> entities_closure;
find_closure(bulk_data, entities, entities_closure);
// the closure of the an empty set of entities on all procs should be empty
EXPECT_TRUE(entities_closure.empty());
}
{
// Get a selector for the univeral part (contains local, shared, and ghosted)
const stk::mesh::Part& universal = m_ring_mesh.m_meta_data.universal_part();
stk::mesh::Selector universal_selector(universal);
// Get the buckets that will give us the universal nodes
BucketVector buckets = bulk_data.get_buckets(NODE_RANK, universal_selector);
// Get the universal nodes
std::vector< Entity> universal_entities;
for (BucketVector::iterator itr = buckets.begin();
itr != buckets.end(); ++itr) {
Bucket& b = **itr;
for (BucketIterator bitr = b.begin(); bitr != b.end(); ++bitr) {
universal_entities.push_back(*bitr);
}
}
buckets.clear();
stk::util::sort_and_unique(universal_entities, stk::mesh::EntityLess(bulk_data));
// Get the buckets that will give us the locally used nodes
stk::mesh::Selector locally_used_selector =
m_ring_mesh.m_meta_data.locally_owned_part() |
m_ring_mesh.m_meta_data.globally_shared_part();
buckets = bulk_data.get_buckets(stk::topology::NODE_RANK, locally_used_selector);
// Get the locally used nodes
std::vector< Entity> entities;
for (BucketVector::iterator itr = buckets.begin();
itr != buckets.end(); ++itr) {
Bucket& b = **itr;
for (BucketIterator bitr = b.begin(); bitr != b.end(); ++bitr) {
entities.push_back(*bitr);
}
}
// Get the closure, passing in the locally used nodes on each proc
std::vector< Entity> entities_closure;
stk::mesh::find_closure(bulk_data, entities, entities_closure);
// The ghosted nodes on this part will be locally used on one of the other
// procs, so we expect that they will be part of the closure. In other
// words, the set of nodes returned by find_closure should exactly match
// the set of universal nodes.
ASSERT_TRUE(universal_entities.size() == entities_closure.size());
for (size_t i = 0; i < entities_closure.size(); ++i) {
EXPECT_TRUE(universal_entities[i] == entities_closure[i]);
}
}
}