Selector selectIntersection( const PartVector& intersection_part_vector )
{
Selector selector;
if (intersection_part_vector.size() > 0) {
selector = *intersection_part_vector[0];
for (unsigned i = 1 ; i < intersection_part_vector.size() ; ++i) {
selector &= *intersection_part_vector[i];
}
}
return selector;
}
bool contain( const PartVector & super , const PartVector & sub )
{
bool result = ( ! sub.empty() ) && ( sub.size() <= super.size() );
if ( result ) {
PartLess comp ;
const PartVector::const_iterator ev = super.end();
PartVector::const_iterator iv = super.begin();
const PartVector::const_iterator ep = sub.end();
PartVector::const_iterator ip = sub.begin();
while ( result && ip != ep ) {
Part * const q = *ip ; ++ip ;
iv = std::lower_bound( iv , ev , q , comp );
result = iv != ev && *iv == q ;
}
}
return result ;
}
void copy_ids( std::vector<unsigned> & v , const PartVector & p )
{
{
const size_t n = p.size();
v.resize( n );
for ( size_t k = 0 ; k < n ; ++k ) {
v[k] = p[k]->mesh_meta_data_ordinal();
}
}
{
std::vector<unsigned>::iterator i = v.begin() , j = v.end();
std::sort( i , j );
i = std::unique( i , j );
v.erase( i , j );
}
}
size_t intersect( const PartVector & v , const PartVector & p , PartVector & r )
{
// Both lists must be sorted, assume v.size() > p.size()
const PartVector::const_iterator ev = v.end();
PartVector::const_iterator iv = v.begin();
const PartVector::const_iterator ep = p.end();
PartVector::const_iterator ip = p.begin();
for ( ; ip != ep && iv != ev ; ++ip ) {
Part * const q = *ip ;
iv = std::lower_bound( iv , ev , q , PartLess() );
if ( iv != ev && *iv == q ) { r.push_back( q ); }
}
return r.size() ;
}
void get_involved_parts(
const PartVector & union_parts,
const Bucket & candidate,
PartVector & involved_parts
)
{
involved_parts.clear();
if (union_parts.size() == 0) {
return;
}
// Used to convert part ordinals to part pointers:
MetaData & meta_data = MetaData::get( * union_parts[0]);
const PartVector & all_parts = meta_data.get_parts();
const std::pair<const unsigned *,const unsigned *>
bucket_part_begin_end_iterators = candidate.superset_part_ordinals(); // sorted and unique
std::vector<unsigned> union_parts_ids;
copy_ids( union_parts_ids , union_parts ); // sorted and unique
std::vector<unsigned>::const_iterator union_part_id_it = union_parts_ids.begin();
const unsigned * bucket_part_id_it = bucket_part_begin_end_iterators.first ;
while ( union_part_id_it != union_parts_ids.end() &&
bucket_part_id_it != bucket_part_begin_end_iterators.second )
{
if ( *union_part_id_it < *bucket_part_id_it ) {
++union_part_id_it ;
}
else if ( *bucket_part_id_it < *union_part_id_it ) {
++bucket_part_id_it ;
}
else {
// Find every match:
Part * const part = all_parts[ *union_part_id_it ];
involved_parts.push_back( part );
++union_part_id_it;
++bucket_part_id_it;
}
}
}
void BulkData::internal_change_entity_parts(
Entity & entity ,
const PartVector & add_parts ,
const PartVector & remove_parts )
{
TraceIfWatching("stk_classic::mesh::BulkData::internal_change_entity_parts", LOG_ENTITY, entity.key());
DiagIfWatching(LOG_ENTITY, entity.key(), "entity state: " << entity);
DiagIfWatching(LOG_ENTITY, entity.key(), "add_parts: " << add_parts);
DiagIfWatching(LOG_ENTITY, entity.key(), "remove_parts: " << remove_parts);
Bucket * const k_old = m_entity_repo.get_entity_bucket( entity );
const unsigned i_old = entity.bucket_ordinal() ;
if ( k_old && k_old->member_all( add_parts ) &&
! k_old->member_any( remove_parts ) ) {
// Is already a member of all add_parts,
// is not a member of any remove_parts,
// thus nothing to do.
return ;
}
PartVector parts_removed ;
OrdinalVector parts_total ; // The final part list
//--------------------------------
if ( k_old ) {
// Keep any of the existing bucket's parts
// that are not a remove part.
// This will include the 'intersection' parts.
//
// These parts are properly ordered and unique.
const std::pair<const unsigned *, const unsigned*>
bucket_parts = k_old->superset_part_ordinals();
const unsigned * parts_begin = bucket_parts.first;
const unsigned * parts_end = bucket_parts.second;
const unsigned num_bucket_parts = parts_end - parts_begin;
parts_total.reserve( num_bucket_parts + add_parts.size() );
parts_total.insert( parts_total.begin(), parts_begin , parts_end);
if ( !remove_parts.empty() ) {
parts_removed.reserve(remove_parts.size());
filter_out( parts_total , remove_parts , parts_removed );
}
}
else {
parts_total.reserve(add_parts.size());
}
if ( !add_parts.empty() ) {
merge_in( parts_total , add_parts );
}
if ( parts_total.empty() ) {
// Always a member of the universal part.
const unsigned univ_ord =
m_mesh_meta_data.universal_part().mesh_meta_data_ordinal();
parts_total.push_back( univ_ord );
}
//--------------------------------
// Move the entity to the new bucket.
Bucket * k_new =
m_bucket_repository.declare_bucket(
entity.entity_rank(),
parts_total.size(),
& parts_total[0] ,
m_mesh_meta_data.get_fields()
);
// If changing buckets then copy its field values from old to new bucket
if ( k_old ) {
m_bucket_repository.copy_fields( *k_new , k_new->size() , *k_old , i_old );
}
else {
m_bucket_repository.initialize_fields( *k_new , k_new->size() );
}
// Set the new bucket
m_entity_repo.change_entity_bucket( *k_new, entity, k_new->size() );
m_bucket_repository.add_entity_to_bucket( entity, *k_new );
// If changing buckets then remove the entity from the bucket,
if ( k_old && k_old->capacity() > 0) { m_bucket_repository.remove_entity( k_old , i_old ); }
// Update the change counter to the current cycle.
m_entity_repo.set_entity_sync_count( entity, m_sync_count );
// Propagate part changes through the entity's relations.
internal_propagate_part_changes( entity , parts_removed );
#ifndef NDEBUG
//ensure_part_superset_consistency( entity );
#endif
}
