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 ;
}
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 Transaction::add_parts_to_partset ( Entity &e , PartSet &pl )
{
PartVector parts;
e.bucket().supersets ( parts );
for ( PartVector::iterator part_iter = parts.begin(); part_iter != parts.end() ; ++part_iter )
pl.insert ( *part_iter );
}
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 Kernel::supersets( PartSet & ps ) const
{
const MetaData & mesh_meta_data = m_mesh.mesh_meta_data();
std::pair<const unsigned *, const unsigned *>
part_ord = superset_part_ordinals();
ps.resize( part_ord.second - part_ord.first );
for ( unsigned i = 0 ;
part_ord.first < part_ord.second ; ++(part_ord.first) , ++i ) {
ps[i] = & mesh_meta_data.get_part( * part_ord.first );
}
}
bool ObjectModifyingUndoStep::getModifiedParts(PartSet& out) const
{
out.insert(getPartIndex());
return !modified_objects.empty();
}
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 );
}
}
}
