void BulkData::destroy_relation( Entity & e1 , Entity & e2 , unsigned kind ) { // When removing a relationship may need to // remove part membership and set field relation pointer to NULL PartSet del ; bool to_e1 = false ; std::vector<Relation>::iterator i ; for ( i = e1.m_relation.end() ; i != e1.m_relation.begin() ; ) { --i ; if ( i->entity() == & e2 && i->kind() == kind ) { if ( i->forward() ) { clear_field_relations( e1 , i->entity_type() , i->identifier() , i->kind() ); deduce_part_relations( e1, e2, i->identifier(), i->kind(), del ); } i = e1.m_relation.erase( i ); } } for ( i = e2.m_relation.end() ; i != e2.m_relation.begin() ; ) { --i ; if ( i->entity() == & e1 && i->kind() == kind ) { if ( i->forward() ) { clear_field_relations( e2 , i->entity_type() , i->identifier() , i->kind() ); deduce_part_relations( e2, e1, i->identifier(), i->kind(), del ); to_e1 = true ; } i = e2.m_relation.erase( i ); } } Entity & e_to = to_e1 ? e1 : e2 ; { PartSet keep ; deduce_part_relations( e_to , keep ); if ( ! keep.empty() ) { // Eliminate the 'keep' from the accumulated 'del' for ( PartSet::iterator j = del.end() ; j != del.begin() ; ) { --j ; if ( contain( keep , **j ) ) { j = del.erase( j ); } } } } if ( ! del.empty() ) { PartSet add ; internal_change_entity_parts( e_to , add , del ); } }
void Graph::printParts () { std::cout << "COUNTING PARTS:" << std::endl; PartSet *set = getParts(); for (PartSet::iterator it = set->begin(); it != set->end(); ++it) { (*it)->print(); std::cout << std::endl; } std::cout << "-> " << set->size() << " PARTS\n" << std::endl; }
void Transaction::translate_partset_to_partvector ( const PartSet &in , PartVector &out ) const { out.resize ( in.size() ); unsigned i = 0; for ( PartSet::const_iterator cur_in = in.begin() ; cur_in != in.end() ; cur_in++ ) { out[i] = *cur_in; ++i; } }
PartSet *Graph::getParts () { PartSet *set = new PartSet (); for (GraphComponentSet::iterator it = graphComponentSet->begin(); it != graphComponentSet->end(); ++it) { PartSet *newSet = (*it)->datatree->getParts(); set->insert(newSet->begin(),newSet->end()); delete newSet; } return set; }
std::ostream & operator << ( std::ostream & s , const Kernel & k ) { const char * const entity_name = entity_type_name( k.entity_type() ); PartSet parts ; k.supersets( parts ); s << "Kernel( " << entity_name << " : " ; for ( PartSet::iterator i = parts.begin() ; i != parts.end() ; ++i ) { s << (*i)->name() << " " ; } s << ")" ; return s ; }
bool Kernel::has_superset( const PartSet & ps ) const { std::pair<const unsigned *, const unsigned *> part_ord = superset_part_ordinals(); bool result = ! ps.empty(); for ( PartSet::const_iterator i = ps.begin() ; result && i != ps.end() ; ++i ) { const unsigned ordinal = (*i)->mesh_meta_data_ordinal(); part_ord.first = std::lower_bound( part_ord.first , part_ord.second , ordinal ); result = part_ord.first < part_ord.second && ordinal == *part_ord.first ; } return result ; }
void BulkData::internal_propagate_part_changes( Entity & entity , const PartSet & removed ) { const EntityType etype = entity.entity_type(); Part * const owns_part = & m_mesh_meta_data.locally_owned_part(); Part * const uses_part = & m_mesh_meta_data.locally_used_part(); PairIterRelation rel = entity.relations(); for ( ; rel ; ++rel ) { const unsigned rel_ident = rel->identifier(); const unsigned rel_kind = rel->kind(); if ( rel->forward() ) { Entity & e_to = * rel->entity(); PartSet to_del ; PartSet to_add ; if ( ! removed.empty() ) { const EntityType t_to = e_to.entity_type(); // Deduce parts for 'e_to' from all upward relations. // Any non-parallel part that I removed that is not deduced for // 'e_to' must be removed from 'e_to' deduce_part_relations( e_to , to_add ); to_del.reserve( removed.size() ); for ( PartSet::const_iterator j = removed.begin() ; j != removed.end() ; ++j ) { Part * const p = *j ; if ( p != owns_part && p != uses_part && ! contain( to_add , *p ) ) { to_del.push_back( p ); // What if removing a part with a part-relation ? const std::vector<PartRelation> & part_rel = m_mesh_meta_data.get_part_relations(); for ( std::vector<PartRelation>::const_iterator k = part_rel.begin() ; k != part_rel.end() ; ++k ) { const PartRelation & stencil = *k ; if ( p == stencil.m_root && 0 <= (*stencil.m_function)(etype,t_to,rel_ident,rel_kind) && ! contain( to_add , * stencil.m_target ) ) { } } } } } else { deduce_part_relations( entity , e_to , rel_ident , rel_kind , to_add ); } internal_change_entity_parts( e_to , to_add , to_del ); set_field_relations( entity, e_to, rel_ident , rel_kind ); } else { Entity & e_from = * rel->entity(); set_field_relations( e_from, entity, rel_ident, rel_kind ); } } }