stk::mesh Namespace Reference


Classes

class  BucketIterator
 A random access iterator for a bucket that dereferences to a entity reference. More...
class  Bucket
 A container for the field data of a homogeneous collection of entities. More...
struct  BucketLess
class  BulkData
 Manager for an integrated collection of entities, entity relations, and buckets of field data. More...
class  DataTraits
class  Entity
 A fundamental unit within the discretization of a problem domain, including but not limited to nodes, edges, sides, and elements. More...
class  EntityLess
 Comparison operator for entities compares the entities' keys. More...
class  EntityEqual
union  EntityKey
 Integer type for the entity keys, which is an encoding of the entity type and entity identifier. More...
class  Field< void, void, void, void, void, void, void, void >
 Field base class with an anonymous data type and anonymous multi-dimension. More...
class  Field
 Field with defined data type and multi-dimensions (if any). More...
struct  FieldTraits< Field< Scalar, void, void, void, void, void, void, void > >
 Scalar type and multi-dimensional array traits of a Field. More...
struct  FieldTraits< Field< Scalar, Tag1, Tag2, Tag3, Tag4, Tag5, Tag6, Tag7 > >
 Scalar type and multi-dimensional array traits of a Field. More...
struct  FieldRelation
 A defined entity-relationship between a field of a pointer type and the field that it should point to. More...
class  BucketArray
 Field data Array for a given array field and bucket More...
class  EntityArray
 Field data Array for a given array field and entity More...
struct  EntityArray< Field< ScalarType, Tag1, Tag2, Tag3, Tag4, Tag5, Tag6, Tag7 > >
 Field data Array for a given array field and entity More...
struct  EntityDimension
 Implement ArrayDimTag for the entity count dimension of a BucketArray. More...
struct  BucketArray< Field< ScalarType, void, void, void, void, void, void, void > >
 Field data Array for a given scalar field and bucket More...
struct  BucketArray< Field< ScalarType, Tag1, Tag2, Tag3, Tag4, Tag5, Tag6, Tag7 > >
 Field data Array for a given array field and bucket More...
class  Ghosting
 Data for ghosting mesh entities. More...
class  MetaData
 The manager of an integrated collection of parts and fields. More...
struct  PartRelation
 A defined entity-relationship between parts. More...
class  Part
 An application-defined subset of a problem domain. More...
struct  PartLess
 Ordering operator for parts. More...
class  Property< void >
 Property base class with an anonymous data type and anonymous multi-dimension. More...
class  Property
 Property with defined data type and multi-dimensions (if any). More...
class  Relation
 A relation between two mesh entities with a relation identifier and kind . More...
struct  LessRelation
class  Selector
 This is a class for selecting buckets based on a set of meshparts and set logic. More...
class  Transaction
 Transaction journal of modifications to the bulk data during a transaction. More...
struct  Cartesian
 Implement an ArrayDimTag for Cartesian coordinate dimensions. More...
struct  Cylindrical
 Implement an ArrayDimTag for Cylindrical coordinate dimensions. More...
struct  FullTensor
 Implement an ArrayDimTag for FullTensor. More...
struct  SymmetricTensor
 Implement an ArrayDimTag for SymmetricTensor. More...
class  ElementNode
 Define an array dimension of the number of nodes per element. More...
struct  QuadratureTag
struct  BasisTag
class  UnitTestBucket
class  UnitTestBulkData
class  UnitTestRelation

Declare field data allocation rules

template<class field_type>
field_type & put_field (field_type &field, unsigned entity_type, const Part &part)
 Declare a field to exist for a given entity type and Part.
template<class field_type>
field_type & put_field (field_type &field, unsigned entity_type, const Part &part, unsigned n1)
 Declare a field to exist for a given entity type and Part.
template<class field_type>
field_type & put_field (field_type &field, unsigned entity_type, const Part &part, unsigned n1, unsigned n2)
template<class field_type>
field_type & put_field (field_type &field, unsigned entity_type, const Part &part, unsigned n1, unsigned n2, unsigned n3)
template<class field_type>
field_type & put_field (field_type &field, unsigned entity_type, const Part &part, unsigned n1, unsigned n2, unsigned n3, unsigned n4)
template<class field_type>
field_type & put_field (field_type &field, unsigned entity_type, const Part &part, unsigned n1, unsigned n2, unsigned n3, unsigned n4, unsigned n5)
template<class field_type>
field_type & put_field (field_type &field, unsigned entity_type, const Part &part, unsigned n1, unsigned n2, unsigned n3, unsigned n4, unsigned n5, unsigned n6)
template<class field_type>
field_type & put_field (field_type &field, unsigned entity_type, const Part &part, unsigned n1, unsigned n2, unsigned n3, unsigned n4, unsigned n5, unsigned n6, unsigned n7)

Typedefs

typedef std::vector< Entity * > EntityVector
typedef std::set< Entity *,
EntityLess
EntitySet
typedef std::set< EntityProc,
EntityLess
EntityProcSet
typedef PairIter< std::vector<
Relation >::const_iterator > 
PairIterRelation
 Span of a sorted relations for a given domain entity.
typedef PairIter< std::vector<
EntityCommInfo >::const_iterator > 
PairIterEntityComm
 Span of ( communication-subset-ordinal , process-rank ) pairs for the communication of an entity.
typedef unsigned EntityType
typedef uint64_t EntityId
typedef std::less< unsigned > LowestRankSharingProcOwns
typedef std::greater< unsigned > HighestRankSharingProcOwns
typedef std::vector< Part * > PartVector
 Collections of parts are frequently maintained as a vector of Part pointers.
typedef Field< void, void,
void, void, void, void, void,
void > 
FieldBase
typedef Property< void > PropertyBase
typedef std::pair< Entity *,
unsigned > 
EntityProc
 Pairing of an entity with a processor rank.
typedef PairIter< std::vector<
EntityProc >::const_iterator > 
PairIterEntityProc
 Spans of a vector of entity-processor pairs are common.
typedef int(*) relation_stencil_ptr (unsigned from_type, unsigned to_type, unsigned identifier)
 A relation stencil maps entity relationships to ordinals.
typedef std::pair< Entity *,
unsigned > 
EntitySideComponent
 A pair of Entity* and a local side id (defined a part of a side).
typedef std::pair< EntitySideComponent,
EntitySideComponent
EntitySide
 A pair of EntitySideComponents (defines a side of the boundary) Most sides will have two EntitySideComponents, but degenerate cases ie shells will can have sides with more than two components).
typedef std::vector< EntitySideEntitySideVector
 A vector of EntitySide (defines a boundary).
typedef Field< double > ScalarField
typedef Field< int > ScalarIntField
typedef Field< double, CartesianVectorField
typedef Field< double, FullTensorFullTensorField
typedef Field< double, SymmetricTensorSymmetricTensorField
typedef Field< double, ElementNodeElementNodeField
 An element Field defining an array of values, one value per node of the element.
typedef Field< double *, ElementNodeElementNodePointerField
 A Field defining an array of pointers to an element's nodal field data.
typedef Field< int *, ElementNodeElementNodeLockField
typedef int BOX [3][2]
typedef int BOX [3][2]
typedef int BOX [3][2]

Enumerations

enum  { OWNERSHIP_PART_COUNT = 3 }
enum  FieldState {
  StateNone = 0,
  StateNew = 0,
  StateNP1 = 0,
  StateOld = 1,
  StateN = 1,
  StateNM1 = 2,
  StateNM2 = 3,
  StateNM3 = 4,
  StateNM4 = 5
}
 Enumeration of states for multi-state fields. More...
enum  { MaximumFieldStates = 6 }
 Maximum number of states that a field can have.
enum  { MaximumFieldDimension = 7 }
 Maximum multi-dimenaional array dimension of a field.
enum  EntityTypeEnum {
  Node = 0,
  Edge = 1,
  Face = 2,
  Element = 3,
  Particle = 4,
  Constraint = 5,
  EntityTypeEnd = 6,
  EntityTypeUndefined = -1
}
 Enumeration of types of entities. More...
enum  EType {
  val_a = 'a',
  val_b = 'b',
  val_c = 'c'
}

Functions

void memory_copy (unsigned char *dst, unsigned char *src, unsigned n)
void memory_zero (unsigned char *dst, unsigned n)
bool bucket_part_equal (const unsigned *lhs, const unsigned *rhs)
bool bucket_key_less (const unsigned *lhs, const unsigned *rhs)
bool has_superset (const Bucket &, const unsigned &ordinal)
 Is this bucket a subset of the given part by partID.
bool has_superset (const Bucket &, const Part &p)
 Is this bucket a subset of the given part.
bool has_superset (const Bucket &, const PartVector &)
 Is this bucket a subset of all of the given parts.
bool field_data_valid (const FieldBase &f, const Bucket &k, unsigned ord=0, const char *required_by=NULL)
 Check for existence of field data.
void throw_field_data_array (const FieldBase &f, unsigned R)
unsigned align (size_t nb)
const FieldBase::Restriction & empty_field_restriction ()
const FieldBase::Restriction & dimension (const FieldBase &field, unsigned etype, const unsigned num_part_ord, const unsigned part_ord[], const char *const method)
void * local_malloc (size_t n)
std::ostream & operator<< (std::ostream &, const Bucket &)
 Print the part names for which this bucket is a subset.
std::ostream & print (std::ostream &, const std::string &indent, const Bucket &)
 Print the parts and entities of this bucket.
unsigned bucket_counter (const unsigned *const key)
std::vector< Bucket * >::iterator lower_bound (std::vector< Bucket * > &v, const unsigned *key)
std::vector< parallel::DistributedIndex::KeySpanconvert_entity_keys_to_spans (const MetaData &meta)
void verify_change_parts (const char *method, const MetaData &meta, const Entity &entity, const PartVector &parts)
void filter_out (std::vector< unsigned > &vec, const PartVector &parts, PartVector &removed)
void merge_in (std::vector< unsigned > &vec, const PartVector &parts)
bool comm_mesh_verify_parallel_consistency (BulkData &M, std::ostream &error_log)
bool send_to_shared_and_ghost_recv (const BulkData &mesh, const std::vector< Entity * > &send, std::vector< EntityProc > &recv)
void pack_induced_memberships (CommAll &comm, const std::vector< Entity * > &entity_comm)
void generate_send_list (const size_t sync_count, const unsigned p_rank, const std::vector< Entity * > &entity_comm, std::vector< EntityProc > &send_list)
void pack_memberships (CommAll &comm, const std::vector< EntityProc > &send_list)
void insert_transitive_closure (std::set< EntityProc, EntityLess > &new_send, const EntityProc &entry)
void comm_recv_to_send (BulkData &mesh, const std::set< Entity *, EntityLess > &new_recv, std::set< EntityProc, EntityLess > &new_send)
void comm_sync_send_recv (BulkData &mesh, std::set< EntityProc, EntityLess > &new_send, std::set< Entity *, EntityLess > &new_recv)
void require_destroy_entity (BulkData &mesh, Entity *entity, const char *const method)
void insert_transitive_closure (std::set< EntityProc, EntityLess > &new_send, const EntityProc &entry)
void comm_recv_to_send (BulkData &mesh, const std::set< Entity *, EntityLess > &new_recv, std::set< EntityProc, EntityLess > &new_send)
void comm_sync_send_recv (BulkData &mesh, std::set< EntityProc, EntityLess > &new_send, std::set< Entity *, EntityLess > &new_recv)
void insert_closure_ghost (const MetaData &meta, Entity *const entity, std::set< Entity *, EntityLess > &remove_list)
void insert_transitive_ghost (const MetaData &meta, Entity *const entity, std::set< Entity *, EntityLess > &remove_list)
void insert_closure_send (const EntityProc send_entry, std::set< EntityProc, EntityLess > &send_list)
bool member_of_owned_closure (const Entity &e, const unsigned p_rank)
void clean_and_verify_parallel_change (const char method[], const BulkData &mesh, std::vector< EntityProc > &local_change)
void generate_parallel_change (const BulkData &mesh, const std::vector< EntityProc > &local_change, std::vector< EntityProc > &shared_change, std::vector< EntityProc > &ghosted_change)
bool verify_parallel_attributes (BulkData &M, std::ostream &error_log)
void pack_owned_verify (CommAll &all, const BulkData &mesh)
bool unpack_not_owned_verify (CommAll &comm_all, const BulkData &mesh, std::ostream &error_log)
bool in_owned_closure (const Entity &entity, unsigned p_local)
bool ordered_comm (const Entity &entity)
bool verify_parallel_attributes (BulkData &M, std::ostream &error_log)
void insert (std::vector< unsigned > &vec, unsigned val)
void pack_owned_verify (CommAll &all, const BulkData &mesh)
bool unpack_not_owned_verify (CommAll &comm_all, const BulkData &mesh, std::ostream &error_log)
void assert_valid_relation (const char method[], const BulkData &mesh, const Entity &e_from, const Entity &e_to)
bool is_degenerate_relation (const Relation &r1, const Relation &r2)
void set_field_relations (Entity &e_from, Entity &e_to, const unsigned ident)
void clear_field_relations (Entity &e_from, const unsigned type, const unsigned ident)
void construct_transitive_closure (EntitySet &closure, Entity &entry)
void find_local_closure (EntitySet &closure, const EntityVector &entities)
void construct_communication_set (const BulkData &bulk, const EntitySet &closure, EntityProcSet &communication_set)
size_t count_non_used_entities (const BulkData &bulk, const EntityVector &entities)
void find_closure (const BulkData &bulk, const std::vector< Entity * > &entities, std::vector< Entity * > &entities_closure)
 Determine closure of the entities vector.
void print_entry (std::ostream &msg, const EntityProc &e)
void sort_unique (std::vector< EntityProc > &)
 Sort and unique an EntityProc array.
std::vector< EntityProc
>::const_iterator 
lower_bound (const std::vector< EntityProc > &, unsigned)
 Find the first entry corresponding to the given entity type.
std::vector< EntityProc
>::const_iterator 
lower_bound (const std::vector< EntityProc > &, Entity &)
 Find the first entry corresponding to the given entity.
std::vector< EntityProc
>::const_iterator 
lower_bound (const std::vector< EntityProc > &, const EntityProc &)
 Find the first entry corresponding to the given entity and processor.
std::vector< EntityProc
>::iterator 
lower_bound (std::vector< EntityProc > &, Entity &)
 Find the first entry corresponding to the given entity.
std::vector< EntityProc
>::iterator 
lower_bound (std::vector< EntityProc > &, const EntityProc &)
 Find the first entry corresponding to the given entity and processor.
bool verify (const std::vector< EntityProc > &, std::string &)
 Sanity check locally for non-null, same-mesh, off-processor, and proper ordering.
bool comm_verify (ParallelMachine, const std::vector< EntityProc > &, std::string &)
 Sanity check on existing or potential parallel relation information.
bool comm_verify (ParallelMachine, const std::vector< EntityProc > &, const std::vector< EntityProc > &, std::string &)
 Sanity check on existing or potential parallel relation information.
bool comm_mesh_counts (BulkData &, std::vector< size_t > &counts, bool=false)
 Global counts for a mesh's entities.
std::pair< std::vector< Entity
* >::const_iterator, std::vector<
Entity * >::const_iterator > 
span (const std::vector< Entity * > &v, const unsigned entity_rank)
bool comm_verify_shared_entity_values (const BulkData &, unsigned, const FieldBase &)
 Verify that the shared entity values are bit-wise identical.
std::size_t stride (std::size_t size, std::size_t align)
template<>
const DataTraitsdata_traits< void > ()
template<>
const DataTraitsdata_traits< char > ()
template<>
const DataTraitsdata_traits< unsigned char > ()
template<>
const DataTraitsdata_traits< short > ()
template<>
const DataTraitsdata_traits< unsigned short > ()
template<>
const DataTraitsdata_traits< int > ()
template<>
const DataTraitsdata_traits< unsigned int > ()
template<>
const DataTraitsdata_traits< long > ()
template<>
const DataTraitsdata_traits< unsigned long > ()
template<>
const DataTraitsdata_traits< float > ()
template<>
const DataTraitsdata_traits< double > ()
template<>
const DataTraitsdata_traits< char * > ()
template<>
const DataTraitsdata_traits< unsigned char * > ()
template<>
const DataTraitsdata_traits< short * > ()
template<>
const DataTraitsdata_traits< unsigned short * > ()
template<>
const DataTraitsdata_traits< int * > ()
template<>
const DataTraitsdata_traits< unsigned int * > ()
template<>
const DataTraitsdata_traits< long * > ()
template<>
const DataTraitsdata_traits< unsigned long * > ()
template<>
const DataTraitsdata_traits< float * > ()
template<>
const DataTraitsdata_traits< double * > ()
template<typename T>
const DataTraitsdata_traits ()
 Query singleton for data traits of a given data type.
template<typename T>
const DataTraitsdata_traits (const T &)
 Query DataTraits for a given data value.
template<>
const DataTraitsdata_traits< signed char > ()
template<>
const DataTraitsdata_traits< signed short > ()
template<>
const DataTraitsdata_traits< signed int > ()
template<>
const DataTraitsdata_traits< signed long > ()
template<>
const DataTraitsdata_traits< std::complex< float > > ()
template<>
const DataTraitsdata_traits< std::complex< double > > ()
template<>
const DataTraitsdata_traits< signed char * > ()
template<>
const DataTraitsdata_traits< signed short * > ()
template<>
const DataTraitsdata_traits< signed int * > ()
template<>
const DataTraitsdata_traits< signed long * > ()
template<>
const DataTraitsdata_traits< std::complex< float > * > ()
template<>
const DataTraitsdata_traits< std::complex< double > * > ()
std::ostream & print_entity_key (std::ostream &os, const MetaData &meta_data, unsigned type, EntityId id)
std::ostream & print_entity_key (std::ostream &, const MetaData &, const EntityKey &)
 Print an entity key for this meta data.
bool in_shared (const Entity &entity)
 Is shared with any other process.
bool in_shared (const Entity &entity, unsigned proc)
 Is shared with a given process.
bool in_receive_ghost (const Entity &entity)
 Is a receive ghost copy of an entity.
bool in_receive_ghost (const Ghosting &ghost, const Entity &entity)
 Is a receive ghost copy of an entity.
bool in_send_ghost (const Entity &entity)
 Is sent to a ghost copy of an entity on any process.
bool in_send_ghost (const Entity &entity, unsigned proc)
 Is sent to a ghost copy of an entity on a given process.
bool in_ghost (const Ghosting &ghost, const Entity &entity, unsigned p)
 Is in ghosting either send to 'p' or receive from 'p'.
void comm_procs (const Entity &entity, std::vector< unsigned > &procs)
 List of all entity communication processes, sorted.
void comm_procs (const Ghosting &ghost, const Entity &entity, std::vector< unsigned > &procs)
 List of entity communication processes for a given ghost, sorted.
void pack_entity_info (CommBuffer &buf, const Entity &entity)
void unpack_entity_info (CommBuffer &buf, const BulkData &mesh, EntityKey &key, unsigned &owner, PartVector &parts, std::vector< Relation > &relations)
void pack_field_values (CommBuffer &, Entity &)
 Pack an entity's field values into a buffer.
bool unpack_field_values (CommBuffer &, Entity &, std::ostream &error_msg)
 Unpack an entity's field values from a buffer.
EntityType entity_rank (const EntityKey &key)
 Given an entity key, return an entity type (rank).
EntityType entity_type (const EntityKey &key)
EntityId entity_id (const EntityKey &key)
 Given an entity key, return the identifier for the entity.
bool entity_key_valid (const EntityKey &key)
 Query if an entity key is valid.
bool entity_id_valid (EntityKey::raw_key_type id)
const char * field_state_name (FieldState)
 Return the string name of a field state.
std::vector< FieldBase::Restriction
>::const_iterator 
find (const std::vector< FieldBase::Restriction > &v, const EntityKey &key)
void print_field_type (std::ostream &arg_msg, const DataTraits &arg_traits, unsigned arg_rank, const shards::ArrayDimTag *const *arg_tags)
void throw_name_suffix (const char *method, const std::string &name, const char *suffix)
void verify_field_type (const char *arg_method, const FieldBase &arg_field, const DataTraits &arg_traits, unsigned arg_rank, const shards::ArrayDimTag *const *arg_dim_tags, unsigned arg_num_states)
FieldBaseget_field (const char *arg_method, const std::string &arg_name, const DataTraits &arg_traits, unsigned arg_rank, const shards::ArrayDimTag *const *arg_dim_tags, unsigned arg_num_states, const std::vector< FieldBase * > &arg_meta_data_fields)
 Get a field by name from a vector of fields.
void print_restriction (std::ostream &os, unsigned type, const Part &part, unsigned rank, const FieldBase::Restriction::size_type *stride)
std::ostream & operator<< (std::ostream &, const FieldBase &)
 Print the field type, text name, and number of states.
std::ostream & print (std::ostream &, const char *const , const FieldBase &)
 Print field and field restrictions on new lines.
void print_field_type (std::ostream &arg_msg, unsigned arg_scalar_type, unsigned arg_rank, const shards::ArrayDimTag *const *arg_tags)
bool field_data_valid (const FieldBase &f, const Entity &e, const char *required_by=NULL)
 Check for existence of field data.
unsigned field_data_size (const FieldBase &f, const Bucket &k)
 Size, in bytes, of the field data for each entity.
unsigned field_data_size (const FieldBase &f, const Entity &e)
 Size, in bytes, of the field data for each entity.
template<class field_type>
FieldTraits< field_type
>::data_type * 
field_data (const field_type &f, const Bucket::iterator &i)
 Pointer to the field data array.
template<class field_type>
FieldTraits< field_type
>::data_type * 
field_data (const field_type &f, const Entity &e)
 Pointer to the field data array.
void communicate_field_data (const Ghosting &ghosts, const std::vector< const FieldBase * > &fields)
void communicate_field_data (ParallelMachine machine, const std::vector< EntityProc > &domain, const std::vector< EntityProc > &range, const std::vector< const FieldBase * > &fields)
 Communicate field data from domain to range.
void communicate_field_data (const BulkData &mesh, const unsigned field_count, const FieldBase *fields[], CommAll &sparse)
 Communicate field data among shared entities.
void communicate_field_data_verify_read (CommAll &sparse)
template<class OpField>
void parallel_reduce (const BulkData &mesh, const OpField &op)
 Parallel reduction of shared entities' field data.
template<class OpField1, class OpField2>
void parallel_reduce (const BulkData &mesh, const OpField1 &op1, const OpField2 &op2)
 Parallel reduction of shared entities' field data.
template<class Type, class Tag1, class Tag2, class Tag3, class Tag4, class Tag5, class Tag6, class Tag7>
ParallelReduceField< Sum<
1 >, Type, Tag1, Tag2, Tag3,
Tag4, Tag5, Tag6, Tag7 > 
sum (const Field< Type, Tag1, Tag2, Tag3, Tag4, Tag5, Tag6, Tag7 > &f)
template<class Type, class Tag1, class Tag2, class Tag3, class Tag4, class Tag5, class Tag6, class Tag7>
ParallelReduceField< Max<
1 >, Type, Tag1, Tag2, Tag3,
Tag4, Tag5, Tag6, Tag7 > 
max (const Field< Type, Tag1, Tag2, Tag3, Tag4, Tag5, Tag6, Tag7 > &f)
template<class Type, class Tag1, class Tag2, class Tag3, class Tag4, class Tag5, class Tag6, class Tag7>
ParallelReduceField< Min<
1 >, Type, Tag1, Tag2, Tag3,
Tag4, Tag5, Tag6, Tag7 > 
min (const Field< Type, Tag1, Tag2, Tag3, Tag4, Tag5, Tag6, Tag7 > &f)
void get_buckets (const Selector &selector, const std::vector< Bucket * > &input, std::vector< Bucket * > &output)
void copy_ids (std::vector< unsigned > &v, const PartVector &p)
void get_involved_parts (const PartVector &union_parts, const Bucket &candidate, PartVector &involved_parts)
void get_entities (const BulkData &, EntityType type, std::vector< Entity * > &)
 Get all entities of the specified type, sorted by ID.
unsigned count_selected_entities (const Selector &selector, const std::vector< Bucket * > &input_buckets)
 Count entities in selected parts (selected by the given selector instance), and sorted by ID.
void get_selected_entities (const Selector &selector, const std::vector< Bucket * > &input_buckets, std::vector< Entity * > &entities)
 Get entities in selected parts (selected by the given selector instance), and sorted by ID.
void count_entities (const Selector &selector, const BulkData &mesh, std::vector< EntityType > &count)
 Local count selected entities of each type.
void assert_not_relation_target (const char *const method, const Part *const part)
void pack (CommBuffer &b, const PartVector &pset)
bool unpack_verify (CommBuffer &b, const PartVector &pset)
void pack (CommBuffer &, const std::vector< FieldBase * > &)
bool unpack_verify (CommBuffer &, const std::vector< FieldBase * > &)
void verify_parallel_consistency (const MetaData &, ParallelMachine)
 Verify that the meta data is identical on all processors.
Partfind (const PartVector &, const std::string &)
 Find a part by name in a collection of parts.
std::ostream & print (std::ostream &, const char *const , const Part &)
 Print a part's information including supersets, subsets, and intersection.
void order (PartVector &)
 Order a collection of parts: invoke sort and then unique.
bool insert (PartVector &, Part &)
 Insert a part into a properly ordered collection of parts.
void remove (PartVector &, Part &)
 Remove a part from a properly ordered collection of parts.
bool contain (const PartVector &, const Part &)
 Query containment within properly ordered PartVector.
bool contain (const PartVector &, const PartVector &)
 Query containment for two properly ordered PartVector.
size_t intersect (const PartVector &, const PartVector &)
 Query cardinality of intersection of two PartVectors.
size_t intersect (const PartVector &, const PartVector &, PartVector &)
 Generate the intersection of two PartVectors.
bool intersect (const Part &, const Part &)
 Query if two parts intersect; i.e., if one is a subset of the other or they share a common subset.
const char * universal_part_name ()
void append_part_method (std::string &msg, const Part &part, const char *method)
void assert_universal_part (Part &part, const char *method)
void assert_contain (Part &superset, Part &subset, const char *method)
void assert_same_universe (const Part &part, const char *method, const Part &arg_part)
void assert_not_same (const Part &part, const char *method, const Part &arg_part)
void assert_not_superset (const Part &part, const char *method, const Part &arg_part)
void assert_rank_ordering (const Part &superset, const char *method, const Part &subset)
void property_data_throw (const PropertyBase &, const Part &)
 Internal function to throw a descriptive error message.
std::ostream & operator<< (std::ostream &, const PropertyBase &)
 Print the text name for a field.
std::ostream & print (std::ostream &, const char *const , const PropertyBase &)
 Print field and field restrictions on new lines.
template<typename property_type>
const property_type::data_type * property_data (const property_type &prop, const Part &part)
 Query pointer to property data for a given part.
template<typename property_type>
property_type::data_type * property_data (property_type &prop, const Part &part)
 Query pointer to property data for a given part.
std::ostream & operator<< (std::ostream &, const Relation &)
 Print the relation attributes and referenced entity's key.
void get_entities_through_relations (PairIterRelation rel, const std::vector< Entity * >::const_iterator i_beg, const std::vector< Entity * >::const_iterator i_end, std::vector< Entity * > &entities_related)
void get_entities_through_relations (const std::vector< Entity * > &entities, std::vector< Entity * > &entities_related)
 Query which mesh entities have a relation to all of the input mesh entities.
void get_entities_through_relations (const std::vector< Entity * > &entities, unsigned entities_related_rank, std::vector< Entity * > &entities_related)
bool membership_is_induced (const Part &part, unsigned entity_type)
 Query if a member entity of the given entity type has an induced membership.
void induced_part_membership (Part &part, unsigned entity_type_from, unsigned entity_type_to, unsigned relation_identifier, PartVector &induced_parts)
 Induce entities' part membership based upon relationships between entities.
void induced_part_membership (const Entity &entity_from, const PartVector &omit, unsigned entity_type_to, unsigned relation_identifier, PartVector &entity_to_parts)
 Induce entities' part membership based upon relationships between entities.
void induced_part_membership (const Entity &entity, const PartVector &omit, PartVector &induced)
 Induce an entity's part membership based upon relationships from other entities.
Selector operator & (const Part &A, const Part &B)
Selector operator & (const Part &A, const Selector &B)
Selector operator & (const Selector &A, const Part &B)
Selector operator & (const Selector &A, const Selector &B)
Selector operator| (const Part &A, const Part &B)
Selector operator| (const Part &A, const Selector &B)
Selector operator| (const Selector &A, const Part &B)
Selector operator| (const Selector &A, const Selector &B)
Selector operator! (const Part &A)
std::ostream & operator<< (std::ostream &out, const Selector &selector)
Selector selectUnion (const PartVector &union_part_vector)
Selector selectIntersection (const PartVector &intersection_part_vector)
template<class OwnershipRule>
void set_owners (BulkData &mesh_bulk_data)
 Sets the owner for shared entities according to the template parameter OwnershipRule.
std::ostream & operator<< (std::ostream &os, const Transaction &rhs)
stk::diag::Writeroperator<< (stk::diag::Writer &dout, const EntityKey &entity_key)
void boundary_analysis (const BulkData &bulk_data, const std::vector< Entity * > &entities_closure, unsigned closure_rank, EntitySideVector &boundary)
 Given a closure, return a boundary of items of closure_rank-1.
const std::vector< std::string > & fem_entity_type_names ()
 Finite element entity-type names.
EntityTypeEnum fem_entity_type (int t)
ScalarFielddeclare_scalar_field_on_all_nodes (MetaData &, const std::string &)
ScalarIntFielddeclare_scalar_int_field_on_all_nodes (MetaData &, const std::string &)
ScalarFielddeclare_scalar_field_on_all_elements (MetaData &, const std::string &)
VectorFielddeclare_vector_field_on_all_nodes (MetaData &, const std::string &, unsigned)
VectorFielddeclare_vector_field_on_all_elements (MetaData &, const std::string &, unsigned)
FullTensorFielddeclare_full_tensor_field_on_all_nodes (MetaData &, const std::string &, unsigned)
FullTensorFielddeclare_full_tensor_field_on_all_elements (MetaData &, const std::string &, unsigned)
SymmetricTensorFielddeclare_symmetric_tensor_field_on_all_nodes (MetaData &, const std::string &, unsigned)
SymmetricTensorFielddeclare_symmetric_tensor_field_on_all_elements (MetaData &, const std::string &, unsigned)
template<typename Type, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
Field< Type, T1, T2, T3, T4,
T5, T6, T7 > & 
put_field_on_nodes (Field< Type, T1, T2, T3, T4, T5, T6, T7 > &f, Part &p)
template<typename Type, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
Field< Type, T1, T2, T3, T4,
T5, T6, T7 > & 
put_field_on_nodes (Field< Type, T1, T2, T3, T4, T5, T6, T7 > &f, Part &p, unsigned n1)
template<typename Type, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
Field< Type, T1, T2, T3, T4,
T5, T6, T7 > & 
put_field_on_nodes (Field< Type, T1, T2, T3, T4, T5, T6, T7 > &f, Part &p, unsigned n1, unsigned n2)
template<typename Type, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
Field< Type, T1, T2, T3, T4,
T5, T6, T7 > & 
put_field_on_nodes (Field< Type, T1, T2, T3, T4, T5, T6, T7 > &f, Part &p, unsigned n1, unsigned n2, unsigned n3)
template<typename Type, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
Field< Type, T1, T2, T3, T4,
T5, T6, T7 > & 
put_field_on_nodes (Field< Type, T1, T2, T3, T4, T5, T6, T7 > &f, Part &p, unsigned n1, unsigned n2, unsigned n3, unsigned n4)
template<typename Type, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
Field< Type, T1, T2, T3, T4,
T5, T6, T7 > & 
put_field_on_nodes (Field< Type, T1, T2, T3, T4, T5, T6, T7 > &f, Part &p, unsigned n1, unsigned n2, unsigned n3, unsigned n4, unsigned n5)
template<typename Type, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
Field< Type, T1, T2, T3, T4,
T5, T6, T7 > & 
put_field_on_nodes (Field< Type, T1, T2, T3, T4, T5, T6, T7 > &f, Part &p, unsigned n1, unsigned n2, unsigned n3, unsigned n4, unsigned n5, unsigned n6)
template<typename Type, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
Field< Type, T1, T2, T3, T4,
T5, T6, T7 > & 
put_field_on_nodes (Field< Type, T1, T2, T3, T4, T5, T6, T7 > &f, Part &p, unsigned n1, unsigned n2, unsigned n3, unsigned n4, unsigned n5, unsigned n6, unsigned n7)
template<typename Type, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
Field< Type, T1, T2, T3, T4,
T5, T6, T7 > & 
put_field_on_all_nodes (Field< Type, T1, T2, T3, T4, T5, T6, T7 > &f)
template<typename Type, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
Field< Type, T1, T2, T3, T4,
T5, T6, T7 > & 
put_field_on_all_nodes (Field< Type, T1, T2, T3, T4, T5, T6, T7 > &f, unsigned n1)
template<typename Type, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
Field< Type, T1, T2, T3, T4,
T5, T6, T7 > & 
put_field_on_all_nodes (Field< Type, T1, T2, T3, T4, T5, T6, T7 > &f, unsigned n1, unsigned n2)
template<typename Type, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
Field< Type, T1, T2, T3, T4,
T5, T6, T7 > & 
put_field_on_all_nodes (Field< Type, T1, T2, T3, T4, T5, T6, T7 > &f, unsigned n1, unsigned n2, unsigned n3)
template<typename Type, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
Field< Type, T1, T2, T3, T4,
T5, T6, T7 > & 
put_field_on_all_nodes (Field< Type, T1, T2, T3, T4, T5, T6, T7 > &f, unsigned n1, unsigned n2, unsigned n3, unsigned n4)
template<typename Type, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
Field< Type, T1, T2, T3, T4,
T5, T6, T7 > & 
put_field_on_all_nodes (Field< Type, T1, T2, T3, T4, T5, T6, T7 > &f, unsigned n1, unsigned n2, unsigned n3, unsigned n4, unsigned n5)
template<typename Type, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
Field< Type, T1, T2, T3, T4,
T5, T6, T7 > & 
put_field_on_all_nodes (Field< Type, T1, T2, T3, T4, T5, T6, T7 > &f, unsigned n1, unsigned n2, unsigned n3, unsigned n4, unsigned n5, unsigned n6)
template<typename Type, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
Field< Type, T1, T2, T3, T4,
T5, T6, T7 > & 
put_field_on_all_nodes (Field< Type, T1, T2, T3, T4, T5, T6, T7 > &f, unsigned n1, unsigned n2, unsigned n3, unsigned n4, unsigned n5, unsigned n6, unsigned n7)
template<typename Type>
Field< Type > & put_field_on_all_elements (Field< Type > &)
template<typename Type>
Field< Type > & put_field_on_elements (Field< Type > &, Part &)
template<typename Type, class T1>
Field< Type, T1 > & put_field_on_all_elements (Field< Type, T1 > &, unsigned n1)
template<typename Type, class T1>
Field< Type, T1 > & put_field_on_elements (Field< Type, T1 > &, Part &, unsigned n1)
template<typename Type, class T1, class T2>
Field< Type, T1, T2 > & put_field_on_all_elements (Field< Type, T1, T2 > &, unsigned n1, unsigned n2)
template<typename Type, class T1, class T2>
Field< Type, T1, T2 > & put_field_on_elements (Field< Type, T1, T2 > &, Part &, unsigned n1, unsigned n2)
unsigned get_index (const char *const func, const unsigned number_names, const char *const *names, const unsigned size, const char *const select)
const char * get_string (const char *const func, const unsigned number_names, const char *const *names, const unsigned size, const unsigned index)
template<class TopologyTraits>
int element_node_stencil (unsigned, unsigned, unsigned)
template<>
int element_node_stencil< void > (unsigned from_type, unsigned to_type, unsigned identifier)
template<class TopologyTraits>
int element_node_stencil (unsigned from_type, unsigned to_type, unsigned identifier)
template<class TopologyTraits>
int element_node_lock_stencil (unsigned, unsigned, unsigned)
template<>
int element_node_lock_stencil< void > (unsigned from_type, unsigned to_type, unsigned identifier)
template<class TopologyTraits>
int element_node_lock_stencil (unsigned from_type, unsigned to_type, unsigned identifier)
ElementNodeFielddeclare_element_node_field (MetaData &md, const std::string &s)
 Declare an element-node field.
template<class NodeField>
ElementNodePointerFielddeclare_element_node_pointer_field (MetaData &md, const std::string &s, NodeField &node_field)
 Declare an element-to-node-data pointer field.
template<class NodeField>
ElementNodeLockFielddeclare_element_node_lock_field (MetaData &md, const std::string &s, NodeField &node_field)
 Declare an element-to-node-data pointer field.
const CellTopologyData * get_cell_topology (const Part &)
 The the CellTopology attached to the Part, if any.
void set_cell_topology (Part &, const CellTopologyData *singleton)
 Attach a CellTopology to a Part.
const CellTopologyData * get_cell_topology (const Bucket &)
 The the CellTopology attached to at most one Part of the Bucket.
const CellTopologyData * get_cell_topology (const Entity &)
 The the CellTopology attached to at most one Part of the Entity.
Entitydeclare_element_side (BulkData &mesh, const stk::mesh::EntityId global_side_id, Entity &elem, const unsigned local_side_id, Part *part=NULL)
 Create (or find) an element side.
bool element_side_polarity (const Entity &elem, const Entity &side, int local_side_id=-1)
 Determine the polarity of the local side, more efficient if the local_side_id is known.
void get_adjacent_entities (const Entity &entity, unsigned subcell_rank, unsigned subcell_identifier, std::vector< std::pair< Entity *, unsigned > > &adjacent_entities)
 Get the entities adjacent to the input entity.
int element_local_side_id (const Entity &elem, const Entity &side)
 Determine the local side identifier, return -1 if the side doesn't match the element.
int element_local_side_id (const Entity &elem, const std::vector< Entity * > &entity_nodes)
 Given an element and collection of nodes, return the local id of any side that contains those nodes.
template<class Traits>
void set_cell_topology (Part &p)
 Attach a CellTopology to a Part.
template<class Traits>
void get_parts_with_topology (stk::mesh::BulkData &mesh, stk::mesh::PartVector &parts)
template<typename IdType>
Entitydeclare_element (BulkData &mesh, Part &part, const IdType elem_id, const IdType node_id[])
 Declare an element member of a Part with a CellTopology and nodes conformal to that topology.
template<typename IdType>
Entitydeclare_element (BulkData &mesh, Part &part, const IdType elem_id, Entity *node[])
 Declare an element member of a Part with a CellTopology and nodes conformal to that topology.
void box_partition (int ip, int up, int axis, const BOX box, BOX p_box[])
void donate_one_element (BulkData &mesh, bool aura)
void donate_all_shared_nodes (BulkData &mesh, bool aura)
void assert_is_destroyed (const Entity *const entity)
void box_partition (int ip, int up, int axis, const BOX box, BOX p_box[])
template<typename T, bool is_integral, bool is_signed>
void test_fundemental_type (bool testComm)
template<typename T>
void test_fundemental_pointer (bool testComm)
void box_partition (int ip, int up, int axis, const BOX box, BOX p_box[])


Function Documentation

bool stk::mesh::@15::verify_parallel_attributes ( BulkData &  M,
std::ostream &  error_log 
) [static]

Definition at line 161 of file BulkDataParallelVerify.cpp.

void stk::mesh::find_closure ( const BulkData &  bulk,
const std::vector< Entity * > &  entities,
std::vector< Entity * > &  entities_closure 
)

Determine closure of the entities vector.

Parameters:
bulk BulkData must be in a parallel consistent state.
entities Each entity must be in the locally_used part.
entities_closure Parallel consisent closure of the input vector. This vector will be sorted and unique. May include ghosted entities.

Definition at line 107 of file BulkModification.cpp.

FieldBase * stk::mesh::get_field ( const char *  arg_method,
const std::string &  arg_name,
const DataTraits &  arg_traits,
unsigned  arg_rank,
const shards::ArrayDimTag *const *  arg_dim_tags,
unsigned  arg_num_states,
const std::vector< FieldBase * > &  arg_meta_data_fields 
)

Get a field by name from a vector of fields.

If found verify its type information, throw and exception if invalid.

Definition at line 198 of file Field.cpp.

void stk::mesh::communicate_field_data ( ParallelMachine  machine,
const std::vector< EntityProc > &  domain,
const std::vector< EntityProc > &  range,
const std::vector< const FieldBase * > &  fields 
)

Communicate field data from domain to range.

The fields array must be identical on all processors. All fields and mesh entities must belong to the same mesh. If symmetric ( & domain == & range) then from owned to not owned.

Definition at line 142 of file FieldParallel.cpp.

template<class OpField>
void stk::mesh::@38::parallel_reduce ( const BulkData &  mesh,
const OpField &  op 
) [static]

Parallel reduction of shared entities' field data.

In the anonymous namespace to avoid redundant link symbols.

example usage: parallel_reduce( mesh , sum( field ) );

where the operations are: sum, max, min

Definition at line 65 of file FieldParallel.hpp.

template<class OpField1, class OpField2>
void stk::mesh::@38::parallel_reduce ( const BulkData &  mesh,
const OpField1 &  op1,
const OpField2 &  op2 
) [static]

Parallel reduction of shared entities' field data.

In the anonymous namespace to avoid redundant link symbols.

example usage: parallel_reduce( mesh , sum( fieldA ) , max( fieldB ) );

Definition at line 87 of file FieldParallel.hpp.

template<class OwnershipRule>
void stk::mesh::set_owners ( BulkData &  mesh_bulk_data  ) 

Sets the owner for shared entities according to the template parameter OwnershipRule.

OwnershipRule is used as a the comparison operator in a std::set. The default behavior of stk::mesh is to give ownership to the highest-rank sharing proc.

Definition at line 28 of file SetOwners.hpp.

void stk::mesh::boundary_analysis ( const BulkData &  bulk_data,
const std::vector< Entity * > &  entities_closure,
unsigned  closure_rank,
EntitySideVector &  boundary 
)

Given a closure, return a boundary of items of closure_rank-1.

A boundary will contain the entities "touching" the "outside" of the closure.

Definition at line 19 of file BoundaryAnalysis.cpp.


Generated on Tue Jul 13 09:27:33 2010 for Sierra Toolkit by  doxygen 1.4.7