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