TraceFunc_::TraceFunc_(std::string const& func_name, std::string const& something) { func_name_ = func_name; indent++; Trace_( (std::string("Entered ") + func_name + " [" + something + "]")); indent++; }
TraceFunc_::TraceFunc_(std::string const& func_name) { func_name_ = func_name; indent++; Trace_( (std::string("Entered ") + func_name)); indent++; }
bool BulkData::modification_begin() { Trace_("stk_classic::mesh::BulkData::modification_begin"); parallel_machine_barrier( m_parallel_machine ); ThrowRequireMsg( m_mesh_finalized == false, "Unable to modifiy, BulkData has been finalized."); if ( m_sync_state == MODIFIABLE && m_mesh_finalized == false ) return false ; if ( ! m_meta_data_verified ) { require_metadata_committed(); if (parallel_size() > 1) { verify_parallel_consistency( m_mesh_meta_data , m_parallel_machine ); } m_meta_data_verified = true ; m_bucket_repository.declare_nil_bucket(); } else { ++m_sync_count ; // Clear out the previous transaction information // m_transaction_log.flush(); m_entity_repo.clean_changes(); } m_sync_state = MODIFIABLE ; return true ; }
void BulkData::generate_new_entities(const std::vector<size_t>& requests, std::vector<Entity *>& requested_entities) { Trace_("stk_classic::mesh::BulkData::generate_new_entities"); typedef stk_classic::parallel::DistributedIndex::KeyType KeyType; std::vector< std::vector<KeyType> > requested_key_types; m_entities_index.generate_new_keys(requests, requested_key_types); //generating 'owned' entities Part * const owns = & m_mesh_meta_data.locally_owned_part(); std::vector<Part*> rem ; std::vector<Part*> add; add.push_back( owns ); requested_entities.clear(); unsigned cnt=0; for (std::vector< std::vector<KeyType> >::const_iterator itr = requested_key_types.begin(); itr != requested_key_types.end(); ++itr) { const std::vector<KeyType>& key_types = *itr; for (std::vector<KeyType>::const_iterator kitr = key_types.begin(); kitr != key_types.end(); ++kitr) { ++cnt; } } requested_entities.reserve(cnt); for (std::vector< std::vector<KeyType> >::const_iterator itr = requested_key_types.begin(); itr != requested_key_types.end(); ++itr) { const std::vector<KeyType>& key_types = *itr; for (std::vector<KeyType>::const_iterator kitr = key_types.begin(); kitr != key_types.end(); ++kitr) { EntityKey key(&(*kitr)); std::pair<Entity *, bool> result = m_entity_repo.internal_create_entity(key); //if an entity is declare with the declare_entity function in //the same modification cycle as the generate_new_entities //function, and it happens to generate a key that was declare //previously in the same cycle it is an error ThrowErrorMsgIf( ! result.second, "Generated " << print_entity_key(m_mesh_meta_data, key) << " which was already used in this modification cycle."); // A new application-created entity Entity* new_entity = result.first; m_entity_repo.set_entity_owner_rank( *new_entity, m_parallel_rank); m_entity_repo.set_entity_sync_count( *new_entity, m_sync_count); //add entity to 'owned' part change_entity_parts( *new_entity , add , rem ); requested_entities.push_back(new_entity); } } }
void PartRepository::declare_part_relation( Part & root_part, PartRelation relation, Part & target_part ) { static const char method[] = "stk_classic::mesh::impl::PartRepository::declare_part_relation" ; Trace_(method); assert_not_same( root_part , target_part , method ); assert_same_universe( root_part , target_part , method ); assert_same( root_part , *relation.m_root , method ); assert_same( target_part , *relation.m_target , method ); root_part.m_partImpl.add_relation( relation ); target_part.m_partImpl.add_relation( relation ); }
void PartRepository::declare_subset( Part & superset, Part & subset ) { static const char method[] = "stk_classic::mesh::impl::PartRepository::declare_subset" ; Trace_(method); if ( ! contain( subset.supersets() , superset ) ) { assert_not_same( superset , subset , method ); assert_not_superset( superset , subset , method ); assert_same_universe( superset , subset , method ); assert_rank_ordering( superset , subset , method ); // Insert this symmetric relationship first // so that it does not get revisited. declare_subset_impl( superset, subset ); // Transitive: const PartVector & subset_subsets = subset.subsets(); for ( PartVector::const_iterator i = subset_subsets.begin() ; i != subset_subsets.end() ; ++i ) { declare_subset( superset, **i ); } const PartVector & superset_supersets = superset.supersets(); for ( PartVector::const_iterator i = superset_supersets.begin() ; i != superset_supersets.end() ; ++i ) { declare_subset( **i, subset ); } // Induced intersection-part membership: const PartVector & superset_subsets = superset.subsets(); for ( PartVector::const_iterator i = superset_subsets.begin() ; i != superset_subsets.end() ; ++i ) { Part & pint = **i ; if ( ! pint.intersection_of().empty() && ( & pint != & subset ) ) { // If 'subset' is a subset of every member of 'pint.intersection_of()' // then it is by definition a subset of 'pint. if ( contain( subset.supersets() , pint.intersection_of() ) ) { declare_subset( pint, subset ); } } } } }
Part * PartRepository::declare_part( const std::string & arg_name , EntityRank arg_rank ) { Trace_("stk_classic::mesh::impl::PartRepository::declare_part"); const PartVector & all_parts = get_all_parts(); Part * p = find( all_parts, arg_name ); if ( p == NULL ) { p = declare_part_impl( arg_name, arg_rank ); } else { p->m_partImpl.set_primary_entity_rank(arg_rank); } return p; }
Part * PartRepository::declare_part( const PartVector & part_intersect ) { static const char method[] = "stk_classic::mesh::impl::PartRepository::declare_part" ; Trace_(method); PartVector pset_clean ; for ( PartVector::const_iterator i = part_intersect.begin() ; i != part_intersect.end() ; ++i ) { Part * const p = *i ; assert_superset( *m_universal_part, *p , method ); // If 'p' is a superset of another member // then it is redundant in this intersection. // Only keep non-redundant intersections. PartVector::const_iterator j = part_intersect.begin(); for ( ; j != part_intersect.end() && ! contain( (*j)->supersets() , *p ) ; ++j ); if ( j == part_intersect.end() ) { pset_clean.push_back( p ); } } // Sort and unique the intersection order( pset_clean ); Part * p = NULL ; if ( 1 == pset_clean.size() ) { // Only one remaining part, it is the subset. p = pset_clean[0] ; } else { const char separator[] = "^" ; // Generate a name and rank reflecting the intersection. // Rank is the minimum rank of the intersection members. std::string p_name ; EntityRank p_rank = InvalidEntityRank; p_name.assign("{"); for ( PartVector::iterator i = pset_clean.begin() ; i != pset_clean.end() ; ++i ) { if ( i != pset_clean.begin() ) { p_name.append( separator ); } p_name.append( (*i)->name() ); if ( (*i)->primary_entity_rank() < p_rank ) { p_rank = (*i)->primary_entity_rank(); } } p_name.append("}"); const PartVector & all_parts = get_all_parts(); p = find( all_parts, p_name ); if ( p == NULL ) { // Create the part: p = declare_part_impl( p_name , p_rank ); // Define the part to be an intersection of the given parts: p->m_partImpl.set_intersection_of( pset_clean ); for ( PartVector::iterator i = pset_clean.begin() ; i != pset_clean.end() ; ++i ) { declare_subset( **i, *p ); } } else { // This error is "inconceivable" and is // only possible by heroic malicious abuse. ThrowInvalidArgMsgIf( pset_clean != p->intersection_of(), p_name << " FAILED FROM MALICIOUS ABUSE" ); } } return p ; }
TraceFunc_::~TraceFunc_() { indent--; Trace_ (std::string("Leaving ") + func_name_); indent--; }