Entity & declare_element_side(
BulkData & mesh ,
const stk::mesh::EntityId global_side_id ,
Entity & elem ,
const unsigned local_side_id ,
Part * part )
{
verify_declare_element_side(mesh, elem, local_side_id);
const CellTopologyData * const elem_top = get_cell_topology_new( elem ).getCellTopologyData();
ThrowErrorMsgIf( elem_top == NULL,
"Element[" << elem.identifier() << "] has no defined topology");
const CellTopologyData * const side_top = elem_top->side[ local_side_id ].topology;
ThrowErrorMsgIf( side_top == NULL,
"Element[" << elem.identifier() << "], local_side_id = " <<
local_side_id << ", side has no defined topology" );
PartVector empty_parts ;
Entity & side = mesh.declare_entity( side_top->dimension , global_side_id, empty_parts );
return declare_element_side( elem, side, local_side_id, part);
}
bool field_data_valid( const FieldBase & f ,
const Bucket & k ,
unsigned ord ,
const char * required_by )
{
const MetaData * const k_mesh_meta_data = & MetaData::get(k);
const MetaData * const f_mesh_meta_data = & MetaData::get(f);
const bool ok_mesh_meta_data = k_mesh_meta_data == f_mesh_meta_data ;
const bool ok_ord = ord < k.size() ;
const bool exists = ok_mesh_meta_data && ok_ord &&
NULL != field_data( f , k.begin() );
if ( required_by && ! exists ) {
std::ostringstream msg_begin ;
msg_begin << "For args: " ;
msg_begin << f << " , " ;
msg_begin << k << " , " ;
msg_begin << ord << " , " ;
msg_begin << required_by ;
msg_begin << "; operation FAILED with " ;
ThrowErrorMsgIf( ! ok_mesh_meta_data,
msg_begin.str() << " different MetaData");
ThrowErrorMsgIf( ! ok_ord, msg_begin.str() <<
" Ordinal " << ord << " >= " << " size " << k.size());
ThrowErrorMsg( msg_begin.str() << " no data");
}
return exists ;
}
PropertyBase *
MetaData::get_property_base( const std::string & name ,
const std::type_info & type ,
unsigned size ) const
{
PropertyBase * p = NULL ;
{
std::vector< PropertyBase * >::const_iterator i ;
for ( i = m_properties.begin() ;
i != m_properties.end() && not_equal_case( (*i)->name() , name ) ;
++i );
if ( i != m_properties.end() ) {
const bool error_type = ( (*i)->m_type != type );
const bool error_size = size && ( (*i)->m_size != size );
ThrowErrorMsgIf( error_type,
"For property name " << name << ": " <<
" actual_type(" << (*i)->m_type.name() <<
") != request_type(" << type.name() << ")");
ThrowErrorMsgIf( error_size,
"For property name " << name << ": " <<
" actual_size(" << (*i)->m_size <<
") != request_size(" << size << ")") ;
p = *i;
}
}
return p ;
}
bool EntityRepository::destroy_relation( Entity & e_from,
Entity & e_to,
const RelationIdentifier local_id )
{
TraceIfWatching("stk::mesh::impl::EntityRepository::destroy_relation", LOG_ENTITY, e_from.key());
bool caused_change_fwd = e_from.m_entityImpl.destroy_relation(e_to, local_id);
// Relationships should always be symmetrical
if ( caused_change_fwd ) {
bool caused_change_inv = e_to.m_entityImpl.destroy_relation(e_from, local_id);
ThrowErrorMsgIf( !caused_change_inv,
" Internal error - could not destroy inverse relation of " <<
print_entity_key( e_from ) << " to " << print_entity_key( e_to ) <<
" with local relation id of " << local_id);
}
// It is critical that the modification be done AFTER the relations are
// changed so that the propagation can happen correctly.
if ( caused_change_fwd ) {
e_to.m_entityImpl.log_modified_and_propagate();
e_from.m_entityImpl.log_modified_and_propagate();
}
return caused_change_fwd;
}
void EntityRepository::declare_relation( Entity & e_from,
Entity & e_to,
const RelationIdentifier local_id,
unsigned sync_count )
{
TraceIfWatching("stk::mesh::impl::EntityRepository::declare_relation", LOG_ENTITY, e_from.key());
bool caused_change_fwd =
e_from.m_entityImpl.declare_relation( e_to, local_id, sync_count);
// Relationships should always be symmetrical
if ( caused_change_fwd ) {
// the setup for the converse relationship works slightly differently
bool is_converse = true;
bool caused_change_inv =
e_to.m_entityImpl.declare_relation( e_from, local_id, sync_count,
is_converse );
ThrowErrorMsgIf( !caused_change_inv,
" Internal error - could not create inverse relation of " <<
print_entity_key( e_from ) << " to " << print_entity_key( e_to ));
}
// It is critical that the modification be done AFTER the relations are
// added so that the propagation can happen correctly.
if ( caused_change_fwd ) {
e_to.m_entityImpl.log_modified_and_propagate();
e_from.m_entityImpl.log_modified_and_propagate();
}
}
void FieldBaseImpl::verify_and_clean_restrictions(
const char * arg_method ,
const Part& superset,
const Part& subset,
const PartVector & arg_all_parts )
{
TraceIfWatching("stk::mesh::impl::FieldBaseImpl::verify_and_clean_restrictions", LOG_FIELD, m_ordinal);
FieldRestrictionVector & restrs = restrictions();
//Check whether both 'superset' and 'subset' are in this field's restrictions.
//If they are, make sure they are compatible and remove the subset restriction.
FieldRestrictionVector::iterator superset_restriction = restrs.end();
FieldRestrictionVector::iterator subset_restriction = restrs.end();
for (FieldRestrictionVector::iterator i = restrs.begin() ; i != restrs.end() ; ++i ) {
if (i->part_ordinal() == superset.mesh_meta_data_ordinal()) {
superset_restriction = i;
if (subset_restriction != restrs.end() && subset_restriction->entity_rank() == superset_restriction->entity_rank()) break;
}
if (i->part_ordinal() == subset.mesh_meta_data_ordinal()) {
subset_restriction = i;
if (superset_restriction != restrs.end() && subset_restriction->entity_rank() == superset_restriction->entity_rank()) break;
}
}
if (superset_restriction != restrs.end() && subset_restriction != restrs.end() &&
superset_restriction->entity_rank() == subset_restriction->entity_rank()) {
ThrowErrorMsgIf( superset_restriction->not_equal_stride(*subset_restriction),
"Incompatible field restrictions for parts "<<superset.name()<<" and "<<subset.name());
restrs.erase(subset_restriction);
}
}
Entity & declare_element( BulkData & mesh ,
Part & part ,
const EntityId elem_id ,
const EntityId node_id[] )
{
FEMMetaData & fem_meta = FEMMetaData::get(mesh);
const CellTopologyData * const top = fem_meta.get_cell_topology( part ).getCellTopologyData();
ThrowErrorMsgIf(top == NULL,
"Part " << part.name() << " does not have a local topology");
PartVector empty ;
PartVector add( 1 ); add[0] = & part ;
const EntityRank entity_rank = fem_meta.element_rank();
Entity & elem = mesh.declare_entity( entity_rank, elem_id, add );
const EntityRank node_rank = fem_meta.node_rank();
for ( unsigned i = 0 ; i < top->node_count ; ++i ) {
//declare node if it doesn't already exist
Entity * node = mesh.get_entity( node_rank , node_id[i]);
if ( NULL == node) {
node = & mesh.declare_entity( node_rank , node_id[i], empty );
}
mesh.declare_relation( elem , *node , i );
}
return elem ;
}
const std::string& MetaData::entity_rank_name( EntityRank entity_rank ) const
{
ThrowErrorMsgIf( entity_rank >= m_entity_rank_names.size(),
"entity-rank " << entity_rank <<
" out of range. Must be in range 0.." << m_entity_rank_names.size());
return m_entity_rank_names[entity_rank];
}
Entity * EntityRepository::get_entity(const EntityKey &key) const
{
ThrowErrorMsgIf( ! entity_key_valid( key ),
"Invalid key: " << entity_rank(key) << " " << entity_id(key));
const EntityMap::const_iterator i = m_entities.find( key );
return i != m_entities.end() ? i->second : NULL ;
}
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 EntityRepository::destroy_later( Entity & e, Bucket* nil_bucket )
{
TraceIfWatching("stk::mesh::impl::EntityRepository::destroy_later", LOG_ENTITY, e.key());
ThrowErrorMsgIf( e.log_query() == EntityLogDeleted,
"double deletion of entity: " << print_entity_key( e ));
change_entity_bucket( *nil_bucket, e, 0);
e.m_entityImpl.log_deleted(); //important that this come last
}
bool element_side_polarity( const Entity & elem ,
const Entity & side , int local_side_id )
{
// 09/14/10: TODO: tscoffe: Will this work in 1D?
FEMMetaData &fem_meta = FEMMetaData::get(elem);
const bool is_side = side.entity_rank() != fem_meta.edge_rank();
const CellTopologyData * const elem_top = get_cell_topology( elem ).getCellTopologyData();
const unsigned side_count = ! elem_top ? 0 : (
is_side ? elem_top->side_count
: elem_top->edge_count );
ThrowErrorMsgIf( elem_top == NULL,
"For Element[" << elem.identifier() << "], element has no defined topology");
ThrowErrorMsgIf( local_side_id < 0 || static_cast<int>(side_count) <= local_side_id,
"For Element[" << elem.identifier() << "], " <<
"side: " << print_entity_key(side) << ", " <<
"local_side_id = " << local_side_id <<
" ; unsupported local_side_id");
const CellTopologyData * const side_top =
is_side ? elem_top->side[ local_side_id ].topology
: elem_top->edge[ local_side_id ].topology ;
const unsigned * const side_map =
is_side ? elem_top->side[ local_side_id ].node
: elem_top->edge[ local_side_id ].node ;
const PairIterRelation elem_nodes = elem.relations( FEMMetaData::NODE_RANK );
const PairIterRelation side_nodes = side.relations( FEMMetaData::NODE_RANK );
const unsigned n = side_top->node_count;
bool good = false ;
for ( unsigned i = 0 ; !good && i < n ; ++i ) {
good = true;
for ( unsigned j = 0; good && j < n ; ++j ) {
good = side_nodes[(j+i)%n].entity() == elem_nodes[ side_map[j] ].entity();
}
}
return good ;
}
void EntityRepository::internal_expunge_entity( EntityMap::iterator i )
{
TraceIfWatching("stk::mesh::impl::EntityRepository::internal_expunge_entity", LOG_ENTITY, i->first);
ThrowErrorMsgIf( i->second == NULL,
"For key " << entity_rank(i->first) << " " <<
entity_id(i->first) << ", value was NULL");
ThrowErrorMsgIf( i->first != i->second->key(),
"Key " << print_entity_key(MetaData::get( *i->second ), i->first) <<
" != " << print_entity_key(i->second));
Entity* deleted_entity = i->second;
#ifdef SIERRA_MIGRATION
destroy_fmwk_attr(deleted_entity->m_fmwk_attrs, m_use_pool);
#endif
destroy_entity(deleted_entity, m_use_pool);
i->second = NULL;
m_entities.erase( i );
}
Entity & declare_element_side(
Entity & elem ,
Entity & side,
const unsigned local_side_id ,
Part * part )
{
BulkData & mesh = BulkData::get(side);
verify_declare_element_side(mesh, elem, local_side_id);
const CellTopologyData * const elem_top = get_cell_topology_new( elem ).getCellTopologyData();
ThrowErrorMsgIf( elem_top == NULL,
"Element[" << elem.identifier() << "] has no defined topology" );
const CellTopologyData * const side_top = elem_top->side[ local_side_id ].topology;
ThrowErrorMsgIf( side_top == NULL,
"Element[" << elem.identifier() << "], local_side_id = " <<
local_side_id << ", side has no defined topology" );
const unsigned * const side_node_map = elem_top->side[ local_side_id ].node ;
PartVector add_parts ;
if ( part ) { add_parts.push_back( part ); }
mesh.change_entity_parts(side, add_parts);
mesh.declare_relation( elem , side , local_side_id );
PairIterRelation rel = elem.relations( FEMMetaData::NODE_RANK );
for ( unsigned i = 0 ; i < side_top->node_count ; ++i ) {
Entity & node = * rel[ side_node_map[i] ].entity();
mesh.declare_relation( side , node , i );
}
return side ;
}
Part * MetaData::get_part( const std::string & p_name ,
const char * required_by ) const
{
const PartVector & all_parts = m_part_repo.get_all_parts();
Part * const p = find( all_parts , p_name );
ThrowErrorMsgIf( required_by && NULL == p,
"Failed to find part with name " << p_name <<
" for method " << required_by );
return p ;
}
void communicate_field_data_verify_read( CommAll & sparse )
{
std::ostringstream msg ;
int error = 0 ;
for ( unsigned p = 0 ; p < sparse.parallel_size() ; ++p ) {
if ( sparse.recv_buffer( p ).remaining() ) {
msg << "P" << sparse.parallel_rank()
<< " Unread data from P" << p << std::endl ;
error = 1 ;
}
}
all_reduce( sparse.parallel() , ReduceSum<1>( & error ) );
ThrowErrorMsgIf( error, msg.str() );
}
void MetaData::declare_part_relation(
Part & root_part ,
relation_stencil_ptr stencil ,
Part & target_part )
{
require_not_committed();
require_not_relation_target( &root_part );
ThrowErrorMsgIf( !stencil, "stencil function pointer cannot be NULL" );
ThrowErrorMsgIf( 0 != target_part.subsets().size() ||
0 != target_part.intersection_of().size() ||
1 != target_part.supersets().size(),
"target Part[" << target_part.name() <<
"] cannot be a superset or subset" );
PartRelation tmp ;
tmp.m_root = & root_part ;
tmp.m_target = & target_part ;
tmp.m_function = stencil ;
m_part_repo.declare_part_relation( root_part, tmp, target_part );
}
void PartImpl::set_primary_entity_rank( EntityRank entity_rank )
{
TraceIfWatching("stk_classic::mesh::impl::PartImpl::set_primary_entity_rank", LOG_PART, m_universe_ordinal);
if ( entity_rank == m_entity_rank ) return;
const bool rank_already_set = m_entity_rank != InvalidEntityRank && entity_rank != m_entity_rank;
//const bool has_subsets = m_subsets.size() > 0;
//ThrowErrorMsgIf( has_subsets, " Error: Part '" << m_name << "' has subsets");
if ( entity_rank == InvalidEntityRank ) return;
ThrowErrorMsgIf( rank_already_set, " Error: Different entity rank has already been set on Part");
m_entity_rank = entity_rank;
}
void skin_mesh( BulkData & mesh, Selector const& element_selector, PartVector const& skin_parts,
const Selector * secondary_selector)
{
ThrowErrorMsgIf( mesh.in_modifiable_state(), "mesh is not SYNCHRONIZED" );
Selector *air = nullptr;
Selector tmp;
if(secondary_selector != nullptr)
{
tmp = !(*secondary_selector);
air = &tmp;
}
stk::mesh::ElemElemGraph elem_elem_graph(mesh, element_selector, air);
elem_elem_graph.skin_mesh(skin_parts);
}
void BulkData::internal_verify_change_parts( const MetaData & meta ,
const Entity & entity ,
const OrdinalVector & parts ) const
{
const std::vector<std::string> & rank_names = meta.entity_rank_names();
const EntityRank undef_rank = InvalidEntityRank;
const EntityRank entity_rank = entity.entity_rank();
bool ok = true ;
std::ostringstream msg ;
for ( OrdinalVector::const_iterator
i = parts.begin() ; i != parts.end() ; ++i ) {
const Part * const p = meta.get_parts()[*i] ;
const unsigned part_rank = p->primary_entity_rank();
bool intersection_ok, rel_target_ok, rank_ok;
internal_basic_part_check(p, entity_rank, undef_rank, intersection_ok, rel_target_ok, rank_ok);
if ( !intersection_ok || !rel_target_ok || !rank_ok ) {
if ( ok ) {
ok = false ;
msg << "change parts for entity " << print_entity_key( entity );
msg << " , { " ;
}
else {
msg << " , " ;
}
msg << p->name() << "[" ;
if ( part_rank < rank_names.size() ) {
msg << rank_names[ part_rank ];
}
else {
msg << part_rank ;
}
msg << "] " ;
if ( !intersection_ok ) { msg << "is_intersection " ; }
if ( !rel_target_ok ) { msg << "is_relation_target " ; }
if ( !rank_ok ) { msg << "is_bad_rank " ; }
}
}
ThrowErrorMsgIf( !ok, msg.str() << "}" );
}
MetaData::MetaData(const std::vector<std::string>& entity_rank_names)
: m_commit( false ),
m_part_repo( this ),
m_attributes(),
m_universal_part( NULL ),
m_owns_part( NULL ),
m_shares_part( NULL ),
m_field_repo(),
m_field_relations( ),
m_properties( ),
m_entity_rank_names( entity_rank_names )
{
ThrowErrorMsgIf( entity_rank_names.empty(), "entity ranks empty" );
// Declare the predefined parts
m_universal_part = m_part_repo.universal_part();
m_owns_part = & declare_part( std::string("{OWNS}") );
m_shares_part = & declare_part( std::string("{SHARES}") );
}
Entity declare_element(BulkData & mesh,
PartVector & parts,
const EntityId elem_id,
const EntityIdVector & node_ids)
{
MetaData & fem_meta = MetaData::get(mesh);
stk::topology top = fem_meta.get_topology(*parts[0]);
ThrowAssert(node_ids.size() >= top.num_nodes());
ThrowErrorMsgIf(top == stk::topology::INVALID_TOPOLOGY,
"Part " << parts[0]->name() << " does not have a local topology");
PartVector empty;
const EntityRank entity_rank = stk::topology::ELEMENT_RANK;
Entity elem = mesh.declare_entity(entity_rank, elem_id, parts);
const EntityRank node_rank = stk::topology::NODE_RANK;
Permutation perm = stk::mesh::Permutation::INVALID_PERMUTATION;
OrdinalVector ordinal_scratch;
ordinal_scratch.reserve(64);
PartVector part_scratch;
part_scratch.reserve(64);
for(unsigned i = 0; i < top.num_nodes(); ++i)
{
//declare node if it doesn't already exist
Entity node = mesh.get_entity(node_rank, node_ids[i]);
if(!mesh.is_valid(node))
{
node = mesh.declare_entity(node_rank, node_ids[i], empty);
}
mesh.declare_relation(elem, node, i, perm, ordinal_scratch, part_scratch);
}
return elem;
}
CellTopology get_cell_topology_new( const Bucket & bucket)
{
const BulkData & bulk_data = BulkData::get(bucket);
const FEMMetaData & fem_meta_data = FEMMetaData::get(bulk_data);
const PartVector & all_parts = fem_meta_data.get_parts();
CellTopology cell_topology;
const std::pair< const unsigned *, const unsigned * > supersets = bucket.superset_part_ordinals();
if (supersets.first != supersets.second) {
const Part *first_found_part = NULL;
for ( const unsigned * it = supersets.first ; it != supersets.second ; ++it ) {
const Part & part = * all_parts[*it] ;
if ( part.primary_entity_rank() == bucket.entity_rank() ) {
CellTopology top = fem_meta_data.get_cell_topology( part );
if ( ! cell_topology.getCellTopologyData() ) {
cell_topology = top ;
if (!first_found_part)
first_found_part = ∂
}
else {
ThrowErrorMsgIf( top.getCellTopologyData() && top != cell_topology,
"Cell topology is ambiguously defined. It is defined as " << cell_topology.getName() <<
" on part " << first_found_part->name() << " and as " << top.getName() << " on its superset part " << part.name() );
}
}
}
}
return cell_topology ;
}
void MetaData::set_entity_rank_names(const std::vector<std::string> &entity_rank_names)
{
ThrowErrorMsgIf( entity_rank_names.empty(), "entity ranks empty" );
m_entity_rank_names = entity_rank_names;
}
void FieldBaseImpl::insert_restriction(
const char * arg_method ,
EntityRank arg_entity_rank ,
const Selector & arg_selector ,
const unsigned * arg_stride,
const void* arg_init_value )
{
TraceIfWatching("stk::mesh::impl::FieldBaseImpl::insert_restriction", LOG_FIELD, m_ordinal);
FieldRestriction tmp( arg_entity_rank , arg_selector );
{
unsigned i = 0 ;
if ( m_field_rank ) {
for ( i = 0 ; i < m_field_rank ; ++i ) { tmp.stride(i) = arg_stride[i] ; }
}
else { // Scalar field is 0 == m_field_rank
i = 1 ;
tmp.stride(0) = 1 ;
}
// Remaining dimensions are 1, no change to stride
for ( ; i < MaximumFieldDimension ; ++i ) {
tmp.stride(i) = tmp.stride(i-1) ;
}
for ( i = 1 ; i < m_field_rank ; ++i ) {
const bool bad_stride = 0 == tmp.stride(i) ||
0 != tmp.stride(i) % tmp.stride(i-1);
ThrowErrorMsgIf( bad_stride,
arg_method << " FAILED for " << *this <<
" WITH BAD STRIDE!");
}
}
if (arg_init_value != NULL) {
//insert_restriction can be called multiple times for the same field, giving
//the field different lengths on different mesh-parts.
//We will only store one initial-value array, we need to store the one with
//maximum length for this field so that it can be used to initialize data
//for all field-restrictions. For the parts on which the field is shorter,
//a subset of the initial-value array will be used.
//
//We want to end up storing the longest arg_init_value array for this field.
//
//Thus, we call set_initial_value only if the current length is longer
//than what's already been stored.
//length in bytes is num-scalars X sizeof-scalar:
size_t num_scalars = 1;
//if rank > 0, then field is not a scalar field, so num-scalars is
//obtained from the stride array:
if (m_field_rank > 0) num_scalars = tmp.stride(m_field_rank-1);
size_t sizeof_scalar = m_data_traits.size_of;
size_t nbytes = sizeof_scalar * num_scalars;
size_t old_nbytes = 0;
if (get_initial_value() != NULL) {
old_nbytes = get_initial_value_num_bytes();
}
if (nbytes > old_nbytes) {
set_initial_value(arg_init_value, num_scalars, nbytes);
}
}
{
FieldRestrictionVector & srvec = selector_restrictions();
bool restriction_already_exists = false;
for(FieldRestrictionVector::const_iterator it=srvec.begin(), it_end=srvec.end();
it!=it_end; ++it) {
if (tmp == *it) {
restriction_already_exists = true;
if (tmp.not_equal_stride(*it)) {
ThrowErrorMsg("Incompatible selector field-restrictions!");
}
}
}
if ( !restriction_already_exists ) {
// New field restriction, verify we are not committed:
ThrowRequireMsg(!m_meta_data->is_commit(), "mesh MetaData has been committed.");
srvec.push_back( tmp );
}
}
}
void FieldBaseImpl::insert_restriction(
const char * arg_method ,
EntityRank arg_entity_rank ,
const Part & arg_part ,
const unsigned * arg_stride,
const void* arg_init_value )
{
TraceIfWatching("stk::mesh::impl::FieldBaseImpl::insert_restriction", LOG_FIELD, m_ordinal);
FieldRestriction tmp( arg_entity_rank , arg_part.mesh_meta_data_ordinal() );
{
unsigned i = 0 ;
if ( m_field_rank ) {
for ( i = 0 ; i < m_field_rank ; ++i ) { tmp.stride(i) = arg_stride[i] ; }
}
else { // Scalar field is 0 == m_field_rank
i = 1 ;
tmp.stride(0) = 1 ;
}
// Remaining dimensions are 1, no change to stride
for ( ; i < MaximumFieldDimension ; ++i ) {
tmp.stride(i) = tmp.stride(i-1) ;
}
for ( i = 1 ; i < m_field_rank ; ++i ) {
const bool bad_stride = 0 == tmp.stride(i) ||
0 != tmp.stride(i) % tmp.stride(i-1);
ThrowErrorMsgIf( bad_stride,
arg_method << " FAILED for " << *this <<
" WITH BAD STRIDE " <<
print_restriction( tmp, arg_entity_rank, arg_part, m_field_rank ));;
}
}
if (arg_init_value != NULL) {
//insert_restriction can be called multiple times for the same field, giving
//the field different lengths on different mesh-parts.
//We will only store one initial-value array, we need to store the one with
//maximum length for this field so that it can be used to initialize data
//for all field-restrictions. For the parts on which the field is shorter,
//a subset of the initial-value array will be used.
//
//We want to end up storing the longest arg_init_value array for this field.
//
//Thus, we call set_initial_value only if the current length is longer
//than what's already been stored.
//length in bytes is num-scalars X sizeof-scalar:
size_t num_scalars = 1;
//if rank > 0, then field is not a scalar field, so num-scalars is
//obtained from the stride array:
if (m_field_rank > 0) num_scalars = tmp.stride(m_field_rank-1);
size_t sizeof_scalar = m_data_traits.size_of;
size_t nbytes = sizeof_scalar * num_scalars;
size_t old_nbytes = 0;
if (get_initial_value() != NULL) {
old_nbytes = get_initial_value_num_bytes();
}
if (nbytes > old_nbytes) {
set_initial_value(arg_init_value, num_scalars, nbytes);
}
}
{
FieldRestrictionVector & restrs = restrictions();
FieldRestrictionVector::iterator restr = restrs.begin();
FieldRestrictionVector::iterator last_restriction = restrs.end();
restr = std::lower_bound(restr,last_restriction,tmp);
const bool new_restriction = ( ( restr == last_restriction ) || !(*restr == tmp) );
if ( new_restriction ) {
// New field restriction, verify we are not committed:
ThrowRequireMsg(!m_meta_data->is_commit(), "mesh MetaData has been committed.");
unsigned num_subsets = 0;
for(FieldRestrictionVector::iterator i=restrs.begin(), iend=restrs.end(); i!=iend; ++i) {
if (i->entity_rank() != arg_entity_rank) continue;
const Part& partI = *m_meta_data->get_parts()[i->part_ordinal()];
bool found_subset = contain(arg_part.subsets(), partI);
if (found_subset) {
ThrowErrorMsgIf( i->not_equal_stride(tmp),
arg_method << " FAILED for " << *this << " " <<
print_restriction( *i, arg_entity_rank, arg_part, m_field_rank ) <<
" WITH INCOMPATIBLE REDECLARATION " <<
print_restriction( tmp, arg_entity_rank, arg_part, m_field_rank ));
*i = tmp;
++num_subsets;
}
bool found_superset = contain(arg_part.supersets(), partI);
if (found_superset) {
ThrowErrorMsgIf( i->not_equal_stride(tmp),
arg_method << " FAILED for " << *this << " " <<
print_restriction( *i, arg_entity_rank, arg_part, m_field_rank ) <<
" WITH INCOMPATIBLE REDECLARATION " <<
print_restriction( tmp, arg_entity_rank, arg_part, m_field_rank ));
//if there's already a restriction for a superset of this part, then
//there's nothing to do and we're out of here..
return;
}
}
if (num_subsets == 0) {
restrs.insert( restr , tmp );
}
else {
//if subsets were found, we replaced them with the new restriction. so now we need
//to sort and unique the vector, and trim it to remove any duplicates:
std::sort(restrs.begin(), restrs.end());
FieldRestrictionVector::iterator it = std::unique(restrs.begin(), restrs.end());
restrs.resize(it - restrs.begin());
}
}
else {
ThrowErrorMsgIf( restr->not_equal_stride(tmp),
arg_method << " FAILED for " << *this << " " <<
print_restriction( *restr, arg_entity_rank, arg_part, m_field_rank ) <<
" WITH INCOMPATIBLE REDECLARATION " <<
print_restriction( tmp, arg_entity_rank, arg_part, m_field_rank ));
}
}
}
STKUNIT_UNIT_TEST(UnitTestingOfThrowMacros, testUnit)
{
// Setting assert handler to NULL should cause exception
STKUNIT_ASSERT_THROW(stk::set_assert_handler(0), std::runtime_error);
// Check that Throw*Msg works
STKUNIT_ASSERT_THROW(force_throw_require_trigger(), std::logic_error);
STKUNIT_ASSERT_THROW(force_throw_error_trigger(), std::runtime_error);
STKUNIT_ASSERT_THROW(force_throw_invarg_trigger(), std::invalid_argument);
// Check that Throw* works
STKUNIT_ASSERT_THROW(force_throw_require_trigger(false), std::logic_error);
STKUNIT_ASSERT_THROW(force_throw_error_trigger(false), std::runtime_error);
STKUNIT_ASSERT_THROW(force_throw_invarg_trigger(false), std::invalid_argument);
// Check that macro interacts appropriately with if statements
STKUNIT_ASSERT_THROW(check_interaction_with_if(), std::logic_error);
STKUNIT_ASSERT_THROW(check_interaction_with_if(false), std::logic_error);
// Check that usage of ThrowRequireMsg/ThrowAssertMsg does not change program
// semantics. Code blocks that are not contained within braces seem to be
// the most likely to be problematic.
bool expected_execution_path = false;
if (false)
ThrowRequireMsg(false, "test");
else
expected_execution_path = true;
STKUNIT_ASSERT(expected_execution_path);
expected_execution_path = false;
if (false)
ThrowAssertMsg(false, "test");
else
expected_execution_path = true;
STKUNIT_ASSERT(expected_execution_path);
expected_execution_path = false;
if (false)
ThrowErrorMsg("test");
else
expected_execution_path = true;
STKUNIT_ASSERT(expected_execution_path);
// These next four statements are to check compilation success
if (false)
ThrowRequireMsg(false, "test");
if (false)
ThrowAssertMsg(false, "test");
if (false)
ThrowRequire(false);
if (false)
ThrowAssert(false);
// Check that do-while still works, again, we are mostly checking compilation
// success here.
do ThrowRequireMsg(true, "test");
while (false);
do ThrowAssertMsg(true, "test");
while (false);
// Check that message with put-tos compiles
int temp = 0;
ThrowRequireMsg(true, "test: " << temp << " blah");
ThrowAssertMsg(true, "test: " << temp << " blah");
// Check that assert behaves as expected (throws in debug, not in opt)
#ifdef NDEBUG
force_throw_assert();
#else
STKUNIT_ASSERT_THROW(force_throw_assert(), std::logic_error);
#endif
// Check that ThrowErrorMsg works
STKUNIT_ASSERT_THROW(test_no_expr_error(), std::runtime_error);
// Check that setting handler for asserts works.
stk::ErrorHandler orig = stk::set_assert_handler(test_assert_handler);
ThrowRequireMsg(false, "test");
STKUNIT_ASSERT(test_assert_handler_called);
stk::set_assert_handler(orig);
STKUNIT_ASSERT_THROW(force_throw_require_trigger(), std::logic_error);
// Check that setting handler for errors works.
orig = stk::set_error_handler(test_error_handler);
ThrowErrorMsgIf(true, "test");
STKUNIT_ASSERT(test_error_handler_called);
stk::set_error_handler(orig);
STKUNIT_ASSERT_THROW(force_throw_error_trigger(), std::runtime_error);
// Check that setting handler for invalid args works.
orig = stk::set_invalid_arg_handler(test_invarg_handler);
ThrowInvalidArgMsgIf(true, "test");
STKUNIT_ASSERT(test_invarg_handler_called);
stk::set_invalid_arg_handler(orig);
STKUNIT_ASSERT_THROW(force_throw_invarg_trigger(), std::invalid_argument);
}
bool test_change_owner_with_constraint( stk_classic::ParallelMachine pm )
{
bool success = true ;
const unsigned p_rank = stk_classic::parallel_machine_rank( pm );
const unsigned p_size = stk_classic::parallel_machine_size( pm );
if ( p_size != 2 ) { return success ; }
std::vector<std::string> rank_names = stk_classic::mesh::fem::entity_rank_names(spatial_dimension);
const stk_classic::mesh::EntityRank constraint_rank = rank_names.size();
rank_names.push_back("Constraint");
stk_classic::mesh::fem::FEMMetaData fem_meta_data( spatial_dimension, rank_names );
const stk_classic::mesh::EntityRank element_rank = fem_meta_data.element_rank();
VectorField * coordinates_field =
& put_field(
fem_meta_data.declare_field<VectorField>("coordinates"),
NODE_RANK,
fem_meta_data.universal_part() ,
3
);
stk_classic::mesh::Part & owned_part = fem_meta_data.locally_owned_part();
stk_classic::mesh::Part & quad_part = stk_classic::mesh::fem::declare_part<Quad4>( fem_meta_data, "quad");
fem_meta_data.commit();
stk_classic::mesh::BulkData bulk_data( stk_classic::mesh::fem::FEMMetaData::get_meta_data(fem_meta_data),
pm,
100 );
bulk_data.modification_begin();
unsigned nx = 3;
unsigned ny = 3;
if ( p_rank==0 )
{
const unsigned nnx = nx + 1 ;
for ( unsigned iy = 0 ; iy < ny ; ++iy ) {
for ( unsigned ix = 0 ; ix < nx ; ++ix ) {
stk_classic::mesh::EntityId elem = 1 + ix + iy * nx ;
stk_classic::mesh::EntityId nodes[4] ;
nodes[0] = 1 + ix + iy * nnx ;
nodes[1] = 2 + ix + iy * nnx ;
nodes[2] = 2 + ix + ( iy + 1 ) * nnx ;
nodes[3] = 1 + ix + ( iy + 1 ) * nnx ;
stk_classic::mesh::fem::declare_element( bulk_data , quad_part , elem , nodes );
}
}
for ( unsigned iy = 0 ; iy < ny+1 ; ++iy ) {
for ( unsigned ix = 0 ; ix < nx+1 ; ++ix ) {
stk_classic::mesh::EntityId nid = 1 + ix + iy * nnx ;
stk_classic::mesh::Entity * n = bulk_data.get_entity( NODE_RANK, nid );
double * const coord = stk_classic::mesh::field_data( *coordinates_field , *n );
coord[0] = .1*ix;
coord[1] = .1*iy;
coord[2] = 0;
}
}
}
bulk_data.modification_end();
if ( p_size>1 )
{
std::vector<stk_classic::mesh::EntityProc> ep;
if ( p_rank==0 )
{
ep.push_back( stk_classic::mesh::EntityProc( bulk_data.get_entity( NODE_RANK, 3 ), 1 ) );
ep.push_back( stk_classic::mesh::EntityProc( bulk_data.get_entity( NODE_RANK, 4 ), 1 ) );
ep.push_back( stk_classic::mesh::EntityProc( bulk_data.get_entity( NODE_RANK, 7 ), 1 ) );
ep.push_back( stk_classic::mesh::EntityProc( bulk_data.get_entity( NODE_RANK, 8 ), 1 ) );
ep.push_back( stk_classic::mesh::EntityProc( bulk_data.get_entity( NODE_RANK, 11 ), 1 ) );
ep.push_back( stk_classic::mesh::EntityProc( bulk_data.get_entity( NODE_RANK, 12 ), 1 ) );
ep.push_back( stk_classic::mesh::EntityProc( bulk_data.get_entity( NODE_RANK, 15 ), 1 ) );
ep.push_back( stk_classic::mesh::EntityProc( bulk_data.get_entity( NODE_RANK, 16 ), 1 ) );
ep.push_back( stk_classic::mesh::EntityProc( bulk_data.get_entity( element_rank, 3 ), 1 ) );
ep.push_back( stk_classic::mesh::EntityProc( bulk_data.get_entity( element_rank, 6 ), 1 ) );
ep.push_back( stk_classic::mesh::EntityProc( bulk_data.get_entity( element_rank, 9 ), 1 ) );
}
bulk_data.modification_begin();
bulk_data.change_entity_owner( ep );
bulk_data.modification_end();
bulk_data.modification_begin();
if ( p_rank==1 )
{
// create constraint
stk_classic::mesh::Entity * n10 = bulk_data.get_entity( NODE_RANK, 10 );
stk_classic::mesh::Entity * n11 = bulk_data.get_entity( NODE_RANK, 11 );
stk_classic::mesh::Entity * n12 = bulk_data.get_entity( NODE_RANK, 12 );
stk_classic::mesh::PartVector add;
add.push_back( &owned_part );
const stk_classic::mesh::EntityId c_entity_id = 1;
stk_classic::mesh::Entity & c = bulk_data.declare_entity( constraint_rank, c_entity_id, add );
bulk_data.declare_relation( c , *n10 , 0 );
bulk_data.declare_relation( c , *n11 , 1 );
bulk_data.declare_relation( c , *n12 , 2 );
}
bulk_data.modification_end();
stk_classic::mesh::Entity * n10 = bulk_data.get_entity( NODE_RANK, 10 );
if ( p_rank==0 or p_rank==1 )
{
ThrowErrorMsgIf( !stk_classic::mesh::in_shared( *n10 ), "NODE[10] not shared" );
}
bulk_data.modification_begin();
if ( p_rank==1 )
{
// destroy constraint
stk_classic::mesh::Entity * c1 = bulk_data.get_entity( constraint_rank, 1 );
ThrowErrorMsgIf( !bulk_data.destroy_entity( c1 ),
"failed to destroy constraint" );
}
bulk_data.modification_end();
if ( p_rank==0 or p_rank==1 )
{
ThrowErrorMsgIf( stk_classic::mesh::in_shared( *n10 ), "NODE[10] shared" );
}
}
return success ;
}
