Mesh Oriented datABase  (version 5.5.1)
An array-based unstructured mesh library
Classes | Public Types | Public Member Functions | Private Member Functions | Private Attributes | Friends | List of all members
moab::Core Class Reference

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>

+ Inheritance diagram for moab::Core:
+ Collaboration diagram for moab::Core:

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
 
- Public Types inherited from moab::Interface
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...
 
- Public Member Functions inherited from moab::Interface
 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...
 
- Public Member Functions inherited from moab::UnknownInterface
virtual ~UnknownInterface ()
 

Private Member Functions

 Core (const Core &copy)
 Do not allow copying. More...
 
Core & operator= (const Core &copy)
 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
 

Detailed Description

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.

Examples
ComputeTriDual.cpp.

Definition at line 49 of file Core.hpp.

Member Typedef Documentation

◆ type_memstorage

typedef unsigned long long moab::Core::type_memstorage

Definition at line 558 of file Core.hpp.

Constructor & Destructor Documentation

◆ Core() [1/2]

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.

◆ ~Core()

moab::Core::~Core ( )

destructor

Definition at line 180 of file Core.cpp.

181 {
182  if( mMBWriteUtil ) delete mMBWriteUtil;
183  if( mMBReadUtil ) delete mMBReadUtil;
184  if( scdInterface ) delete scdInterface;
185 
186  mMBWriteUtil = NULL;
187  mMBReadUtil = NULL;
188  scdInterface = NULL;
189 
190  deinitialize();
191 }

◆ Core() [2/2]

moab::Core::Core ( const Core &  copy)
private

Do not allow copying.

Member Function Documentation

◆ a_entity_factory() [1/2]

AEntityFactory* moab::Core::a_entity_factory ( )
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().

◆ a_entity_factory() [2/2]

const AEntityFactory* moab::Core::a_entity_factory ( ) const
inline

Definition at line 1073 of file Core.hpp.

1074  {
1075  return aEntityFactory;
1076  }

References aEntityFactory.

◆ add_child_meshset()

ErrorCode moab::Core::add_child_meshset ( EntityHandle  meshset,
const EntityHandle  child_meshset 
)
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.

◆ add_child_meshsets()

ErrorCode moab::Core::add_child_meshsets ( EntityHandle  meshset,
const EntityHandle *  children,
int  count 
)
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.

◆ add_entities() [1/2]

ErrorCode moab::Core::add_entities ( EntityHandle  meshset,
const EntityHandle *  entities,
const int  num_entities 
)
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.

◆ add_entities() [2/2]

ErrorCode moab::Core::add_entities ( EntityHandle  meshset,
const Range &  entities 
)
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().

◆ add_parent_child()

ErrorCode moab::Core::add_parent_child ( EntityHandle  parent,
EntityHandle  child 
)
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().

◆ add_parent_meshset()

ErrorCode moab::Core::add_parent_meshset ( EntityHandle  meshset,
const EntityHandle  parent_meshset 
)
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.

◆ add_parent_meshsets()

ErrorCode moab::Core::add_parent_meshsets ( EntityHandle  meshset,
const EntityHandle *  parents,
int  count 
)
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.

◆ add_vsequence()

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 
)

Definition at line 4262 of file Core.cpp.

4273 {
4274  return sequence_manager()->add_vsequence( vert_seq, elem_seq, p1, q1, p2, q2, p3, q3, bb_input, bb_min, bb_max );
4275 }

◆ adjacencies_iterate()

ErrorCode moab::Core::adjacencies_iterate ( Range::const_iterator  iter,
Range::const_iterator  end,
const std::vector< EntityHandle > **&  adjs_ptr,
int &  count 
)
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.

Parameters
iterIterator to beginning of entity range desired
endEnd iterator for which adjacencies are requested
adjs_ptrPointer to pointer to const std::vector<EntityHandle>; each member of that array is the vector of adjacencies for this entity
countNumber 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().

◆ check_adjacencies() [1/2]

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.

◆ check_adjacencies() [2/2]

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.

◆ clean_up_failed_read()

void moab::Core::clean_up_failed_read ( const Range &  initial_ents,
std::vector< Tag >  initial_tags 
)
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().

◆ clear_meshset() [1/2]

ErrorCode moab::Core::clear_meshset ( const EntityHandle *  ms_handles,
const int  num_meshsets 
)
virtual

Empty a vector of mesh set.

Empty a mesh set.

Parameters
ms_handles1d vector of handles of sets being emptied
num_meshsetsNumber 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().

◆ clear_meshset() [2/2]

ErrorCode moab::Core::clear_meshset ( const Range &  ms_handles)
virtual

Empty a range of mesh set.

Empty a mesh set.

Parameters
ms_handlesRange 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.

◆ connect_iterate()

ErrorCode moab::Core::connect_iterate ( Range::const_iterator  iter,
Range::const_iterator  end,
EntityHandle *&  connect,
int &  verts_per_entity,
int &  count 
)
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().

◆ contains_entities()

bool moab::Core::contains_entities ( EntityHandle  meshset,
const EntityHandle *  entities,
int  num_entities,
const int  operation_type = Interface::INTERSECT 
)
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().

◆ convert_entities()

ErrorCode moab::Core::convert_entities ( const EntityHandle  meshset,
const bool  mid_edge,
const bool  mid_face,
const bool  mid_region,
Interface::HONodeAddedRemoved *  function_object = 0 
)
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.

Parameters
meshsetThe set of entities being converted
mid_edgeIf true, mid-edge nodes are created
mid_faceIf true, mid-face nodes are created
mid_regionIf true, mid-element nodes are created
function_objectIf 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().

◆ coords_iterate()

ErrorCode moab::Core::coords_iterate ( Range::const_iterator  iter,
Range::const_iterator  end,
double *&  xcoords_ptr,
double *&  ycoords_ptr,
double *&  zcoords_ptr,
int &  count 
)
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().

◆ create_element()

ErrorCode moab::Core::create_element ( const EntityType  type,
const EntityHandle *  connectivity,
const int  num_nodes,
EntityHandle &  element_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.

Parameters
typeType of element to create. (MBTET, MBTRI, MBKNIFE, etc.)
connectivityVector containing connectivity of element to create.
handleEntityHandle 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().

◆ create_meshset()

ErrorCode moab::Core::create_meshset ( const unsigned int  options,
EntityHandle &  ms_handle,
int  start_id = 0 
)
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().

◆ create_scd_sequence()

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.

◆ create_set_iterator()

ErrorCode moab::Core::create_set_iterator ( EntityHandle  meshset,
EntityType  ent_type,
int  ent_dim,
int  chunk_size,
bool  check_valid,
SetIterator *&  set_iter 
)
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.

Parameters
meshsetThe entity set associated with this iterator (use 0 for whole instance)
ent_typeEntity type associated with this iterator
ent_dimDimension associated with this iterator
chunk_sizeChunk size of the iterator
check_validIf 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.

◆ create_vertex()

ErrorCode moab::Core::create_vertex ( const double  coords[3],
EntityHandle &  entity_handle 
)
virtual

Creates a vertex based on coordinates.

creates a vertex based on coordinates, returns a handle and error code

Parameters
coordinatesArray that has 3 doubles in it.
entity_handleEntityHandle 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().

◆ create_vertices()

ErrorCode moab::Core::create_vertices ( const double *  coordinates,
const int  nverts,
Range &  entity_handles 
)
virtual

Create a set of vertices with the specified coordinates.

Parameters
coordinatesArray that has 3*n doubles in it.
nvertsNumber of vertices to create
entity_handlesRange 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().

◆ deinitialize()

void moab::Core::deinitialize ( )
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.

◆ delete_entities() [1/2]

ErrorCode moab::Core::delete_entities ( const EntityHandle *  entities,
const int  num_entities 
)
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.

Parameters
entities1d vector of entities to delete
num_entitiesNumber 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().

◆ delete_entities() [2/2]

ErrorCode moab::Core::delete_entities ( const Range &  range)
virtual

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.

Parameters
entitiesRange 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().

◆ delete_mesh()

ErrorCode moab::Core::delete_mesh ( )
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().

◆ dimension_from_handle()

int moab::Core::dimension_from_handle ( const  handle) const
virtual

Returns the topological dimension of an entity.

Returns the topological dimension of an entity.

Parameters
handleThe EntityHandle you want to find the dimension of.
Returns
type The topological dimension of handle.

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().

◆ dirichletBC_tag()

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.

◆ estimated_memory_use() [1/2]

void moab::Core::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 
)
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.

Parameters
ent_arrayArray of entities for which to estimate the memory use. If NULL, estimate is done for all entities.
num_entsThe length of ent_array. Not used if ent_rray is NULL.
total_(amortized_)storageThe sum of the memory entity, adjacency, and all tag storage.
(amortized_)entity_storageThe storage for the entity definitions (connectivity arrays for elements, coordinates for vertices, list storage within sets, etc.)
(amortized_)adjacency_storageThe storage for adjacency data.
tag_arrayAn array of tags for which to calculate the memory use.
num_tagsThe lenght of tag_array
(amortized_)tag_storageIf 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().

◆ estimated_memory_use() [2/2]

void moab::Core::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 
)
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.)

Parameters
entsEntities for which to estimate the memory use.
total_(amortized_)storageThe sum of the memory entity, adjacency, and all tag storage.
(amortized_)entity_storageThe storage for the entity definitions (connectivity arrays for elements, coordinates for vertices, list storage within sets, etc.)
(amortized_)adjacency_storageThe storage for adjacency data.
tag_arrayAn array of tags for which to calculate the memory use.
num_tagsThe lenght of tag_array
(amortized_)tag_storageIf 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 }

◆ estimated_memory_use_internal()

void moab::Core::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 
)
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().

◆ geom_dimension_tag()

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.

◆ get_adjacencies() [1/3]

ErrorCode moab::Core::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 
)
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.

◆ get_adjacencies() [2/3]

ErrorCode moab::Core::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 
)
virtual

get the adjacencies associated with a set of entities

Parameters
from_entitiesvector of EntityHandle to get adjacencies of.
to_dimensionDimension of desired adjacency information.
adj_entitiesVector in which adjacent EntityHandles are returned.
operation_typeenum 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().

◆ get_adjacencies() [3/3]

ErrorCode moab::Core::get_adjacencies ( const Range &  from_entities,
const int  to_dimension,
const bool  create_if_missing,
Range &  adj_entities,
const int  operation_type = Interface::INTERSECT 
)
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.

◆ get_child_meshsets() [1/2]

ErrorCode moab::Core::get_child_meshsets ( const EntityHandle  meshset,
Range &  children,
const int  num_hops = 1 
) const
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.

◆ get_child_meshsets() [2/2]

ErrorCode moab::Core::get_child_meshsets ( const EntityHandle  meshset,
std::vector< EntityHandle > &  children,
const int  num_hops = 1 
) const
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().

◆ get_connectivity() [1/4]

ErrorCode moab::Core::get_connectivity ( const EntityHandle *  entity_handles,
const int  num_handles,
Range &  connectivity,
bool  corners_only = false 
) const
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.

◆ get_connectivity() [2/4]

ErrorCode moab::Core::get_connectivity ( const EntityHandle *  entity_handles,
const int  num_handles,
std::vector< EntityHandle > &  connectivity,
bool  corners_only = false,
std::vector< int > *  offsets = NULL 
) const
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.

Parameters
entity_handleEntityHandle to get connectivity of.
connectivityVector in which connectivity of entity_handle is returned. Should contain MeshVertices.
corners_onlyIf 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().

◆ get_connectivity() [3/4]

ErrorCode moab::Core::get_connectivity ( const EntityHandle  entity_handle,
const EntityHandle *&  connectivity,
int &  number_nodes,
bool  corners_only = false,
std::vector< EntityHandle > *  storage = 0 
) const
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.

Parameters
entity_handleEntityHandle to get connectivity of.
connectivityArray in which connectivity of entity_handle is returned. Should contain MBVERTEX's.
num_nodesNumber 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().

◆ get_connectivity() [4/4]

ErrorCode moab::Core::get_connectivity ( const Range &  from_entities,
Range &  adj_entities,
bool  corners_only = false 
) const
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().

◆ get_connectivity_by_type()

ErrorCode moab::Core::get_connectivity_by_type ( const EntityType  entity_type,
std::vector< EntityHandle > &  connect 
) const
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().

◆ get_contained_meshsets() [1/2]

ErrorCode moab::Core::get_contained_meshsets ( const EntityHandle  meshset,
Range &  children,
const int  num_hops = 1 
) const
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.

◆ get_contained_meshsets() [2/2]

ErrorCode moab::Core::get_contained_meshsets ( const EntityHandle  meshset,
std::vector< EntityHandle > &  children,
const int  num_hops = 1 
) const
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.

◆ get_coords() [1/4]

ErrorCode moab::Core::get_coords ( const EntityHandle *  entity_handles,
const int  num_entities,
double *  coords 
) const
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().

◆ get_coords() [2/4]

ErrorCode moab::Core::get_coords ( const EntityHandle  entity_handle,
const double *&  x,
const double *&  y,
const double *&  z 
) const
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_coords() [3/4]

ErrorCode moab::Core::get_coords ( const Range &  entities,
double *  coords 
) const
virtual

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().

◆ get_coords() [4/4]

ErrorCode moab::Core::get_coords ( const Range &  entities,
double *  x_coords,
double *  y_coords,
double *  z_coords 
) const
virtual
Author
Jason Kraftcheck kraft.nosp@m.che@.nosp@m.cae.w.nosp@m.isc..nosp@m.edu - 2007-5-15

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().

◆ get_dimension()

ErrorCode moab::Core::get_dimension ( int &  dim) const
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.

◆ get_entities_by_dimension() [1/2]

ErrorCode moab::Core::get_entities_by_dimension ( const EntityHandle  meshset,
const int  dimension,
Range &  entities,
const bool  recursive = false 
) const
virtual

Adds adjacencies.

Parameters
from_handleentities
both_waysadd 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.

Examples
ExtractLand.cpp, addPCdata.cpp, and copyPartition.cpp.

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().

◆ get_entities_by_dimension() [2/2]

ErrorCode moab::Core::get_entities_by_dimension ( const EntityHandle  meshset,
const int  dimension,
std::vector< EntityHandle > &  entities,
const bool  recursive = false 
) const
virtual

Retrieves all entities of a given topological dimension in the database or meshset.

Appends entities to list passed in.

Parameters
meshsetMeshset whose entities are being queried (zero if query is for entire mesh).
dimensionTopological dimension of entities desired.
entitiesRange in which entities of dimension dimension are returned.
recursiveIf 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.

◆ get_entities_by_handle() [1/2]

ErrorCode moab::Core::get_entities_by_handle ( const EntityHandle  meshset,
Range &  entities,
const bool  recursive = false 
) const
virtual

Retrieves all entities in the data base.

Parameters
entitiesRange 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().

◆ get_entities_by_handle() [2/2]

ErrorCode moab::Core::get_entities_by_handle ( const EntityHandle  meshset,
std::vector< EntityHandle > &  entities,
const bool  recursive = false 
) const
virtual

Retrieves all entities in the data base.

Parameters
entitiesRange 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().

◆ get_entities_by_type() [1/2]

ErrorCode moab::Core::get_entities_by_type ( const EntityHandle  meshset,
const EntityType  type,
Range &  entities,
const bool  recursive = false 
) const
virtual

Retrieves all entities in the data base of given type.

Parameters
typeEntityType of entities desired (ie, MBHEX, MBEDGE, MBTRI, etc )
entitiesRange 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().

◆ get_entities_by_type() [2/2]

ErrorCode moab::Core::get_entities_by_type ( const EntityHandle  meshset,
const EntityType  type,
std::vector< EntityHandle > &  entities,
const bool  recursive = false 
) const
virtual

Retrieves all entities in the data base of given type.

Parameters
typeEntityType of entities desired (ie, MBHEX, MBEDGE, MBTRI, etc )
entitiesRange 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.

◆ get_entities_by_type_and_tag()

ErrorCode moab::Core::get_entities_by_type_and_tag ( const EntityHandle  meshset,
const EntityType  type,
const Tag *  tag_handles,
const void *const *  values,
const int  num_tags,
Range &  entities,
const int  condition = Interface::INTERSECT,
const bool  recursive = false 
) const
virtual

Retrieve entities in the database or meshset which have any or all of the tag(s) and (optionally) value(s) specified.

Parameters
meshsetMeshset whose entities are being queried (zero if query is for entire mesh).
typeType of entities to be returned
tag_handlesVector of tag handles entities must have
valuesVector of pointers to values of tags in tag_handles
num_tagsNumber of tags and values in tag_handles and values
entitiesRange in which entities are returned.
conditionBoolean condition, either Interface::UNION or Interface::INTERSECT
recursiveIf 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().

◆ get_error_string()

std::string moab::Core::get_error_string ( const ErrorCode  code) const
virtual

Return string representation of given error code.

Parameters
codeError 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().

◆ get_last_error()

ErrorCode moab::Core::get_last_error ( std::string &  info) const
virtual

Return information about the last error.

Parameters
infostd::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().

◆ get_meshset_options()

ErrorCode moab::Core::get_meshset_options ( const EntityHandle  ms_handle,
unsigned int &  options 
) const
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().

◆ get_number_entities_by_dimension()

ErrorCode moab::Core::get_number_entities_by_dimension ( const EntityHandle  meshset,
const int  dimension,
int &  number,
const bool  recursive = false 
) const
virtual

Retrieves all entities in the database of given dimension.

get # entities of a given dimension

Parameters
dimensionDimension of entities desired.
entitiesRange 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().

◆ get_number_entities_by_handle()

ErrorCode moab::Core::get_number_entities_by_handle ( const EntityHandle  meshset,
int &  num_entities,
const bool  recursive = false 
) const
virtual

Retrieves all entities in the data base.

Parameters
entitiesRange 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().

◆ get_number_entities_by_type()

ErrorCode moab::Core::get_number_entities_by_type ( const EntityHandle  meshset,
const EntityType  type,
int &  num_entities,
const bool  recursive = false 
) const
virtual

Retrieves all entities in the data base of given type.

returns the number of entities with a given type and tag

Parameters
typeEntityType of entities desired (ie, MBHEX, MBEDGE, MBTRI, etc )
entitiesRange 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().

◆ get_number_entities_by_type_and_tag()

ErrorCode moab::Core::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
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

Parameters
meshsetMeshset whose entities are being queried (zero if query is for entire mesh).
typeType of entities to be returned
tag_handlesVector of tag handles entities must have
valuesVector of pointers to values of tags in tag_handles
num_tagsNumber of tags and values in tag_handles and values
num_entitiesRange in which number of entities are returned.
recursiveIf 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().

◆ get_parent_meshsets() [1/2]

ErrorCode moab::Core::get_parent_meshsets ( const EntityHandle  meshset,
Range &  parents,
const int  num_hops = 1 
) const
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.

◆ get_parent_meshsets() [2/2]

ErrorCode moab::Core::get_parent_meshsets ( const EntityHandle  meshset,
std::vector< EntityHandle > &  parents,
const int  num_hops = 1 
) const
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().

◆ get_root_set()

EntityHandle moab::Core::get_root_set ( )
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 }

◆ get_sequence_multiplier()

double moab::Core::get_sequence_multiplier ( ) const
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 }

◆ get_set_iterators()

ErrorCode moab::Core::get_set_iterators ( EntityHandle  meshset,
std::vector< SetIterator * > &  set_iters 
)

Get all set iterators associated with the set passed in.

Parameters
meshsetMeshset for which iterators are requested
set_itersSet iterators for the set

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.

◆ get_vertex_coordinates()

ErrorCode moab::Core::get_vertex_coordinates ( std::vector< double > &  coords) const
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_vertices()

ErrorCode moab::Core::get_vertices ( const Range &  from_entities,
Range &  vertices 
)
virtual

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().

◆ globalId_tag()

Tag moab::Core::globalId_tag ( )
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.

Parameters
meshsetThe mesh set whose parents are being queried
parentsSTL vector holding the parents returned by this function
num_hopsNumber of generations to traverse (0 = all)

Implements moab::Interface.

Examples
ExtractLand.cpp, and copyPartition.cpp.

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().

◆ handle_from_id()

ErrorCode moab::Core::handle_from_id ( const EntityType  type,
const EntityID  id,
EntityHandle &  handle 
) const
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().

◆ high_order_node()

ErrorCode moab::Core::high_order_node ( const EntityHandle  parent_handle,
const EntityHandle *  subfacet_conn,
const EntityType  subfacet_type,
EntityHandle &  hon 
) const
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().

◆ id_from_handle()

EntityID moab::Core::id_from_handle ( const EntityHandle  handle) const
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().

◆ impl_version()

float moab::Core::impl_version ( std::string *  version_string = NULL)
virtual

Returns the major.minor version number of the implementation.

Parameters
iface_nameIf 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.

◆ initialize()

ErrorCode moab::Core::initialize ( )
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.

◆ intersect_meshset()

ErrorCode moab::Core::intersect_meshset ( EntityHandle  meshset1,
const EntityHandle  meshset2 
)
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.

◆ is_valid()

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().

◆ list_entities() [1/2]

ErrorCode moab::Core::list_entities ( const EntityHandle *  entities,
const int  num_entities 
) const
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.

Parameters
entities1d vector of entities to list
num_entitiesNumber 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() [2/2]

ErrorCode moab::Core::list_entities ( const Range &  entities) const
virtual

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().

◆ list_entity()

ErrorCode moab::Core::list_entity ( const EntityHandle  entity) const
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.

Parameters
entityThe 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().

◆ load_file()

ErrorCode moab::Core::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 
)
virtual

Load or import a file.

Implements moab::Interface.

Examples
ExtractLand.cpp, addPCdata.cpp, and copyPartition.cpp.

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().

◆ load_mesh()

ErrorCode moab::Core::load_mesh ( const char *  file_name,
const int *  active_block_id_list = NULL,
const int  num_blocks = 0 
)
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().

◆ material_tag()

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.

◆ merge_entities()

ErrorCode moab::Core::merge_entities ( EntityHandle  entity_to_keep,
EntityHandle  entity_to_remove,
bool  auto_merge,
bool  delete_removed_entity 
)
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().

◆ neumannBC_tag()

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.

◆ num_child_meshsets()

ErrorCode moab::Core::num_child_meshsets ( const EntityHandle  meshset,
int *  number,
const int  num_hops = 1 
) const
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().

◆ num_contained_meshsets()

ErrorCode moab::Core::num_contained_meshsets ( const EntityHandle  meshset,
int *  number,
const int  num_hops = 1 
) const
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().

◆ num_parent_meshsets()

ErrorCode moab::Core::num_parent_meshsets ( const EntityHandle  meshset,
int *  number,
const int  num_hops = 1 
) const
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().

◆ operator=()

Core& moab::Core::operator= ( const Core &  copy)
private

Do not allow copying.

◆ print()

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.

◆ print_database()

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().

◆ print_entity_tags()

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.

◆ query_interface_type()

ErrorCode moab::Core::query_interface_type ( const std::type_info &  interface_type,
void *&  ptr 
)
virtual

Get a pointer to an internal MOAB interface.

Returns
NULL if not found, iterface pointer otherwise

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.

◆ QueryInterface()

int moab::Core::QueryInterface ( const MBuuid &  uuid,
UnknownInterface **  iface 
)
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().

◆ reader_writer_set()

ReaderWriterSet* moab::Core::reader_writer_set ( )
inline

return set of registered IO tools

Definition at line 1090 of file Core.hpp.

1091  {
1092  return readerWriterSet;
1093  }

References readerWriterSet.

◆ release_interface_type()

ErrorCode moab::Core::release_interface_type ( const std::type_info &  interface_type,
void *  iface 
)
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.

◆ remove_child_meshset()

ErrorCode moab::Core::remove_child_meshset ( EntityHandle  meshset,
const EntityHandle  child_meshset 
)
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().

◆ remove_entities() [1/2]

ErrorCode moab::Core::remove_entities ( EntityHandle  meshset,
const EntityHandle *  entities,
const int  num_entities 
)
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().

◆ remove_entities() [2/2]

ErrorCode moab::Core::remove_entities ( EntityHandle  meshset,
const Range &  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().

◆ remove_parent_child()

ErrorCode moab::Core::remove_parent_child ( EntityHandle  parent,
EntityHandle  child 
)
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().

◆ remove_parent_meshset()

ErrorCode moab::Core::remove_parent_meshset ( EntityHandle  meshset,
const EntityHandle  parent_meshset 
)
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().

◆ remove_set_iterator()

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.

Parameters
set_iterSet 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().

◆ replace_entities()

ErrorCode moab::Core::replace_entities ( EntityHandle  meshset,
const EntityHandle *  old_entities,
const EntityHandle *  new_entities,
int  num_entities 
)
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().

◆ sequence_manager() [1/2]

SequenceManager* moab::Core::sequence_manager ( )
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().

◆ sequence_manager() [2/2]

const SequenceManager* moab::Core::sequence_manager ( ) const
inline

Definition at line 1043 of file Core.hpp.

1044  {
1045  return sequenceManager;
1046  }

References sequenceManager.

◆ serial_load_file()

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().

◆ serial_read_tag()

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().

◆ set_connectivity()

ErrorCode moab::Core::set_connectivity ( const EntityHandle  entity_handle,
EntityHandle *  connect,
const int  num_connect 
)
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.

Parameters
entity_handleEntityHandle to set connectivity of.
connectVector containing new connectivity of entity_handle.
num_connectNumber 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().

◆ set_coords() [1/2]

ErrorCode moab::Core::set_coords ( const EntityHandle *  entity_handles,
const int  num_entities,
const double *  coords 
)
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_coords() [2/2]

ErrorCode moab::Core::set_coords ( Range  entity_handles,
const double *  coords 
)
virtual

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().

◆ set_dimension()

ErrorCode moab::Core::set_dimension ( const int  dim)
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.

◆ set_meshset_options()

ErrorCode moab::Core::set_meshset_options ( const EntityHandle  ms_handle,
const unsigned int  options 
)
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().

◆ set_sequence_multiplier()

void moab::Core::set_sequence_multiplier ( double  factor)
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.

Parameters
meshsetUser 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 }

◆ side_element()

ErrorCode moab::Core::side_element ( const EntityHandle  source_entity,
const int  dim,
const int  sd_number,
EntityHandle &  target_entity 
) const
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().

◆ side_number()

ErrorCode moab::Core::side_number ( const EntityHandle  parent,
const EntityHandle  child,
int &  sd_number,
int &  sense,
int &  offset 
) const
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().

◆ subtract_meshset()

ErrorCode moab::Core::subtract_meshset ( EntityHandle  meshset1,
const EntityHandle  meshset2 
)
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().

◆ tag_clear_data() [1/2]

ErrorCode moab::Core::tag_clear_data ( Tag  tag_handle,
const EntityHandle *  entity_handles,
int  num_entities,
const void *  tag_data,
int  tag_size = 0 
)
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.

Parameters
tag_handleThe tag
entity_handlesThe entity handles for which to set tag values.
tag_dataA pointer to the tag value.
tag_sizesFor 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().

◆ tag_clear_data() [2/2]

ErrorCode moab::Core::tag_clear_data ( Tag  tag_handle,
const Range &  entity_handles,
const void *  tag_data,
int  tag_size = 0 
)
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.

Parameters
tag_handleThe tag
entity_handlesThe entity handles for which to set tag values.
tag_dataA pointer to the tag value.
tag_sizesFor 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().

◆ tag_delete()

ErrorCode moab::Core::tag_delete ( Tag  tag_handle)
virtual

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().

◆ tag_delete_data() [1/2]

ErrorCode moab::Core::tag_delete_data ( Tag  tag_handle,
const EntityHandle *  entity_handles,
int  num_entities 
)
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.

Parameters
tag_handleHandle of the (sparse) tag being deleted from entity
entity_handles1d vector of entity handles from which the tag is being deleted
num_handlesNumber 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().

◆ tag_delete_data() [2/2]

ErrorCode moab::Core::tag_delete_data ( Tag  tag_handle,
const Range &  entity_handles 
)
virtual

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.

Parameters
tag_handleHandle of the (sparse) tag being deleted from entity
entity_rangeRange 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().

◆ tag_get_by_ptr() [1/2]

ErrorCode moab::Core::tag_get_by_ptr ( const Tag  tag_handle,
const EntityHandle *  entity_handles,
int  num_entities,
const void **  tag_data,
int *  tag_sizes = 0 
) const
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.

Note
This function may not be used for bit tags.
Parameters
tag_handleThe tag
entity_handlesAn array of entity handles for which to retreive tag values.
num_entitiesThe length of the 'entity_handles' array.
tag_dataAn 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_sizesThe 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().

◆ tag_get_by_ptr() [2/2]

ErrorCode moab::Core::tag_get_by_ptr ( const Tag  tag_handle,
const Range &  entity_handles,
const void **  tag_data,
int *  tag_sizes = 0 
) const
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.

Note
This function may not be used for bit tags.
Parameters
tag_handleThe tag
entity_handlesThe entity handles for which to retreive tag values.
tag_dataAn array of 'const void*'. Array is populated (output) with pointers to the internal storage for the tag value corresponding to each entity handle.
tag_sizesThe 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().

◆ tag_get_bytes()

ErrorCode moab::Core::tag_get_bytes ( const Tag  tag,
int &  tag_size 
) const
virtual

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().

◆ tag_get_data() [1/2]

ErrorCode moab::Core::tag_get_data ( const Tag  tag_handle,
const EntityHandle *  entity_handles,
const int  num_entities,
void *  tag_data 
) const
virtual

return the tag data for a given EntityHandle and Tag

Implements moab::Interface.

Examples
ExtractLand.cpp, addPCdata.cpp, and copyPartition.cpp.

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().

◆ tag_get_data() [2/2]

ErrorCode moab::Core::tag_get_data ( const Tag  tag_handle,
const Range &  entity_handles,
void *  tag_data 
) const
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().

◆ tag_get_data_type()

ErrorCode moab::Core::tag_get_data_type ( const Tag  handle,
DataType &  type 
) const
virtual

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.

Parameters
tagThe tag
typeThe 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().

◆ tag_get_default_value() [1/2]

ErrorCode moab::Core::tag_get_default_value ( const Tag  tag,
void *  def_val 
) const
virtual

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().

◆ tag_get_default_value() [2/2]

ErrorCode moab::Core::tag_get_default_value ( Tag  tag,
const void *&  def_val,
int &  size 
) const
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.

Parameters
nameThe tag name
sizeTag 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.
typeThe type of the data (used for IO)
tag_handleOutput: the resulting tag handle.
flagsBitwise OR of values from TagType
default_valueOptional default value for tag.
createdOptional returned boolean indicating that the tag was created.
Returns
- 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 specified
  • MB_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 parameter
  • MB_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().

◆ tag_get_handle() [1/3]

ErrorCode moab::Core::tag_get_handle ( const char *  name,
int  size,
DataType  type,
Tag &  tag_handle,
unsigned  flags = 0,
const void *  default_value = 0 
) const
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.

◆ tag_get_handle() [2/3]

ErrorCode moab::Core::tag_get_handle ( const char *  name,
int  size,
DataType  type,
Tag &  tag_handle,
unsigned  flags = 0,
const void *  default_value = 0,
bool *  created = 0 
)
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.

Parameters
nameThe tag name
sizeTag 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.
typeThe type of the data (used for IO)
tag_handleOutput: the resulting tag handle.
flagsBitwise OR of values from TagType
default_valueOptional default value for tag.
createdOptional returned boolean indicating that the tag was created.
Returns
- 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 specified
  • MB_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 parameter
  • MB_VARIABLE_DATA_LENGTH if MB_TAG_VARLEN and default_value is non-null and default_value_size is not specified.

Implements moab::Interface.

Examples
addPCdata.cpp, and copyPartition.cpp.

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().

◆ tag_get_handle() [3/3]

ErrorCode moab::Core::tag_get_handle ( const char *  tag_name,
Tag &  tag_handle 
) const
virtual

Gets the tag handle corresponding to a name.

If a tag of that name does not exist, returns MB_TAG_NOT_FOUND

Parameters
tag_nameName of the desired tag.
tag_handleTag 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.

◆ tag_get_length()

ErrorCode moab::Core::tag_get_length ( const Tag  tag,
int &  tag_size 
) const
virtual

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().

◆ tag_get_name()

ErrorCode moab::Core::tag_get_name ( const Tag  tag_handle,
std::string &  tag_name 
) const
virtual

Gets the tag name string of the tag_handle.

gets the tag name string for the tag_handle

Parameters
tag_handleTag you want the name of.
tag_nameName 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().

◆ tag_get_tags()

ErrorCode moab::Core::tag_get_tags ( std::vector< Tag > &  tag_handles) const
virtual

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().

◆ tag_get_tags_on_entity()

ErrorCode moab::Core::tag_get_tags_on_entity ( const EntityHandle  entity,
std::vector< Tag > &  tag_handles 
) const
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.

◆ tag_get_type()

ErrorCode moab::Core::tag_get_type ( const Tag  tag_handle,
TagType &  tag_type 
) const
virtual

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().

◆ tag_iterate()

ErrorCode moab::Core::tag_iterate ( Tag  tag_handle,
Range::const_iterator  iter,
Range::const_iterator  end,
int &  count,
void *&  data_ptr,
bool  allocate = true 
)
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.

Parameters
tag_handleThe handle of the tag for which to access data
iterThe first entity for which to return data.
endOne past the last entity for which data is desired.
countThe number of entities for which data was returned
data_ptrOutput: pointer to tag storage.
allocateIf 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().

◆ tag_set_by_ptr() [1/2]

ErrorCode moab::Core::tag_set_by_ptr ( Tag  tag_handle,
const EntityHandle *  entity_handles,
int  num_entities,
void const *const *  tag_data,
const int *  tag_sizes = 0 
)
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.

Note
This function may not be used for bit tags.
Parameters
tag_handleThe tag
entity_handlesAn array of entity handles for which to set tag values.
num_entitiesThe length of the 'entity_handles' array.
tag_dataAn 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_sizesThe 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().

◆ tag_set_by_ptr() [2/2]

ErrorCode moab::Core::tag_set_by_ptr ( Tag  tag_handle,
const Range &  entity_handles,
void const *const *  tag_data,
const int *  tag_sizes = 0 
)
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.

Note
This function may not be used for bit tags.
Parameters
tag_handleThe tag
entity_handlesThe entity handles for which to set tag values.
tag_dataAn array of 'const void*'. Array is expected to contain pointers to tag values for the corresponding EntityHandle in 'entity_handles'.
tag_sizesThe 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().

◆ tag_set_data() [1/2]

ErrorCode moab::Core::tag_set_data ( Tag  tag_handle,
const EntityHandle *  entity_handles,
int  num_entities,
const void *  tag_data 
)
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.

Parameters
tag_handleTag indicating what data is to be set.
entity_handleEntityHandle on which to set tag's data.
tag_dataData 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.

Examples
addPCdata.cpp.

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().

◆ tag_set_data() [2/2]

ErrorCode moab::Core::tag_set_data ( Tag  tag_handle,
const Range &  entity_handles,
const void *  tag_data 
)
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().

◆ type_from_handle()

EntityType moab::Core::type_from_handle ( const EntityHandle  handle) const
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().

◆ unite_meshset()

ErrorCode moab::Core::unite_meshset ( EntityHandle  meshset1,
const EntityHandle  meshset2 
)
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().

◆ valid_tag_handle()

bool moab::Core::valid_tag_handle ( const TagInfo *  t) const
inlineprivate

Definition at line 1315 of file Core.hpp.

1316  {
1317  return std::find( tagList.begin(), tagList.end(), t ) != tagList.end();
1318  }

References tagList.

◆ write_file() [1/2]

ErrorCode moab::Core::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

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::WriteVtk::write_file().

◆ write_file() [2/2]

ErrorCode moab::Core::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

Write or export a file.

Implements moab::Interface.

Examples
addPCdata.cpp.

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 CreateTempestMesh(), main(), obbvis_create(), and perform_laplacian_smoothing().

◆ write_mesh()

ErrorCode moab::Core::write_mesh ( const char *  file_name,
const EntityHandle *  output_list = NULL,
const int  num_sets = 0 
)
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.

Parameters
file_nameName of file to write.
output_list1d array of material set handles to write; if NULL, all sets are written
num_setsNumber 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().

Friends And Related Function Documentation

◆ SetIterator

friend class SetIterator
friend

Definition at line 53 of file Core.hpp.

Member Data Documentation

◆ aEntityFactory

AEntityFactory* moab::Core::aEntityFactory
private

Definition at line 1322 of file Core.hpp.

Referenced by a_entity_factory().

◆ dirichletBCTag

Tag moab::Core::dirichletBCTag
private

Definition at line 1309 of file Core.hpp.

◆ geomDimensionTag

Tag moab::Core::geomDimensionTag
private

Definition at line 1310 of file Core.hpp.

◆ geometricDimension

int moab::Core::geometricDimension
private

store the total number of elements defined in this interface

store the total number of nodes defined in this interface the overall geometric dimension of this mesh

Definition at line 1305 of file Core.hpp.

◆ globalIdTag

Tag moab::Core::globalIdTag
private

Definition at line 1311 of file Core.hpp.

◆ initErrorHandlerInCore

bool moab::Core::initErrorHandlerInCore
private

Definition at line 1329 of file Core.hpp.

◆ materialTag

Tag moab::Core::materialTag
private

Definition at line 1307 of file Core.hpp.

◆ mError

Error* moab::Core::mError
private

Definition at line 1326 of file Core.hpp.

◆ mMBReadUtil

ReadUtil* moab::Core::mMBReadUtil
private

Definition at line 1295 of file Core.hpp.

◆ mMBWriteUtil

WriteUtil* moab::Core::mMBWriteUtil
private

Definition at line 1294 of file Core.hpp.

◆ mpiFinalize

bool moab::Core::mpiFinalize
private

Definition at line 1327 of file Core.hpp.

◆ neumannBCTag

Tag moab::Core::neumannBCTag
private

Definition at line 1308 of file Core.hpp.

◆ readerWriterSet

ReaderWriterSet* moab::Core::readerWriterSet
private

Definition at line 1324 of file Core.hpp.

Referenced by reader_writer_set().

◆ scdInterface

ScdInterface* moab::Core::scdInterface
private

Definition at line 1296 of file Core.hpp.

◆ sequenceManager

SequenceManager* moab::Core::sequenceManager
private

Definition at line 1320 of file Core.hpp.

Referenced by sequence_manager().

◆ setIterators

std::vector< SetIterator* > moab::Core::setIterators
private

list of iterators

Definition at line 1332 of file Core.hpp.

◆ tagList

std::list< TagInfo* > moab::Core::tagList
private

tag server for this interface

Definition at line 1314 of file Core.hpp.

Referenced by valid_tag_handle().

◆ writeMPELog

int moab::Core::writeMPELog
private

Definition at line 1328 of file Core.hpp.

The documentation for this class was generated from the following files: