Implementation of MOAB Interface Implementation of the MOAB Interface class. You shouldn't call functions directly on an object of type Core (use Interface instead), unless you really have to access non-API functionality. More...
#include <Core.hpp>
Classes | |
class | HONodeAddedRemoved |
function object for recieving events from MB of higher order nodes added to entities More... | |
Public Types | |
typedef unsigned long long | type_memstorage |
![]() | |
enum | { INTERSECT , UNION } |
Enumerated type used in get_adjacencies() and other functions. More... | |
Public Member Functions | |
Core () | |
constructor More... | |
~Core () | |
destructor More... | |
virtual ErrorCode | query_interface_type (const std::type_info &interface_type, void *&ptr) |
Get a pointer to an internal MOAB interface. More... | |
virtual ErrorCode | release_interface_type (const std::type_info &interface_type, void *iface) |
Release reference to MB interface. More... | |
virtual int | QueryInterface (const MBuuid &uuid, UnknownInterface **iface) |
virtual float | impl_version (std::string *version_string=NULL) |
Returns the major.minor version number of the implementation. More... | |
virtual EntityType | type_from_handle (const EntityHandle handle) const |
get the type from a handle, returns type More... | |
virtual EntityID | id_from_handle (const EntityHandle handle) const |
get the id from a handle, returns id More... | |
virtual ErrorCode | handle_from_id (const EntityType type, const EntityID id, EntityHandle &handle) const |
get a handle from an id and type More... | |
virtual int | dimension_from_handle (const EntityHandle) const |
Returns the topological dimension of an entity. More... | |
virtual ErrorCode | load_mesh (const char *file_name, const int *active_block_id_list=NULL, const int num_blocks=0) |
load mesh from data in file NOTE: if there is mesh already present, the new mesh will be added More... | |
virtual ErrorCode | load_file (const char *file_name, const EntityHandle *file_set=0, const char *options=0, const char *set_tag_name=0, const int *set_tag_vals=0, int num_set_tag_vals=0) |
ErrorCode | serial_load_file (const char *file_name, const EntityHandle *file_set, const FileOptions &opts, const ReaderIface::SubsetList *subsets=0, const Tag *file_id_tag=0) |
ErrorCode | serial_read_tag (const char *file_name, const char *tag_name, const FileOptions &opts, std::vector< int > &tag_vals, const ReaderIface::SubsetList *subsets=0) |
virtual ErrorCode | write_mesh (const char *file_name, const EntityHandle *output_list=NULL, const int num_sets=0) |
Writes mesh to a file. More... | |
virtual ErrorCode | write_file (const char *file_name, const char *file_type=0, const char *options=0, const EntityHandle *output_sets=0, int num_output_sets=0, const Tag *tag_list=0, int num_tags=0) |
virtual ErrorCode | write_file (const char *file_name, const char *file_type, const char *options, const Range &output_sets, const Tag *tag_list=0, int num_tags=0) |
virtual ErrorCode | delete_mesh () |
deletes all mesh entities from this datastore More... | |
virtual ErrorCode | get_dimension (int &dim) const |
get overall geometric dimension More... | |
virtual ErrorCode | set_dimension (const int dim) |
set overall geometric dimension More... | |
virtual ErrorCode | get_vertex_coordinates (std::vector< double > &coords) const |
get blocked vertex coordinates for all vertices More... | |
virtual ErrorCode | coords_iterate (Range::const_iterator iter, Range::const_iterator end, double *&xcoords_ptr, double *&ycoords_ptr, double *&zcoords_ptr, int &count) |
get pointers to coordinate data More... | |
virtual ErrorCode | get_coords (const Range &entities, double *coords) const |
get the coordinate information for this handle if it is of type Vertex otherwise, return an error More... | |
virtual ErrorCode | get_coords (const EntityHandle *entities, const int num_entities, double *coords) const |
Gets xyz coordinate information for vector of vertices. More... | |
virtual ErrorCode | get_coords (const EntityHandle entity_handle, const double *&x, const double *&y, const double *&z) const |
virtual ErrorCode | get_coords (const Range &entities, double *x_coords, double *y_coords, double *z_coords) const |
virtual ErrorCode | set_coords (const EntityHandle *entity_handles, const int num_entities, const double *coords) |
set the coordinate information for this handle if it is of type Vertex otherwise, return an error More... | |
virtual ErrorCode | set_coords (Range entity_handles, const double *coords) |
set the coordinate information for this handle if it is of type Vertex otherwise, return an error More... | |
virtual ErrorCode | get_connectivity_by_type (const EntityType type, std::vector< EntityHandle > &connect) const |
get global connectivity array for specified entity type More... | |
virtual ErrorCode | connect_iterate (Range::const_iterator iter, Range::const_iterator end, EntityHandle *&connect, int &verts_per_entity, int &count) |
get pointer to connectivity data More... | |
virtual ErrorCode | get_connectivity (const EntityHandle *entity_handles, const int num_handles, std::vector< EntityHandle > &connectivity, bool corners_only=false, std::vector< int > *offsets=NULL) const |
Gets the connectivity for an element EntityHandle. More... | |
virtual ErrorCode | get_connectivity (const EntityHandle *entity_handles, const int num_handles, Range &connectivity, bool corners_only=false) const |
Gets the connectivity for a vector of elements. More... | |
virtual ErrorCode | get_connectivity (const Range &from_entities, Range &adj_entities, bool corners_only=false) const |
Gets the connectivity for elements. More... | |
virtual ErrorCode | get_connectivity (const EntityHandle entity_handle, const EntityHandle *&connectivity, int &number_nodes, bool corners_only=false, std::vector< EntityHandle > *storage=0) const |
Gets a pointer to constant connectivity data of entity_handle More... | |
virtual ErrorCode | set_connectivity (const EntityHandle entity_handle, EntityHandle *connect, const int num_connect) |
Sets the connectivity for an EntityHandle. For non-element handles, return an error. More... | |
virtual ErrorCode | get_adjacencies (const EntityHandle *from_entities, const int num_entities, const int to_dimension, const bool create_if_missing, std::vector< EntityHandle > &adj_entities, const int operation_type=Interface::INTERSECT) |
get the adjacencies associated with a set of entities More... | |
virtual ErrorCode | get_adjacencies (const EntityHandle *from_entities, const int num_entities, const int to_dimension, const bool create_if_missing, Range &adj_entities, const int operation_type=Interface::INTERSECT) |
Get the adjacencies associated with a vector of entities to entities of a specfied dimension. More... | |
virtual ErrorCode | get_adjacencies (const Range &from_entities, const int to_dimension, const bool create_if_missing, Range &adj_entities, const int operation_type=Interface::INTERSECT) |
Get the adjacencies associated with a range of entities to entities of a specfied dimension. More... | |
ErrorCode | adjacencies_iterate (Range::const_iterator iter, Range::const_iterator end, const std::vector< EntityHandle > **&adjs_ptr, int &count) |
Get a ptr to adjacency lists Get a pointer to adjacency lists. These lists are std::vector<EntityHandle>, which are pointed to by adjs[i]. Adjacencies are not guaranteed to be in order of increasing dimension. Only a const version of this function is given, because adjacency data is managed more carefully in MOAB and should be treated as read-only by applications. If adjacencies have not yet been initialized, adjs_ptr will be NULL (i.e. adjs_ptr == NULL). There may also be NULL entries for individual entities, i.e. adjs_ptr[i] == NULL. More... | |
virtual ErrorCode | get_vertices (const Range &from_entities, Range &vertices) |
Get all vertices for input entities. More... | |
virtual ErrorCode | get_entities_by_dimension (const EntityHandle meshset, const int dimension, Range &entities, const bool recursive=false) const |
Adds adjacencies. More... | |
virtual ErrorCode | get_entities_by_dimension (const EntityHandle meshset, const int dimension, std::vector< EntityHandle > &entities, const bool recursive=false) const |
Retrieves all entities of a given topological dimension in the database or meshset. More... | |
virtual ErrorCode | get_entities_by_type (const EntityHandle meshset, const EntityType type, Range &entities, const bool recursive=false) const |
Retrieves all entities in the data base of given type. More... | |
virtual ErrorCode | get_entities_by_type (const EntityHandle meshset, const EntityType type, std::vector< EntityHandle > &entities, const bool recursive=false) const |
Retrieves all entities in the data base of given type. More... | |
virtual ErrorCode | get_entities_by_type_and_tag (const EntityHandle meshset, const EntityType type, const Tag *tags, const void *const *values, const int num_tags, Range &entities, const int condition=Interface::INTERSECT, const bool recursive=false) const |
Retrieve entities in the database or meshset which have any or all of the tag(s) and (optionally) value(s) specified. More... | |
virtual ErrorCode | get_entities_by_handle (const EntityHandle meshset, Range &entities, const bool recursive=false) const |
Retrieves all entities in the data base. More... | |
virtual ErrorCode | get_entities_by_handle (const EntityHandle meshset, std::vector< EntityHandle > &entities, const bool recursive=false) const |
Retrieves all entities in the data base. More... | |
virtual ErrorCode | get_number_entities_by_dimension (const EntityHandle meshset, const int dimension, int &number, const bool recursive=false) const |
Retrieves all entities in the database of given dimension. More... | |
virtual ErrorCode | get_number_entities_by_type (const EntityHandle meshset, const EntityType type, int &num_entities, const bool recursive=false) const |
Retrieves all entities in the data base of given type. More... | |
virtual ErrorCode | get_number_entities_by_type_and_tag (const EntityHandle meshset, const EntityType type, const Tag *tag_handles, const void *const *values, const int num_tags, int &num_entities, const int condition=Interface::INTERSECT, const bool recursive=false) const |
Retrieve number of entities in the database or meshset which have any or all of the tag(s) and (optionally) value(s) specified. More... | |
virtual ErrorCode | get_number_entities_by_handle (const EntityHandle meshset, int &num_entities, const bool recursive=false) const |
Retrieves all entities in the data base. More... | |
virtual ErrorCode | create_element (const EntityType type, const EntityHandle *connectivity, const int num_nodes, EntityHandle &element_handle) |
Creates an element based on the type and connectivity. More... | |
virtual ErrorCode | create_vertex (const double coords[3], EntityHandle &entity_handle) |
Creates a vertex based on coordinates. More... | |
virtual ErrorCode | create_vertices (const double *coordinates, const int nverts, Range &entity_handles) |
Create a set of vertices with the specified coordinates. More... | |
virtual ErrorCode | merge_entities (EntityHandle entity_to_keep, EntityHandle entity_to_remove, bool auto_merge, bool delete_removed_entity) |
merges two entities More... | |
virtual ErrorCode | delete_entities (const EntityHandle *entities, const int num_entities) |
Removes entities in a vector from the data base. More... | |
virtual ErrorCode | delete_entities (const Range &range) |
Removes entities in a range from the data base. More... | |
virtual ErrorCode | list_entities (const Range &temp_range) const |
List entities to standard output. More... | |
virtual ErrorCode | list_entities (const EntityHandle *entities, const int num_entities) const |
List entities, or number of entities in database, to standard output. More... | |
virtual ErrorCode | list_entity (const EntityHandle entity) const |
List a single entity; no header printed. More... | |
virtual ErrorCode | convert_entities (const EntityHandle meshset, const bool mid_side, const bool mid_face, const bool mid_volume, Interface::HONodeAddedRemoved *function_object=0) |
Convert entities to higher-order elements by adding mid nodes. More... | |
virtual ErrorCode | side_number (const EntityHandle parent, const EntityHandle child, int &sd_number, int &sense, int &offset) const |
function to get the side number given two elements; returns MB_FAILURE if child not related to parent; does not create adjacencies between parent and child More... | |
virtual ErrorCode | high_order_node (const EntityHandle parent_handle, const EntityHandle *subfacet_conn, const EntityType subfacet_type, EntityHandle &hon) const |
given an entity and the connectivity and type of one of its subfacets, find the high order node on that subfacet, if any More... | |
virtual ErrorCode | side_element (const EntityHandle source_entity, const int dim, const int sd_number, EntityHandle &target_entity) const |
given an entity and a target dimension & side number, get that entity More... | |
virtual ErrorCode | tag_get_handle (const char *name, int size, DataType type, Tag &tag_handle, unsigned flags=0, const void *default_value=0, bool *created=0) |
Get a tag handle, possibly creating the tag. More... | |
virtual ErrorCode | tag_get_handle (const char *name, int size, DataType type, Tag &tag_handle, unsigned flags=0, const void *default_value=0) const |
same as non-const version, except that TAG_CREAT flag is ignored. More... | |
virtual ErrorCode | tag_get_name (const Tag tag_handle, std::string &tag_name) const |
Gets the tag name string of the tag_handle. More... | |
virtual ErrorCode | tag_get_handle (const char *tag_name, Tag &tag_handle) const |
Gets the tag handle corresponding to a name. More... | |
virtual ErrorCode | tag_get_tags_on_entity (const EntityHandle entity, std::vector< Tag > &tag_handles) const |
Get handles for all tags defined on this entity. More... | |
virtual ErrorCode | tag_get_bytes (const Tag tag, int &tag_size) const |
Get the size of the specified tag in bytes. More... | |
virtual ErrorCode | tag_get_length (const Tag tag, int &tag_size) const |
Get the array length of a tag. More... | |
virtual ErrorCode | tag_get_default_value (const Tag tag, void *def_val) const |
Get the default value of the specified tag. More... | |
virtual ErrorCode | tag_get_default_value (Tag tag, const void *&ptr, int &size) const |
Get a tag handle, possibly creating the tag. More... | |
virtual ErrorCode | tag_get_type (const Tag, TagType &tag_type) const |
get type of tag (sparse, dense, etc.; 0 = dense, 1 = sparse, 2 = bit, 3 = mesh) More... | |
virtual ErrorCode | tag_get_data_type (const Tag handle, DataType &type) const |
Get data type of tag. More... | |
virtual ErrorCode | tag_get_tags (std::vector< Tag > &tag_handles) const |
get handles for all tags defined More... | |
virtual ErrorCode | tag_get_data (const Tag tag_handle, const EntityHandle *entity_handles, const int num_entities, void *tag_data) const |
return the tag data for a given EntityHandle and Tag More... | |
virtual ErrorCode | tag_get_data (const Tag tag_handle, const Range &entity_handles, void *tag_data) const |
return the tag data for a given EntityHandle and Tag More... | |
virtual ErrorCode | tag_set_data (Tag tag_handle, const EntityHandle *entity_handles, int num_entities, const void *tag_data) |
Sets the data of a given EntityHandle and Tag. More... | |
virtual ErrorCode | tag_set_data (Tag tag_handle, const Range &entity_handles, const void *tag_data) |
set the data for given EntityHandles and Tag More... | |
virtual ErrorCode | tag_get_by_ptr (const Tag tag_handle, const EntityHandle *entity_handles, int num_entities, const void **tag_data, int *tag_sizes=0) const |
Get pointers to tag data. More... | |
virtual ErrorCode | tag_get_by_ptr (const Tag tag_handle, const Range &entity_handles, const void **tag_data, int *tag_sizes=0) const |
Get pointers to tag data. More... | |
virtual ErrorCode | tag_set_by_ptr (Tag tag_handle, const EntityHandle *entity_handles, int num_entities, void const *const *tag_data, const int *tag_sizes=0) |
Set tag data given an array of pointers to tag values. More... | |
virtual ErrorCode | tag_set_by_ptr (Tag tag_handle, const Range &entity_handles, void const *const *tag_data, const int *tag_sizes=0) |
Set tag data given an array of pointers to tag values. More... | |
virtual ErrorCode | tag_clear_data (Tag tag_handle, const Range &entity_handles, const void *tag_data, int tag_size=0) |
Set tag data given value. More... | |
virtual ErrorCode | tag_clear_data (Tag tag_handle, const EntityHandle *entity_handles, int num_entities, const void *tag_data, int tag_size=0) |
Set tag data given value. More... | |
virtual ErrorCode | tag_delete_data (Tag tag_handle, const EntityHandle *entity_handles, int num_entities) |
Delete the data of a vector of entity handles and sparse tag. More... | |
virtual ErrorCode | tag_delete_data (Tag tag_handle, const Range &entity_handles) |
Delete the data of a range of entity handles and sparse tag. More... | |
virtual ErrorCode | tag_delete (Tag tag_handle) |
Removes the tag from the database and deletes all of its associated data. More... | |
virtual ErrorCode | tag_iterate (Tag tag_handle, Range::const_iterator iter, Range::const_iterator end, int &count, void *&data_ptr, bool allocate=true) |
Access tag data via direct pointer into contiguous blocks. More... | |
virtual ErrorCode | create_meshset (const unsigned int options, EntityHandle &ms_handle, int start_id=0) |
creates a mesh set More... | |
virtual ErrorCode | clear_meshset (const EntityHandle *ms_handles, const int num_meshsets) |
Empty a vector of mesh set. More... | |
virtual ErrorCode | clear_meshset (const Range &ms_handles) |
Empty a range of mesh set. More... | |
virtual ErrorCode | get_meshset_options (const EntityHandle ms_handle, unsigned int &options) const |
get the options of a mesh set More... | |
virtual ErrorCode | set_meshset_options (const EntityHandle ms_handle, const unsigned int options) |
set the options of a mesh set More... | |
virtual ErrorCode | subtract_meshset (EntityHandle meshset1, const EntityHandle meshset2) |
subtracts meshset2 from meshset1 - modifies meshset1 More... | |
virtual ErrorCode | intersect_meshset (EntityHandle meshset1, const EntityHandle meshset2) |
intersects meshset2 with meshset1 - modifies meshset1 More... | |
virtual ErrorCode | unite_meshset (EntityHandle meshset1, const EntityHandle meshset2) |
unites meshset2 with meshset1 - modifies meshset1 More... | |
virtual ErrorCode | add_entities (EntityHandle meshset, const Range &entities) |
add entities to meshset More... | |
virtual ErrorCode | add_entities (EntityHandle meshset, const EntityHandle *entities, const int num_entities) |
add entities to meshset More... | |
virtual ErrorCode | remove_entities (EntityHandle meshset, const Range &entities) |
remove entities from meshset More... | |
virtual ErrorCode | remove_entities (EntityHandle meshset, const EntityHandle *entities, const int num_entities) |
remove entities from meshset More... | |
virtual bool | contains_entities (EntityHandle meshset, const EntityHandle *entities, int num_entities, const int operation_type=Interface::INTERSECT) |
return true if all entities are contained in set More... | |
virtual ErrorCode | replace_entities (EntityHandle meshset, const EntityHandle *old_entities, const EntityHandle *new_entities, int num_entities) |
replace entities More... | |
virtual ErrorCode | get_parent_meshsets (const EntityHandle meshset, std::vector< EntityHandle > &parents, const int num_hops=1) const |
get parent meshsets More... | |
virtual ErrorCode | get_parent_meshsets (const EntityHandle meshset, Range &parents, const int num_hops=1) const |
get parent meshsets More... | |
virtual ErrorCode | get_child_meshsets (const EntityHandle meshset, std::vector< EntityHandle > &children, const int num_hops=1) const |
get child meshsets More... | |
virtual ErrorCode | get_child_meshsets (const EntityHandle meshset, Range &children, const int num_hops=1) const |
get child meshsets More... | |
virtual ErrorCode | get_contained_meshsets (const EntityHandle meshset, std::vector< EntityHandle > &children, const int num_hops=1) const |
get contained meshsets More... | |
virtual ErrorCode | get_contained_meshsets (const EntityHandle meshset, Range &children, const int num_hops=1) const |
get contained meshsets More... | |
virtual ErrorCode | num_parent_meshsets (const EntityHandle meshset, int *number, const int num_hops=1) const |
gets number of parent meshsets More... | |
virtual ErrorCode | num_child_meshsets (const EntityHandle meshset, int *number, const int num_hops=1) const |
gets number of child meshsets More... | |
virtual ErrorCode | num_contained_meshsets (const EntityHandle meshset, int *number, const int num_hops=1) const |
gets number of contained meshsets More... | |
virtual ErrorCode | add_parent_meshset (EntityHandle meshset, const EntityHandle parent_meshset) |
add a parent meshset More... | |
virtual ErrorCode | add_parent_meshsets (EntityHandle meshset, const EntityHandle *parents, int count) |
add parent meshsets More... | |
virtual ErrorCode | add_child_meshset (EntityHandle meshset, const EntityHandle child_meshset) |
add a child meshset More... | |
virtual ErrorCode | add_child_meshsets (EntityHandle meshset, const EntityHandle *children, int count) |
add parent meshsets More... | |
virtual ErrorCode | add_parent_child (EntityHandle parent, EntityHandle child) |
adds 'parent' to child's parent list and adds 'child' to parent's child list More... | |
virtual ErrorCode | remove_parent_child (EntityHandle parent, EntityHandle child) |
removes 'parent' to child's parent list and removes 'child' to parent's child list More... | |
virtual ErrorCode | remove_parent_meshset (EntityHandle meshset, const EntityHandle parent_meshset) |
remove parent meshset More... | |
virtual ErrorCode | remove_child_meshset (EntityHandle meshset, const EntityHandle child_meshset) |
remove child meshset More... | |
Tag | material_tag () |
return various specific tag handles More... | |
Tag | neumannBC_tag () |
Tag | dirichletBC_tag () |
Tag | globalId_tag () |
Get parent mesh sets of a mesh set. More... | |
Tag | geom_dimension_tag () |
SequenceManager * | sequence_manager () |
get/set the number of nodes More... | |
const SequenceManager * | sequence_manager () const |
ErrorCode | create_scd_sequence (const HomCoord &coord_min, const HomCoord &coord_max, EntityType type, EntityID start_id_hint, EntityHandle &first_handle_out, EntitySequence *&sequence_out) |
create structured sequence More... | |
ErrorCode | add_vsequence (EntitySequence *vert_seq, EntitySequence *elem_seq, const HomCoord &p1, const HomCoord &q1, const HomCoord &p2, const HomCoord &q2, const HomCoord &p3, const HomCoord &q3, bool bb_input=false, const HomCoord *bb_min=NULL, const HomCoord *bb_max=NULL) |
AEntityFactory * | a_entity_factory () |
return the a_entity_factory pointer More... | |
const AEntityFactory * | a_entity_factory () const |
ReaderWriterSet * | reader_writer_set () |
return set of registered IO tools More... | |
void | print (const EntityHandle handle, const char *prefix, bool first_call=true) const |
ErrorCode | print_entity_tags (std::string indent_prefix, const EntityHandle handle, TagType tp) const |
virtual ErrorCode | get_last_error (std::string &info) const |
Return information about the last error. More... | |
virtual std::string | get_error_string (const ErrorCode code) const |
Return string representation of given error code. More... | |
ErrorCode | check_adjacencies () |
check all adjacencies for consistency More... | |
ErrorCode | check_adjacencies (const EntityHandle *ents, int num_ents) |
check some adjacencies for consistency More... | |
bool | is_valid (const EntityHandle this_ent) const |
return whether the input handle is valid or not More... | |
virtual ErrorCode | create_set_iterator (EntityHandle meshset, EntityType ent_type, int ent_dim, int chunk_size, bool check_valid, SetIterator *&set_iter) |
Create an iterator over the set Create a new iterator that iterates over entities with the specified type or dimension. Only one of ent_type or dim can be set; use dim=-1 or ent_type=MBMAXTYPE for the other. Iterators for list-type (ordered) sets are stable over set modification, unless entity removed or deleted is the one at the current position of the iterator. If the check_valid parameter is passed as true, entities are checked for validity before being passed back by get_next_entities function (checking entity validity can have a non-negligible cost). More... | |
ErrorCode | remove_set_iterator (SetIterator *set_iter) |
Remove the set iterator from the instance's list. More... | |
ErrorCode | get_set_iterators (EntityHandle meshset, std::vector< SetIterator * > &set_iters) |
Get all set iterators associated with the set passed in. More... | |
void | estimated_memory_use (const EntityHandle *ent_array=0, unsigned long num_ents=0, unsigned long long *total_storage=0, unsigned long long *total_amortized_storage=0, unsigned long long *entity_storage=0, unsigned long long *amortized_entity_storage=0, unsigned long long *adjacency_storage=0, unsigned long long *amortized_adjacency_storage=0, const Tag *tag_array=0, unsigned num_tags=0, unsigned long long *tag_storage=0, unsigned long long *amortized_tag_storage=0) |
Calculate amount of memory used to store MOAB data. More... | |
void | estimated_memory_use (const Range &ents, unsigned long long *total_storage=0, unsigned long long *total_amortized_storage=0, unsigned long long *entity_storage=0, unsigned long long *amortized_entity_storage=0, unsigned long long *adjacency_storage=0, unsigned long long *amortized_adjacency_storage=0, const Tag *tag_array=0, unsigned num_tags=0, unsigned long long *tag_storage=0, unsigned long long *amortized_tag_storage=0) |
Calculate amount of memory used to store MOAB data. More... | |
void | print_database () const |
Sequence Option controllers | |
virtual double | get_sequence_multiplier () const |
Interface to control memory allocation for sequences Provide a factor that controls the size of the sequence that gets allocated. This is typically useful in the parallel setting when a-priori, the number of ghost entities and the memory required for them within the same sequence as the owned entities are unknown. The default factor is 1.0 but this can be appropriately updated at runtime so that we do not have broken sequences. More... | |
virtual void | set_sequence_multiplier (double factor) |
Interface to control memory allocation for sequences Provide a factor that controls the size of the sequence that gets allocated. This is typically useful in the parallel setting when a-priori, the number of ghost entities and the memory required for them within the same sequence as the owned entities are unknown. The default factor is 1.0 but this can be appropriately updated at runtime so that we do not have broken sequences. More... | |
![]() | |
Interface () | |
constructor More... | |
virtual | ~Interface () |
destructor More... | |
template<class IFace > | |
ErrorCode | query_interface (IFace *&ptr) |
Get a pointer to an internal MOAB interface. More... | |
template<class IFace > | |
ErrorCode | release_interface (IFace *interface) |
constructor More... | |
virtual float | api_version (std::string *version_string=NULL) |
Release reference to MB interface. More... | |
virtual ErrorCode | add_adjacencies (const EntityHandle from_handle, const EntityHandle *to_handles, const int num_handles, bool both_ways)=0 |
Adds adjacencies between "from" and "to" entities. More... | |
virtual ErrorCode | add_adjacencies (const EntityHandle from_handle, Range &adjacencies, bool both_ways)=0 |
Adds adjacencies; same as vector-based, but with range instead. More... | |
virtual ErrorCode | remove_adjacencies (const EntityHandle from_handle, const EntityHandle *to_handles, const int num_handles)=0 |
Removes adjacencies between handles. More... | |
![]() | |
virtual | ~UnknownInterface () |
Private Member Functions | |
Core (const Core ©) | |
Do not allow copying. More... | |
Core & | operator= (const Core ©) |
Do not allow copying. More... | |
void | estimated_memory_use_internal (const Range *ents, unsigned long long *total_storage, unsigned long long *total_amortized_storage, unsigned long long *entity_storage, unsigned long long *amortized_entity_storage, unsigned long long *adjacency_storage, unsigned long long *amortized_adjacency_storage, const Tag *tag_array, unsigned num_tags, unsigned long long *tag_storage, unsigned long long *amortized_tag_storage) |
ErrorCode | initialize () |
database init and de-init routines More... | |
void | deinitialize () |
EntityHandle | get_root_set () |
return the entity set representing the whole mesh More... | |
void | clean_up_failed_read (const Range &initial_ents, std::vector< Tag > initial_tags) |
Clean up after a file reader returns failure. More... | |
bool | valid_tag_handle (const TagInfo *t) const |
Private Attributes | |
WriteUtil * | mMBWriteUtil |
ReadUtil * | mMBReadUtil |
ScdInterface * | scdInterface |
int | geometricDimension |
store the total number of elements defined in this interface More... | |
Tag | materialTag |
Tag | neumannBCTag |
Tag | dirichletBCTag |
Tag | geomDimensionTag |
Tag | globalIdTag |
std::list< TagInfo * > | tagList |
tag server for this interface More... | |
SequenceManager * | sequenceManager |
AEntityFactory * | aEntityFactory |
ReaderWriterSet * | readerWriterSet |
Error * | mError |
bool | mpiFinalize |
int | writeMPELog |
bool | initErrorHandlerInCore |
std::vector< SetIterator * > | setIterators |
list of iterators More... | |
Friends | |
class | SetIterator |
Implementation of MOAB Interface Implementation of the MOAB Interface class. You shouldn't call functions directly on an object of type Core (use Interface instead), unless you really have to access non-API functionality.
typedef unsigned long long moab::Core::type_memstorage |
moab::Core::Core | ( | ) |
constructor
Constructor.
Definition at line 170 of file Core.cpp.
171 {
172 if( initialize() != MB_SUCCESS )
173 {
174 printf( "Error initializing moab::Core\n" );
175 exit( 1 );
176 }
177 }
References GaussIntegration::initialize(), and MB_SUCCESS.
moab::Core::~Core | ( | ) |
|
private |
Do not allow copying.
|
inline |
return the a_entity_factory pointer
Definition at line 1069 of file Core.hpp.
1070 {
1071 return aEntityFactory;
1072 }
References aEntityFactory.
Referenced by moab::HigherOrderFactory::center_node_exist(), moab::Skinner::find_skin(), moab::WriteUtil::get_adjacencies(), moab::HigherOrderFactory::tag_for_deletion(), and moab::ReadUtil::update_adjacencies().
|
inline |
Definition at line 1073 of file Core.hpp.
1074 {
1075 return aEntityFactory;
1076 }
References aEntityFactory.
|
virtual |
add a child meshset
Implements moab::Interface.
Definition at line 3551 of file Core.cpp.
3552 {
3553 MeshSet* set_ptr = get_mesh_set( sequence_manager(), meshset );
3554 MeshSet* child_ptr = get_mesh_set( sequence_manager(), child_meshset );
3555 if( !set_ptr || !child_ptr ) return MB_ENTITY_NOT_FOUND;
3556
3557 set_ptr->add_child( child_meshset );
3558 return MB_SUCCESS;
3559 }
References moab::MeshSet::add_child(), moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and MB_SUCCESS.
|
virtual |
add parent meshsets
Implements moab::Interface.
Definition at line 3561 of file Core.cpp.
3562 {
3563 MeshSet* set_ptr = get_mesh_set( sequence_manager(), meshset );
3564 if( !set_ptr ) return MB_ENTITY_NOT_FOUND;
3565
3566 for( int i = 0; i < count; ++i )
3567 if( !get_mesh_set( sequence_manager(), children[i] ) ) return MB_ENTITY_NOT_FOUND;
3568
3569 for( int i = 0; i < count; ++i )
3570 set_ptr->add_child( children[i] );
3571 return MB_SUCCESS;
3572 }
References moab::MeshSet::add_child(), children, moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and MB_SUCCESS.
|
virtual |
add entities to meshset
Implements moab::Interface.
Definition at line 3352 of file Core.cpp.
3353 {
3354 MeshSet* set = get_mesh_set( sequence_manager(), meshset );
3355 if( set )
3356 return set->add_entities( entities, num_entities, meshset, a_entity_factory() );
3357 else
3358 return MB_ENTITY_NOT_FOUND;
3359 }
References moab::MeshSet::add_entities(), entities, moab::get_mesh_set(), and MB_ENTITY_NOT_FOUND.
|
virtual |
add entities to meshset
Implements moab::Interface.
Definition at line 3343 of file Core.cpp.
3344 {
3345 MeshSet* set = get_mesh_set( sequence_manager(), meshset );
3346 if( set )
3347 return set->add_entities( entities, meshset, a_entity_factory() );
3348 else
3349 return MB_ENTITY_NOT_FOUND;
3350 }
References moab::MeshSet::add_entities(), entities, moab::get_mesh_set(), and MB_ENTITY_NOT_FOUND.
Referenced by moab::NestedRefine::create_hm_storage_single_level(), moab::NestedRefine::exchange_ghosts(), main(), process_partition_file(), moab::ReorderTool::update_set_contents(), and moab::NestedRefine::update_special_tags().
|
virtual |
adds 'parent' to child's parent list and adds 'child' to parent's child list
Implements moab::Interface.
Definition at line 3574 of file Core.cpp.
3575 {
3576 MeshSet* parent_ptr = get_mesh_set( sequence_manager(), parent );
3577 MeshSet* child_ptr = get_mesh_set( sequence_manager(), child );
3578 if( !parent_ptr || !child_ptr ) return MB_ENTITY_NOT_FOUND;
3579
3580 parent_ptr->add_child( child );
3581 child_ptr->add_parent( parent );
3582 return MB_SUCCESS;
3583 }
References moab::MeshSet::add_child(), moab::MeshSet::add_parent(), child, moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and MB_SUCCESS.
Referenced by main().
|
virtual |
add a parent meshset
Implements moab::Interface.
Definition at line 3528 of file Core.cpp.
3529 {
3530 MeshSet* set_ptr = get_mesh_set( sequence_manager(), meshset );
3531 MeshSet* parent_ptr = get_mesh_set( sequence_manager(), parent_meshset );
3532 if( !set_ptr || !parent_ptr ) return MB_ENTITY_NOT_FOUND;
3533
3534 set_ptr->add_parent( parent_meshset );
3535 return MB_SUCCESS;
3536 }
References moab::MeshSet::add_parent(), moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and MB_SUCCESS.
|
virtual |
add parent meshsets
Implements moab::Interface.
Definition at line 3538 of file Core.cpp.
3539 {
3540 MeshSet* set_ptr = get_mesh_set( sequence_manager(), meshset );
3541 if( !set_ptr ) return MB_ENTITY_NOT_FOUND;
3542
3543 for( int i = 0; i < count; ++i )
3544 if( !get_mesh_set( sequence_manager(), parents[i] ) ) return MB_ENTITY_NOT_FOUND;
3545
3546 for( int i = 0; i < count; ++i )
3547 set_ptr->add_parent( parents[i] );
3548 return MB_SUCCESS;
3549 }
References moab::MeshSet::add_parent(), moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and MB_SUCCESS.
ErrorCode moab::Core::add_vsequence | ( | EntitySequence * | vert_seq, |
EntitySequence * | elem_seq, | ||
const HomCoord & | p1, | ||
const HomCoord & | q1, | ||
const HomCoord & | p2, | ||
const HomCoord & | q2, | ||
const HomCoord & | p3, | ||
const HomCoord & | q3, | ||
bool | bb_input = false , |
||
const HomCoord * | bb_min = NULL , |
||
const HomCoord * | bb_max = NULL |
||
) |
|
virtual |
Get a ptr to adjacency lists Get a pointer to adjacency lists. These lists are std::vector<EntityHandle>, which are pointed to by adjs[i]. Adjacencies are not guaranteed to be in order of increasing dimension. Only a const version of this function is given, because adjacency data is managed more carefully in MOAB and should be treated as read-only by applications. If adjacencies have not yet been initialized, adjs_ptr will be NULL (i.e. adjs_ptr == NULL). There may also be NULL entries for individual entities, i.e. adjs_ptr[i] == NULL.
iter | Iterator to beginning of entity range desired |
end | End iterator for which adjacencies are requested |
adjs_ptr | Pointer to pointer to const std::vector<EntityHandle>; each member of that array is the vector of adjacencies for this entity |
count | Number of entities in the contiguous chunk starting from *iter |
Implements moab::Interface.
Definition at line 1804 of file Core.cpp.
1808 {
1809 // Make sure the entity should have a connectivity.
1810 EntityType entity_type = TYPE_FROM_HANDLE( *iter );
1811
1812 // WARNING: This is very dependent on the ordering of the EntityType enum
1813 if( entity_type < MBVERTEX || entity_type > MBENTITYSET ) return MB_TYPE_OUT_OF_RANGE;
1814
1815 EntitySequence* seq = NULL;
1816
1817 // We know that connectivity is stored in an EntitySequence so jump straight
1818 // to the entity sequence
1819 ErrorCode rval = sequence_manager()->find( *iter, seq );
1820 if( !seq || rval != MB_SUCCESS ) return MB_ENTITY_NOT_FOUND;
1821
1822 adjs_ptr = const_cast< const std::vector< EntityHandle >** >( seq->data()->get_adjacency_data() );
1823 if( !adjs_ptr ) return rval;
1824
1825 adjs_ptr += *iter - seq->data()->start_handle();
1826
1827 EntityHandle real_end = *( iter.end_of_block() );
1828 if( *end ) real_end = std::min( real_end, *end );
1829 count = real_end - *iter + 1;
1830
1831 return MB_SUCCESS;
1832 }
References moab::EntitySequence::data(), moab::Range::const_iterator::end_of_block(), ErrorCode, moab::SequenceData::get_adjacency_data(), MB_ENTITY_NOT_FOUND, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MBENTITYSET, moab::SequenceData::start_handle(), and moab::TYPE_FROM_HANDLE().
ErrorCode moab::Core::check_adjacencies | ( | ) |
check all adjacencies for consistency
Definition at line 3763 of file Core.cpp.
3764 {
3765 // run through all entities, checking adjacencies and reverse-evaluating them
3766 Range all_ents;
3767 ErrorCode result = get_entities_by_handle( 0, all_ents );MB_CHK_ERR( result );
3768
3769 for( Range::iterator rit = all_ents.begin(); rit != all_ents.end(); ++rit )
3770 {
3771 result = check_adjacencies( &( *rit ), 1 );MB_CHK_ERR( result );
3772 }
3773
3774 return MB_SUCCESS;
3775 }
References moab::Range::begin(), moab::Range::end(), ErrorCode, MB_CHK_ERR, and MB_SUCCESS.
ErrorCode moab::Core::check_adjacencies | ( | const EntityHandle * | ents, |
int | num_ents | ||
) |
check some adjacencies for consistency
Definition at line 3777 of file Core.cpp.
3778 {
3779
3780 ErrorCode result = MB_SUCCESS, tmp_result;
3781 std::ostringstream oss;
3782
3783 for( int i = 0; i < num_ents; i++ )
3784 {
3785 EntityHandle this_ent = ents[i];
3786 std::ostringstream ent_str;
3787 ent_str << CN::EntityTypeName( TYPE_FROM_HANDLE( this_ent ) ) << " " << ID_FROM_HANDLE( this_ent ) << ": ";
3788 int this_dim = dimension_from_handle( this_ent );
3789
3790 if( !is_valid( this_ent ) )
3791 {
3792 std::cerr << ent_str.str() << "Not a valid entity." << std::endl;
3793 result = MB_FAILURE;
3794 }
3795
3796 else
3797 {
3798 if( TYPE_FROM_HANDLE( this_ent ) == MBENTITYSET ) continue;
3799
3800 // get adjacencies for this entity
3801 Range adjs;
3802 for( int dim = 0; dim <= 3; dim++ )
3803 {
3804 if( dim == this_dim ) continue;
3805 tmp_result = get_adjacencies( &this_ent, 1, dim, false, adjs, Interface::UNION );
3806 if( MB_SUCCESS != tmp_result )
3807 {
3808 oss << ent_str.str() << "Failed to get adjacencies for dimension " << dim << "." << std::endl;
3809 result = tmp_result;
3810 }
3811 }
3812 if( !oss.str().empty() )
3813 {
3814 std::cerr << oss.str();
3815 oss.str( "" );
3816 }
3817
3818 // now check and reverse-evaluate them
3819 for( Range::iterator rit = adjs.begin(); rit != adjs.end(); ++rit )
3820 {
3821 EntitySequence* seq = 0;
3822 tmp_result = sequence_manager()->find( *rit, seq );
3823 if( seq == 0 || tmp_result != MB_SUCCESS )
3824 {
3825 oss << ent_str.str() << "Adjacent entity " << CN::EntityTypeName( TYPE_FROM_HANDLE( *rit ) ) << " "
3826 << ID_FROM_HANDLE( *rit ) << " is invalid." << std::endl;
3827 result = tmp_result;
3828 }
3829 else
3830 {
3831 Range rev_adjs;
3832 tmp_result = get_adjacencies( &( *rit ), 1, this_dim, false, rev_adjs );
3833 if( MB_SUCCESS != tmp_result )
3834 {
3835 oss << ent_str.str() << "Failed to get reverse adjacency from "
3836 << CN::EntityTypeName( TYPE_FROM_HANDLE( *rit ) ) << " " << ID_FROM_HANDLE( *rit );
3837 if( MB_MULTIPLE_ENTITIES_FOUND == tmp_result )
3838 oss << " (MULTIPLE)" << std::endl;
3839 else
3840 oss << " (" << tmp_result << ")" << std::endl;
3841 result = tmp_result;
3842 }
3843 else if( rev_adjs.find( this_ent ) == rev_adjs.end() )
3844 {
3845 oss << ent_str.str() << "Failed to find adjacency to this entity from "
3846 << CN::EntityTypeName( TYPE_FROM_HANDLE( *rit ) ) << " " << ID_FROM_HANDLE( *rit ) << "."
3847 << std::endl;
3848 result = tmp_result;
3849 }
3850 }
3851 if( !oss.str().empty() )
3852 {
3853 std::cerr << oss.str();
3854 oss.str( "" );
3855 }
3856 }
3857 }
3858 }
3859
3860 return result;
3861 }
References moab::Range::begin(), dim, moab::Range::end(), moab::CN::EntityTypeName(), ErrorCode, moab::Range::find(), moab::ID_FROM_HANDLE(), MB_MULTIPLE_ENTITIES_FOUND, MB_SUCCESS, MBENTITYSET, moab::TYPE_FROM_HANDLE(), and moab::Interface::UNION.
|
private |
Clean up after a file reader returns failure.
Delete all entities not contained in initial_entities and all tags not contained in initial_tags.
Definition at line 491 of file Core.cpp.
492 {
493 Range new_ents;
494 get_entities_by_handle( 0, new_ents );
495 new_ents = subtract( new_ents, initial_ents );
496 delete_entities( new_ents );
497
498 std::vector< Tag > all_tags, new_tags;
499 tag_get_tags( all_tags );
500 std::sort( initial_tags.begin(), initial_tags.end() );
501 std::sort( all_tags.begin(), all_tags.end() );
502 std::set_difference( all_tags.begin(), all_tags.end(), initial_tags.begin(), initial_tags.end(),
503 std::back_inserter( new_tags ) );
504 while( !new_tags.empty() )
505 {
506 tag_delete( new_tags.back() );
507 new_tags.pop_back();
508 }
509 }
References moab::subtract().
|
virtual |
Empty a vector of mesh set.
Empty a mesh set.
ms_handles | 1d vector of handles of sets being emptied |
num_meshsets | Number of entities in 1d vector |
Implements moab::Interface.
Definition at line 3286 of file Core.cpp.
3287 {
3288 ErrorCode result = MB_SUCCESS;
3289 for( int i = 0; i < num_meshsets; ++i )
3290 {
3291 MeshSet* set = get_mesh_set( sequence_manager(), ms_handles[i] );
3292 if( set )
3293 set->clear( ms_handles[i], a_entity_factory() );
3294 else
3295 result = MB_ENTITY_NOT_FOUND;
3296 }
3297
3298 return result;
3299 }
References moab::MeshSet::clear(), ErrorCode, moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and MB_SUCCESS.
Referenced by main(), process_partition_file(), moab::AEntityFactory::remove_all_adjacencies(), and moab::ReorderTool::update_set_contents().
Empty a range of mesh set.
Empty a mesh set.
ms_handles | Range of handles of sets being emptied |
Implements moab::Interface.
Definition at line 3301 of file Core.cpp.
3302 {
3303 ErrorCode result = MB_SUCCESS;
3304 for( Range::iterator i = ms_handles.begin(); i != ms_handles.end(); ++i )
3305 {
3306 MeshSet* set = get_mesh_set( sequence_manager(), *i );
3307 if( set )
3308 set->clear( *i, a_entity_factory() );
3309 else
3310 result = MB_ENTITY_NOT_FOUND;
3311 }
3312
3313 return result;
3314 }
References moab::Range::begin(), moab::MeshSet::clear(), moab::Range::end(), ErrorCode, moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and MB_SUCCESS.
|
virtual |
get pointer to connectivity data
Implements moab::Interface.
Definition at line 1682 of file Core.cpp.
1687 {
1688 // Make sure the entity should have a connectivity.
1689 EntityType entity_type = TYPE_FROM_HANDLE( *iter );
1690
1691 // WARNING: This is very dependent on the ordering of the EntityType enum
1692 if( entity_type <= MBVERTEX || entity_type >= MBENTITYSET ) return MB_TYPE_OUT_OF_RANGE;
1693
1694 EntitySequence* seq = NULL;
1695
1696 // We know that connectivity is stored in an EntitySequence so jump straight
1697 // to the entity sequence
1698 ErrorCode rval = sequence_manager()->find( *iter, seq );
1699 if( !seq || rval != MB_SUCCESS ) return MB_ENTITY_NOT_FOUND;
1700
1701 ElementSequence* eseq = dynamic_cast< ElementSequence* >( seq );
1702 assert( eseq != NULL );
1703
1704 connect = eseq->get_connectivity_array();
1705 if( !connect )
1706 {
1707 MB_SET_ERR( MB_FAILURE, "Couldn't find connectivity array for start handle" );
1708 }
1709
1710 connect += eseq->nodes_per_element() * ( *iter - eseq->start_handle() );
1711
1712 EntityHandle real_end = std::min( eseq->end_handle(), *( iter.end_of_block() ) );
1713 if( *end ) real_end = std::min( real_end, *end );
1714 count = real_end - *iter + 1;
1715
1716 verts_per_entity = eseq->nodes_per_element();
1717
1718 return MB_SUCCESS;
1719 }
References moab::EntitySequence::end_handle(), moab::Range::const_iterator::end_of_block(), ErrorCode, moab::ElementSequence::get_connectivity_array(), MB_ENTITY_NOT_FOUND, MB_SET_ERR, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MBENTITYSET, moab::ElementSequence::nodes_per_element(), moab::EntitySequence::start_handle(), and moab::TYPE_FROM_HANDLE().
|
virtual |
return true if all entities are contained in set
Implements moab::Interface.
Definition at line 3382 of file Core.cpp.
3386 {
3387 if( !meshset ) // root
3388 return true;
3389 else if( MeshSet* set = get_mesh_set( sequence_manager(), meshset ) )
3390 return set->contains_entities( entities, num_entities, operation_type );
3391 else
3392 return false;
3393 }
References entities, and moab::get_mesh_set().
Referenced by moab::numAdjTriInSet().
|
virtual |
Convert entities to higher-order elements by adding mid nodes.
This function causes MB to create mid-nodes on all edges, faces, and element interiors for all entities in meshset. Higher order nodes appear in an element's connectivity array according to the algorithm described in the documentation for Mesh. If HONodeAddedRemoved function is input, this function is called to notify the application of nodes being added/removed from the mesh.
meshset | The set of entities being converted |
mid_edge | If true, mid-edge nodes are created |
mid_face | If true, mid-face nodes are created |
mid_region | If true, mid-element nodes are created |
function_object | If non-NULL, the node_added or node_removed functions on this object are called when nodes are added or removed from an entity, respectively |
Implements moab::Interface.
Definition at line 2998 of file Core.cpp.
3003 {
3004 HigherOrderFactory fact( this, function_object );
3005 return fact.convert( meshset, mid_side, mid_face, mid_volume );
3006 }
References moab::HigherOrderFactory::convert().
Referenced by main().
|
virtual |
get pointers to coordinate data
Implements moab::Interface.
Definition at line 827 of file Core.cpp.
833 {
834 EntitySequence* seq;
835 ErrorCode rval = sequence_manager()->find( *iter, seq );
836 if( MB_SUCCESS != rval )
837 {
838 xcoords_ptr = ycoords_ptr = zcoords_ptr = NULL;
839 MB_SET_ERR( rval, "Couldn't find sequence for start handle" );
840 }
841 VertexSequence* vseq = dynamic_cast< VertexSequence* >( seq );
842 if( !vseq )
843 {
844 MB_SET_ERR( MB_ENTITY_NOT_FOUND, "Couldn't find sequence for start handle" );
845 }
846
847 unsigned int offset = *iter - vseq->data()->start_handle();
848 xcoords_ptr = reinterpret_cast< double* >( vseq->data()->get_sequence_data( 0 ) ) + offset;
849 ycoords_ptr = reinterpret_cast< double* >( vseq->data()->get_sequence_data( 1 ) ) + offset;
850 zcoords_ptr = reinterpret_cast< double* >( vseq->data()->get_sequence_data( 2 ) ) + offset;
851
852 EntityHandle real_end = std::min( seq->end_handle(), *( iter.end_of_block() ) );
853 if( *end ) real_end = std::min( real_end, *end );
854 count = real_end - *iter + 1;
855
856 return MB_SUCCESS;
857 }
References moab::EntitySequence::data(), moab::EntitySequence::end_handle(), moab::Range::const_iterator::end_of_block(), ErrorCode, moab::SequenceData::get_sequence_data(), MB_ENTITY_NOT_FOUND, MB_SET_ERR, MB_SUCCESS, and moab::SequenceData::start_handle().
|
virtual |
Creates an element based on the type and connectivity.
creates an element based on the type and connectivity. returns a handle and error code
If connectivity vector is not correct for EntityType type (ie, a vector with 3 vertices is passed in to make an MBQUAD), the function returns MB_FAILURE.
type | Type of element to create. (MBTET, MBTRI, MBKNIFE, etc.) |
connectivity | Vector containing connectivity of element to create. |
handle | EntityHandle representing the newly created element in the database. |
Example:
EntityType type = MBQUAD;
std::vector<EntityHandle> connectivity(4);
quad_conn[0] = vertex0;
quad_conn[1] = vertex1;
quad_conn[2] = vertex2;
quad_conn[3] = vertex3;
EntityHandle element_handle;
create_element( type, connectivity, element_handle );
Implements moab::Interface.
Definition at line 2640 of file Core.cpp.
2644 {
2645 // make sure we have enough vertices for this entity type
2646 if( num_nodes < CN::VerticesPerEntity( entity_type ) ) return MB_FAILURE;
2647
2648 ErrorCode status = sequence_manager()->create_element( entity_type, connectivity, num_nodes, handle );
2649 if( MB_SUCCESS == status ) status = aEntityFactory->notify_create_entity( handle, connectivity, num_nodes );
2650
2651 #ifdef MOAB_HAVE_AHF
2652 mesh_modified = true;
2653 #endif
2654
2655 return status;
2656 }
References ErrorCode, MB_SUCCESS, and moab::CN::VerticesPerEntity().
Referenced by moab::AEntityFactory::get_down_adjacency_elements_poly(), moab::AEntityFactory::get_element(), main(), and obbvis_create().
|
virtual |
creates a mesh set
Implements moab::Interface.
Definition at line 3258 of file Core.cpp.
3259 {
3260 return sequence_manager()->create_mesh_set( setoptions, ms_handle );
3261 }
Referenced by moab::ReadUtil::create_gather_set(), moab::NestedRefine::create_hm_storage_single_level(), main(), process_partition_file(), and RuntimeContext::RuntimeContext().
ErrorCode moab::Core::create_scd_sequence | ( | const HomCoord & | coord_min, |
const HomCoord & | coord_max, | ||
EntityType | type, | ||
EntityID | start_id_hint, | ||
EntityHandle & | first_handle_out, | ||
EntitySequence *& | sequence_out | ||
) |
create structured sequence
Definition at line 4239 of file Core.cpp.
4245 {
4246 // NR: Previously, the structured element sequences were created via direct call to
4247 // the sequence manager instead of using the same from the ScdInterface which
4248 // creates the associated scd bounding box after element sequence creation.
4249
4250 if( !scdInterface ) scdInterface = new ScdInterface( this );
4251 ScdBox* newBox = NULL;
4252 ErrorCode rval = scdInterface->create_scd_sequence( coord_min, coord_max, entity_type,
4253 /*starting_id*/ (int)start_id_hint, newBox );MB_CHK_ERR( rval );
4254
4255 if( MBVERTEX == entity_type )
4256 first_handle_out = newBox->get_vertex( coord_min );
4257 else
4258 first_handle_out = newBox->get_element( coord_min );
4259 return sequence_manager()->find( first_handle_out, sequence_out );
4260 }
References ErrorCode, moab::ScdBox::get_element(), moab::ScdBox::get_vertex(), MB_CHK_ERR, and MBVERTEX.
|
virtual |
Create an iterator over the set Create a new iterator that iterates over entities with the specified type or dimension. Only one of ent_type or dim can be set; use dim=-1 or ent_type=MBMAXTYPE for the other. Iterators for list-type (ordered) sets are stable over set modification, unless entity removed or deleted is the one at the current position of the iterator. If the check_valid parameter is passed as true, entities are checked for validity before being passed back by get_next_entities function (checking entity validity can have a non-negligible cost).
Iterators returned by this function can be deleted using the normal C++ delete function. After creating the iterator through this function, further interactions are through methods on the SetIterator class.
meshset | The entity set associated with this iterator (use 0 for whole instance) |
ent_type | Entity type associated with this iterator |
ent_dim | Dimension associated with this iterator |
chunk_size | Chunk size of the iterator |
check_valid | If true, entities are checked for validity before being returned |
Implements moab::Interface.
Definition at line 3870 of file Core.cpp.
3876 {
3877 // check the type of set
3878 unsigned int setoptions;
3879 ErrorCode rval = MB_SUCCESS;
3880 if( meshset )
3881 {
3882 rval = get_meshset_options( meshset, setoptions );MB_CHK_ERR( rval );
3883 }
3884
3885 if( !meshset || ( setoptions & MESHSET_SET ) )
3886 set_iter = new( std::nothrow ) RangeSetIterator( this, meshset, chunk_size, ent_type, ent_dim, check_valid );
3887 else
3888 set_iter = new( std::nothrow ) VectorSetIterator( this, meshset, chunk_size, ent_type, ent_dim, check_valid );
3889
3890 setIterators.push_back( set_iter );
3891 return MB_SUCCESS;
3892 }
References ErrorCode, MB_CHK_ERR, MB_SUCCESS, and MESHSET_SET.
|
virtual |
Creates a vertex based on coordinates.
creates a vertex based on coordinates, returns a handle and error code
coordinates | Array that has 3 doubles in it. |
entity_handle | EntityHandle representing the newly created vertex in the database. |
Example:
double *coordinates = double[3];
coordinates[0] = 1.034;
coordinates[1] = 23.23;
coordinates[2] = -0.432;
EntityHandle entity_handle = 0;
create_vertex( coordinates, entity_handle );
Implements moab::Interface.
Definition at line 2659 of file Core.cpp.
2660 {
2661 // get an available vertex handle
2662 return sequence_manager()->create_vertex( coords, handle );
2663 }
Referenced by moab::HigherOrderFactory::add_mid_edge_nodes(), moab::HigherOrderFactory::add_mid_face_nodes(), and moab::HigherOrderFactory::add_mid_volume_nodes().
|
virtual |
Create a set of vertices with the specified coordinates.
coordinates | Array that has 3*n doubles in it. |
nverts | Number of vertices to create |
entity_handles | Range passed back with new vertex handles |
Implements moab::Interface.
Definition at line 2665 of file Core.cpp.
2666 {
2667 // Create vertices
2668 ReadUtilIface* read_iface;
2669 ErrorCode result = Interface::query_interface( read_iface );MB_CHK_ERR( result );
2670
2671 std::vector< double* > arrays;
2672 EntityHandle start_handle_out = 0;
2673 result = read_iface->get_node_coords( 3, nverts, MB_START_ID, start_handle_out, arrays );
2674 Interface::release_interface( read_iface );MB_CHK_ERR( result );
2675 // Cppcheck warning (false positive): variable arrays is assigned a value that is never used
2676 for( int i = 0; i < nverts; i++ )
2677 {
2678 arrays[0][i] = coordinates[3 * i];
2679 arrays[1][i] = coordinates[3 * i + 1];
2680 arrays[2][i] = coordinates[3 * i + 2];
2681 }
2682
2683 entity_handles.clear();
2684 entity_handles.insert( start_handle_out, start_handle_out + nverts - 1 );
2685
2686 return MB_SUCCESS;
2687 }
References moab::Range::clear(), ErrorCode, moab::ReadUtilIface::get_node_coords(), moab::Range::insert(), MB_CHK_ERR, MB_START_ID, MB_SUCCESS, moab::Interface::query_interface(), and moab::Interface::release_interface().
Referenced by main(), obbvis_create(), and TestErrorHandling_4().
|
private |
Definition at line 261 of file Core.cpp.
262 {
263
264 #ifdef MOAB_HAVE_MPI
265 std::vector< ParallelComm* > pc_list;
266 ParallelComm::get_all_pcomm( this, pc_list );
267 for( std::vector< ParallelComm* >::iterator vit = pc_list.begin(); vit != pc_list.end(); ++vit )
268 delete *vit;
269 #endif
270
271 #ifdef MOAB_HAVE_AHF
272 delete ahfRep;
273 ahfRep = 0;
274 #endif
275
276 if( aEntityFactory ) delete aEntityFactory;
277
278 aEntityFactory = 0;
279
280 while( !tagList.empty() )
281 tag_delete( tagList.front() );
282
283 if( sequenceManager ) delete sequenceManager;
284
285 sequenceManager = 0;
286
287 delete readerWriterSet;
288 readerWriterSet = 0;
289
290 if( mError ) delete mError;
291 mError = 0;
292
293 #ifdef MOAB_HAVE_MPI
294 if( writeMPELog )
295 {
296 const char* default_log = MOAB_MPE_LOG;
297 const char* logfile = getenv( "MPE_LOG_FILE" );
298 if( !logfile ) logfile = default_log;
299 MPE_Finish_log( logfile );
300 }
301 #endif
302
303 if( initErrorHandlerInCore ) MBErrorHandler_Finalize();
304 }
References moab::ParallelComm::get_all_pcomm(), moab::MBErrorHandler_Finalize(), MOAB_MPE_LOG, and MPE_Finish_log.
|
virtual |
Removes entities in a vector from the data base.
deletes an entity vector
If any of the entities are contained in any meshsets, it is removed from those meshsets which were created with MESHSET_TRACK_OWNER option bit set. Tags for entity< > are removed as part of this function.
entities | 1d vector of entities to delete |
num_entities | Number of entities in 1d vector |
Implements moab::Interface.
Definition at line 2793 of file Core.cpp.
2794 {
2795 ErrorCode result = MB_SUCCESS, temp_result;
2796 Range failed_ents;
2797
2798 for( std::list< TagInfo* >::iterator i = tagList.begin(); i != tagList.end(); ++i )
2799 {
2800 temp_result = ( *i )->remove_data( sequenceManager, mError, entities, num_entities );
2801 // ok if the error is tag_not_found, some ents may not have every tag on them
2802 if( MB_SUCCESS != temp_result && MB_TAG_NOT_FOUND != temp_result ) result = temp_result;
2803 }
2804
2805 for( int i = 0; i < num_entities; i++ )
2806 {
2807
2808 // tell AEntityFactory that this element is going away
2809 bool failed = false;
2810 temp_result = aEntityFactory->notify_delete_entity( entities[i] );
2811 if( MB_SUCCESS != temp_result )
2812 {
2813 result = temp_result;
2814 failed = true;
2815 }
2816
2817 if( TYPE_FROM_HANDLE( entities[i] ) == MBENTITYSET )
2818 {
2819 if( MeshSet* ptr = get_mesh_set( sequence_manager(), entities[i] ) )
2820 {
2821 int j, count;
2822 const EntityHandle* rel;
2823 ptr->clear( entities[i], a_entity_factory() );
2824 rel = ptr->get_parents( count );
2825 for( j = 0; j < count; ++j )
2826 remove_child_meshset( rel[j], entities[i] );
2827 rel = ptr->get_children( count );
2828 for( j = 0; j < count; ++j )
2829 remove_parent_meshset( rel[j], entities[i] );
2830 }
2831 }
2832
2833 if( failed )
2834 // don't test for success, since we'll return failure in this case
2835 sequence_manager()->delete_entity( mError, entities[i] );
2836 else
2837 {
2838 // now delete the entity
2839 temp_result = sequence_manager()->delete_entity( mError, entities[i] );
2840 if( MB_SUCCESS != temp_result ) result = temp_result;
2841 }
2842 }
2843
2844 return result;
2845 }
References moab::Range::clear(), entities, ErrorCode, moab::get_mesh_set(), MB_SUCCESS, MB_TAG_NOT_FOUND, MBENTITYSET, and moab::TYPE_FROM_HANDLE().
Referenced by moab::HigherOrderFactory::convert_sequence(), and main().
Removes entities in a range from the data base.
deletes an entity range
If any of the entities are contained in any meshsets, it is removed from those meshsets which were created with MESHSET_TRACK_OWNER option bit set. Tags for entity< > are removed as part of this function.
entities | Range of entities to delete |
Implements moab::Interface.
Definition at line 2738 of file Core.cpp.
2739 {
2740 ErrorCode result = MB_SUCCESS, temp_result;
2741 Range failed_ents;
2742
2743 for( std::list< TagInfo* >::iterator i = tagList.begin(); i != tagList.end(); ++i )
2744 {
2745 temp_result = ( *i )->remove_data( sequenceManager, mError, range );
2746 // ok if the error is tag_not_found, some ents may not have every tag on them
2747 if( MB_SUCCESS != temp_result && MB_TAG_NOT_FOUND != temp_result ) result = temp_result;
2748 }
2749
2750 for( Range::const_reverse_iterator rit = range.rbegin(); rit != range.rend(); ++rit )
2751 {
2752
2753 // tell AEntityFactory that this element is going away
2754 temp_result = aEntityFactory->notify_delete_entity( *rit );
2755 if( MB_SUCCESS != temp_result )
2756 {
2757 result = temp_result;
2758 failed_ents.insert( *rit );
2759 continue;
2760 }
2761
2762 if( TYPE_FROM_HANDLE( *rit ) == MBENTITYSET )
2763 {
2764 if( MeshSet* ptr = get_mesh_set( sequence_manager(), *rit ) )
2765 {
2766 int j, count;
2767 const EntityHandle* rel;
2768 ptr->clear( *rit, a_entity_factory() );
2769 rel = ptr->get_parents( count );
2770 for( j = 0; j < count; ++j )
2771 remove_child_meshset( rel[j], *rit );
2772 rel = ptr->get_children( count );
2773 for( j = 0; j < count; ++j )
2774 remove_parent_meshset( rel[j], *rit );
2775 }
2776 }
2777 }
2778
2779 if( !failed_ents.empty() )
2780 {
2781 Range dum_range = subtract( range, failed_ents );
2782 // don't test for success, since we'll return failure in this case
2783 sequence_manager()->delete_entities( mError, dum_range );
2784 }
2785 else
2786 // now delete the entities
2787 result = sequence_manager()->delete_entities( mError, range );
2788
2789 return result;
2790 }
References moab::Range::empty(), ErrorCode, moab::get_mesh_set(), moab::Range::insert(), MB_SUCCESS, MB_TAG_NOT_FOUND, MBENTITYSET, moab::Range::rbegin(), moab::Range::rend(), moab::subtract(), and moab::TYPE_FROM_HANDLE().
|
virtual |
deletes all mesh entities from this datastore
Implements moab::Interface.
Definition at line 747 of file Core.cpp.
748 {
749
750 ErrorCode result = MB_SUCCESS;
751
752 // perform all deinitialization procedures to clean up
753 if( aEntityFactory ) delete aEntityFactory;
754 aEntityFactory = new AEntityFactory( this );
755
756 for( std::list< TagInfo* >::iterator i = tagList.begin(); i != tagList.end(); ++i )
757 {
758 result = ( *i )->release_all_data( sequenceManager, mError, false );MB_CHK_ERR( result );
759 }
760
761 sequenceManager->clear();
762
763 return MB_SUCCESS;
764 }
References ErrorCode, MB_CHK_ERR, and MB_SUCCESS.
Referenced by main().
|
virtual |
Returns the topological dimension of an entity.
Returns the topological dimension of an entity.
handle | The EntityHandle you want to find the dimension of. |
Example:
int dim = dimension_from_handle( handle);
if( dim == 0 ) ...
Implements moab::Interface.
Definition at line 400 of file Core.cpp.
401 {
402 if( !handle ) // root set
403 return 4;
404 else
405 return CN::Dimension( TYPE_FROM_HANDLE( handle ) );
406 }
References moab::CN::Dimension(), and moab::TYPE_FROM_HANDLE().
Referenced by moab::AEntityFactory::check_equiv_entities(), moab::AEntityFactory::create_explicit_adjs(), moab::HalfFacetRep::get_adjacencies(), moab::HalfFacetRep::get_down_adjacencies(), moab::AEntityFactory::get_element(), moab::HalfFacetRep::get_neighbor_adjacencies(), moab::HalfFacetRep::get_up_adjacencies(), and moab::HigherOrderFactory::tag_for_deletion().
Tag moab::Core::dirichletBC_tag | ( | ) |
Definition at line 2613 of file Core.cpp.
2614 {
2615 const int negone = -1;
2616 if( 0 == dirichletBCTag )
2617 tag_get_handle( DIRICHLET_SET_TAG_NAME, 1, MB_TYPE_INTEGER, dirichletBCTag, MB_TAG_CREAT | MB_TAG_SPARSE,
2618 &negone );
2619 return dirichletBCTag;
2620 }
References DIRICHLET_SET_TAG_NAME, MB_TAG_CREAT, MB_TAG_SPARSE, and MB_TYPE_INTEGER.
|
virtual |
Calculate amount of memory used to store MOAB data.
This function calculates the amount of memory used to store MOAB data.
There are two possible values for each catagory of memory use. The exact value and the amortized value. The exact value is the amount of memory used to store the data for the specified entities. The amortized value includes the exact value and an amortized estimate of the memory consumed in overhead for storing the values (indexing structures, access structures, etc.)
Note: If ent_array is NULL, the total memory used by MOAB for storing data will be returned in the address pointed to by total_amortized_storage, if total_amortized_storage is not NULL.
ent_array | Array of entities for which to estimate the memory use. If NULL, estimate is done for all entities. |
num_ents | The length of ent_array. Not used if ent_rray is NULL. |
total_(amortized_)storage | The sum of the memory entity, adjacency, and all tag storage. |
(amortized_)entity_storage | The storage for the entity definitions (connectivity arrays for elements, coordinates for vertices, list storage within sets, etc.) |
(amortized_)adjacency_storage | The storage for adjacency data. |
tag_array | An array of tags for which to calculate the memory use. |
num_tags | The lenght of tag_array |
(amortized_)tag_storage | If tag_array is not NULL, then one value for each tag specifying the memory used for storing that tag. If tag_array is NULL and this value is not, the location at which to store the total memory used for all tags. |
Implements moab::Interface.
Definition at line 4074 of file Core.cpp.
4086 {
4087 Range range;
4088
4089 // If non-empty entity list, call range version of function
4090 if( ent_array )
4091 {
4092 if( num_ents > 20 )
4093 {
4094 std::vector< EntityHandle > list( num_ents );
4095 std::copy( ent_array, ent_array + num_ents, list.begin() );
4096 std::sort( list.begin(), list.end() );
4097 Range::iterator j = range.begin();
4098 for( std::vector< EntityHandle >::reverse_iterator i = list.rbegin(); i != list.rend(); ++i )
4099 j = range.insert( j, *i, *i );
4100 }
4101 else
4102 {
4103 std::copy( ent_array, ent_array + num_ents, range_inserter( range ) );
4104 }
4105 }
4106
4107 estimated_memory_use_internal( ent_array ? &range : 0, total_storage, total_amortized_storage, entity_storage,
4108 amortized_entity_storage, adjacency_storage, amortized_adjacency_storage, tag_array,
4109 num_tags, tag_storage, amortized_tag_storage );
4110 }
References moab::Range::begin(), and moab::Range::insert().
|
virtual |
Calculate amount of memory used to store MOAB data.
This function calculates the amount of memory used to store MOAB data.
There are two possible values for each catagory of memory use. The exact value and the amortized value. The exact value is the amount of memory used to store the data for the specified entities. The amortized value includes the exact value and an amortized estimate of the memory consumed in overhead for storing the values (indexing structures, access structures, etc.)
ents | Entities for which to estimate the memory use. |
total_(amortized_)storage | The sum of the memory entity, adjacency, and all tag storage. |
(amortized_)entity_storage | The storage for the entity definitions (connectivity arrays for elements, coordinates for vertices, list storage within sets, etc.) |
(amortized_)adjacency_storage | The storage for adjacency data. |
tag_array | An array of tags for which to calculate the memory use. |
num_tags | The lenght of tag_array |
(amortized_)tag_storage | If tag_array is not NULL, then one value for each tag specifying the memory used for storing that tag. If tag_array is NULL and this value is not, the location at which to store the total memory used for all tags. |
Implements moab::Interface.
Definition at line 4112 of file Core.cpp.
4123 { 4124 estimated_memory_use_internal( &ents, total_storage, total_amortized_storage, entity_storage, 4125 amortized_entity_storage, adjacency_storage, amortized_adjacency_storage, tag_array, 4126 num_tags, tag_storage, amortized_tag_storage ); 4127 }
|
private |
Definition at line 3923 of file Core.cpp.
3934 {
3935 // Figure out which values we need to calculate
3936 type_memstorage i_entity_storage, ia_entity_storage, i_adjacency_storage, ia_adjacency_storage, i_tag_storage,
3937 ia_tag_storage;
3938 type_memstorage *total_tag_storage = 0, *amortized_total_tag_storage = 0;
3939 if( !tag_array )
3940 {
3941 total_tag_storage = tag_storage;
3942 amortized_total_tag_storage = amortized_tag_storage;
3943 }
3944 if( total_storage || total_amortized_storage )
3945 {
3946 if( !entity_storage ) entity_storage = &i_entity_storage;
3947 if( !amortized_entity_storage ) amortized_entity_storage = &ia_entity_storage;
3948 if( !adjacency_storage ) adjacency_storage = &i_adjacency_storage;
3949 if( !amortized_adjacency_storage ) amortized_adjacency_storage = &ia_adjacency_storage;
3950 }
3951 else
3952 {
3953 if( entity_storage || amortized_entity_storage )
3954 {
3955 if( !amortized_entity_storage )
3956 amortized_entity_storage = &ia_entity_storage;
3957 else if( !entity_storage )
3958 entity_storage = &i_entity_storage;
3959 }
3960 if( adjacency_storage || amortized_adjacency_storage )
3961 {
3962 if( !amortized_adjacency_storage )
3963 amortized_adjacency_storage = &ia_adjacency_storage;
3964 else if( !adjacency_storage )
3965 adjacency_storage = &i_adjacency_storage;
3966 }
3967 }
3968 if( !total_tag_storage && total_storage ) total_tag_storage = &i_tag_storage;
3969 if( !amortized_total_tag_storage && total_amortized_storage ) amortized_total_tag_storage = &ia_tag_storage;
3970
3971 // get entity storage
3972 if( amortized_entity_storage )
3973 {
3974 if( ents )
3975 sequenceManager->get_memory_use( *ents, *entity_storage, *amortized_entity_storage );
3976 else
3977 sequenceManager->get_memory_use( *entity_storage, *amortized_entity_storage );
3978 }
3979
3980 // get adjacency storage
3981 if( amortized_adjacency_storage )
3982 {
3983 if( ents )
3984 aEntityFactory->get_memory_use( *ents, *adjacency_storage, *amortized_adjacency_storage );
3985 else
3986 #ifdef MOAB_HAVE_AHF
3987 ahfRep->get_memory_use( *adjacency_storage, *amortized_adjacency_storage );
3988 #else
3989 aEntityFactory->get_memory_use( *adjacency_storage, *amortized_adjacency_storage );
3990 #endif
3991 }
3992
3993 // get storage for requested list of tags
3994 if( tag_array )
3995 {
3996 for( unsigned i = 0; i < num_tags; ++i )
3997 {
3998 if( !valid_tag_handle( tag_array[i] ) ) continue;
3999
4000 unsigned long total = 0, per_ent = 0;
4001 tag_array[i]->get_memory_use( sequenceManager, total, per_ent );
4002
4003 if( ents )
4004 {
4005 size_t count = 0, count2 = 0;
4006 tag_array[i]->num_tagged_entities( sequenceManager, count, MBMAXTYPE, ents );
4007 if( tag_storage ) tag_storage[i] = count * per_ent;
4008 if( amortized_tag_storage )
4009 {
4010 tag_array[i]->num_tagged_entities( sequenceManager, count2 );
4011 if( count2 )
4012 amortized_tag_storage[i] = static_cast< type_memstorage >( total * count * 1.0 / count2 );
4013 }
4014 }
4015 else
4016 {
4017 size_t count = 0;
4018 if( tag_storage )
4019 {
4020 tag_array[i]->num_tagged_entities( sequenceManager, count );
4021 tag_storage[i] = count * per_ent;
4022 }
4023 if( amortized_tag_storage ) amortized_tag_storage[i] = total;
4024 }
4025 }
4026 }
4027
4028 // get storage for all tags
4029 if( total_tag_storage || amortized_total_tag_storage )
4030 {
4031 if( amortized_total_tag_storage ) *amortized_total_tag_storage = 0;
4032 if( total_tag_storage ) *total_tag_storage = 0;
4033
4034 std::vector< Tag > tags;
4035 tag_get_tags( tags );
4036 for( std::list< TagInfo* >::const_iterator i = tagList.begin(); i != tagList.end(); ++i )
4037 {
4038 unsigned long total = 0, per_ent = 0;
4039 ( *i )->get_memory_use( sequenceManager, total, per_ent );
4040
4041 if( ents )
4042 {
4043 size_t count = 0, count2 = 0;
4044 ( *i )->num_tagged_entities( sequenceManager, count, MBMAXTYPE, ents );
4045 if( total_tag_storage ) *total_tag_storage += count * per_ent;
4046 if( amortized_total_tag_storage )
4047 {
4048 ( *i )->num_tagged_entities( sequenceManager, count2 );
4049 if( count2 )
4050 *amortized_total_tag_storage += static_cast< type_memstorage >( total * count * 1.0 / count2 );
4051 }
4052 }
4053 else
4054 {
4055 size_t count = 0;
4056 if( total_tag_storage )
4057 {
4058 ( *i )->num_tagged_entities( sequenceManager, count );
4059 *total_tag_storage += count * per_ent;
4060 }
4061 if( amortized_total_tag_storage ) *amortized_total_tag_storage += total;
4062 }
4063 }
4064 }
4065
4066 // calculate totals
4067 if( total_storage ) *total_storage = *entity_storage + *adjacency_storage + *total_tag_storage;
4068
4069 if( total_amortized_storage )
4070 *total_amortized_storage =
4071 *amortized_entity_storage + *amortized_adjacency_storage + *amortized_total_tag_storage;
4072 }
References moab::TagInfo::get_memory_use(), MBMAXTYPE, and moab::TagInfo::num_tagged_entities().
Tag moab::Core::geom_dimension_tag | ( | ) |
Definition at line 2630 of file Core.cpp.
2631 {
2632 const int negone = -1;
2633 if( 0 == geomDimensionTag )
2634 tag_get_handle( GEOM_DIMENSION_TAG_NAME, 1, MB_TYPE_INTEGER, geomDimensionTag, MB_TAG_CREAT | MB_TAG_SPARSE,
2635 &negone );
2636 return geomDimensionTag;
2637 }
References GEOM_DIMENSION_TAG_NAME, MB_TAG_CREAT, MB_TAG_SPARSE, and MB_TYPE_INTEGER.
|
virtual |
Get the adjacencies associated with a vector of entities to entities of a specfied dimension.
Identical to vector-based get_adjacencies function, except results are returned in a range instead of a vector.
Implements moab::Interface.
Definition at line 1608 of file Core.cpp.
1614 {
1615 if( operation_type == Interface::INTERSECT )
1616 return get_adjacencies_intersection( this, from_entities, from_entities + num_entities, to_dimension,
1617 create_if_missing, adj_entities );
1618 else if( operation_type == Interface::UNION )
1619 return get_adjacencies_union( this, from_entities, from_entities + num_entities, to_dimension,
1620 create_if_missing, adj_entities );
1621 else
1622 return MB_FAILURE;
1623 }
References moab::get_adjacencies_intersection(), moab::get_adjacencies_union(), moab::Interface::INTERSECT, and moab::Interface::UNION.
|
virtual |
get the adjacencies associated with a set of entities
from_entities | vector of EntityHandle to get adjacencies of. |
to_dimension | Dimension of desired adjacency information. |
adj_entities | Vector in which adjacent EntityHandles are returned. |
operation_type | enum of INTERSECT or UNION. Defines whether to take the intersection or union of the set of adjacencies recovered for the from_entities. |
The adjacent entities in vector adjacencies are not in any particular order.
Example:
// get the set of edges that are adjacent to all entities in the from_entities list
std::vector<EntityHandle> from_entities = {hex1, hex2};
std::vector<EntityHandle> adjacencies;
get_adjacencies( from_entities, MB_1D_ENTITY, adjacencies );
Implements moab::Interface.
Definition at line 1513 of file Core.cpp.
1519 {
1520
1521 #ifdef MOAB_HAVE_AHF
1522 bool can_handle = true;
1523
1524 if( to_dimension == 4 )
1525 can_handle = false; // NOT SUPPORTED: meshsets
1526 else if( create_if_missing )
1527 can_handle = false; // NOT SUPPORTED: create_if_missing
1528
1529 bool mixed = ahfRep->check_mixed_entity_type(); // NOT SUPPORTED: mixed entity types or
1530 // polygonal/hedrals types
1531 if( mixed ) can_handle = false;
1532
1533 if( mesh_modified ) // NOT SUPPORTED: modified mesh
1534 can_handle = false;
1535
1536 if( can_handle )
1537 {
1538 ErrorCode result;
1539 if( operation_type == Interface::INTERSECT )
1540 return get_adjacencies_intersection_ahf( this, from_entities, from_entities + num_entities, to_dimension,
1541 adj_entities );
1542 else if( operation_type != Interface::UNION )
1543 return MB_FAILURE;
1544
1545 // do union
1546
1547 std::vector< EntityHandle > tmp_storage;
1548 const EntityHandle* conn;
1549 int len;
1550 for( int i = 0; i < num_entities; ++i )
1551 {
1552 if( to_dimension == 0 && TYPE_FROM_HANDLE( from_entities[0] ) != MBPOLYHEDRON )
1553 {
1554 result = get_connectivity( from_entities[i], conn, len, false, &tmp_storage );
1555 adj_entities.insert( adj_entities.end(), conn, conn + len );
1556 if( MB_SUCCESS != result ) return result;
1557 }
1558 else
1559 {
1560 result = ahfRep->get_adjacencies( from_entities[i], to_dimension, adj_entities );
1561 if( MB_SUCCESS != result ) return result;
1562 }
1563 }
1564 std::sort( adj_entities.begin(), adj_entities.end() );
1565 adj_entities.erase( std::unique( adj_entities.begin(), adj_entities.end() ), adj_entities.end() );
1566 }
1567 else
1568 {
1569
1570 #endif
1571
1572 if( operation_type == Interface::INTERSECT )
1573 return get_adjacencies_intersection( this, from_entities, from_entities + num_entities, to_dimension,
1574 create_if_missing, adj_entities );
1575 else if( operation_type != Interface::UNION )
1576 return MB_FAILURE;
1577
1578 // do union
1579 ErrorCode result;
1580 std::vector< EntityHandle > tmp_storage;
1581 const EntityHandle* conn;
1582 int len;
1583 for( int i = 0; i < num_entities; ++i )
1584 {
1585 if( to_dimension == 0 && TYPE_FROM_HANDLE( from_entities[0] ) != MBPOLYHEDRON )
1586 {
1587 result = get_connectivity( from_entities[i], conn, len, false, &tmp_storage );MB_CHK_ERR( result );
1588 adj_entities.insert( adj_entities.end(), conn, conn + len );
1589 }
1590 else
1591 {
1592 result =
1593 aEntityFactory->get_adjacencies( from_entities[i], to_dimension, create_if_missing, adj_entities );MB_CHK_ERR( result );
1594 }
1595 }
1596 std::sort( adj_entities.begin(), adj_entities.end() );
1597 adj_entities.erase( std::unique( adj_entities.begin(), adj_entities.end() ), adj_entities.end() );
1598
1599 // return MB_SUCCESS;
1600
1601 #ifdef MOAB_HAVE_AHF
1602 }
1603 #endif
1604
1605 return MB_SUCCESS;
1606 }
References ErrorCode, moab::get_adjacencies_intersection(), moab::Interface::INTERSECT, MB_CHK_ERR, MB_SUCCESS, MBPOLYHEDRON, moab::TYPE_FROM_HANDLE(), and moab::Interface::UNION.
Referenced by moab::DualTool::check_dual_equiv_edges(), moab::AEntityFactory::check_equiv_entities(), moab::AEntityFactory::create_explicit_adjs(), moab::NestedRefine::exchange_ghosts(), moab::ReadUtil::gather_related_ents(), gather_set_stats(), get_adjacent_elems(), moab::AEntityFactory::get_down_adjacency_elements_poly(), moab::AEntityFactory::get_polyhedron_vertices(), moab::AEntityFactory::get_up_adjacency_elements(), moab::AEntityFactory::get_vertices(), hcFilter(), moab::ReorderTool::int_order_from_sets_and_adj(), laplacianFilter(), main(), moab::AEntityFactory::merge_adjust_adjacencies(), moab::numAdjTriInSet(), perform_lloyd_relaxation(), tag_depth(), and moab::HiReconstruction::vertex_get_incident_elements().
|
virtual |
Get the adjacencies associated with a range of entities to entities of a specfied dimension.
Identical to vector-based get_adjacencies function, except "from" entities specified in a range instead of a vector.
Implements moab::Interface.
Definition at line 1744 of file Core.cpp.
1749 {
1750 if( operation_type == Interface::INTERSECT )
1751 return get_adjacencies_intersection( this, from_entities.begin(), from_entities.end(), to_dimension,
1752 create_if_missing, adj_entities );
1753 else if( operation_type != Interface::UNION )
1754 return MB_FAILURE;
1755 else if( to_dimension == 0 )
1756 return get_vertices( from_entities, adj_entities );
1757 else
1758 return get_adjacencies_union( this, from_entities.begin(), from_entities.end(), to_dimension, create_if_missing,
1759 adj_entities );
1760 }
References moab::Range::begin(), moab::Range::end(), moab::get_adjacencies_intersection(), moab::get_adjacencies_union(), moab::Interface::INTERSECT, and moab::Interface::UNION.
|
virtual |
get child meshsets
Implements moab::Interface.
Definition at line 3447 of file Core.cpp.
3448 {
3449 if( 0 == meshset ) return MB_ENTITY_NOT_FOUND;
3450
3451 std::vector< EntityHandle > child_vec;
3452 ErrorCode result = get_child_meshsets( meshset, child_vec, num_hops );MB_CHK_ERR( result );
3453 std::sort( child_vec.begin(), child_vec.end() );
3454 std::copy( child_vec.rbegin(), child_vec.rend(), range_inserter( children ) );
3455 return MB_SUCCESS;
3456 }
References children, ErrorCode, MB_CHK_ERR, MB_ENTITY_NOT_FOUND, and MB_SUCCESS.
|
virtual |
get child meshsets
Implements moab::Interface.
Definition at line 3433 of file Core.cpp.
3436 {
3437 if( 0 == meshset ) return MB_ENTITY_NOT_FOUND;
3438
3439 const EntitySequence* seq;
3440 ErrorCode rval = sequence_manager()->find( meshset, seq );
3441 if( MB_SUCCESS != rval ) return MB_ENTITY_NOT_FOUND;
3442 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
3443
3444 return mseq->get_children( sequence_manager(), meshset, children, num_hops );
3445 }
References children, ErrorCode, moab::MeshSetSequence::get_children(), MB_ENTITY_NOT_FOUND, and MB_SUCCESS.
Referenced by moab::ReadUtil::gather_related_ents().
|
virtual |
Gets the connectivity for a vector of elements.
get the connectivity for element /handles. For non-element handles, return an error
Same as vector-based version except range is returned (unordered!)
Implements moab::Interface.
Definition at line 1143 of file Core.cpp.
1147 {
1148 std::vector< EntityHandle > tmp_connect;
1149 ErrorCode result = get_connectivity( entity_handles, num_handles, tmp_connect, corners_only );MB_CHK_ERR( result );
1150
1151 std::sort( tmp_connect.begin(), tmp_connect.end() );
1152 std::copy( tmp_connect.rbegin(), tmp_connect.rend(), range_inserter( connectivity ) );
1153 return result;
1154 }
References ErrorCode, and MB_CHK_ERR.
|
virtual |
Gets the connectivity for an element EntityHandle.
get the connectivity for element /handles. For non-element handles, return an error
For non-element handles (ie, MeshSets), returns an error. Connectivity data is copied from the database into the vector connectivity. The nodes in connectivity are properly ordered.
entity_handle | EntityHandle to get connectivity of. |
connectivity | Vector in which connectivity of entity_handle is returned. Should contain MeshVertices. |
corners_only | If true, returns only corner vertices, otherwise returns all of them (including any higher-order vertices) |
Example:
std::vector<EntityHandle> conn;
get_connectivity( entity_handle, conn );
Implements moab::Interface.
Definition at line 1157 of file Core.cpp.
1162 {
1163 connectivity.clear(); // this seems wrong as compared to other API functions,
1164 // but changing it breaks lost of code, so I'm leaving
1165 // it in. - j.kraftcheck 2009-11-06
1166
1167 ErrorCode rval;
1168 std::vector< EntityHandle > tmp_storage; // used only for structured mesh
1169 const EntityHandle* conn;
1170 int len;
1171 if( offsets ) offsets->push_back( 0 );
1172 for( int i = 0; i < num_handles; ++i )
1173 {
1174 rval = get_connectivity( entity_handles[i], conn, len, corners_only, &tmp_storage );MB_CHK_ERR( rval );
1175 connectivity.insert( connectivity.end(), conn, conn + len );
1176 if( offsets ) offsets->push_back( connectivity.size() );
1177 }
1178 return MB_SUCCESS;
1179 }
References ErrorCode, MB_CHK_ERR, and MB_SUCCESS.
Referenced by moab::HalfFacetRep::add_cells_of_single_component(), moab::HalfFacetRep::another_halfedge(), moab::HiReconstruction::average_vertex_normal(), moab::HiReconstruction::average_vertex_tangent(), moab::HigherOrderFactory::center_node_exist(), moab::HalfFacetRep::collect_and_compare(), moab::HalfFacetRep::determine_border_vertices(), moab::HalfFacetRep::determine_incident_halfedges(), moab::HalfFacetRep::determine_incident_halffaces(), moab::HalfFacetRep::determine_incident_halfverts(), moab::HalfFacetRep::determine_sibling_halfedges(), moab::HalfFacetRep::determine_sibling_halffaces(), moab::HalfFacetRep::determine_sibling_halfverts(), moab::AEntityFactory::entities_equivalent(), moab::NestedRefine::exchange_ghosts(), moab::HalfFacetRep::find_matching_halfedge(), moab::HalfFacetRep::find_matching_halfface(), moab::HalfFacetRep::find_matching_implicit_edge_in_cell(), moab::WriteUtil::gather_nodes_from_elements(), gather_set_stats(), moab::AEntityFactory::get_adjacencies(), moab::NestedRefine::get_connectivity(), moab::HalfFacetRep::get_down_adjacencies_2d(), moab::HalfFacetRep::get_down_adjacencies_edg_3d(), moab::HalfFacetRep::get_down_adjacencies_face_3d(), moab::AEntityFactory::get_down_adjacency_elements(), moab::AEntityFactory::get_down_adjacency_elements_poly(), moab::HalfFacetRep::get_face_edges(), moab::HalfFacetRep::get_half_facet_in_comp(), moab::ReadUtil::get_ordered_vertices(), moab::AEntityFactory::get_polyhedron_vertices(), moab::HalfFacetRep::get_up_adjacencies_2d(), moab::HalfFacetRep::get_up_adjacencies_edg_3d(), moab::HalfFacetRep::get_up_adjacencies_edg_3d_comp(), moab::HalfFacetRep::get_up_adjacencies_vert_3d(), moab::AEntityFactory::get_up_adjacency_elements(), moab::AEntityFactory::get_vertices(), hcFilter(), moab::HiReconstruction::hiproj_walf_in_element(), laplacianFilter(), main(), moab::HalfFacetRep::mark_halfedges(), moab::AEntityFactory::merge_adjust_adjacencies(), moab::HiReconstruction::obtain_nring_ngbvs(), perform_laplacian_smoothing(), perform_lloyd_relaxation(), moab::ReorderTool::reorder_entities(), moab::HigherOrderFactory::tag_for_deletion(), test_spectral_quad(), moab::NestedRefine::update_global_ahf_3D(), and moab::NestedRefine::update_special_tags().
|
virtual |
Gets a pointer to constant connectivity data of entity_handle
get the connectivity for element handles. For non-element handles, return an error
Sets number_nodes equal to the number of nodes of the entity_handle . Faster then the other get_connectivity function. The nodes in 'connectivity' are properly ordered.
entity_handle | EntityHandle to get connectivity of. |
connectivity | Array in which connectivity of entity_handle is returned. Should contain MBVERTEX's. |
num_nodes | Number of MeshVertices in array connectivity. |
Example:
const EntityHandle* conn;
int number_nodes = 0;
get_connectivity( entity_handle, conn, number_nodes );
Example2:
std::vector<EntityHandle> sm_storage;
const EntityHandle* conn;
int number_nodes;
get_connectivity( handle, conn, number_nodes, false, &sm_storage );
if (conn == &sm_storage[0])
std::cout << "Structured mesh element" << std::endl;
Implements moab::Interface.
Definition at line 1182 of file Core.cpp.
1187 {
1188 ErrorCode status;
1189
1190 // Make sure the entity should have a connectivity.
1191 EntityType entity_type = TYPE_FROM_HANDLE( entity_handle );
1192
1193 // WARNING: This is very dependent on the ordering of the EntityType enum
1194 if( entity_type < MBVERTEX || entity_type >= MBENTITYSET )
1195 return MB_TYPE_OUT_OF_RANGE;
1196
1197 else if( entity_type == MBVERTEX )
1198 {
1199 return MB_FAILURE;
1200 }
1201
1202 const EntitySequence* seq = 0;
1203
1204 // We know that connectivity is stored in an EntitySequence so jump straight
1205 // to the entity sequence
1206 status = sequence_manager()->find( entity_handle, seq );
1207 if( seq == 0 || status != MB_SUCCESS ) return MB_ENTITY_NOT_FOUND;
1208
1209 return static_cast< const ElementSequence* >( seq )->get_connectivity( entity_handle, connectivity, number_nodes,
1210 corners_only, storage );
1211 }
References ErrorCode, MB_ENTITY_NOT_FOUND, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MBENTITYSET, MBVERTEX, and moab::TYPE_FROM_HANDLE().
|
virtual |
Gets the connectivity for elements.
Same as vector-based version except range is returned (unordered!)
Implements moab::Interface.
Definition at line 1625 of file Core.cpp.
1626 {
1627 const size_t DEFAULT_MAX_BLOCKS_SIZE = 4000;
1628 const size_t MAX_OUTER_ITERATIONS = 100;
1629
1630 std::vector< EntityHandle > temp_vec, storage;
1631 std::vector< EntityHandle >::const_iterator ti;
1632 ErrorCode result = MB_SUCCESS, tmp_result;
1633 Range::const_iterator i = from_entities.begin();
1634 Range::iterator ins;
1635 const EntityHandle* conn;
1636 int conn_len;
1637
1638 // Just copy any vertices from the input range into the output
1639 size_t remaining = from_entities.size();
1640 for( ; i != from_entities.end() && TYPE_FROM_HANDLE( *i ) == MBVERTEX; ++i )
1641 --remaining;
1642 adj_entities.merge( from_entities.begin(), i );
1643
1644 // How many entities to work with at once? 2000 or so shouldn't require
1645 // too much memory, but don't iterate in outer loop more than a
1646 // 1000 times (make it bigger if many input entiites.)
1647 const size_t block_size = std::max( DEFAULT_MAX_BLOCKS_SIZE, remaining / MAX_OUTER_ITERATIONS );
1648 while( remaining > 0 )
1649 {
1650 const size_t count = remaining > block_size ? block_size : remaining;
1651 remaining -= count;
1652 temp_vec.clear();
1653 for( size_t j = 0; j < count; ++i, ++j )
1654 {
1655 tmp_result = get_connectivity( *i, conn, conn_len, corners_only, &storage );
1656 if( MB_SUCCESS != tmp_result )
1657 {
1658 result = tmp_result;
1659 continue;
1660 }
1661
1662 const size_t oldsize = temp_vec.size();
1663 temp_vec.resize( oldsize + conn_len );
1664 memcpy( &temp_vec[oldsize], conn, sizeof( EntityHandle ) * conn_len );
1665 }
1666
1667 std::sort( temp_vec.begin(), temp_vec.end() );
1668 ins = adj_entities.begin();
1669 ti = temp_vec.begin();
1670 while( ti != temp_vec.end() )
1671 {
1672 EntityHandle first = *ti;
1673 EntityHandle second = *ti;
1674 for( ++ti; ti != temp_vec.end() && ( *ti - second <= 1 ); ++ti )
1675 second = *ti;
1676 ins = adj_entities.insert( ins, first, second );
1677 }
1678 }
1679 return result;
1680 }
References moab::Range::begin(), moab::Range::end(), ErrorCode, moab::GeomUtil::first(), moab::Range::insert(), MB_SUCCESS, MBVERTEX, moab::Range::merge(), moab::Range::size(), and moab::TYPE_FROM_HANDLE().
|
virtual |
get global connectivity array for specified entity type
Assumes just vertices, no higher order nodes
Implements moab::Interface.
Definition at line 1120 of file Core.cpp.
1121 {
1122 // inefficient implementation until we get blocked tag access
1123
1124 // get the range of entities of this type
1125 Range this_range;
1126 ErrorCode result = get_entities_by_type( 0, entity_type, this_range );
1127
1128 int num_ents = this_range.size();
1129 connect.reserve( num_ents * CN::VerticesPerEntity( entity_type ) );
1130
1131 // now loop over these entities, getting connectivity for each
1132 for( Range::iterator this_it = this_range.begin(); this_it != this_range.end(); ++this_it )
1133 {
1134 const EntityHandle* connect_vec = NULL;
1135 result = get_connectivity( *this_it, connect_vec, num_ents, true );MB_CHK_ERR( result );
1136 connect.insert( connect.end(), &connect_vec[0], &connect_vec[num_ents] );
1137 }
1138
1139 return MB_SUCCESS;
1140 }
References moab::Range::begin(), moab::Range::end(), ErrorCode, MB_CHK_ERR, MB_SUCCESS, moab::Range::size(), and moab::CN::VerticesPerEntity().
|
virtual |
get contained meshsets
Implements moab::Interface.
Definition at line 3475 of file Core.cpp.
3476 {
3477 if( 0 == meshset )
3478 {
3479 return get_entities_by_type( meshset, MBENTITYSET, children );
3480 }
3481
3482 std::vector< EntityHandle > child_vec;
3483 ErrorCode result = get_contained_meshsets( meshset, child_vec, num_hops );MB_CHK_ERR( result );
3484 std::sort( child_vec.begin(), child_vec.end() );
3485 std::copy( child_vec.rbegin(), child_vec.rend(), range_inserter( children ) );
3486 return MB_SUCCESS;
3487 }
References children, ErrorCode, MB_CHK_ERR, MB_SUCCESS, and MBENTITYSET.
|
virtual |
get contained meshsets
Implements moab::Interface.
Definition at line 3458 of file Core.cpp.
3461 {
3462 if( 0 == meshset )
3463 {
3464 return get_entities_by_type( meshset, MBENTITYSET, children );
3465 }
3466
3467 const EntitySequence* seq;
3468 ErrorCode rval = sequence_manager()->find( meshset, seq );
3469 if( MB_SUCCESS != rval ) return MB_ENTITY_NOT_FOUND;
3470 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
3471
3472 return mseq->get_contained_sets( sequence_manager(), meshset, children, num_hops );
3473 }
References children, ErrorCode, moab::MeshSetSequence::get_contained_sets(), MB_ENTITY_NOT_FOUND, MB_SUCCESS, and MBENTITYSET.
|
virtual |
Gets xyz coordinate information for vector of vertices.
Identical to range-based function, except entity handles are specified using a 1d vector and vector length.
Implements moab::Interface.
Definition at line 974 of file Core.cpp.
975 {
976 const EntitySequence* seq = NULL;
977 const VertexSequence* vseq = NULL;
978 const EntityHandle* const end = entities + num_entities;
979 const EntityHandle* iter = entities;
980 ErrorCode status = MB_SUCCESS;
981
982 while( iter != end )
983 {
984 if( TYPE_FROM_HANDLE( *iter ) == MBVERTEX )
985 {
986 if( !seq )
987 {
988 seq = sequence_manager()->get_last_accessed_sequence( MBVERTEX );
989 vseq = static_cast< const VertexSequence* >( seq );
990 }
991 if( !vseq )
992 return MB_ENTITY_NOT_FOUND;
993 else if( vseq->start_handle() > *iter || vseq->end_handle() < *iter )
994 {
995 if( MB_SUCCESS != sequence_manager()->find( *iter, seq ) ) return MB_ENTITY_NOT_FOUND;
996 vseq = static_cast< const VertexSequence* >( seq );
997 }
998 vseq->get_coordinates( *iter, coords );
999 }
1000 else
1001 {
1002 static std::vector< EntityHandle > dum_conn( CN::MAX_NODES_PER_ELEMENT );
1003 static std::vector< double > dum_pos( 3 * CN::MAX_NODES_PER_ELEMENT );
1004 static const EntityHandle* conn;
1005 static int num_conn;
1006 status = get_connectivity( *iter, conn, num_conn, false, &dum_conn );MB_CHK_ERR( status );
1007 status = get_coords( conn, num_conn, &dum_pos[0] );MB_CHK_ERR( status );
1008 coords[0] = coords[1] = coords[2] = 0.0;
1009 for( int i = 0; i < num_conn; i++ )
1010 {
1011 coords[0] += dum_pos[3 * i];
1012 coords[1] += dum_pos[3 * i + 1];
1013 coords[2] += dum_pos[3 * i + 2];
1014 }
1015 coords[0] /= num_conn;
1016 coords[1] /= num_conn;
1017 coords[2] /= num_conn;
1018 }
1019 coords += 3;
1020 ++iter;
1021 }
1022
1023 return status;
1024 }
References moab::EntitySequence::end_handle(), entities, ErrorCode, moab::VertexSequence::get_coordinates(), moab::CN::MAX_NODES_PER_ELEMENT, MB_CHK_ERR, MB_ENTITY_NOT_FOUND, MB_SUCCESS, MBVERTEX, moab::EntitySequence::start_handle(), and moab::TYPE_FROM_HANDLE().
|
virtual |
Definition at line 1026 of file Core.cpp.
1030 {
1031 ErrorCode status = MB_TYPE_OUT_OF_RANGE;
1032
1033 if( TYPE_FROM_HANDLE( entity_handle ) == MBVERTEX )
1034 {
1035 const EntitySequence* seq = 0;
1036 status = sequence_manager()->find( entity_handle, seq );
1037
1038 if( seq == 0 || status != MB_SUCCESS ) return MB_ENTITY_NOT_FOUND;
1039
1040 status = static_cast< const VertexSequence* >( seq )->get_coordinates_ref( entity_handle, x, y, z );
1041 }
1042
1043 return status;
1044 }
References ErrorCode, MB_ENTITY_NOT_FOUND, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MBVERTEX, and moab::TYPE_FROM_HANDLE().
get the coordinate information for this handle if it is of type Vertex otherwise, return an error
Implements moab::Interface.
Definition at line 859 of file Core.cpp.
860 {
861 const TypeSequenceManager& vert_data = sequence_manager()->entity_map( MBVERTEX );
862 TypeSequenceManager::const_iterator seq_iter;
863
864 Range::const_pair_iterator i = entities.const_pair_begin();
865 EntityHandle first = i->first;
866 while( i != entities.const_pair_end() && TYPE_FROM_HANDLE( i->first ) == MBVERTEX )
867 {
868
869 seq_iter = vert_data.lower_bound( first );
870 if( seq_iter == vert_data.end() || first < ( *seq_iter )->start_handle() ) return MB_ENTITY_NOT_FOUND;
871 const VertexSequence* vseq = reinterpret_cast< const VertexSequence* >( *seq_iter );
872
873 EntityID offset = first - vseq->start_handle();
874 EntityID count;
875 if( i->second <= vseq->end_handle() )
876 {
877 count = i->second - first + 1;
878 ++i;
879 if( i != entities.const_pair_end() ) first = i->first;
880 }
881 else
882 {
883 count = vseq->end_handle() - first + 1;
884 first = vseq->end_handle() + 1;
885 }
886
887 double const *x, *y, *z;
888 ErrorCode rval = vseq->get_coordinate_arrays( x, y, z );MB_CHK_ERR( rval );
889 x += offset;
890 y += offset;
891 z += offset;
892 for( EntityID j = 0; j < count; ++j )
893 {
894 coords[3 * j] = x[j];
895 coords[3 * j + 1] = y[j];
896 coords[3 * j + 2] = z[j];
897 }
898 coords = &coords[3 * count];
899 }
900
901 // for non-vertices...
902 ErrorCode rval = MB_SUCCESS;
903 for( Range::const_iterator rit( &( *i ), i->first ); rit != entities.end(); ++rit )
904 {
905 rval = get_coords( &( *rit ), 1, coords );MB_CHK_ERR( rval );
906 coords += 3;
907 }
908
909 return rval;
910 }
References moab::TypeSequenceManager::end(), moab::EntitySequence::end_handle(), entities, ErrorCode, moab::GeomUtil::first(), moab::VertexSequence::get_coordinate_arrays(), moab::TypeSequenceManager::lower_bound(), MB_CHK_ERR, MB_ENTITY_NOT_FOUND, MB_SUCCESS, MBVERTEX, moab::EntitySequence::start_handle(), and moab::TYPE_FROM_HANDLE().
Referenced by moab::HiReconstruction::average_vertex_normal(), moab::HiReconstruction::average_vertex_tangent(), RuntimeContext::compute_centroids(), moab::NestedRefine::copy_vertices_from_prev_level(), gather_set_stats(), moab::NestedRefine::get_coordinates(), moab::WriteUtil::get_node_coords(), moab::HiReconstruction::hiproj_walf_around_vertex(), moab::HiReconstruction::hiproj_walf_in_element(), main(), perform_laplacian_smoothing(), perform_lloyd_relaxation(), moab::HiReconstruction::polyfit3d_walf_curve_vertex(), moab::HiReconstruction::polyfit3d_walf_surf_vertex(), moab::ReorderTool::reorder_entities(), and test_spectral_quad().
|
virtual |
Implements moab::Interface.
Definition at line 913 of file Core.cpp.
914 {
915 const TypeSequenceManager& vert_data = sequence_manager()->entity_map( MBVERTEX );
916 TypeSequenceManager::const_iterator seq_iter;
917
918 Range::const_pair_iterator i = entities.const_pair_begin();
919 EntityHandle first = i->first;
920 while( i != entities.const_pair_end() && TYPE_FROM_HANDLE( i->first ) == MBVERTEX )
921 {
922
923 seq_iter = vert_data.lower_bound( first );
924 if( seq_iter == vert_data.end() || first < ( *seq_iter )->start_handle() ) return MB_ENTITY_NOT_FOUND;
925 const VertexSequence* vseq = reinterpret_cast< const VertexSequence* >( *seq_iter );
926
927 EntityID offset = first - vseq->start_handle();
928 EntityID count;
929 if( i->second <= vseq->end_handle() )
930 {
931 count = i->second - first + 1;
932 ++i;
933 if( i != entities.const_pair_end() ) first = i->first;
934 }
935 else
936 {
937 count = vseq->end_handle() - first + 1;
938 first = vseq->end_handle() + 1;
939 }
940
941 double const *x, *y, *z;
942 ErrorCode rval = vseq->get_coordinate_arrays( x, y, z );MB_CHK_ERR( rval );
943 if( x_coords )
944 {
945 memcpy( x_coords, x + offset, count * sizeof( double ) );
946 x_coords += count;
947 }
948 if( y_coords )
949 {
950 memcpy( y_coords, y + offset, count * sizeof( double ) );
951 y_coords += count;
952 }
953 if( z_coords )
954 {
955 memcpy( z_coords, z + offset, count * sizeof( double ) );
956 z_coords += count;
957 }
958 }
959
960 // for non-vertices...
961 ErrorCode rval = MB_SUCCESS;
962 double xyz[3];
963 for( Range::const_iterator rit( &( *i ), i->first ); rit != entities.end(); ++rit )
964 {
965 rval = get_coords( &( *rit ), 1, xyz );MB_CHK_ERR( rval );
966 *x_coords++ = xyz[0];
967 *y_coords++ = xyz[1];
968 *z_coords++ = xyz[2];
969 }
970
971 return rval;
972 }
References moab::TypeSequenceManager::end(), moab::EntitySequence::end_handle(), entities, ErrorCode, moab::GeomUtil::first(), moab::VertexSequence::get_coordinate_arrays(), moab::TypeSequenceManager::lower_bound(), MB_CHK_ERR, MB_ENTITY_NOT_FOUND, MB_SUCCESS, MBVERTEX, moab::EntitySequence::start_handle(), and moab::TYPE_FROM_HANDLE().
|
virtual |
get overall geometric dimension
Implements moab::Interface.
Definition at line 767 of file Core.cpp.
768 {
769 dim = geometricDimension;
770 return MB_SUCCESS;
771 }
References dim, and MB_SUCCESS.
|
virtual |
Adds adjacencies.
from_handle | entities |
both_ways | add the adjacency information to both the to_handle and and the from_from :handle |
Example:
/
virtual ErrorCode add_adjacencies( const EntityHandle entity_handle,
const EntityHandle* adjacencies,
const int num_handles,
bool both_ways );
//! Adds adjacencies; same as vector-based, but with range instead
virtual ErrorCode add_adjacencies( const EntityHandle entity_handle, Range& adjacencies, bool both_ways );
//! Removes adjacencies
/** \param handle EntityHandle to get adjacencies of.
Example: \code
*/
virtual ErrorCode remove_adjacencies( const EntityHandle entity_handle,
const EntityHandle* adjacencies,
const int num_handles );
//! Retrieves all entities in the database of given dimension.
/** \param dimension Dimension of entities desired.
\param entities Range in which entities of dimension <em>dimension</em> are returned.
Example: \code
int dimension = 2;
Range entities;
get_entities_by_dimension( dimension, entities ); //get 2D EntityHandles in the database
Implements moab::Interface.
Definition at line 1834 of file Core.cpp.
1838 {
1839 ErrorCode result = MB_SUCCESS;
1840 if( meshset )
1841 {
1842 const EntitySequence* seq;
1843 result = sequence_manager()->find( meshset, seq );MB_CHK_ERR( result );
1844 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
1845 result = mseq->get_dimension( sequence_manager(), meshset, dimension, entities, recursive );MB_CHK_ERR( result );
1846 }
1847 else if( dimension > 3 )
1848 {
1849 sequence_manager()->get_entities( MBENTITYSET, entities );
1850 }
1851 else
1852 {
1853 for( EntityType this_type = CN::TypeDimensionMap[dimension].first;
1854 this_type <= CN::TypeDimensionMap[dimension].second; this_type++ )
1855 {
1856 sequence_manager()->get_entities( this_type, entities );
1857 }
1858 }
1859
1860 return MB_SUCCESS;
1861 }
References entities, ErrorCode, moab::GeomUtil::first(), moab::MeshSetSequence::get_dimension(), MB_CHK_ERR, MB_SUCCESS, MBENTITYSET, and moab::CN::TypeDimensionMap.
Referenced by moab::HalfFacetRep::check_mixed_entity_type(), moab::NestedRefine::count_subentities(), moab::NestedRefine::exchange_ghosts(), moab::HalfFacetRep::initialize(), moab::HiReconstruction::initialize(), moab::ReorderTool::int_order_from_sets_and_adj(), main(), process_partition_file(), tag_depth(), test_spectral_hex(), and moab::HalfFacetRep::update_entity_ranges().
|
virtual |
Retrieves all entities of a given topological dimension in the database or meshset.
Appends entities to list passed in.
meshset | Meshset whose entities are being queried (zero if query is for entire mesh). |
dimension | Topological dimension of entities desired. |
entities | Range in which entities of dimension dimension are returned. |
recursive | If true, meshsets containing meshsets are queried recursively. Returns the contents of meshsets, but not the meshsets themselves if true. |
Example:
// get 1d (edge) elements in the entire mesh
Range edges;
get_entities_by_dimension( 0, 1, edges );
Implements moab::Interface.
Definition at line 1863 of file Core.cpp.
1867 {
1868 ErrorCode result = MB_SUCCESS;
1869 if( meshset )
1870 {
1871 const EntitySequence* seq;
1872 result = sequence_manager()->find( meshset, seq );MB_CHK_ERR( result );
1873 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
1874 result = mseq->get_dimension( sequence_manager(), meshset, dimension, entities, recursive );MB_CHK_ERR( result );
1875 }
1876 else if( dimension > 3 )
1877 {
1878 sequence_manager()->get_entities( MBENTITYSET, entities );
1879 }
1880 else
1881 {
1882 for( EntityType this_type = CN::TypeDimensionMap[dimension].first;
1883 this_type <= CN::TypeDimensionMap[dimension].second; this_type++ )
1884 {
1885 sequence_manager()->get_entities( this_type, entities );
1886 }
1887 }
1888
1889 return MB_SUCCESS;
1890 }
References entities, ErrorCode, moab::GeomUtil::first(), moab::MeshSetSequence::get_dimension(), MB_CHK_ERR, MB_SUCCESS, MBENTITYSET, and moab::CN::TypeDimensionMap.
|
virtual |
Retrieves all entities in the data base.
entities | Range in which entities of EntityType type are returned. |
Example:
Range entities;
get_entities( entities ); //get MBTET type EntityHandles in the database
Implements moab::Interface.
Definition at line 1992 of file Core.cpp.
1993 {
1994 ErrorCode result = MB_SUCCESS;
1995 if( meshset )
1996 {
1997 const EntitySequence* seq;
1998 result = sequence_manager()->find( meshset, seq );MB_CHK_ERR( result );
1999 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
2000 result = mseq->get_entities( sequence_manager(), meshset, entities, recursive );MB_CHK_ERR( result );
2001 }
2002 else
2003 {
2004 // iterate backwards so range insertion is quicker
2005 for( EntityType entity_type = MBENTITYSET; entity_type >= MBVERTEX; --entity_type )
2006 sequence_manager()->get_entities( entity_type, entities );
2007 }
2008
2009 return MB_SUCCESS;
2010 }
References entities, ErrorCode, moab::MeshSetSequence::get_entities(), MB_CHK_ERR, MB_SUCCESS, MBENTITYSET, and MBVERTEX.
Referenced by moab::RangeSetIterator::build_pair_vec(), moab::HigherOrderFactory::convert(), moab::WriteUtil::gather_entities(), moab::ReadUtil::gather_related_ents(), get_max_volume(), main(), moab::ReorderTool::update_set_contents(), and moab::NestedRefine::update_special_tags().
|
virtual |
Retrieves all entities in the data base.
entities | Range in which entities of EntityType type are returned. |
Example:
Range entities;
get_entities( entities ); //get MBTET type EntityHandles in the database
Implements moab::Interface.
Definition at line 2012 of file Core.cpp.
2015 {
2016 ErrorCode result;
2017 if( recursive || !meshset )
2018 {
2019 Range tmp_range;
2020 result = get_entities_by_handle( meshset, tmp_range, recursive );
2021 size_t offset = entities.size();
2022 entities.resize( offset + tmp_range.size() );
2023 std::copy( tmp_range.begin(), tmp_range.end(), entities.begin() + offset );
2024 }
2025 else
2026 {
2027 const EntitySequence* seq;
2028 result = sequence_manager()->find( meshset, seq );MB_CHK_ERR( result );
2029 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
2030 result = mseq->get_entities( meshset, entities );MB_CHK_ERR( result );
2031 }
2032 return MB_SUCCESS;
2033 }
References moab::Range::begin(), moab::Range::end(), entities, ErrorCode, moab::MeshSetSequence::get_entities(), MB_CHK_ERR, MB_SUCCESS, and moab::Range::size().
|
virtual |
Retrieves all entities in the data base of given type.
type | EntityType of entities desired (ie, MBHEX, MBEDGE, MBTRI, etc ) |
entities | Range in which entities of EntityType type are returned. |
Example:
EntityType type = MBTET;
Range entities;
get_entities_by_dimension( type, entities ); //get MBTET type EntityHandles in the database
Implements moab::Interface.
Definition at line 1892 of file Core.cpp.
1896 {
1897 ErrorCode result = MB_SUCCESS;
1898 if( meshset )
1899 {
1900 const EntitySequence* seq;
1901 result = sequence_manager()->find( meshset, seq );MB_CHK_ERR( result );
1902 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
1903 result = mseq->get_type( sequence_manager(), meshset, entity_type, entities, recursive );MB_CHK_ERR( result );
1904 }
1905 else
1906 {
1907 sequence_manager()->get_entities( entity_type, entities );
1908 }
1909
1910 return MB_SUCCESS;
1911 }
References entities, ErrorCode, moab::MeshSetSequence::get_type(), MB_CHK_ERR, and MB_SUCCESS.
Referenced by moab::AEntityFactory::create_vert_elem_adjacencies(), dot_contained(), dot_nodes(), moab::ReadUtil::gather_related_ents(), gather_set_stats(), main(), test_spectral_quad(), and moab::ReorderTool::update_set_contents().
|
virtual |
Retrieves all entities in the data base of given type.
type | EntityType of entities desired (ie, MBHEX, MBEDGE, MBTRI, etc ) |
entities | Range in which entities of EntityType type are returned. |
Example:
EntityType type = MBTET;
Range entities;
get_entities_by_dimension( type, entities ); //get MBTET type EntityHandles in the database
Implements moab::Interface.
Definition at line 1913 of file Core.cpp.
1917 {
1918 ErrorCode result = MB_SUCCESS;
1919 if( meshset )
1920 {
1921 const EntitySequence* seq;
1922 result = sequence_manager()->find( meshset, seq );MB_CHK_ERR( result );
1923 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
1924 result = mseq->get_type( sequence_manager(), meshset, entity_type, entities, recursive );MB_CHK_ERR( result );
1925 }
1926 else
1927 {
1928 sequence_manager()->get_entities( entity_type, entities );
1929 }
1930
1931 return MB_SUCCESS;
1932 }
References entities, ErrorCode, moab::MeshSetSequence::get_type(), MB_CHK_ERR, and MB_SUCCESS.
|
virtual |
Retrieve entities in the database or meshset which have any or all of the tag(s) and (optionally) value(s) specified.
meshset | Meshset whose entities are being queried (zero if query is for entire mesh). |
type | Type of entities to be returned |
tag_handles | Vector of tag handles entities must have |
values | Vector of pointers to values of tags in tag_handles |
num_tags | Number of tags and values in tag_handles and values |
entities | Range in which entities are returned. |
condition | Boolean condition, either Interface::UNION or Interface::INTERSECT |
recursive | If true, meshsets containing meshsets are queried recursively. Returns the contents of meshsets, but not the meshsets themselves. Specifying both recursive=true and type=MBENTITYSET is an error, as it would always result in an empty list. |
If Interface::UNION is specified as the condition, entities with any of the tags and values specified are returned. If Interface::INTERSECT is specified, only entities with all of the tags/values are returned.
If values is NULL, entities with the specified tags and any corresponding values are returned. Note that if values is non-NULL, it is a vector of pointers to tag values.
Example:
// get the dirichlet sets in a mesh
Range dir_sets;
Tag dir_tag;
tag_get_handle(DIRICHLET_SET_TAG_NAME, dir_tag, 1, MB_TYPE_INTEGER);
get_entities_by_type_and_tag(0, MBENTITYSET, &dir_tag, NULL, 1, dir_sets,
Interface::UNION);
Implements moab::Interface.
Definition at line 1934 of file Core.cpp.
1942 {
1943 ErrorCode result;
1944 Range range;
1945
1946 result = get_entities_by_type( meshset, entity_type, range, recursive );MB_CHK_ERR( result );
1947 if( !entities.empty() && Interface::INTERSECT == condition ) range = intersect( entities, range );
1948
1949 // For each tag:
1950 // if operation is INTERSECT remove from 'range' any non-tagged entities
1951 // if operation is UNION add to 'entities' any tagged entities
1952 for( int it = 0; it < num_tags && !range.empty(); it++ )
1953 {
1954 if( !valid_tag_handle( tags[it] ) ) return MB_TAG_NOT_FOUND;
1955
1956 // Of the entities in 'range', put in 'tmp_range' the subset
1957 // that are tagged as requested for this tag.
1958 Range tmp_range;
1959
1960 // get the entities with this tag/value combo
1961 if( NULL == values || NULL == values[it] )
1962 {
1963 result = tags[it]->get_tagged_entities( sequenceManager, tmp_range, entity_type, &range );MB_CHK_ERR( result );
1964 }
1965 else
1966 {
1967 result = tags[it]->find_entities_with_value( sequenceManager, mError, tmp_range, values[it], 0, entity_type,
1968 &range );MB_CHK_ERR( result );
1969 // if there is a default value, then we should return all entities
1970 // that are untagged
1971 if( tags[it]->equals_default_value( values[it] ) )
1972 {
1973 Range all_tagged, untagged;
1974 result = tags[it]->get_tagged_entities( sequenceManager, all_tagged, entity_type, &range );MB_CHK_ERR( result );
1975 // add to 'tmp_range' any untagged entities in 'range'
1976 tmp_range.merge( subtract( range, all_tagged ) );
1977 }
1978 }
1979
1980 // The above calls should have already done the intersect for us.
1981 if( Interface::INTERSECT == condition )
1982 range.swap( tmp_range );
1983 else
1984 entities.merge( tmp_range );
1985 }
1986
1987 if( Interface::INTERSECT == condition ) entities.swap( range );
1988
1989 return MB_SUCCESS;
1990 }
References moab::Range::empty(), entities, ErrorCode, moab::TagInfo::find_entities_with_value(), moab::TagInfo::get_tagged_entities(), moab::intersect(), moab::Interface::INTERSECT, MB_CHK_ERR, MB_SUCCESS, MB_TAG_NOT_FOUND, moab::Range::merge(), moab::subtract(), and moab::Range::swap().
Referenced by moab::HigherOrderFactory::convert_sequence(), dot_get_sets(), moab::ReadUtil::get_gather_set(), moab::ReadParallel::load_file(), main(), process_partition_file(), moab::ReorderTool::reorder_tag_data(), test_spectral_hex(), and moab::NestedRefine::update_special_tags().
|
virtual |
Return string representation of given error code.
code | Error code for which string is wanted |
Implements moab::Interface.
Definition at line 3618 of file Core.cpp.
3619 {
3620 return (unsigned)code <= (unsigned)MB_FAILURE ? ErrorCodeStr[code] : "INVALID ERROR CODE";
3621 }
Referenced by main().
|
virtual |
Return information about the last error.
info | std::string into which information on the last error is written. |
Implements moab::Interface.
Definition at line 3612 of file Core.cpp.
3613 {
3614 MBErrorHandler_GetLastError( info );
3615 return MB_SUCCESS;
3616 }
References MB_SUCCESS, and moab::MBErrorHandler_GetLastError().
Referenced by main().
|
virtual |
get the options of a mesh set
Implements moab::Interface.
Definition at line 3263 of file Core.cpp.
3264 {
3265 if( !ms_handle )
3266 { // root set
3267 setoptions = MESHSET_SET | MESHSET_TRACK_OWNER;
3268 return MB_SUCCESS;
3269 }
3270
3271 const MeshSet* set = get_mesh_set( sequence_manager(), ms_handle );
3272 if( !set ) return MB_ENTITY_NOT_FOUND;
3273
3274 setoptions = set->flags();
3275 return MB_SUCCESS;
3276 }
References moab::MeshSet::flags(), moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, MB_SUCCESS, MESHSET_SET, and MESHSET_TRACK_OWNER.
Referenced by moab::ReorderTool::update_set_contents().
|
virtual |
Retrieves all entities in the database of given dimension.
get # entities of a given dimension
dimension | Dimension of entities desired. |
entities | Range in which entities of dimension dimension are returned. |
Example:
int dimension = 2;
Range entities;
get_entities_by_dimension( dimension, entities ); //get 2D EntityHandles in the database
Implements moab::Interface.
Definition at line 2036 of file Core.cpp.
2040 {
2041 ErrorCode result = MB_SUCCESS;
2042
2043 if( !meshset )
2044 {
2045 number = 0;
2046 for( EntityType this_type = CN::TypeDimensionMap[dim].first; this_type <= CN::TypeDimensionMap[dim].second;
2047 this_type++ )
2048 {
2049 number += sequence_manager()->get_number_entities( this_type );
2050 }
2051 }
2052 else
2053 {
2054 const EntitySequence* seq;
2055 result = sequence_manager()->find( meshset, seq );MB_CHK_ERR( result );
2056 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
2057 result = mseq->num_dimension( sequence_manager(), meshset, dim, number, recursive );MB_CHK_ERR( result );
2058 }
2059
2060 return MB_SUCCESS;
2061 }
References dim, ErrorCode, moab::GeomUtil::first(), MB_CHK_ERR, MB_SUCCESS, moab::MeshSetSequence::num_dimension(), and moab::CN::TypeDimensionMap.
Referenced by main().
|
virtual |
Retrieves all entities in the data base.
entities | Range in which entities of EntityType type are returned. |
Example:
Range entities;
get_entities( entities ); //get MBTET type EntityHandles in the database
Implements moab::Interface.
Definition at line 2105 of file Core.cpp.
2106 {
2107 ErrorCode result;
2108 if( meshset )
2109 {
2110 const EntitySequence* seq;
2111 result = sequence_manager()->find( meshset, seq );MB_CHK_ERR( result );
2112 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
2113 return mseq->num_entities( sequence_manager(), meshset, num_ent, recursive );
2114 }
2115
2116 num_ent = 0;
2117 for( EntityType this_type = MBVERTEX; this_type < MBMAXTYPE; this_type++ )
2118 {
2119 int dummy = 0;
2120 result = get_number_entities_by_type( 0, this_type, dummy );
2121 if( result != MB_SUCCESS )
2122 {
2123 num_ent = 0;
2124 return result;
2125 }
2126 num_ent += dummy;
2127 }
2128
2129 return MB_SUCCESS;
2130 }
References ErrorCode, MB_CHK_ERR, MB_SUCCESS, MBMAXTYPE, MBVERTEX, and moab::MeshSetSequence::num_entities().
|
virtual |
Retrieves all entities in the data base of given type.
returns the number of entities with a given type and tag
type | EntityType of entities desired (ie, MBHEX, MBEDGE, MBTRI, etc ) |
entities | Range in which entities of EntityType type are returned. |
Example:
EntityType type = MBTET;
Range entities;
get_entities_by_dimension( type, entities ); //get MBTET type EntityHandles in the database
Implements moab::Interface.
Definition at line 2064 of file Core.cpp.
2068 {
2069 ErrorCode result = MB_SUCCESS;
2070
2071 if( recursive && entity_type == MBENTITYSET ) // will never return anything
2072 return MB_TYPE_OUT_OF_RANGE;
2073
2074 if( meshset )
2075 {
2076 const EntitySequence* seq;
2077 result = sequence_manager()->find( meshset, seq );MB_CHK_ERR( result );
2078 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
2079 result = mseq->num_type( sequence_manager(), meshset, entity_type, num_ent, recursive );MB_CHK_ERR( result );
2080 }
2081 else
2082 {
2083 num_ent = sequence_manager()->get_number_entities( entity_type );
2084 }
2085
2086 return MB_SUCCESS;
2087 }
References ErrorCode, MB_CHK_ERR, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MBENTITYSET, and moab::MeshSetSequence::num_type().
Referenced by gather_set_stats().
|
virtual |
Retrieve number of entities in the database or meshset which have any or all of the tag(s) and (optionally) value(s) specified.
Identical to get_entities_by_type_and_tag, except number instead of entities are returned
meshset | Meshset whose entities are being queried (zero if query is for entire mesh). |
type | Type of entities to be returned |
tag_handles | Vector of tag handles entities must have |
values | Vector of pointers to values of tags in tag_handles |
num_tags | Number of tags and values in tag_handles and values |
num_entities | Range in which number of entities are returned. |
recursive | If true, meshsets containing meshsets are queried recursively. Returns the contents of meshsets, but not the meshsets themselves. Specifying both recursive=true and type=MBENTITYSET is an error, as it would always result in an empty list. |
Implements moab::Interface.
Definition at line 2089 of file Core.cpp.
2097 {
2098 Range dum_ents;
2099 ErrorCode result = get_entities_by_type_and_tag( meshset, entity_type, tag_handles, values, num_tags, dum_ents,
2100 condition, recursive );
2101 num_entities = dum_ents.size();
2102 return result;
2103 }
References ErrorCode, and moab::Range::size().
Referenced by gather_tag_counts().
|
virtual |
get parent meshsets
Implements moab::Interface.
Definition at line 3422 of file Core.cpp.
3423 {
3424 if( 0 == meshset ) return MB_ENTITY_NOT_FOUND;
3425
3426 std::vector< EntityHandle > parent_vec;
3427 ErrorCode result = get_parent_meshsets( meshset, parent_vec, num_hops );MB_CHK_ERR( result );
3428 std::sort( parent_vec.begin(), parent_vec.end() );
3429 std::copy( parent_vec.rbegin(), parent_vec.rend(), range_inserter( parents ) );
3430 return MB_SUCCESS;
3431 }
References ErrorCode, MB_CHK_ERR, MB_ENTITY_NOT_FOUND, and MB_SUCCESS.
|
virtual |
get parent meshsets
Implements moab::Interface.
Definition at line 3408 of file Core.cpp.
3411 {
3412 if( 0 == meshset ) return MB_ENTITY_NOT_FOUND;
3413
3414 const EntitySequence* seq;
3415 ErrorCode rval = sequence_manager()->find( meshset, seq );
3416 if( MB_SUCCESS != rval ) return MB_ENTITY_NOT_FOUND;
3417 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
3418
3419 return mseq->get_parents( sequence_manager(), meshset, parents, num_hops );
3420 }
References ErrorCode, moab::MeshSetSequence::get_parents(), MB_ENTITY_NOT_FOUND, and MB_SUCCESS.
Referenced by dot_children(), and moab::ReadUtil::gather_related_ents().
|
privatevirtual |
return the entity set representing the whole mesh
Implements moab::Interface.
Definition at line 256 of file Core.cpp.
257 {
258 return 0;
259 }
|
virtual |
Interface to control memory allocation for sequences Provide a factor that controls the size of the sequence that gets allocated. This is typically useful in the parallel setting when a-priori, the number of ghost entities and the memory required for them within the same sequence as the owned entities are unknown. The default factor is 1.0 but this can be appropriately updated at runtime so that we do not have broken sequences.
Implements moab::Interface.
Definition at line 1106 of file Core.cpp.
1107 {
1108 return sequenceManager->get_sequence_multiplier();
1109 }
ErrorCode moab::Core::get_set_iterators | ( | EntityHandle | meshset, |
std::vector< SetIterator * > & | set_iters | ||
) |
Get all set iterators associated with the set passed in.
Definition at line 3916 of file Core.cpp.
3917 {
3918 for( std::vector< SetIterator* >::const_iterator vit = setIterators.begin(); vit != setIterators.end(); ++vit )
3919 if( ( *vit )->ent_set() == meshset ) set_iters.push_back( *vit );
3920 return MB_SUCCESS;
3921 }
References MB_SUCCESS.
|
virtual |
get blocked vertex coordinates for all vertices
Blocked = all x, then all y, etc.
Implements moab::Interface.
Definition at line 801 of file Core.cpp.
802 {
803 // INEFFICIENT implementation for now, until we get blocked tag access
804 Range vertices;
805 ErrorCode result = get_entities_by_type( 0, MBVERTEX, vertices );MB_CHK_ERR( result );
806
807 // the least we can do is resize the vector and only go through the
808 // vertex list once
809 int num_verts = vertices.size();
810 int vec_pos = 0;
811 double xyz[3];
812 coords.resize( geometricDimension * num_verts );
813 for( Range::iterator it = vertices.begin(); it != vertices.end(); ++it )
814 {
815 result = get_coords( &( *it ), 1, xyz );MB_CHK_ERR( result );
816
817 coords[vec_pos] = xyz[0];
818 coords[num_verts + vec_pos] = xyz[1];
819 coords[2 * num_verts + vec_pos] = xyz[2];
820
821 vec_pos++;
822 }
823
824 return MB_SUCCESS;
825 }
References moab::Range::begin(), moab::Range::end(), ErrorCode, MB_CHK_ERR, MB_SUCCESS, MBVERTEX, and moab::Range::size().
Get all vertices for input entities.
Special case of get_adjacencies where to_dimension == 0 and operation_type == Interface::UNION. \Note This is not a variation of get_connectivity because the behavior is different for polyhedra.
Definition at line 1721 of file Core.cpp.
1722 {
1723 Range range;
1724 ErrorCode rval = get_connectivity( from_entities, range );MB_CHK_ERR( rval );
1725
1726 // If input contained polyhedra, connectivity will contain faces.
1727 // Get vertices from faces.
1728 if( !range.all_of_dimension( 0 ) )
1729 {
1730 Range::iterator it = range.upper_bound( MBVERTEX );
1731 Range polygons;
1732 polygons.merge( it, range.end() );
1733 range.erase( it, range.end() );
1734 rval = get_connectivity( polygons, range );MB_CHK_ERR( rval );
1735 }
1736
1737 if( vertices.empty() )
1738 vertices.swap( range );
1739 else
1740 vertices.merge( range );
1741 return MB_SUCCESS;
1742 }
References moab::Range::all_of_dimension(), moab::Range::empty(), moab::Range::end(), moab::Range::erase(), ErrorCode, MB_CHK_ERR, MB_SUCCESS, MBVERTEX, moab::Range::merge(), moab::Range::swap(), and moab::Range::upper_bound().
|
virtual |
Get parent mesh sets of a mesh set.
If num_hops is 1, only immediate parents are returned. If num_hops is zero, all ancenstors are returned. Otherwise, num_hops specifies the maximum number of generations to traverse.
meshset | The mesh set whose parents are being queried |
parents | STL vector holding the parents returned by this function |
num_hops | Number of generations to traverse (0 = all) |
Implements moab::Interface.
Definition at line 2622 of file Core.cpp.
2623 {
2624 const int negone = -1;
2625 if( 0 == globalIdTag )
2626 tag_get_handle( GLOBAL_ID_TAG_NAME, 1, MB_TYPE_INTEGER, globalIdTag, MB_TAG_CREAT | MB_TAG_DENSE, &negone );
2627 return globalIdTag;
2628 }
References GLOBAL_ID_TAG_NAME, MB_TAG_CREAT, MB_TAG_DENSE, and MB_TYPE_INTEGER.
Referenced by moab::WriteUtil::assign_ids(), and main().
|
virtual |
get a handle from an id and type
Implements moab::Interface.
Definition at line 389 of file Core.cpp.
390 {
391 int err;
392 handle = CREATE_HANDLE( entity_type, id, err );
393
394 // check to see if handle exists
395 const EntitySequence* dummy_seq = 0;
396 ErrorCode error_code = sequence_manager()->find( handle, dummy_seq );
397 return error_code;
398 }
References moab::CREATE_HANDLE(), and ErrorCode.
Referenced by moab::HalfFacetRep::fid_from_halfacet().
|
virtual |
given an entity and the connectivity and type of one of its subfacets, find the high order node on that subfacet, if any
Implements moab::Interface.
Definition at line 3134 of file Core.cpp.
3138 {
3139 hon = 0;
3140
3141 EntityType parent_type = TYPE_FROM_HANDLE( parent_handle );
3142
3143 // get the parent's connectivity
3144 const EntityHandle* parent_conn = NULL;
3145 int num_parent_vertices = 0;
3146 ErrorCode result = get_connectivity( parent_handle, parent_conn, num_parent_vertices, false );MB_CHK_ERR( result );
3147
3148 // find whether this entity has ho nodes
3149 int mid_nodes[4];
3150 CN::HasMidNodes( parent_type, num_parent_vertices, mid_nodes );
3151
3152 // check whether this entity has mid nodes on this dimension subfacet;
3153 // use dimension-1 because vertices don't have mid nodes
3154 if( !mid_nodes[CN::Dimension( subfacet_type )] ) return MB_SUCCESS;
3155
3156 // ok, we have mid nodes; now must compute expected index in connectivity array;
3157 // ho nodes stored for edges, faces then entity
3158
3159 // offset starts with # corner vertices
3160 int offset = CN::VerticesPerEntity( parent_type );
3161 int i;
3162
3163 for( i = 0; i < CN::Dimension( subfacet_type ) - 1; i++ )
3164 // for each dimension lower than that of the subfacet we're looking for,
3165 // if this entity has midnodes in that dimension, increment offset by #
3166 // of subfacets of that dimension; use dimension-1 in loop because
3167 // canon numbering table only has 2 positions, for edges and faces;
3168 if( mid_nodes[i + 1] ) offset += CN::mConnectivityMap[parent_type][i].num_sub_elements;
3169
3170 // now add the index of this subfacet; only need to if it's not the highest dimension
3171 if( subfacet_type != parent_type )
3172 {
3173
3174 // find indices into parent_conn for each entry in child_conn
3175 unsigned subfacet_size = CN::VerticesPerEntity( subfacet_type );
3176 int subfacet_indices[10];
3177 assert( subfacet_size <= sizeof( subfacet_indices ) / sizeof( subfacet_indices[0] ) );
3178 for( unsigned j = 0; j < subfacet_size; ++j )
3179 {
3180 subfacet_indices[j] =
3181 std::find( parent_conn, parent_conn + num_parent_vertices, subfacet_conn[j] ) - parent_conn;
3182 if( subfacet_indices[j] >= num_parent_vertices )
3183 {
3184 return MB_FAILURE;
3185 }
3186 }
3187
3188 int dum, side_no, temp_offset;
3189 int temp_result =
3190 CN::SideNumber( parent_type, subfacet_indices, subfacet_size, subfacet_type, side_no, dum, temp_offset );
3191 if( temp_result != 0 ) return MB_FAILURE;
3192
3193 offset += side_no;
3194 }
3195
3196 // offset shouldn't be off the end of the connectivity vector
3197 if( offset >= num_parent_vertices ) return MB_INDEX_OUT_OF_RANGE;
3198
3199 hon = parent_conn[offset];
3200
3201 return MB_SUCCESS;
3202 }
References moab::CN::Dimension(), moab::dum, ErrorCode, moab::CN::HasMidNodes(), MB_CHK_ERR, MB_INDEX_OUT_OF_RANGE, MB_SUCCESS, moab::CN::mConnectivityMap, moab::CN::ConnMap::num_sub_elements, moab::CN::SideNumber(), moab::TYPE_FROM_HANDLE(), and moab::CN::VerticesPerEntity().
|
virtual |
get the id from a handle, returns id
Implements moab::Interface.
Definition at line 383 of file Core.cpp.
384 {
385 return ID_FROM_HANDLE( handle );
386 }
References moab::ID_FROM_HANDLE().
Referenced by dot_down_link(), dot_nodes(), dot_write_node(), main(), and perform_laplacian_smoothing().
|
virtual |
Returns the major.minor version number of the implementation.
iface_name | If non-NULL, will be filled in with a string, possibly containing implementation-specific information |
Implements moab::Interface.
Definition at line 366 of file Core.cpp.
367 {
368 if( version_string ) *version_string = MOAB_VERSION_STRING;
369
370 return MOAB_VERSION_MAJOR + MOAB_VERSION_MINOR / 100.0f;
371 }
References MOAB_VERSION_MAJOR, MOAB_VERSION_MINOR, and MOAB_VERSION_STRING.
|
private |
database init and de-init routines
Definition at line 193 of file Core.cpp.
194 {
195 #ifdef MOAB_HAVE_MPI
196 int flag;
197 if( MPI_SUCCESS == MPI_Initialized( &flag ) )
198 {
199 if( flag )
200 {
201 writeMPELog = !MPE_Initialized_logging();
202 if( writeMPELog ) (void)MPE_Init_log();
203 }
204 }
205 #endif
206
207 initErrorHandlerInCore = false;
208 if( !MBErrorHandler_Initialized() )
209 {
210 MBErrorHandler_Init();
211 initErrorHandlerInCore = true;
212 }
213
214 geometricDimension = 3;
215 materialTag = 0;
216 neumannBCTag = 0;
217 dirichletBCTag = 0;
218 geomDimensionTag = 0;
219 globalIdTag = 0;
220
221 sequenceManager = new( std::nothrow ) SequenceManager;
222 if( !sequenceManager ) return MB_MEMORY_ALLOCATION_FAILED;
223
224 aEntityFactory = new( std::nothrow ) AEntityFactory( this );
225 if( !aEntityFactory ) return MB_MEMORY_ALLOCATION_FAILED;
226
227 mError = new( std::nothrow ) Error;
228 if( !mError ) return MB_MEMORY_ALLOCATION_FAILED;
229
230 mMBWriteUtil = NULL;
231 mMBReadUtil = NULL;
232 scdInterface = NULL;
233
234 // Readers and writers try to get pointers to above utils.
235 // Do this after pointers are initialized. (Pointers should
236 // really be initialized in constructor to avoid this kind
237 // of thing -- j.kraftcheck.)
238 readerWriterSet = new( std::nothrow ) ReaderWriterSet( this );
239 if( !readerWriterSet ) return MB_MEMORY_ALLOCATION_FAILED;
240
241 material_tag();
242 neumannBC_tag();
243 dirichletBC_tag();
244 geom_dimension_tag();
245 globalId_tag();
246
247 #ifdef MOAB_HAVE_AHF
248 ahfRep = new HalfFacetRep( this );
249 if( !ahfRep ) return MB_MEMORY_ALLOCATION_FAILED;
250 mesh_modified = false;
251 #endif
252
253 return MB_SUCCESS;
254 }
References MB_MEMORY_ALLOCATION_FAILED, MB_SUCCESS, moab::MBErrorHandler_Init(), moab::MBErrorHandler_Initialized(), MPE_Init_log, and MPE_Initialized_logging.
|
virtual |
intersects meshset2 with meshset1 - modifies meshset1
Implements moab::Interface.
Definition at line 3325 of file Core.cpp.
3326 {
3327 MeshSet* set1 = get_mesh_set( sequence_manager(), meshset1 );
3328 MeshSet* set2 = get_mesh_set( sequence_manager(), meshset2 );
3329 if( !set1 || !set2 ) return MB_ENTITY_NOT_FOUND;
3330
3331 return set1->intersect( set2, meshset1, a_entity_factory() );
3332 }
References moab::get_mesh_set(), moab::MeshSet::intersect(), and MB_ENTITY_NOT_FOUND.
bool moab::Core::is_valid | ( | const EntityHandle | this_ent | ) | const |
return whether the input handle is valid or not
Definition at line 3863 of file Core.cpp.
3864 {
3865 const EntitySequence* seq = 0;
3866 ErrorCode result = sequence_manager()->find( this_ent, seq );
3867 return seq != 0 && result == MB_SUCCESS;
3868 }
References ErrorCode, and MB_SUCCESS.
Referenced by moab::RangeSetIterator::get_next_arr(), moab::VectorSetIterator::get_next_arr(), and moab::ScdBox::~ScdBox().
|
virtual |
List entities, or number of entities in database, to standard output.
Lists data pertaining to entities to standard output. If entities is NULL and num_entities is zero, lists only the number of entities of each type in the database. If entities is NULL and num_entities is non-zero, lists all information for all entities in the database.
entities | 1d vector of entities to list |
num_entities | Number of entities in 1d vector |
Implements moab::Interface.
Definition at line 2847 of file Core.cpp.
2848 {
2849 Range temp_range;
2850 ErrorCode result = MB_SUCCESS;
2851 if( NULL == entities && num_entities == 0 )
2852 {
2853 // just list the numbers of each entity type
2854 int num_ents;
2855 std::cout << std::endl;
2856 std::cout << "Number of entities per type: " << std::endl;
2857 for( EntityType this_type = MBVERTEX; this_type < MBMAXTYPE; this_type++ )
2858 {
2859 result = get_number_entities_by_type( 0, this_type, num_ents );
2860 std::cout << CN::EntityTypeName( this_type ) << ": " << num_ents << std::endl;
2861 }
2862 std::cout << std::endl;
2863
2864 return MB_SUCCESS;
2865 }
2866 else if( NULL == entities && num_entities < 0 )
2867 {
2868
2869 // list all entities of all types
2870 std::cout << std::endl;
2871 for( EntityType this_type = MBVERTEX; this_type < MBMAXTYPE; this_type++ )
2872 {
2873 result = get_entities_by_type( 0, this_type, temp_range );
2874 }
2875
2876 return list_entities( temp_range );
2877 }
2878 else if( NULL == entities && num_entities > 0 )
2879 {
2880
2881 // list all entities of type == num_entities
2882 std::cout << std::endl;
2883 result = get_entities_by_type( 0, (EntityType)num_entities, temp_range );
2884
2885 return list_entities( temp_range );
2886 }
2887 else
2888 {
2889 ErrorCode tmp_result;
2890 for( int i = 0; i < num_entities; i++ )
2891 {
2892 EntityType this_type = TYPE_FROM_HANDLE( entities[i] );
2893 std::cout << CN::EntityTypeName( this_type ) << " " << ID_FROM_HANDLE( entities[i] ) << ":" << endl;
2894
2895 tmp_result = ( const_cast< Core* >( this ) )->list_entity( entities[i] );
2896 if( MB_SUCCESS != tmp_result ) result = tmp_result;
2897 }
2898 }
2899
2900 return result;
2901 }
References entities, moab::CN::EntityTypeName(), ErrorCode, moab::ID_FROM_HANDLE(), MB_SUCCESS, MBMAXTYPE, MBVERTEX, and moab::TYPE_FROM_HANDLE().
List entities to standard output.
Lists all data pertaining to entities (i.e. vertex coordinates if vertices, connectivity if elements, set membership if set). Useful for debugging, but output can become quite long for large databases.
Implements moab::Interface.
Definition at line 2903 of file Core.cpp.
2904 {
2905 ErrorCode result = MB_SUCCESS, tmp_result;
2906
2907 for( Range::const_iterator rit = temp_range.begin(); rit != temp_range.end(); ++rit )
2908 {
2909 EntityType this_type = TYPE_FROM_HANDLE( *rit );
2910 std::cout << CN::EntityTypeName( this_type ) << " " << ID_FROM_HANDLE( *rit ) << ":" << endl;
2911
2912 tmp_result = ( const_cast< Core* >( this ) )->list_entity( *rit );
2913 if( MB_SUCCESS != tmp_result ) result = tmp_result;
2914 }
2915
2916 return result;
2917 }
References moab::Range::begin(), moab::Range::end(), moab::CN::EntityTypeName(), ErrorCode, moab::ID_FROM_HANDLE(), MB_SUCCESS, and moab::TYPE_FROM_HANDLE().
Referenced by main().
|
virtual |
List a single entity; no header printed.
Lists a single entity, including its connectivity and its adjacencies. No header is printed, because calling function might print information between header and information printed by this function.
entity | The entity to be listed. |
Implements moab::Interface.
Definition at line 2919 of file Core.cpp.
2920 {
2921 ErrorCode result;
2922 HandleVec adj_vec;
2923
2924 if( !is_valid( entity ) )
2925 {
2926 std::cout << "(invalid)" << std::endl;
2927 return MB_SUCCESS;
2928 }
2929
2930 if( 0 != globalIdTag )
2931 {
2932 int dum;
2933 result = tag_get_data( globalIdTag, &entity, 1, &dum );
2934 if( MB_SUCCESS == result ) std::cout << "Global id = " << dum << std::endl;
2935 }
2936
2937 // list entity
2938 EntityType this_type = TYPE_FROM_HANDLE( entity );
2939 if( this_type == MBVERTEX )
2940 {
2941 double coords[3];
2942 result = get_coords( &( entity ), 1, coords );MB_CHK_ERR( result );
2943 std::cout << "Coordinates: (" << coords[0] << ", " << coords[1] << ", " << coords[2] << ")" << std::endl;
2944 }
2945 else if( this_type == MBENTITYSET )
2946 this->print( entity, "" );
2947
2948 std::cout << " Adjacencies:" << std::endl;
2949 bool some = false;
2950 int multiple = 0;
2951 for( int dim = 0; dim <= 3; dim++ )
2952 {
2953 if( dim == CN::Dimension( this_type ) ) continue;
2954 adj_vec.clear();
2955 // use const_cast here 'cuz we're in a const function and we're passing 'false' for
2956 // create_if_missing, so we know we won't change anything
2957 result = ( const_cast< Core* >( this ) )->get_adjacencies( &( entity ), 1, dim, false, adj_vec );
2958 if( MB_FAILURE == result ) continue;
2959 for( HandleVec::iterator adj_it = adj_vec.begin(); adj_it != adj_vec.end(); ++adj_it )
2960 {
2961 if( adj_it != adj_vec.begin() )
2962 std::cout << ", ";
2963 else
2964 std::cout << " ";
2965 std::cout << CN::EntityTypeName( TYPE_FROM_HANDLE( *adj_it ) ) << " " << ID_FROM_HANDLE( *adj_it );
2966 }
2967 if( !adj_vec.empty() )
2968 {
2969 std::cout << std::endl;
2970 some = true;
2971 }
2972 if( MB_MULTIPLE_ENTITIES_FOUND == result ) multiple += dim;
2973 }
2974 if( !some ) std::cout << "(none)" << std::endl;
2975 const EntityHandle* explicit_adjs;
2976 int num_exp;
2977 aEntityFactory->get_adjacencies( entity, explicit_adjs, num_exp );
2978 if( NULL != explicit_adjs && 0 != num_exp )
2979 {
2980 std::cout << " Explicit adjacencies: ";
2981 for( int i = 0; i < num_exp; i++ )
2982 {
2983 if( i != 0 ) std::cout << ", ";
2984 std::cout << CN::EntityTypeName( TYPE_FROM_HANDLE( explicit_adjs[i] ) ) << " "
2985 << ID_FROM_HANDLE( explicit_adjs[i] );
2986 }
2987 std::cout << std::endl;
2988 }
2989 if( multiple != 0 ) std::cout << " (MULTIPLE = " << multiple << ")" << std::endl;
2990
2991 result = print_entity_tags( std::string(), entity, MB_TAG_DENSE );
2992
2993 std::cout << std::endl;
2994
2995 return result;
2996 }
References dim, moab::CN::Dimension(), moab::dum, moab::CN::EntityTypeName(), ErrorCode, moab::ID_FROM_HANDLE(), MB_CHK_ERR, MB_MULTIPLE_ENTITIES_FOUND, MB_SUCCESS, MB_TAG_DENSE, MBENTITYSET, MBVERTEX, and moab::TYPE_FROM_HANDLE().
|
virtual |
Load or import a file.
Implements moab::Interface.
Definition at line 416 of file Core.cpp.
422 {
423 FileOptions opts( setoptions );
424 ErrorCode rval;
425 ReaderIface::IDTag t = { set_tag_name, set_tag_vals, num_set_tag_vals };
426 ReaderIface::SubsetList sl = { &t, 1, 0, 0 };
427
428 assert( !file_set || ( *file_set && is_valid( *file_set ) ) );
429 if( file_set && !*file_set )
430 {
431 MB_SET_GLB_ERR( MB_FAILURE, "Non-NULL file set pointer should point to non-NULL set" );
432 }
433
434 // if reading in parallel, call a different reader
435 std::string parallel_opt;
436 rval = opts.get_option( "PARALLEL", parallel_opt );
437 if( MB_SUCCESS == rval )
438 {
439 #ifdef MOAB_HAVE_MPI
440 ParallelComm* pcomm = 0;
441 int pcomm_id;
442 rval = opts.get_int_option( "PARALLEL_COMM", pcomm_id );
443 if( MB_ENTITY_NOT_FOUND == rval ) rval = opts.get_int_option( "PCOMM", pcomm_id );
444 if( rval == MB_SUCCESS )
445 {
446 pcomm = ParallelComm::get_pcomm( this, pcomm_id );
447 if( !pcomm ) return MB_ENTITY_NOT_FOUND;
448 }
449 else if( rval != MB_ENTITY_NOT_FOUND )
450 return rval;
451 if( set_tag_name && num_set_tag_vals )
452 {
453 rval = ReadParallel( this, pcomm ).load_file( file_name, file_set, opts, &sl );MB_CHK_ERR( rval );
454 }
455 else
456 {
457 rval = ReadParallel( this, pcomm ).load_file( file_name, file_set, opts );MB_CHK_ERR( rval );
458 }
459 #else
460 MB_SET_GLB_ERR( MB_FAILURE, "PARALLEL option not valid, this instance compiled for serial execution" );
461 #endif
462 }
463 else
464 {
465 if( set_tag_name && num_set_tag_vals )
466 {
467 rval = serial_load_file( file_name, file_set, opts, &sl );MB_CHK_ERR( rval );
468 }
469 else
470 {
471 rval = serial_load_file( file_name, file_set, opts );MB_CHK_ERR( rval );
472 }
473 }
474
475 if( MB_SUCCESS == rval && !opts.all_seen() )
476 {
477 std::string bad_opt;
478 if( MB_SUCCESS == opts.get_unseen_option( bad_opt ) )
479 {
480 MB_SET_ERR( MB_UNHANDLED_OPTION, "Unrecognized option: \"" << bad_opt << "\"" );
481 }
482 else
483 {
484 MB_SET_ERR( MB_UNHANDLED_OPTION, "Unrecognized option" );
485 }
486 }
487
488 return MB_SUCCESS;
489 }
References moab::FileOptions::all_seen(), ErrorCode, moab::FileOptions::get_int_option(), moab::FileOptions::get_option(), moab::ParallelComm::get_pcomm(), moab::FileOptions::get_unseen_option(), moab::ReadParallel::load_file(), MB_CHK_ERR, MB_ENTITY_NOT_FOUND, MB_SET_ERR, MB_SET_GLB_ERR, MB_SUCCESS, and MB_UNHANDLED_OPTION.
Referenced by RuntimeContext::load_file(), main(), TestErrorHandling_1(), TestErrorHandling_2(), TestErrorHandling_3(), TestErrorHandlingPar_1(), and TestErrorHandlingPar_2().
|
virtual |
load mesh from data in file NOTE: if there is mesh already present, the new mesh will be added
Implements moab::Interface.
Definition at line 410 of file Core.cpp.
411 {
412 const char* name = block_id_list ? MATERIAL_SET_TAG_NAME : 0;
413 return load_file( file_name, 0, 0, name, block_id_list, num_blocks );
414 }
References MATERIAL_SET_TAG_NAME.
Referenced by main(), test_spectral_hex(), and test_spectral_quad().
Tag moab::Core::material_tag | ( | ) |
return various specific tag handles
Definition at line 2597 of file Core.cpp.
2598 {
2599 const int negone = -1;
2600 if( 0 == materialTag )
2601 tag_get_handle( MATERIAL_SET_TAG_NAME, 1, MB_TYPE_INTEGER, materialTag, MB_TAG_CREAT | MB_TAG_SPARSE, &negone );
2602 return materialTag;
2603 }
References MATERIAL_SET_TAG_NAME, MB_TAG_CREAT, MB_TAG_SPARSE, and MB_TYPE_INTEGER.
|
virtual |
merges two entities
Implements moab::Interface.
Definition at line 2690 of file Core.cpp.
2694 {
2695 if( auto_merge ) return MB_FAILURE;
2696
2697 // The two entities to merge must not be the same entity.
2698 if( entity_to_keep == entity_to_remove ) return MB_FAILURE;
2699
2700 // The two entities to merge must be of the same type
2701 EntityType type_to_keep = TYPE_FROM_HANDLE( entity_to_keep );
2702
2703 if( type_to_keep != TYPE_FROM_HANDLE( entity_to_remove ) ) return MB_TYPE_OUT_OF_RANGE;
2704
2705 // Make sure both entities exist before trying to merge.
2706 EntitySequence* seq = 0;
2707 ErrorCode result, status;
2708 status = sequence_manager()->find( entity_to_keep, seq );
2709 if( seq == 0 || status != MB_SUCCESS ) return MB_ENTITY_NOT_FOUND;
2710 status = sequence_manager()->find( entity_to_remove, seq );
2711 if( seq == 0 || status != MB_SUCCESS ) return MB_ENTITY_NOT_FOUND;
2712
2713 // If auto_merge is not set, all sub-entities should
2714 // be merged if the entities are to be merged.
2715 int ent_dim = CN::Dimension( type_to_keep );
2716 if( ent_dim > 0 )
2717 {
2718 std::vector< EntityHandle > conn, conn2;
2719
2720 result = get_connectivity( &entity_to_keep, 1, conn );MB_CHK_ERR( result );
2721 result = get_connectivity( &entity_to_remove, 1, conn2 );MB_CHK_ERR( result );
2722
2723 // Check to see if we can merge before pulling adjacencies.
2724 int dum1, dum2;
2725 if( !auto_merge &&
2726 ( conn.size() != conn2.size() || !CN::ConnectivityMatch( &conn[0], &conn2[0], conn.size(), dum1, dum2 ) ) )
2727 return MB_FAILURE;
2728 }
2729
2730 result = aEntityFactory->merge_adjust_adjacencies( entity_to_keep, entity_to_remove );
2731
2732 if( MB_SUCCESS == result && delete_removed_entity ) result = delete_entities( &entity_to_remove, 1 );
2733
2734 return result;
2735 }
References moab::CN::ConnectivityMatch(), moab::CN::Dimension(), ErrorCode, MB_CHK_ERR, MB_ENTITY_NOT_FOUND, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, and moab::TYPE_FROM_HANDLE().
Tag moab::Core::neumannBC_tag | ( | ) |
Definition at line 2605 of file Core.cpp.
2606 {
2607 const int negone = -1;
2608 if( 0 == neumannBCTag )
2609 tag_get_handle( NEUMANN_SET_TAG_NAME, 1, MB_TYPE_INTEGER, neumannBCTag, MB_TAG_CREAT | MB_TAG_SPARSE, &negone );
2610 return neumannBCTag;
2611 }
References MB_TAG_CREAT, MB_TAG_SPARSE, MB_TYPE_INTEGER, and NEUMANN_SET_TAG_NAME.
|
virtual |
gets number of child meshsets
Implements moab::Interface.
Definition at line 3501 of file Core.cpp.
3502 {
3503 if( 0 == meshset ) return MB_ENTITY_NOT_FOUND;
3504
3505 const EntitySequence* seq;
3506 ErrorCode rval = sequence_manager()->find( meshset, seq );
3507 if( MB_SUCCESS != rval ) return MB_ENTITY_NOT_FOUND;
3508 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
3509
3510 return mseq->num_children( sequence_manager(), meshset, *number, num_hops );
3511 }
References ErrorCode, MB_ENTITY_NOT_FOUND, MB_SUCCESS, and moab::MeshSetSequence::num_children().
|
virtual |
gets number of contained meshsets
Implements moab::Interface.
Definition at line 3513 of file Core.cpp.
3514 {
3515 if( 0 == meshset )
3516 {
3517 return get_number_entities_by_type( 0, MBENTITYSET, *number );
3518 }
3519
3520 const EntitySequence* seq;
3521 ErrorCode rval = sequence_manager()->find( meshset, seq );
3522 if( MB_SUCCESS != rval ) return MB_ENTITY_NOT_FOUND;
3523 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
3524
3525 return mseq->num_contained_sets( sequence_manager(), meshset, *number, num_hops );
3526 }
References ErrorCode, MB_ENTITY_NOT_FOUND, MB_SUCCESS, MBENTITYSET, and moab::MeshSetSequence::num_contained_sets().
|
virtual |
gets number of parent meshsets
Implements moab::Interface.
Definition at line 3489 of file Core.cpp.
3490 {
3491 if( 0 == meshset ) return MB_ENTITY_NOT_FOUND;
3492
3493 const EntitySequence* seq;
3494 ErrorCode rval = sequence_manager()->find( meshset, seq );
3495 if( MB_SUCCESS != rval ) return MB_ENTITY_NOT_FOUND;
3496 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
3497
3498 return mseq->num_parents( sequence_manager(), meshset, *number, num_hops );
3499 }
References ErrorCode, MB_ENTITY_NOT_FOUND, MB_SUCCESS, and moab::MeshSetSequence::num_parents().
void moab::Core::print | ( | const EntityHandle | handle, |
const char * | prefix, | ||
bool | first_call = true |
||
) | const |
Definition at line 3623 of file Core.cpp.
3624 {
3625 // get the entities
3626 Range entities;
3627
3628 if( 0 != ms_handle )
3629 {
3630 get_entities_by_handle( ms_handle, entities );
3631 std::cout << prefix << "MBENTITYSET " << ID_FROM_HANDLE( ms_handle ) << std::endl;
3632 }
3633 else
3634 {
3635 get_entities_by_dimension( 0, 3, entities );
3636 if( entities.empty() ) get_entities_by_dimension( 0, 2, entities );
3637 if( entities.empty() ) get_entities_by_dimension( 0, 1, entities );
3638 get_entities_by_dimension( 0, 0, entities );
3639 get_entities_by_type( 0, MBENTITYSET, entities );
3640 std::cout << prefix << "--: " << std::endl;
3641 }
3642
3643 std::string indent_prefix = prefix;
3644 indent_prefix += " ";
3645 entities.print( indent_prefix.c_str() );
3646
3647 if( !first_call || !ms_handle ) return;
3648
3649 // print parent/children
3650 Range temp;
3651 this->get_parent_meshsets( ms_handle, temp );
3652 std::cout << " Parent sets: ";
3653 if( temp.empty() )
3654 std::cout << "(none)" << std::endl;
3655 else
3656 {
3657 for( Range::iterator rit = temp.begin(); rit != temp.end(); ++rit )
3658 {
3659 if( rit != temp.begin() ) std::cout << ", ";
3660 std::cout << ID_FROM_HANDLE( *rit );
3661 }
3662 std::cout << std::endl;
3663 }
3664
3665 temp.clear();
3666 this->get_child_meshsets( ms_handle, temp );
3667 std::cout << " Child sets: ";
3668 if( temp.empty() )
3669 std::cout << "(none)" << std::endl;
3670 else
3671 {
3672 for( Range::iterator rit = temp.begin(); rit != temp.end(); ++rit )
3673 {
3674 if( rit != temp.begin() ) std::cout << ", ";
3675 std::cout << ID_FROM_HANDLE( *rit );
3676 }
3677 std::cout << std::endl;
3678 }
3679
3680 // print all sparse tags
3681 print_entity_tags( indent_prefix, ms_handle, MB_TAG_SPARSE );
3682 }
References moab::Range::begin(), moab::Range::clear(), moab::Range::empty(), moab::Range::end(), entities, moab::ID_FROM_HANDLE(), MB_TAG_SPARSE, and MBENTITYSET.
void moab::Core::print_database | ( | ) | const |
Definition at line 4129 of file Core.cpp.
4130 {
4131 ErrorCode rval;
4132 TypeSequenceManager::const_iterator i;
4133 const TypeSequenceManager& verts = sequence_manager()->entity_map( MBVERTEX );
4134 if( !verts.empty() )
4135 printf( " Vertex ID X Y Z Adjacencies \n"
4136 " ---------- -------- -------- -------- -----------...\n" );
4137 const EntityHandle* adj;
4138 int nadj;
4139 for( i = verts.begin(); i != verts.end(); ++i )
4140 {
4141 const VertexSequence* seq = static_cast< const VertexSequence* >( *i );
4142 printf( "(Sequence [%d,%d] in SequenceData [%d,%d])\n", (int)ID_FROM_HANDLE( seq->start_handle() ),
4143 (int)ID_FROM_HANDLE( seq->end_handle() ), (int)ID_FROM_HANDLE( seq->data()->start_handle() ),
4144 (int)ID_FROM_HANDLE( seq->data()->end_handle() ) );
4145
4146 double c[3];
4147 for( EntityHandle h = seq->start_handle(); h <= seq->end_handle(); ++h )
4148 {
4149 rval = seq->get_coordinates( h, c );
4150 if( MB_SUCCESS == rval )
4151 printf( " %10d %8g %8g %8g", (int)ID_FROM_HANDLE( h ), c[0], c[1], c[2] );
4152 else
4153 printf( " %10d < ERROR %4d >", (int)ID_FROM_HANDLE( h ), (int)rval );
4154
4155 rval = a_entity_factory()->get_adjacencies( h, adj, nadj );
4156 if( MB_SUCCESS != rval )
4157 {
4158 printf( " <ERROR %d>\n", (int)rval );
4159 continue;
4160 }
4161 EntityType pt = MBMAXTYPE;
4162 for( int j = 0; j < nadj; ++j )
4163 {
4164 if( TYPE_FROM_HANDLE( adj[j] ) != pt )
4165 {
4166 pt = TYPE_FROM_HANDLE( adj[j] );
4167 printf( " %s", pt >= MBMAXTYPE ? "INVALID TYPE" : CN::EntityTypeName( pt ) );
4168 }
4169 printf( " %d", (int)ID_FROM_HANDLE( adj[j] ) );
4170 }
4171 printf( "\n" );
4172 }
4173 }
4174
4175 for( EntityType t = MBEDGE; t < MBENTITYSET; ++t )
4176 {
4177 const TypeSequenceManager& elems = sequence_manager()->entity_map( t );
4178 if( elems.empty() ) continue;
4179
4180 int clen = 0;
4181 for( i = elems.begin(); i != elems.end(); ++i )
4182 {
4183 int n = static_cast< const ElementSequence* >( *i )->nodes_per_element();
4184 if( n > clen ) clen = n;
4185 }
4186
4187 clen *= 5;
4188 if( clen < (int)strlen( "Connectivity" ) ) clen = strlen( "Connectivity" );
4189 std::vector< char > dashes( clen, '-' );
4190 dashes.push_back( '\0' );
4191 printf( " %7s ID %-*s Adjacencies\n", CN::EntityTypeName( t ), clen, "Connectivity" );
4192 printf( " ---------- %s -----------...\n", &dashes[0] );
4193
4194 std::vector< EntityHandle > storage;
4195 const EntityHandle* conn;
4196 int nconn;
4197 for( i = elems.begin(); i != elems.end(); ++i )
4198 {
4199 const ElementSequence* seq = static_cast< const ElementSequence* >( *i );
4200 printf( "(Sequence [%d,%d] in SequenceData [%d,%d])\n", (int)ID_FROM_HANDLE( seq->start_handle() ),
4201 (int)ID_FROM_HANDLE( seq->end_handle() ), (int)ID_FROM_HANDLE( seq->data()->start_handle() ),
4202 (int)ID_FROM_HANDLE( seq->data()->end_handle() ) );
4203
4204 for( EntityHandle h = seq->start_handle(); h <= seq->end_handle(); ++h )
4205 {
4206 printf( " %10d", (int)ID_FROM_HANDLE( h ) );
4207 rval = get_connectivity( h, conn, nconn, false, &storage );
4208 if( MB_SUCCESS != rval )
4209 printf( " <ERROR %2d>%*s", (int)rval, clen - 10, "" );
4210 else
4211 {
4212 for( int j = 0; j < nconn; ++j )
4213 printf( " %4d", (int)ID_FROM_HANDLE( conn[j] ) );
4214 printf( "%*s", clen - 5 * nconn, "" );
4215 }
4216
4217 rval = a_entity_factory()->get_adjacencies( h, adj, nadj );
4218 if( MB_SUCCESS != rval )
4219 {
4220 printf( " <ERROR %d>\n", (int)rval );
4221 continue;
4222 }
4223 EntityType pt = MBMAXTYPE;
4224 for( int j = 0; j < nadj; ++j )
4225 {
4226 if( TYPE_FROM_HANDLE( adj[j] ) != pt )
4227 {
4228 pt = TYPE_FROM_HANDLE( adj[j] );
4229 printf( " %s", pt >= MBMAXTYPE ? "INVALID TYPE" : CN::EntityTypeName( pt ) );
4230 }
4231 printf( " %d", (int)ID_FROM_HANDLE( adj[j] ) );
4232 }
4233 printf( "\n" );
4234 }
4235 }
4236 }
4237 }
References moab::TypeSequenceManager::begin(), dashes(), moab::EntitySequence::data(), moab::TypeSequenceManager::empty(), moab::TypeSequenceManager::end(), moab::EntitySequence::end_handle(), moab::SequenceData::end_handle(), moab::CN::EntityTypeName(), ErrorCode, moab::VertexSequence::get_coordinates(), moab::ID_FROM_HANDLE(), MB_SUCCESS, MBEDGE, MBENTITYSET, MBMAXTYPE, MBVERTEX, moab::ElementSequence::nodes_per_element(), moab::EntitySequence::start_handle(), moab::SequenceData::start_handle(), and moab::TYPE_FROM_HANDLE().
ErrorCode moab::Core::print_entity_tags | ( | std::string | indent_prefix, |
const EntityHandle | handle, | ||
TagType | tp | ||
) | const |
Definition at line 3684 of file Core.cpp.
3685 {
3686 std::vector< Tag > set_tags;
3687 ErrorCode result = this->tag_get_tags_on_entity( handle, set_tags );
3688 std::cout << indent_prefix << ( tp == MB_TAG_SPARSE ? "Sparse tags:" : "Dense tags:" ) << std::endl;
3689 indent_prefix += " ";
3690
3691 for( std::vector< Tag >::iterator vit = set_tags.begin(); vit != set_tags.end(); ++vit )
3692 {
3693 TagType this_type;
3694 result = this->tag_get_type( *vit, this_type );
3695 if( MB_SUCCESS != result || tp != this_type ) continue;
3696 DataType this_data_type;
3697 result = this->tag_get_data_type( *vit, this_data_type );
3698 if( MB_SUCCESS != result ) continue;
3699 int this_size;
3700 result = this->tag_get_length( *vit, this_size );
3701 if( MB_SUCCESS != result ) continue;
3702 // use double since this is largest single-valued tag
3703 std::vector< double > dbl_vals( this_size );
3704 std::vector< int > int_vals( this_size );
3705 std::vector< EntityHandle > hdl_vals( this_size );
3706 std::string tag_name;
3707 result = this->tag_get_name( *vit, tag_name );
3708 if( MB_SUCCESS != result ) continue;
3709 switch( this_data_type )
3710 {
3711 case MB_TYPE_INTEGER:
3712 result = this->tag_get_data( *vit, &handle, 1, &int_vals[0] );
3713 if( MB_SUCCESS != result ) continue;
3714 std::cout << indent_prefix << tag_name << " = ";
3715 if( this_size < 10 )
3716 for( int i = 0; i < this_size; i++ )
3717 std::cout << int_vals[i] << " ";
3718 else
3719 std::cout << int_vals[0] << "... (mult values)";
3720 std::cout << std::endl;
3721 break;
3722 case MB_TYPE_DOUBLE:
3723 result = this->tag_get_data( *vit, &handle, 1, &dbl_vals[0] );
3724 if( MB_SUCCESS != result ) continue;
3725 std::cout << indent_prefix << tag_name << " = ";
3726 if( this_size < 10 )
3727 for( int i = 0; i < this_size; i++ )
3728 std::cout << dbl_vals[i] << " ";
3729 else
3730 std::cout << dbl_vals[0] << "... (mult values)";
3731 std::cout << std::endl;
3732 break;
3733 case MB_TYPE_HANDLE:
3734 result = this->tag_get_data( *vit, &handle, 1, &hdl_vals[0] );
3735 if( MB_SUCCESS != result ) continue;
3736 std::cout << indent_prefix << tag_name << " = ";
3737 if( this_size < 10 )
3738 for( int i = 0; i < this_size; i++ )
3739 std::cout << hdl_vals[i] << " ";
3740 else
3741 std::cout << hdl_vals[0] << "... (mult values)";
3742 std::cout << std::endl;
3743 break;
3744 case MB_TYPE_OPAQUE:
3745 if( NAME_TAG_SIZE == this_size )
3746 {
3747 char dum_tag[NAME_TAG_SIZE];
3748 result = this->tag_get_data( *vit, &handle, 1, &dum_tag );
3749 if( MB_SUCCESS != result ) continue;
3750 // insert NULL just in case there isn't one
3751 dum_tag[NAME_TAG_SIZE - 1] = '\0';
3752 std::cout << indent_prefix << tag_name << " = " << dum_tag << std::endl;
3753 }
3754 break;
3755 case MB_TYPE_BIT:
3756 break;
3757 }
3758 }
3759
3760 return MB_SUCCESS;
3761 }
References ErrorCode, MB_SUCCESS, MB_TAG_SPARSE, MB_TYPE_BIT, MB_TYPE_DOUBLE, MB_TYPE_HANDLE, MB_TYPE_INTEGER, MB_TYPE_OPAQUE, NAME_TAG_SIZE, and TagType.
|
virtual |
Get a pointer to an internal MOAB interface.
Implements moab::Interface.
Definition at line 306 of file Core.cpp.
307 {
308 if( interface_type == typeid( ReadUtilIface ) )
309 {
310 if( !mMBReadUtil ) mMBReadUtil = new ReadUtil( this, mError );
311 ptr = static_cast< ReadUtilIface* >( mMBReadUtil );
312 }
313 else if( interface_type == typeid( WriteUtilIface ) )
314 {
315 if( !mMBWriteUtil ) mMBWriteUtil = new WriteUtil( this );
316 ptr = static_cast< WriteUtilIface* >( mMBWriteUtil );
317 }
318 else if( interface_type == typeid( ReaderWriterSet ) )
319 {
320 ptr = reader_writer_set();
321 }
322 else if( interface_type == typeid( Error ) )
323 {
324 ptr = mError;
325 }
326 else if( interface_type == typeid( ExoIIInterface ) )
327 {
328 ptr = static_cast< ExoIIInterface* >( new ExoIIUtil( this ) );
329 }
330 else if( interface_type == typeid( ScdInterface ) )
331 {
332 if( !scdInterface ) scdInterface = new ScdInterface( this );
333 ptr = scdInterface;
334 }
335 else
336 {
337 ptr = 0;
338 return MB_FAILURE;
339 }
340 return MB_SUCCESS;
341 }
References MB_SUCCESS.
|
virtual |
Implements moab::UnknownInterface.
Definition at line 355 of file Core.cpp.
356 {
357 *iface = 0;
358 if( uuid == IDD_MBUnknown ) *iface = this;
359 if( uuid == IDD_MBCore )
360 *iface = this;
361 else
362 return 0;
363 return 1;
364 }
References moab::IDD_MBCore, moab::IDD_MBUnknown, and iface.
Referenced by moab::ComponentFactory::QueryInterface().
|
inline |
return set of registered IO tools
Definition at line 1090 of file Core.hpp.
1091 {
1092 return readerWriterSet;
1093 }
References readerWriterSet.
|
virtual |
Release reference to MB interface.
Implements moab::Interface.
Definition at line 343 of file Core.cpp.
344 {
345 if( interface_type == typeid( ExoIIInterface ) )
346 delete static_cast< ExoIIInterface* >( iface );
347 else if( interface_type != typeid( ReadUtilIface ) && interface_type != typeid( WriteUtilIface ) &&
348 interface_type != typeid( ReaderWriterSet ) && interface_type != typeid( Error ) &&
349 interface_type != typeid( ScdInterface ) )
350 return MB_FAILURE;
351
352 return MB_SUCCESS;
353 }
References iface, and MB_SUCCESS.
|
virtual |
remove child meshset
Implements moab::Interface.
Definition at line 3604 of file Core.cpp.
3605 {
3606 MeshSet* set_ptr = get_mesh_set( sequence_manager(), meshset );
3607 if( !set_ptr ) return MB_ENTITY_NOT_FOUND;
3608 set_ptr->remove_child( child_meshset );
3609 return MB_SUCCESS;
3610 }
References moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, MB_SUCCESS, and moab::MeshSet::remove_child().
|
virtual |
remove entities from meshset
remove a vector of entities from a meshset
Implements moab::Interface.
Definition at line 3372 of file Core.cpp.
3373 {
3374 MeshSet* set = get_mesh_set( sequence_manager(), meshset );
3375 if( set )
3376 return set->remove_entities( entities, num_entities, meshset, a_entity_factory() );
3377 else
3378 return MB_ENTITY_NOT_FOUND;
3379 }
References entities, moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and moab::MeshSet::remove_entities().
|
virtual |
remove entities from meshset
remove a range of entities from a meshset
Implements moab::Interface.
Definition at line 3362 of file Core.cpp.
3363 {
3364 MeshSet* set = get_mesh_set( sequence_manager(), meshset );
3365 if( set )
3366 return set->remove_entities( entities, meshset, a_entity_factory() );
3367 else
3368 return MB_ENTITY_NOT_FOUND;
3369 }
References entities, moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and moab::MeshSet::remove_entities().
Referenced by main(), moab::AEntityFactory::remove_adjacency(), moab::ReorderTool::update_set_contents(), and moab::NestedRefine::update_special_tags().
|
virtual |
removes 'parent' to child's parent list and removes 'child' to parent's child list
Implements moab::Interface.
Definition at line 3585 of file Core.cpp.
3586 {
3587 MeshSet* parent_ptr = get_mesh_set( sequence_manager(), parent );
3588 MeshSet* child_ptr = get_mesh_set( sequence_manager(), child );
3589 if( !parent_ptr || !child_ptr ) return MB_ENTITY_NOT_FOUND;
3590
3591 parent_ptr->remove_child( child );
3592 child_ptr->remove_parent( parent );
3593 return MB_SUCCESS;
3594 }
References child, moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, MB_SUCCESS, moab::MeshSet::remove_child(), and moab::MeshSet::remove_parent().
|
virtual |
remove parent meshset
Implements moab::Interface.
Definition at line 3596 of file Core.cpp.
3597 {
3598 MeshSet* set_ptr = get_mesh_set( sequence_manager(), meshset );
3599 if( !set_ptr ) return MB_ENTITY_NOT_FOUND;
3600 set_ptr->remove_parent( parent_meshset );
3601 return MB_SUCCESS;
3602 }
References moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, MB_SUCCESS, and moab::MeshSet::remove_parent().
ErrorCode moab::Core::remove_set_iterator | ( | SetIterator * | set_iter | ) |
Remove the set iterator from the instance's list.
Remove the set iterator from the instance's list This function is called from the SetIterator destructor, and should not be called directly from anywhere else.
set_iter | Set iterator being removed |
Definition at line 3899 of file Core.cpp.
3900 {
3901 std::vector< SetIterator* >::iterator vit = std::find( setIterators.begin(), setIterators.end(), set_iter );
3902 if( vit == setIterators.end() )
3903 {
3904 MB_SET_ERR( MB_FAILURE, "Didn't find that iterator" );
3905 }
3906
3907 setIterators.erase( vit );
3908
3909 return MB_SUCCESS;
3910 }
References MB_SET_ERR, and MB_SUCCESS.
Referenced by moab::SetIterator::~SetIterator().
|
virtual |
replace entities
Implements moab::Interface.
Definition at line 3396 of file Core.cpp.
3400 {
3401 MeshSet* set = get_mesh_set( sequence_manager(), meshset );
3402 if( set )
3403 return set->replace_entities( meshset, old_entities, new_entities, num_entities, a_entity_factory() );
3404 else
3405 return MB_ENTITY_NOT_FOUND;
3406 }
References moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and moab::MeshSet::replace_entities().
Referenced by moab::AEntityFactory::merge_adjust_adjacencies().
|
inline |
get/set the number of nodes
get/set the number of elements return a reference to the sequence manager
Definition at line 1039 of file Core.hpp.
1040 {
1041 return sequenceManager;
1042 }
References sequenceManager.
Referenced by moab::HigherOrderFactory::add_mid_edge_nodes(), moab::HigherOrderFactory::add_mid_face_nodes(), moab::HigherOrderFactory::add_mid_volume_nodes(), moab::ScdInterface::construct_box(), moab::HigherOrderFactory::convert(), moab::HigherOrderFactory::convert_sequence(), moab::ReadUtil::create_entity_sets(), moab::ScdInterface::create_scd_sequence(), moab::WriteUtil::gather_nodes_from_elements(), moab::AEntityFactory::get_adjacency_ptr(), moab::ReadUtil::get_element_connect(), moab::WriteUtil::get_element_connect(), moab::ReorderTool::get_entities(), moab::WriteUtil::get_entity_list_pointers(), moab::AEntityFactory::get_memory_use(), moab::ReadUtil::get_node_coords(), moab::WriteUtil::get_node_coords(), moab::ReorderTool::handle_order_from_int_tag(), moab::ParallelComm::initialize(), moab::ReorderTool::reorder_entities(), moab::AEntityFactory::set_adjacency_ptr(), and moab::AEntityFactory::~AEntityFactory().
|
inline |
Definition at line 1043 of file Core.hpp.
1044 {
1045 return sequenceManager;
1046 }
References sequenceManager.
ErrorCode moab::Core::serial_load_file | ( | const char * | file_name, |
const EntityHandle * | file_set, | ||
const FileOptions & | opts, | ||
const ReaderIface::SubsetList * | subsets = 0 , |
||
const Tag * | file_id_tag = 0 |
||
) |
Load or import a file.
Definition at line 511 of file Core.cpp.
516 {
517 int status;
518 #if defined( WIN32 ) || defined( WIN64 ) || defined( MSC_VER )
519 struct _stat stat_data;
520 status = _stat( file_name, &stat_data );
521 #else
522 struct stat stat_data;
523 status = stat( file_name, &stat_data );
524 #endif
525 if( status )
526 {
527 MB_SET_GLB_ERR( MB_FILE_DOES_NOT_EXIST, file_name << ": " << strerror( errno ) );
528 }
529 #if defined( WIN32 ) || defined( WIN64 ) || defined( MSC_VER )
530 else if( stat_data.st_mode & _S_IFDIR )
531 {
532 #else
533 else if( S_ISDIR( stat_data.st_mode ) )
534 {
535 #endif
536 MB_SET_GLB_ERR( MB_FILE_DOES_NOT_EXIST, file_name << ": Cannot read directory/folder" );
537 }
538
539 const ReaderWriterSet* set = reader_writer_set();
540
541 Range initial_ents;
542 ErrorCode rval = get_entities_by_handle( 0, initial_ents );MB_CHK_ERR( rval );
543
544 std::vector< Tag > initial_tags;
545 rval = tag_get_tags( initial_tags );MB_CHK_ERR( rval );
546
547 // otherwise try using the file extension to select a reader
548 std::string ext = set->extension_from_filename( file_name );
549
550 // Try all the readers
551 ReaderWriterSet::iterator iter;
552 rval = MB_FAILURE;
553 bool tried_one = false;
554 for( iter = set->begin(); iter != set->end(); ++iter )
555 {
556 if( !iter->reads_extension( ext.c_str() ) ) continue;
557
558 ReaderIface* reader = iter->make_reader( this );
559 if( NULL != reader )
560 {
561 tried_one = true;
562 rval = reader->load_file( file_name, file_set, opts, subsets, id_tag );
563 delete reader;
564 if( MB_SUCCESS == rval ) break;
565 clean_up_failed_read( initial_ents, initial_tags );
566 }
567 }
568
569 if( MB_SUCCESS != rval && !tried_one )
570 {
571 // didn't recognize the extension; try all of them now
572 for( iter = set->begin(); iter != set->end(); ++iter )
573 {
574 ReaderIface* reader = iter->make_reader( this );
575 if( !reader ) continue;
576 rval = reader->load_file( file_name, file_set, opts, subsets, id_tag );
577 delete reader;
578 if( MB_SUCCESS == rval )
579 break;
580 else
581 clean_up_failed_read( initial_ents, initial_tags );
582 }
583 }
584
585 if( MB_SUCCESS != rval )
586 {
587 clean_up_failed_read( initial_ents, initial_tags );
588 MB_SET_ERR( rval, "Failed to load file after trying all possible readers" );
589 }
590 else if( file_set )
591 {
592 Range new_ents;
593 get_entities_by_handle( 0, new_ents );
594 new_ents = subtract( new_ents, initial_ents );
595
596 // Check if gather set exists
597 EntityHandle gather_set;
598 rval = mMBReadUtil->get_gather_set( gather_set );
599 if( MB_SUCCESS == rval )
600 {
601 // Exclude gather set itself
602 new_ents.erase( gather_set );
603
604 // Exclude gather set entities
605 Range gather_ents;
606 rval = get_entities_by_handle( gather_set, gather_ents );
607 if( MB_SUCCESS == rval ) new_ents = subtract( new_ents, gather_ents );
608 }
609
610 rval = add_entities( *file_set, new_ents );
611 }
612
613 return rval;
614 } // namespace moab
References moab::ReaderWriterSet::begin(), moab::ReaderWriterSet::end(), moab::Range::erase(), ErrorCode, moab::ReaderWriterSet::extension_from_filename(), moab::ReaderIface::load_file(), MB_CHK_ERR, MB_FILE_DOES_NOT_EXIST, MB_SET_ERR, MB_SET_GLB_ERR, MB_SUCCESS, and moab::subtract().
Referenced by moab::ReadParallel::load_file().
ErrorCode moab::Core::serial_read_tag | ( | const char * | file_name, |
const char * | tag_name, | ||
const FileOptions & | opts, | ||
std::vector< int > & | tag_vals, | ||
const ReaderIface::SubsetList * | subsets = 0 |
||
) |
Definition at line 616 of file Core.cpp.
621 {
622 ErrorCode rval = MB_FAILURE;
623 const ReaderWriterSet* set = reader_writer_set();
624
625 // otherwise try using the file extension to select a reader
626 ReaderIface* reader = set->get_file_extension_reader( file_name );
627 if( reader )
628 {
629 rval = reader->read_tag_values( file_name, tag_name, opts, vals, subsets );
630 delete reader;
631 }
632 else
633 {
634 // Try all the readers
635 ReaderWriterSet::iterator iter;
636 for( iter = set->begin(); iter != set->end(); ++iter )
637 {
638 reader = iter->make_reader( this );
639 if( NULL != reader )
640 {
641 rval = reader->read_tag_values( file_name, tag_name, opts, vals, subsets );
642 delete reader;
643 if( MB_SUCCESS == rval ) break;
644 }
645 }
646 }
647
648 return rval;
649 }
References moab::ReaderWriterSet::begin(), moab::ReaderWriterSet::end(), ErrorCode, moab::ReaderWriterSet::get_file_extension_reader(), MB_SUCCESS, and moab::ReaderIface::read_tag_values().
|
virtual |
Sets the connectivity for an EntityHandle. For non-element handles, return an error.
set the connectivity for element handles. For non-element handles, return an error
Connectivity is stored exactly as it is ordered in vector connectivity.
entity_handle | EntityHandle to set connectivity of. |
connect | Vector containing new connectivity of entity_handle. |
num_connect | Number of vertices in connect |
Example:
std::vector<EntityHandle> conn(3);
conn[0] = node1;
conn[1] = node2;
conn[2] = node3;
set_connectivity( entity_handle, conn, 3 );
Implements moab::Interface.
Definition at line 1214 of file Core.cpp.
1215 {
1216 ErrorCode status = MB_FAILURE;
1217
1218 // Make sure the entity should have a connectivity.
1219 // WARNING: This is very dependent on the ordering of the EntityType enum
1220 EntityType entity_type = TYPE_FROM_HANDLE( entity_handle );
1221
1222 EntitySequence* seq = 0;
1223
1224 if( entity_type < MBVERTEX || entity_type > MBENTITYSET ) return MB_TYPE_OUT_OF_RANGE;
1225
1226 status = sequence_manager()->find( entity_handle, seq );
1227 if( seq == 0 || status != MB_SUCCESS ) return ( status != MB_SUCCESS ? status : MB_ENTITY_NOT_FOUND );
1228
1229 const EntityHandle* old_conn;
1230 int len;
1231 status = static_cast< ElementSequence* >( seq )->get_connectivity( entity_handle, old_conn, len );MB_CHK_ERR( status );
1232
1233 aEntityFactory->notify_change_connectivity( entity_handle, old_conn, connect, num_connect );
1234
1235 status = static_cast< ElementSequence* >( seq )->set_connectivity( entity_handle, connect, num_connect );
1236 if( status != MB_SUCCESS )
1237 aEntityFactory->notify_change_connectivity( entity_handle, connect, old_conn, num_connect );
1238
1239 return status;
1240 }
References ErrorCode, MB_CHK_ERR, MB_ENTITY_NOT_FOUND, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MBENTITYSET, and moab::TYPE_FROM_HANDLE().
Referenced by moab::AEntityFactory::merge_adjust_adjacencies(), and moab::ReorderTool::reorder_entities().
|
virtual |
set the coordinate information for this handle if it is of type Vertex otherwise, return an error
Implements moab::Interface.
Definition at line 1048 of file Core.cpp.
1049 {
1050
1051 ErrorCode status = MB_SUCCESS;
1052
1053 int i, j = 0;
1054
1055 for( i = 0; i < num_entities; i++ )
1056 {
1057 if( TYPE_FROM_HANDLE( entity_handles[i] ) == MBVERTEX )
1058 {
1059 EntitySequence* seq = 0;
1060 status = sequence_manager()->find( entity_handles[i], seq );
1061
1062 if( seq != 0 && status == MB_SUCCESS )
1063 {
1064 status = static_cast< VertexSequence* >( seq )->set_coordinates( entity_handles[i], coords[j],
1065 coords[j + 1], coords[j + 2] );
1066 j += 3;
1067 }
1068 }
1069 else if( status == MB_SUCCESS )
1070 status = MB_TYPE_OUT_OF_RANGE;
1071 }
1072
1073 return status;
1074 }
References ErrorCode, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MBVERTEX, and moab::TYPE_FROM_HANDLE().
Referenced by main(), perform_laplacian_smoothing(), perform_lloyd_relaxation(), and moab::ReorderTool::reorder_entities().
set the coordinate information for this handle if it is of type Vertex otherwise, return an error
Implements moab::Interface.
Definition at line 1078 of file Core.cpp.
1079 {
1080
1081 ErrorCode status = MB_SUCCESS;
1082
1083 int j = 0;
1084
1085 for( Range::iterator rit = entity_handles.begin(); rit != entity_handles.end(); ++rit )
1086 {
1087 if( TYPE_FROM_HANDLE( *rit ) == MBVERTEX )
1088 {
1089 EntitySequence* seq = 0;
1090 status = sequence_manager()->find( *rit, seq );
1091
1092 if( seq != 0 && status == MB_SUCCESS )
1093 {
1094 status = static_cast< VertexSequence* >( seq )->set_coordinates( *rit, coords[j], coords[j + 1],
1095 coords[j + 2] );
1096 j += 3;
1097 }
1098 }
1099 else if( status == MB_SUCCESS )
1100 status = MB_TYPE_OUT_OF_RANGE;
1101 }
1102
1103 return status;
1104 }
References moab::Range::begin(), moab::Range::end(), ErrorCode, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MBVERTEX, and moab::TYPE_FROM_HANDLE().
|
virtual |
set overall geometric dimension
Returns error if setting to 3 dimensions, mesh has been created, and there are only 2 dimensions on that mesh
Implements moab::Interface.
Definition at line 777 of file Core.cpp.
778 {
779 // check to see if current dimension is smaller
780 if( geometricDimension < dim )
781 {
782 // need to check the number of entities
783 int num;
784 /*ErrorCode result = */ get_number_entities_by_dimension( 0, geometricDimension, num );
785
786 // test written to be more readable but possibly less efficient
787 // if (MB_SUCCESS != result) return MB_FAILURE;
788 // else if (0 != num && dim == 2 && ycoordTag == 0) return MB_FAILURE;
789 // else if (0 != num && dim == 3 && (ycoordTag == 0 || zcoordTag == 0)) return MB_FAILURE;
790 // TODO -- replace this with not using xcoordTag, etc...
791 }
792
793 // if we got here, it's ok to set dimension
794 geometricDimension = dim;
795 return MB_SUCCESS;
796 }
References dim, and MB_SUCCESS.
|
virtual |
set the options of a mesh set
Implements moab::Interface.
Definition at line 3278 of file Core.cpp.
3279 {
3280 MeshSet* set = get_mesh_set( sequence_manager(), ms_handle );
3281 if( !set ) return MB_ENTITY_NOT_FOUND;
3282
3283 return set->set_flags( setoptions, ms_handle, a_entity_factory() );
3284 }
References moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and moab::MeshSet::set_flags().
|
virtual |
Interface to control memory allocation for sequences Provide a factor that controls the size of the sequence that gets allocated. This is typically useful in the parallel setting when a-priori, the number of ghost entities and the memory required for them within the same sequence as the owned entities are unknown. The default factor is 1.0 but this can be appropriately updated at runtime so that we do not have broken sequences.
meshset | User specified multiplier (should be greater than 1.0) |
Implements moab::Interface.
Definition at line 1111 of file Core.cpp.
1112 {
1113 assert( factor >= 1.0 );
1114 sequenceManager->set_sequence_multiplier( factor );
1115 }
|
virtual |
given an entity and a target dimension & side number, get that entity
Implements moab::Interface.
Definition at line 3205 of file Core.cpp.
3209 {
3210 // get a handle on the connectivity
3211 const EntityHandle* verts;
3212 int num_verts;
3213 ErrorCode result = get_connectivity( source_entity, verts, num_verts );MB_CHK_ERR( result );
3214
3215 // special case for vertices
3216 if( dim == 0 )
3217 {
3218 if( sd_number < num_verts )
3219 {
3220 target_entity = verts[sd_number];
3221 return MB_SUCCESS;
3222 }
3223
3224 else
3225 return MB_INDEX_OUT_OF_RANGE;
3226 }
3227
3228 // get the vertices comprising the target entity
3229 Range side_verts, target_ents;
3230 const EntityType source_type = TYPE_FROM_HANDLE( source_entity );
3231 // first get the indices
3232 std::vector< int > vertex_indices;
3233
3234 int temp_result = CN::AdjacentSubEntities( source_type, &sd_number, 1, dim, 0, vertex_indices );
3235 if( 0 != temp_result ) return MB_FAILURE;
3236 // now get the actual vertices
3237 for( unsigned int i = 0; i < vertex_indices.size(); i++ )
3238 side_verts.insert( verts[vertex_indices[i]] );
3239
3240 // now look for an entity of the correct type
3241 // use const_cast here 'cuz we're in a const function and we're passing 'false' for
3242 // create_if_missing, so we know we won't change anything
3243 result = ( const_cast< Core* >( this ) )->get_adjacencies( side_verts, dim, false, target_ents );
3244 if( MB_SUCCESS != result && MB_MULTIPLE_ENTITIES_FOUND != result ) return result;
3245
3246 if( !target_ents.empty() && TYPE_FROM_HANDLE( *( target_ents.begin() ) ) != MBVERTEX &&
3247 TYPE_FROM_HANDLE( *( target_ents.begin() ) ) !=
3248 CN::mConnectivityMap[source_type][dim - 1].target_type[sd_number] )
3249 return MB_ENTITY_NOT_FOUND;
3250
3251 if( !target_ents.empty() ) target_entity = *( target_ents.begin() );
3252
3253 return result;
3254 }
References moab::CN::AdjacentSubEntities(), moab::Range::begin(), dim, moab::Range::empty(), ErrorCode, moab::Range::insert(), MB_CHK_ERR, MB_ENTITY_NOT_FOUND, MB_INDEX_OUT_OF_RANGE, MB_MULTIPLE_ENTITIES_FOUND, MB_SUCCESS, MBVERTEX, moab::CN::mConnectivityMap, moab::CN::ConnMap::target_type, and moab::TYPE_FROM_HANDLE().
Referenced by moab::HigherOrderFactory::tag_for_deletion().
|
virtual |
function to get the side number given two elements; returns MB_FAILURE if child not related to parent; does not create adjacencies between parent and child
Implements moab::Interface.
Definition at line 3011 of file Core.cpp.
3016 {
3017 // get the connectivity of parent and child
3018 const EntityHandle *parent_conn = NULL, *child_conn = NULL;
3019 int num_parent_vertices = 0, num_child_vertices = 0;
3020 ErrorCode result = get_connectivity( parent, parent_conn, num_parent_vertices, true );
3021 if( MB_NOT_IMPLEMENTED == result )
3022 {
3023 static std::vector< EntityHandle > tmp_connect( CN::MAX_NODES_PER_ELEMENT );
3024 result = get_connectivity( parent, parent_conn, num_parent_vertices, true, &tmp_connect );
3025 }
3026 if( MB_SUCCESS != result ) return result;
3027
3028 if( TYPE_FROM_HANDLE( child ) == MBVERTEX )
3029 {
3030 int child_index = std::find( parent_conn, parent_conn + num_parent_vertices, child ) - parent_conn;
3031 if( child_index == num_parent_vertices )
3032 {
3033 sd_number = -1;
3034 sense = 0;
3035 return MB_FAILURE;
3036 }
3037 else
3038 {
3039 sd_number = child_index;
3040 sense = 1;
3041 return MB_SUCCESS;
3042 }
3043 }
3044
3045 if( TYPE_FROM_HANDLE( parent ) == MBPOLYHEDRON )
3046 {
3047 // find the child in the parent_conn connectivity list, and call it a day ..
3048 // it should work only for faces within a conn list
3049 for( int i = 0; i < num_parent_vertices; i++ )
3050 if( child == parent_conn[i] )
3051 {
3052 sd_number = i;
3053 sense = 1; // always
3054 offset = 0;
3055 return MB_SUCCESS;
3056 }
3057 return MB_FAILURE;
3058 }
3059 result = get_connectivity( child, child_conn, num_child_vertices, true );MB_CHK_ERR( result );
3060
3061 // call handle vector-based function
3062 if( TYPE_FROM_HANDLE( parent ) != MBPOLYGON && TYPE_FROM_HANDLE( parent ) != MBPOLYHEDRON )
3063 {
3064
3065 // find indices into parent_conn for each entry in child_conn
3066 int child_conn_indices[10];
3067 assert( (unsigned)num_child_vertices <= sizeof( child_conn_indices ) / sizeof( child_conn_indices[0] ) );
3068 for( int i = 0; i < num_child_vertices; ++i )
3069 {
3070 child_conn_indices[i] =
3071 std::find( parent_conn, parent_conn + num_parent_vertices, child_conn[i] ) - parent_conn;
3072 if( child_conn_indices[i] >= num_parent_vertices )
3073 {
3074 sd_number = -1;
3075 return MB_FAILURE;
3076 }
3077 }
3078
3079 int temp_result = CN::SideNumber( TYPE_FROM_HANDLE( parent ), child_conn_indices, num_child_vertices,
3080 CN::Dimension( TYPE_FROM_HANDLE( child ) ), sd_number, sense, offset );
3081 return ( 0 == temp_result ? MB_SUCCESS : MB_FAILURE );
3082 }
3083 else if( TYPE_FROM_HANDLE( parent ) == MBPOLYGON )
3084 {
3085 // find location of 1st vertex; this works even for padded vertices
3086 const EntityHandle* first_v = std::find( parent_conn, parent_conn + num_parent_vertices, child_conn[0] );
3087 if( first_v == parent_conn + num_parent_vertices ) return MB_ENTITY_NOT_FOUND;
3088 sd_number = first_v - parent_conn;
3089 offset = sd_number;
3090 if( TYPE_FROM_HANDLE( child ) == MBVERTEX )
3091 {
3092 sense = 0;
3093 return MB_SUCCESS;
3094 }
3095 else if( TYPE_FROM_HANDLE( child ) == MBPOLYGON )
3096 {
3097 bool match = CN::ConnectivityMatch( parent_conn, child_conn, num_parent_vertices, sense, offset );
3098 sd_number = 0;
3099 if( match )
3100 return MB_SUCCESS;
3101 else
3102 return MB_ENTITY_NOT_FOUND;
3103 }
3104 else if( TYPE_FROM_HANDLE( child ) == MBEDGE )
3105 {
3106 // determine the actual number of vertices, for the padded case
3107 // the padded case could be like ABCDEFFF; num_parent_vertices=8,
3108 // actual_num_parent_vertices=6
3109 int actual_num_parent_vertices = num_parent_vertices;
3110 while( actual_num_parent_vertices >= 3 &&
3111 ( parent_conn[actual_num_parent_vertices - 2] == parent_conn[actual_num_parent_vertices - 1] ) )
3112 actual_num_parent_vertices--;
3113
3114 if( parent_conn[( sd_number + 1 ) % num_parent_vertices] == child_conn[1] )
3115 sense = 1;
3116 else if( parent_conn[( sd_number + num_parent_vertices - 1 ) % num_parent_vertices] ==
3117 child_conn[1] ) // this will also cover edge AF for padded case, side will
3118 // be 0, sense -1
3119 sense = -1;
3120 // if edge FA in above example, we should return sd_number = 5, sense 1
3121 else if( ( sd_number == actual_num_parent_vertices - 1 ) && ( child_conn[1] == parent_conn[0] ) )
3122 sense = 1;
3123 else
3124 return MB_ENTITY_NOT_FOUND;
3125 return MB_SUCCESS;
3126 }
3127 }
3128
3129 return MB_FAILURE;
3130 }
References child, moab::CN::ConnectivityMatch(), moab::CN::Dimension(), ErrorCode, moab::CN::MAX_NODES_PER_ELEMENT, MB_CHK_ERR, MB_ENTITY_NOT_FOUND, MB_NOT_IMPLEMENTED, MB_SUCCESS, MBEDGE, MBPOLYGON, MBPOLYHEDRON, MBVERTEX, moab::CN::SideNumber(), and moab::TYPE_FROM_HANDLE().
|
virtual |
subtracts meshset2 from meshset1 - modifies meshset1
Implements moab::Interface.
Definition at line 3316 of file Core.cpp.
3317 {
3318 MeshSet* set1 = get_mesh_set( sequence_manager(), meshset1 );
3319 MeshSet* set2 = get_mesh_set( sequence_manager(), meshset2 );
3320 if( !set1 || !set2 ) return MB_ENTITY_NOT_FOUND;
3321
3322 return set1->subtract( set2, meshset1, a_entity_factory() );
3323 }
References moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and moab::MeshSet::subtract().
|
virtual |
Set tag data given value.
set the data for given EntityHandles and Tag
For a tag, set the values for a list of passed entity handles to the same, specified value.
tag_handle | The tag |
entity_handles | The entity handles for which to set tag values. |
tag_data | A pointer to the tag value. |
tag_sizes | For variable-length tags, the lenght of the tag value. This argument will be ignored for fixed-length tags. |
Implements moab::Interface.
Definition at line 2246 of file Core.cpp.
2251 {
2252 assert( valid_tag_handle( tag_handle ) );
2253 CHECK_MESH_NULL
2254 return tag_handle->clear_data( sequenceManager, mError, entity_handles, num_entities, tag_data,
2255 tag_size * TagInfo::size_from_data_type( tag_handle->get_data_type() ) );
2256 }
References CHECK_MESH_NULL, moab::TagInfo::clear_data(), moab::TagInfo::get_data_type(), and moab::TagInfo::size_from_data_type().
|
virtual |
Set tag data given value.
set the data for given EntityHandles and Tag
For a tag, set the values for a list of passed entity handles to the same, specified value.
tag_handle | The tag |
entity_handles | The entity handles for which to set tag values. |
tag_data | A pointer to the tag value. |
tag_sizes | For variable-length tags, the lenght of the tag value. This argument will be ignored for fixed-length tags. |
Implements moab::Interface.
Definition at line 2259 of file Core.cpp.
2260 {
2261 assert( valid_tag_handle( tag_handle ) );
2262 return tag_handle->clear_data( sequenceManager, mError, entity_handles, tag_data,
2263 tag_size * TagInfo::size_from_data_type( tag_handle->get_data_type() ) );
2264 }
References moab::TagInfo::clear_data(), moab::TagInfo::get_data_type(), and moab::TagInfo::size_from_data_type().
Removes the tag from the database and deletes all of its associated data.
removes the tag from MB
Implements moab::Interface.
Definition at line 2464 of file Core.cpp.
2465 {
2466 std::list< TagInfo* >::iterator i = std::find( tagList.begin(), tagList.end(), tag_handle );
2467 if( i == tagList.end() ) return MB_TAG_NOT_FOUND;
2468
2469 ErrorCode rval = tag_handle->release_all_data( sequenceManager, mError, true );MB_CHK_ERR( rval );
2470
2471 tagList.erase( i );
2472 delete tag_handle;
2473 return MB_SUCCESS;
2474 }
References ErrorCode, MB_CHK_ERR, MB_SUCCESS, MB_TAG_NOT_FOUND, and moab::TagInfo::release_all_data().
Referenced by moab::HigherOrderFactory::convert_sequence(), moab::WriteUtil::gather_nodes_from_elements(), moab::ReorderTool::handle_order_from_int_tag(), moab::ReorderTool::handle_order_from_sets_and_adj(), main(), and perform_lloyd_relaxation().
|
virtual |
Delete the data of a vector of entity handles and sparse tag.
removes the tag from the entity
Delete the data of a tag on a vector of entity handles. Only sparse tag data are deleted with this function; dense tags are deleted by deleting the tag itself using tag_delete.
tag_handle | Handle of the (sparse) tag being deleted from entity |
entity_handles | 1d vector of entity handles from which the tag is being deleted |
num_handles | Number of entity handles in 1d vector |
Implements moab::Interface.
Definition at line 2449 of file Core.cpp.
2450 {
2451 assert( valid_tag_handle( tag_handle ) );
2452 CHECK_MESH_NULL
2453 return tag_handle->remove_data( sequenceManager, mError, entity_handles, num_entities );
2454 }
References CHECK_MESH_NULL, and moab::TagInfo::remove_data().
Referenced by process_partition_file(), and moab::ReorderTool::reorder_tag_data().
Delete the data of a range of entity handles and sparse tag.
removes the tag from the entity
Delete the data of a tag on a range of entity handles. Only sparse tag data are deleted with this function; dense tags are deleted by deleting the tag itself using tag_delete.
tag_handle | Handle of the (sparse) tag being deleted from entity |
entity_range | Range of entities from which the tag is being deleted |
Implements moab::Interface.
Definition at line 2457 of file Core.cpp.
2458 {
2459 assert( valid_tag_handle( tag_handle ) );
2460 return tag_handle->remove_data( sequenceManager, mError, entity_handles );
2461 }
References moab::TagInfo::remove_data().
|
virtual |
Get pointers to tag data.
return the tag data for a given EntityHandle and Tag
For a tag, get the values for a list of passed entity handles.
tag_handle | The tag |
entity_handles | An array of entity handles for which to retreive tag values. |
num_entities | The length of the 'entity_handles' array. |
tag_data | An array of 'const void*'. Array must be at least 'num_entitities' long. Array is populated (output) with pointers to the internal storage for the tag value corresponding to each entity handle. |
tag_sizes | The length of each tag value. Optional for fixed-length tags. Required for variable-length tags. |
Implements moab::Interface.
Definition at line 2169 of file Core.cpp.
2174 {
2175 assert( valid_tag_handle( tag_handle ) );
2176 CHECK_MESH_NULL
2177 ErrorCode result =
2178 tag_handle->get_data( sequenceManager, mError, entity_handles, num_entities, tag_data, tag_sizes );
2179 int typesize = TagInfo::size_from_data_type( tag_handle->get_data_type() );
2180 if( tag_sizes && typesize != 1 )
2181 for( int i = 0; i < num_entities; ++i )
2182 tag_sizes[i] /= typesize;
2183 return result;
2184 }
References CHECK_MESH_NULL, ErrorCode, moab::TagInfo::get_data(), moab::TagInfo::get_data_type(), and moab::TagInfo::size_from_data_type().
Referenced by moab::ReorderTool::reorder_tag_data(), and test_spectral_hex().
|
virtual |
Get pointers to tag data.
return the tag data for a given EntityHandle and Tag
For a tag, get the values for a list of passed entity handles.
tag_handle | The tag |
entity_handles | The entity handles for which to retreive tag values. |
tag_data | An array of 'const void*'. Array is populated (output) with pointers to the internal storage for the tag value corresponding to each entity handle. |
tag_sizes | The length of each tag value. Optional for fixed-length tags. Required for variable-length tags. |
Implements moab::Interface.
Definition at line 2187 of file Core.cpp.
2191 {
2192 assert( valid_tag_handle( tag_handle ) );
2193 ErrorCode result = tag_handle->get_data( sequenceManager, mError, entity_handles, tag_data, tag_sizes );
2194 int typesize = TagInfo::size_from_data_type( tag_handle->get_data_type() );
2195 if( tag_sizes && typesize != 1 )
2196 {
2197 int num_entities = entity_handles.size();
2198 for( int i = 0; i < num_entities; ++i )
2199 tag_sizes[i] /= typesize;
2200 }
2201 return result;
2202 }
References ErrorCode, moab::TagInfo::get_data(), moab::TagInfo::get_data_type(), moab::Range::size(), and moab::TagInfo::size_from_data_type().
Get the size of the specified tag in bytes.
get size of tag in bytes
Implements moab::Interface.
Definition at line 2504 of file Core.cpp.
2505 {
2506 if( !valid_tag_handle( tag_handle ) ) return MB_TAG_NOT_FOUND;
2507
2508 if( tag_handle->variable_length() )
2509 {
2510 tag_size = MB_VARIABLE_LENGTH;
2511 return MB_VARIABLE_DATA_LENGTH;
2512 }
2513 else if( tag_handle->get_storage_type() == MB_TAG_BIT )
2514 {
2515 tag_size = 1;
2516 return MB_SUCCESS;
2517 }
2518 else
2519 {
2520 tag_size = tag_handle->get_size();
2521 return MB_SUCCESS;
2522 }
2523 }
References moab::TagInfo::get_size(), moab::TagInfo::get_storage_type(), MB_SUCCESS, MB_TAG_BIT, MB_TAG_NOT_FOUND, MB_VARIABLE_DATA_LENGTH, MB_VARIABLE_LENGTH, and moab::TagInfo::variable_length().
Referenced by moab::check_int_tag(), main(), and moab::ReorderTool::reorder_tag_data().
|
virtual |
return the tag data for a given EntityHandle and Tag
Implements moab::Interface.
Definition at line 2133 of file Core.cpp.
2137 {
2138 assert( valid_tag_handle( tag_handle ) );
2139 CHECK_MESH_NULL
2140 return tag_handle->get_data( sequenceManager, mError, entity_handles, num_entities, tag_data );
2141 }
References CHECK_MESH_NULL, and moab::TagInfo::get_data().
Referenced by moab::HigherOrderFactory::convert_sequence(), dot_nodes(), dot_write_id_nodes(), moab::WriteUtil::gather_nodes_from_elements(), moab::WriteUtil::get_adjacencies(), moab::WriteUtil::get_element_connect(), moab::ReorderTool::get_new_handles(), moab::ReorderTool::get_reordered_handles(), moab::ReorderTool::handle_order_from_int_tag(), hcFilter(), moab::ReorderTool::int_order_from_sets_and_adj(), laplacianFilter(), main(), perform_laplacian_smoothing(), perform_lloyd_relaxation(), process_partition_file(), moab::ReorderTool::reorder_tag_data(), tag_depth(), and test_spectral_hex().
|
virtual |
return the tag data for a given EntityHandle and Tag
Implements moab::Interface.
Definition at line 2144 of file Core.cpp.
2145 {
2146 assert( valid_tag_handle( tag_handle ) );
2147 return tag_handle->get_data( sequenceManager, mError, entity_handles, tag_data );
2148 }
References moab::TagInfo::get_data().
Get data type of tag.
Get the type of the tag data. The tag is data is assumed to be a vector of this type. If the tag data vetcor contains more than one value, then the tag size must be a multiple of the size of this type.
tag | The tag |
type | The type of the specified tag (output). |
Implements moab::Interface.
Definition at line 2542 of file Core.cpp.
2543 {
2544 if( !valid_tag_handle( handle ) ) return MB_TAG_NOT_FOUND;
2545
2546 data_type = handle->get_data_type();
2547 return MB_SUCCESS;
2548 }
References moab::TagInfo::get_data_type(), MB_SUCCESS, and MB_TAG_NOT_FOUND.
Referenced by moab::check_int_tag(), main(), and moab::ReorderTool::reorder_tag_data().
Get the default value of the specified tag.
get default value of the tag
Implements moab::Interface.
Definition at line 2551 of file Core.cpp.
2552 {
2553 if( !valid_tag_handle( tag_handle ) ) return MB_TAG_NOT_FOUND;
2554
2555 if( tag_handle->variable_length() ) return MB_VARIABLE_DATA_LENGTH;
2556
2557 if( !tag_handle->get_default_value() ) return MB_ENTITY_NOT_FOUND;
2558
2559 memcpy( def_value, tag_handle->get_default_value(), tag_handle->get_default_value_size() );
2560 return MB_SUCCESS;
2561 }
References moab::TagInfo::get_default_value(), moab::TagInfo::get_default_value_size(), MB_ENTITY_NOT_FOUND, MB_SUCCESS, MB_TAG_NOT_FOUND, MB_VARIABLE_DATA_LENGTH, and moab::TagInfo::variable_length().
Referenced by moab::ReorderTool::reorder_entities().
|
virtual |
Get a tag handle, possibly creating the tag.
Get a handle used to associate application-defined values with MOAB entities. If the tag does not already exist then flags
should contain exactly one of MB_TAG_SPARSE
, MB_TAG_DENSE
, MB_TAG_MESH
unless type
is MB_TYPE_BIT, which implies MB_TAG_BIT
storage.
name | The tag name |
size | Tag size as number of values of of data type per entity (or number of bytes if MB_TAG_BYTES is passed in flags). If MB_TAG_VARLEN is specified, this value is taken to be the size of the default value if one is specified and is otherwise ignored. |
type | The type of the data (used for IO) |
tag_handle | Output: the resulting tag handle. |
flags | Bitwise OR of values from TagType |
default_value | Optional default value for tag. |
created | Optional returned boolean indicating that the tag was created. |
MB_ALREADY_ALLOCATED
if tag exists and MB_TAG_EXCL
is specified, or default values do not match (and MB_TAG_ANY
or MB_TAG_DFTOK
not specified).MB_TAG_NOT_FOUND
if tag does not exist and MB_TAG_CREAT
is not specifiedMB_INVALID_SIZE
if tag value size is not a multiple of the size of the data type (and MB_TAG_ANY
not specified).MB_TYPE_OUT_OF_RANGE
invalid or inconsistent parameterMB_VARIABLE_DATA_LENGTH
if MB_TAG_VARLEN
and default_value
is non-null and default_value_size
is not specified.\NOTE A call to tag_get_handle that includes a default value will fail if the tag already exists with a different default value. A call without a default value will succeed if the tag already exists, regardless of whether or not the existing tag has a default value.
Examples:
Retrieve a handle for an existing tag, returning a non-success error code if the tag does not exist or does not store 1 integer value per entity:
Tag git_tag; mb.tag_get_handle( GLOBAL_ID_TAG_NAME, 1, MB_TYPE_INTEGER, gid_tag );
Get the tag handle, or create it as a dense tag if it does not already exist:
Tag gid_tag; mb.tag_get_handle( GLOBAL_ID_TAG_NAME, 1, MB_TYPE_INTEGER, gid_tag, MB_TAG_CREAT|MB_TAG_BIT );
Create the tag or fail if it already exists:
Tag gid_tag; mb.tag_get_handle( GLOBAL_ID_TAG_NAME, 1, MB_TYPE_INTEGER, gid_tag, MB_TAG_EXCL|MB_TAG_DENSE );
Get an existing variable length tag, failing if it does not exist or is not variable-length or does not contain double values.
Tag vtag; mb.tag_get_handle( *tag_name, 0, MB_TYPE_DOUBLE, vtag );
Get the same variable-length tag, but create it with a default value if it doesn't exist. Note that if the tag already exists this call will return a non-success error code if the existing tag has a different default value.
Tag
*vtag; const double default_val = M_PI; const int def_val_len = 1; mb.tag_get_handle( tag_name,
*def_val_len, MB_TYPE_DOUBLE, vtag, MB_TAG_SPARSE|MB_TAG_VARLEN|MB_TAG_CREAT, &default_val );
Implements moab::Interface.
Definition at line 2563 of file Core.cpp.
2564 {
2565 if( !valid_tag_handle( tag ) ) return MB_ENTITY_NOT_FOUND;
2566
2567 if( !tag->get_default_value() ) return MB_ENTITY_NOT_FOUND;
2568
2569 ptr = tag->get_default_value();
2570 size = tag->get_default_value_size() / TagInfo::size_from_data_type( tag->get_data_type() );
2571 return MB_SUCCESS;
2572 }
References moab::TagInfo::get_data_type(), moab::TagInfo::get_default_value(), moab::TagInfo::get_default_value_size(), MB_ENTITY_NOT_FOUND, MB_SUCCESS, size, and moab::TagInfo::size_from_data_type().
|
virtual |
same as non-const version, except that TAG_CREAT flag is ignored.
Implements moab::Interface.
Definition at line 2414 of file Core.cpp.
2420 {
2421 // If caller specified MB_TAG_EXCL, then we must fail because
2422 // this const function can never create a tag. We need to test
2423 // this here because the non-const version of this function
2424 // assumes MB_TAG_CREAT if MB_TAG_EXCL is specified.
2425 if( flags & MB_TAG_EXCL )
2426 {
2427 // anonymous tag?
2428 if( !name || !*name ) return MB_TAG_NOT_FOUND;
2429
2430 // search for an existing tag
2431 tag_handle = 0;
2432 for( std::list< Tag >::const_iterator i = tagList.begin(); i != tagList.end(); ++i )
2433 {
2434 if( ( *i )->get_name() == name )
2435 {
2436 tag_handle = *i;
2437 return MB_ALREADY_ALLOCATED;
2438 }
2439 }
2440
2441 return MB_TAG_NOT_FOUND;
2442 }
2443
2444 return const_cast< Core* >( this )->tag_get_handle( name, size, data_type, tag_handle,
2445 flags & ~(unsigned)MB_TAG_CREAT, default_value );
2446 }
References MB_ALREADY_ALLOCATED, MB_TAG_CREAT, MB_TAG_EXCL, MB_TAG_NOT_FOUND, and size.
|
virtual |
Get a tag handle, possibly creating the tag.
Get a handle used to associate application-defined values with MOAB entities. If the tag does not already exist then flags
should contain exactly one of MB_TAG_SPARSE
, MB_TAG_DENSE
, MB_TAG_MESH
unless type
is MB_TYPE_BIT, which implies MB_TAG_BIT
storage.
name | The tag name |
size | Tag size as number of values of of data type per entity (or number of bytes if MB_TAG_BYTES is passed in flags). If MB_TAG_VARLEN is specified, this value is taken to be the size of the default value if one is specified and is otherwise ignored. |
type | The type of the data (used for IO) |
tag_handle | Output: the resulting tag handle. |
flags | Bitwise OR of values from TagType |
default_value | Optional default value for tag. |
created | Optional returned boolean indicating that the tag was created. |
MB_ALREADY_ALLOCATED
if tag exists and MB_TAG_EXCL
is specified, or default values do not match (and MB_TAG_ANY
or MB_TAG_DFTOK
not specified).MB_TAG_NOT_FOUND
if tag does not exist and MB_TAG_CREAT
is not specifiedMB_INVALID_SIZE
if tag value size is not a multiple of the size of the data type (and MB_TAG_ANY
not specified).MB_TYPE_OUT_OF_RANGE
invalid or inconsistent parameterMB_VARIABLE_DATA_LENGTH
if MB_TAG_VARLEN
and default_value
is non-null and default_value_size
is not specified. Implements moab::Interface.
Definition at line 2275 of file Core.cpp.
2282 {
2283 if( created ) *created = false;
2284
2285 // we always work with sizes in bytes internally
2286 if( !( ( flags & MB_TAG_VARLEN ) && size == MB_VARIABLE_LENGTH ) )
2287 {
2288 if( flags & MB_TAG_BYTES )
2289 {
2290 if( size % TagInfo::size_from_data_type( data_type ) ) return MB_INVALID_SIZE;
2291 }
2292 else
2293 {
2294 size *= TagInfo::size_from_data_type( data_type );
2295 }
2296 }
2297
2298 const TagType storage = static_cast< TagType >( flags & 3 );
2299
2300 // search for an existing tag
2301 tag_handle = 0;
2302 if( name && *name )
2303 { // not anonymous tag
2304 for( std::list< Tag >::iterator i = tagList.begin(); i != tagList.end(); ++i )
2305 {
2306 if( ( *i )->get_name() == name )
2307 {
2308 tag_handle = *i;
2309 break;
2310 }
2311 }
2312 }
2313
2314 if( tag_handle )
2315 {
2316 if( flags & MB_TAG_EXCL ) return MB_ALREADY_ALLOCATED;
2317 // user asked that we not check anything
2318 if( flags & MB_TAG_ANY ) return MB_SUCCESS;
2319 // user asked that we also match storage types
2320 if( ( flags & MB_TAG_STORE ) && tag_handle->get_storage_type() != storage ) return MB_TYPE_OUT_OF_RANGE;
2321 // check if data type matches
2322 const DataType extype = tag_handle->get_data_type();
2323 if( extype != data_type )
2324 {
2325 if( flags & MB_TAG_NOOPQ )
2326 return MB_TYPE_OUT_OF_RANGE;
2327 else if( extype != MB_TYPE_OPAQUE && data_type != MB_TYPE_OPAQUE )
2328 return MB_TYPE_OUT_OF_RANGE;
2329 }
2330
2331 // Require that the size value be zero or MB_VARIABLE_LENGTH
2332 // for variable length tags. The caller passing such a size
2333 // value is sufficient to indicate that the caller is aware
2334 // that it is requesting a variable-length tag, so no need
2335 // to also require/check the MB_TAG_VARLEN bit in the flags.
2336 if( tag_handle->variable_length() )
2337 {
2338 if( size != 0 && size != MB_VARIABLE_LENGTH && !( flags & MB_TAG_VARLEN ) ) return MB_INVALID_SIZE;
2339 }
2340 // But /do/ fail if MB_TAG_VARLEN flag is set and tag is
2341 // not variable length.
2342 else if( flags & MB_TAG_VARLEN )
2343 return MB_TYPE_OUT_OF_RANGE;
2344 // check size for fixed-length tag
2345 else if( tag_handle->get_size() != size )
2346 return MB_INVALID_SIZE;
2347
2348 // If user passed a default value, check that it matches.
2349 // If user did not pass a default value, assume they're OK
2350 // with the existing one.
2351 // If tag does not have a default value but the user passed
2352 // one, allow it only if the tag is dense and the passed value
2353 // is all zero bytes because dense tags have an implicit default
2354 // value of all zeros in some cases.
2355 if( default_value && !( flags & MB_TAG_DFTOK ) &&
2356 !( tag_handle->equals_default_value( default_value, size ) ||
2357 ( !tag_handle->get_default_value() && tag_handle->get_storage_type() == MB_TAG_DENSE &&
2358 is_zero_bytes( default_value, size ) ) ) )
2359 return MB_ALREADY_ALLOCATED;
2360
2361 return MB_SUCCESS;
2362 }
2363
2364 // MB_TAG_EXCL implies MB_TAG_CREAT
2365 if( !( flags & ( MB_TAG_CREAT | MB_TAG_EXCL ) ) ) return MB_TAG_NOT_FOUND;
2366
2367 // if a non-opaque non-bit type was specified, then the size
2368 // must be multiple of the size of the type
2369 if( ( !( flags & MB_TAG_VARLEN ) || default_value ) &&
2370 ( size <= 0 || ( size % TagInfo::size_from_data_type( data_type ) ) != 0 ) )
2371 return MB_INVALID_SIZE;
2372
2373 // if MB_TYPE_BIT may be used only with MB_TAG_BIT
2374 // if (storage != MB_TAG_BIT && data_type == MB_TYPE_BIT)
2375 // return MB_INVALID_ARG;
2376 if( data_type == MB_TYPE_BIT ) flags &= ~(unsigned)( MB_TAG_DENSE | MB_TAG_SPARSE );
2377
2378 // create the tag
2379 switch( flags & ( MB_TAG_DENSE | MB_TAG_SPARSE | MB_TAG_MESH | MB_TAG_VARLEN ) )
2380 {
2381 case MB_TAG_DENSE | MB_TAG_VARLEN:
2382 tag_handle = VarLenDenseTag::create_tag( sequenceManager, mError, name, data_type, default_value, size );
2383 break;
2384 case MB_TAG_DENSE:
2385 tag_handle = DenseTag::create_tag( sequenceManager, mError, name, size, data_type, default_value );
2386 break;
2387 case MB_TAG_SPARSE | MB_TAG_VARLEN:
2388 tag_handle = new VarLenSparseTag( name, data_type, default_value, size );
2389 break;
2390 case MB_TAG_SPARSE:
2391 tag_handle = new SparseTag( name, size, data_type, default_value );
2392 break;
2393 case MB_TAG_MESH | MB_TAG_VARLEN:
2394 tag_handle = new MeshTag( name, MB_VARIABLE_LENGTH, data_type, default_value, size );
2395 break;
2396 case MB_TAG_MESH:
2397 tag_handle = new MeshTag( name, size, data_type, default_value, size );
2398 break;
2399 case MB_TAG_BIT:
2400 if( MB_TYPE_BIT != data_type && MB_TYPE_OPAQUE != data_type ) return MB_TYPE_OUT_OF_RANGE;
2401 tag_handle = BitTag::create_tag( name, size, default_value );
2402 break;
2403 default: // some illegal combination (multiple storage types, variable-length bit tag, etc.)
2404 return MB_TYPE_OUT_OF_RANGE;
2405 }
2406
2407 if( !tag_handle ) return MB_INVALID_SIZE;
2408
2409 if( created ) *created = true;
2410 tagList.push_back( tag_handle );
2411 return MB_SUCCESS;
2412 }
References moab::BitTag::create_tag(), moab::DenseTag::create_tag(), moab::VarLenDenseTag::create_tag(), moab::TagInfo::equals_default_value(), moab::TagInfo::get_data_type(), moab::TagInfo::get_default_value(), moab::TagInfo::get_size(), moab::TagInfo::get_storage_type(), moab::is_zero_bytes(), MB_ALREADY_ALLOCATED, MB_INVALID_SIZE, MB_SUCCESS, MB_TAG_ANY, MB_TAG_BIT, MB_TAG_BYTES, MB_TAG_CREAT, MB_TAG_DENSE, MB_TAG_EXCL, MB_TAG_MESH, MB_TAG_NOOPQ, MB_TAG_NOT_FOUND, MB_TAG_SPARSE, MB_TAG_STORE, MB_TAG_VARLEN, MB_TYPE_BIT, MB_TYPE_OPAQUE, MB_TYPE_OUT_OF_RANGE, MB_VARIABLE_LENGTH, size, moab::TagInfo::size_from_data_type(), TagType, and moab::TagInfo::variable_length().
Referenced by moab::HigherOrderFactory::convert_sequence(), moab::ReadUtil::create_gather_set(), moab::NestedRefine::create_hm_storage_single_level(), RuntimeContext::create_sv_tags(), moab::WriteUtil::gather_nodes_from_elements(), moab::NestedRefine::generate_hm(), moab::ReadUtil::get_gather_set(), moab::ReorderTool::handle_order_from_int_tag(), moab::ReorderTool::handle_order_from_sets_and_adj(), moab::ReadParallel::load_file(), main(), obbvis_create(), perform_laplacian_smoothing(), perform_lloyd_relaxation(), process_partition_file(), test_spectral_hex(), TestErrorHandling_4(), and moab::NestedRefine::update_special_tags().
Gets the tag handle corresponding to a name.
If a tag of that name does not exist, returns MB_TAG_NOT_FOUND
tag_name | Name of the desired tag. |
tag_handle | Tag handle corresponding to tag_name |
Implements moab::Interface.
Definition at line 2498 of file Core.cpp.
2499 {
2500 return tag_get_handle( tag_name, 0, MB_TYPE_OPAQUE, tag_handle, MB_TAG_ANY );
2501 }
References MB_TAG_ANY, and MB_TYPE_OPAQUE.
Get the array length of a tag.
get size of tag in $values
Implements moab::Interface.
Definition at line 2526 of file Core.cpp.
2527 {
2528 if( !valid_tag_handle( tag_handle ) ) return MB_TAG_NOT_FOUND;
2529
2530 if( tag_handle->variable_length() )
2531 {
2532 tag_size = MB_VARIABLE_LENGTH;
2533 return MB_VARIABLE_DATA_LENGTH;
2534 }
2535 else
2536 {
2537 tag_size = tag_handle->get_size() / TagInfo::size_from_data_type( tag_handle->get_data_type() );
2538 return MB_SUCCESS;
2539 }
2540 }
References moab::TagInfo::get_data_type(), moab::TagInfo::get_size(), MB_SUCCESS, MB_TAG_NOT_FOUND, MB_VARIABLE_DATA_LENGTH, MB_VARIABLE_LENGTH, moab::TagInfo::size_from_data_type(), and moab::TagInfo::variable_length().
Referenced by moab::WriteUtil::get_tag_list(), and main().
Gets the tag name string of the tag_handle.
gets the tag name string for the tag_handle
tag_handle | Tag you want the name of. |
tag_name | Name string of tag_handle. |
Example:
Tag tag_handle = 0;
std::string tag_name = "my_special_tag";
tag_get_name( tag_handle, tag_name ); //gets the Tag from the tag's name string
Implements moab::Interface.
Definition at line 2491 of file Core.cpp.
2492 {
2493 if( !valid_tag_handle( tag_handle ) ) return MB_TAG_NOT_FOUND;
2494 tag_name = tag_handle->get_name();
2495 return MB_SUCCESS;
2496 }
References moab::TagInfo::get_name(), MB_SUCCESS, and MB_TAG_NOT_FOUND.
Referenced by gather_tag_counts(), moab::WriteUtil::get_tag_list(), and main().
get handles for all tags defined
Implements moab::Interface.
Definition at line 2583 of file Core.cpp.
2584 {
2585 std::copy( tagList.begin(), tagList.end(), std::back_inserter( tag_handles ) );
2586 return MB_SUCCESS;
2587 }
References MB_SUCCESS.
Referenced by gather_tag_counts(), moab::WriteUtil::get_tag_list(), main(), and moab::ReorderTool::reorder_entities().
|
virtual |
Get handles for all tags defined on this entity.
Implements moab::Interface.
Definition at line 2590 of file Core.cpp.
2591 {
2592 for( std::list< TagInfo* >::const_iterator i = tagList.begin(); i != tagList.end(); ++i )
2593 if( ( *i )->is_tagged( sequenceManager, entity ) ) tag_handles.push_back( *i );
2594 return MB_SUCCESS;
2595 }
References MB_SUCCESS.
get type of tag (sparse, dense, etc.; 0 = dense, 1 = sparse, 2 = bit, 3 = mesh)
get type of tag (sparse, dense, etc.; 0 = dense, 1 = sparse, 2 = bit, 3 = static)
Implements moab::Interface.
Definition at line 2575 of file Core.cpp.
2576 {
2577 assert( valid_tag_handle( tag_handle ) );
2578 tag_type = tag_handle->get_storage_type();
2579 return MB_SUCCESS;
2580 }
References moab::TagInfo::get_storage_type(), and MB_SUCCESS.
Referenced by main().
|
virtual |
Access tag data via direct pointer into contiguous blocks.
Iteratively obtain direct access to contiguous blocks of tag storage. This function cannot be used with bit tags because of the compressed bit storage. This function cannot be used with variable length tags because it does not provide a mechanism to determine the length of the value for each entity. This function may be used with sparse tags, but if it is used, it will return data for a single entity at a time.
tag_handle | The handle of the tag for which to access data |
iter | The first entity for which to return data. |
end | One past the last entity for which data is desired. |
count | The number of entities for which data was returned |
data_ptr | Output: pointer to tag storage. |
allocate | If true, space for this tag will be allocated, if not it wont |
\Note If this function is called for entities for which no tag value has been set, but for which a default value exists, it will force the allocation of explicit storage for each such entity even though MOAB would normally not explicitly store tag values for such entities.
\Example:
Range ents; // range to iterate over
Tag tag; // tag for which to access data
int bytes;
ErrorCode err = mb.tag_get_size( tag, bytes );
if (err) { ... }
...
Range::iterator iter = ents.begin();
while (iter != ents.end()) {
int count;
// get contiguous block of tag dat
void* ptr;
err = mb.tag_iterate( tag, iter, ents.end(), count, ptr );
if (err) { ... }
// do something with tag data
process_Data( ptr, count );
// advance to next block of data
iter += count;
}
Implements moab::Interface.
Definition at line 2476 of file Core.cpp.
2482 {
2483 Range::const_iterator init = iter;
2484 assert( valid_tag_handle( tag_handle ) );
2485 ErrorCode result = tag_handle->tag_iterate( sequenceManager, mError, iter, end, data_ptr, allocate );
2486 if( MB_SUCCESS == result ) count = iter - init;
2487 return result;
2488 }
References ErrorCode, MB_SUCCESS, and moab::TagInfo::tag_iterate().
Referenced by main(), and TestErrorHandling_4().
|
virtual |
Set tag data given an array of pointers to tag values.
set the data for given EntityHandles and Tag
For a tag, set the values for a list of passed entity handles.
tag_handle | The tag |
entity_handles | An array of entity handles for which to set tag values. |
num_entities | The length of the 'entity_handles' array. |
tag_data | An array of 'const void*'. Array must be at least 'num_entitities' long. Array is expected to contain pointers to tag values for the corresponding EntityHandle in 'entity_handles'. |
tag_sizes | The length of each tag value. Optional for fixed-length tags. Required for variable-length tags. |
Implements moab::Interface.
Definition at line 2205 of file Core.cpp.
2210 {
2211 assert( valid_tag_handle( tag_handle ) );
2212 CHECK_MESH_NULL
2213 std::vector< int > tmp_sizes;
2214 int typesize = TagInfo::size_from_data_type( tag_handle->get_data_type() );
2215 if( typesize != 1 && tag_sizes )
2216 {
2217 tmp_sizes.resize( num_entities );
2218 for( int i = 0; i < num_entities; ++i )
2219 tmp_sizes[i] = tag_sizes[i] * typesize;
2220 tag_sizes = &tmp_sizes[0];
2221 }
2222 return tag_handle->set_data( sequenceManager, mError, entity_handles, num_entities, tag_data, tag_sizes );
2223 }
References CHECK_MESH_NULL, moab::TagInfo::get_data_type(), moab::TagInfo::set_data(), and moab::TagInfo::size_from_data_type().
Referenced by moab::ReorderTool::reorder_tag_data().
|
virtual |
Set tag data given an array of pointers to tag values.
set the data for given EntityHandles and Tag
For a tag, set the values for a list of passed entity handles.
tag_handle | The tag |
entity_handles | The entity handles for which to set tag values. |
tag_data | An array of 'const void*'. Array is expected to contain pointers to tag values for the corresponding EntityHandle in 'entity_handles'. |
tag_sizes | The length of each tag value. Optional for fixed-length tags. Required for variable-length tags. |
Implements moab::Interface.
Definition at line 2226 of file Core.cpp.
2230 {
2231 assert( valid_tag_handle( tag_handle ) );
2232 std::vector< int > tmp_sizes;
2233 int typesize = TagInfo::size_from_data_type( tag_handle->get_data_type() );
2234 if( typesize != 1 && tag_sizes )
2235 {
2236 int num_entities = entity_handles.size();
2237 tmp_sizes.resize( num_entities );
2238 for( int i = 0; i < num_entities; ++i )
2239 tmp_sizes[i] = tag_sizes[i] * typesize;
2240 tag_sizes = &tmp_sizes[0];
2241 }
2242 return tag_handle->set_data( sequenceManager, mError, entity_handles, tag_data, tag_sizes );
2243 }
References moab::TagInfo::get_data_type(), moab::TagInfo::set_data(), moab::Range::size(), and moab::TagInfo::size_from_data_type().
|
virtual |
Sets the data of a given EntityHandle and Tag.
set the data for given EntityHandles and Tag
If the tag_handle and the entity type of entity_handle are not compatible, data of entity_handle never existed and MB_FAILURE is returned.
tag_handle | Tag indicating what data is to be set. |
entity_handle | EntityHandle on which to set tag's data. |
tag_data | Data to set the entity_handle's tag data to. |
Example:
int tag_data = 1004;
tag_set_data( tag_handle, entity_handle, &tag_data );
Implements moab::Interface.
Definition at line 2151 of file Core.cpp.
2155 {
2156 assert( valid_tag_handle( tag_handle ) );
2157 CHECK_MESH_NULL
2158 return tag_handle->set_data( sequenceManager, mError, entity_handles, num_entities, tag_data );
2159 }
References CHECK_MESH_NULL, and moab::TagInfo::set_data().
Referenced by moab::WriteUtil::assign_ids(), moab::ReadUtil::assign_ids(), moab::ReadUtil::create_gather_set(), RuntimeContext::create_sv_tags(), moab::HalfFacetRep::determine_border_vertices(), moab::WriteUtil::gather_nodes_from_elements(), moab::WriteUtil::get_element_connect(), moab::WriteUtil::get_node_coords(), moab::ReorderTool::handle_order_from_int_tag(), moab::ReorderTool::int_order_from_sets_and_adj(), main(), obbvis_create(), perform_laplacian_smoothing(), perform_lloyd_relaxation(), process_partition_file(), moab::HigherOrderFactory::remove_ho_nodes(), moab::ReorderTool::reorder_tag_data(), and tag_depth().
|
virtual |
set the data for given EntityHandles and Tag
Implements moab::Interface.
Definition at line 2162 of file Core.cpp.
2163 {
2164 assert( valid_tag_handle( tag_handle ) );
2165 return tag_handle->set_data( sequenceManager, mError, entity_handles, tag_data );
2166 }
References moab::TagInfo::set_data().
|
virtual |
get the type from a handle, returns type
Implements moab::Interface.
Definition at line 374 of file Core.cpp.
375 {
376 if( !handle ) // root set
377 return MBENTITYSET;
378 else
379 return TYPE_FROM_HANDLE( handle );
380 }
References MBENTITYSET, and moab::TYPE_FROM_HANDLE().
Referenced by moab::HalfFacetRep::add_cells_of_single_component(), moab::HalfFacetRep::another_halfedge(), moab::NestedRefine::child_to_parent(), moab::HalfFacetRep::collect_and_compare(), moab::NestedRefine::compute_coordinates(), moab::NestedRefine::construct_hm_2D(), moab::NestedRefine::construct_hm_3D(), moab::NestedRefine::create_hm_storage_single_level(), moab::HalfFacetRep::determine_border_vertices(), moab::HalfFacetRep::determine_incident_halfedges(), moab::HalfFacetRep::determine_sibling_halfedges(), moab::HalfFacetRep::determine_sibling_halffaces(), moab::NestedRefine::estimate_hm_storage(), moab::HalfFacetRep::find_matching_halfedge(), moab::HalfFacetRep::find_matching_halfface(), moab::HalfFacetRep::find_matching_implicit_edge_in_cell(), moab::HalfFacetRep::find_total_edges_2d(), moab::WriteUtil::gather_nodes_from_elements(), moab::NestedRefine::get_connectivity(), moab::HalfFacetRep::get_down_adjacencies_2d(), moab::HalfFacetRep::get_face_edges(), moab::HalfFacetRep::get_half_facet_in_comp(), moab::HalfFacetRep::get_index_in_lmap(), moab::HalfFacetRep::get_neighbor_adjacencies_2d(), moab::HalfFacetRep::get_neighbor_adjacencies_3d(), moab::HalfFacetRep::get_up_adjacencies_2d(), moab::HalfFacetRep::get_up_adjacencies_edg_3d(), moab::HalfFacetRep::get_up_adjacencies_edg_3d_comp(), moab::HalfFacetRep::get_up_adjacencies_face_3d(), moab::HalfFacetRep::get_up_adjacencies_vert_2d(), moab::HalfFacetRep::get_up_adjacencies_vert_3d(), moab::HalfFacetRep::init_surface(), moab::NestedRefine::initialize(), moab::NestedRefine::is_entity_on_boundary(), main(), moab::HalfFacetRep::mark_halfedges(), moab::NestedRefine::parent_to_child(), perform_laplacian_smoothing(), moab::HalfFacetRep::print_tags(), moab::HalfFacetRep::resize_hf_maps(), moab::NestedRefine::update_global_ahf_2D(), moab::NestedRefine::update_global_ahf_2D_sub(), moab::NestedRefine::update_global_ahf_3D(), moab::NestedRefine::update_special_tags(), and moab::NestedRefine::update_tracking_verts().
|
virtual |
unites meshset2 with meshset1 - modifies meshset1
Implements moab::Interface.
Definition at line 3334 of file Core.cpp.
3335 {
3336 MeshSet* set1 = get_mesh_set( sequence_manager(), meshset1 );
3337 MeshSet* set2 = get_mesh_set( sequence_manager(), meshset2 );
3338 if( !set1 || !set2 ) return MB_ENTITY_NOT_FOUND;
3339
3340 return set1->unite( set2, meshset1, a_entity_factory() );
3341 }
References moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and moab::MeshSet::unite().
|
inlineprivate |
|
virtual |
Write or export a file
Implements moab::Interface.
Definition at line 669 of file Core.cpp.
675 {
676 // convert range to vector
677 std::vector< EntityHandle > list( output_sets.size() );
678 std::copy( output_sets.begin(), output_sets.end(), list.begin() );
679
680 // parse some options
681 FileOptions opts( options_string );
682 ErrorCode rval;
683
684 rval = opts.get_null_option( "CREATE" );
685 if( rval == MB_TYPE_OUT_OF_RANGE )
686 {
687 MB_SET_GLB_ERR( MB_FAILURE, "Unexpected value for CREATE option" );
688 }
689 bool overwrite = ( rval == MB_ENTITY_NOT_FOUND );
690
691 // Get the file writer
692 std::string ext = ReaderWriterSet::extension_from_filename( file_name );
693 std::vector< std::string > qa_records;
694 const EntityHandle* list_ptr = list.empty() ? (EntityHandle*)0 : &list[0];
695
696 rval = MB_TYPE_OUT_OF_RANGE;
697
698 // Try all possible writers
699 for( ReaderWriterSet::iterator i = reader_writer_set()->begin(); i != reader_writer_set()->end(); ++i )
700 {
701
702 if( ( file_type && !i->name().compare( file_type ) ) || i->writes_extension( ext.c_str() ) )
703 {
704
705 WriterIface* writer = i->make_writer( this );
706
707 // write the file
708 rval =
709 writer->write_file( file_name, overwrite, opts, list_ptr, list.size(), qa_records, tag_list, num_tags );
710 delete writer;
711 if( MB_SUCCESS == rval ) break;
712 printf( "Writer with name %s for file %s using extension %s (file type \"%s\") was "
713 "unsuccessful\n",
714 i->name().c_str(), file_name, ext.c_str(), file_type );
715 }
716 }
717
718 if( file_type && rval == MB_TYPE_OUT_OF_RANGE )
719 {
720 MB_SET_ERR( rval, "Unrecognized file type \"" << file_type << "\"" );
721 }
722 // Should we use default writer (e.g. HDF5)?
723 else if( MB_SUCCESS != rval )
724 {
725 DefaultWriter writer( this );
726 printf( "Using default writer %s for file %s \n", DefaultWriterName, file_name );
727 rval = writer.write_file( file_name, overwrite, opts, list_ptr, list.size(), qa_records, tag_list, num_tags );
728 }
729
730 if( MB_SUCCESS == rval && !opts.all_seen() )
731 {
732 std::string bad_opt;
733 if( MB_SUCCESS == opts.get_unseen_option( bad_opt ) )
734 {
735 MB_SET_ERR( MB_UNHANDLED_OPTION, "Unrecognized option: \"" << bad_opt << "\"" );
736 }
737 else
738 {
739 MB_SET_ERR( MB_UNHANDLED_OPTION, "Unrecognized option" );
740 }
741 }
742
743 return MB_SUCCESS;
744 }
References moab::FileOptions::all_seen(), moab::Range::begin(), DefaultWriterName, moab::Range::end(), ErrorCode, moab::ReaderWriterSet::extension_from_filename(), moab::FileOptions::get_null_option(), moab::FileOptions::get_unseen_option(), MB_ENTITY_NOT_FOUND, MB_SET_ERR, MB_SET_GLB_ERR, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MB_UNHANDLED_OPTION, moab::FileOptions::size(), moab::Range::size(), moab::WriterIface::write_file(), and moab::WriteHDF5::write_file().
|
virtual |
Write or export a file.
Implements moab::Interface.
Definition at line 656 of file Core.cpp.
663 {
664 Range range;
665 std::copy( output_sets, output_sets + num_output_sets, range_inserter( range ) );
666 return write_file( file_name, file_type, options_string, range, tag_list, num_tags );
667 }
Referenced by main(), obbvis_create(), and perform_laplacian_smoothing().
|
virtual |
Writes mesh to a file.
Write mesh to file 'file_name'; if output_list is non-NULL, only material sets contained in that list will be written.
file_name | Name of file to write. |
output_list | 1d array of material set handles to write; if NULL, all sets are written |
num_sets | Number of sets in output_list array |
Example:
EntityHandle output_list[] = {meshset1, meshset2, meshset3};
write_mesh( "output_file.gen", output_list, 3 );
Implements moab::Interface.
Definition at line 651 of file Core.cpp.
652 {
653 return write_file( file_name, 0, 0, output_list, num_sets );
654 }
Referenced by main().
|
friend |
|
private |
Definition at line 1322 of file Core.hpp.
Referenced by a_entity_factory().
|
private |
|
private |
Definition at line 1324 of file Core.hpp.
Referenced by reader_writer_set().
|
private |
|
private |
Definition at line 1320 of file Core.hpp.
Referenced by sequence_manager().
|
private |
|
private |
tag server for this interface
Definition at line 1314 of file Core.hpp.
Referenced by valid_tag_handle().