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--;
}
