#include "moab/MOABConfig.h"
#include "iMesh_extensions.h"
#include "moab/Core.hpp"
#include "moab/Range.hpp"
#include "moab/CN.hpp"
#include "moab/MeshTopoUtil.hpp"
#include "moab/ScdInterface.hpp"
#include "moab/FileOptions.hpp"
#include "iMesh_MOAB.hpp"
#include "MBIter.hpp"
#include "MBTagConventions.hpp"
#include "Internals.hpp"
#include <map>
#include <iostream>
#include <cassert>
#include <cctype>
#include <cstring>
#include <cstdarg>
#include <cstdio>

Include dependency graph for iMesh_MOAB.cpp:

Defines
#define	IS_BUILDING_MB
#define	STRINGIFY_(X) #X
#define	STRINGIFY(X) STRINGIFY_( X )
#define	MIN(a, b) ( ( a ) < ( b ) ? ( a ) : ( b ) )
#define	HANDLE_ARRAY_PTR(array) ( reinterpret_cast< EntityHandle* >( array ) )
#define	CONST_HANDLE_ARRAY_PTR(array) reinterpret_cast< const EntityHandle* >( array )
#define	TAG_HANDLE(handle) reinterpret_cast< Tag >( handle )
#define	CONST_TAG_HANDLE(handle) static_cast< const Tag >( handle )
#define	ENTITY_HANDLE(handle) reinterpret_cast< EntityHandle >( handle )
#define	CONST_ENTITY_HANDLE(handle) reinterpret_cast< const EntityHandle >( handle )
#define	CAST_TO_VOID(ptr) ( reinterpret_cast< void* >( ptr ) )
Functions
static ErrorCode	create_int_ents (MBiMesh mbimesh, Range &from_ents, const EntityHandle in_set=0)
static void	ht_content_type (const std::vector< EntityHandle > &h, bool &saw_ent, bool &saw_set, bool &saw_root)
static ErrorCode	check_handle_tag_type (Tag t, MBiMesh *mbi)
static void	remove_var_len_tags (Interface *mb, std::vector< Tag > &tags)
static void	munge_adj_table (int *adjTable, int geom_dim)
static void	eatwhitespace (std::string &this_string)
void	iMesh_getErrorType (iMesh_Instance instance, int *error_type)
	Get the error type returned from the last iMesh function.
void	iMesh_getDescription (iMesh_Instance instance, char *descr, int descr_len)
	Get a description of the error returned from the last iMesh function.
void	iMesh_newMesh (const char options, iMesh_Instance instance, int *err, int options_len)
	Construct a new iMesh instance.
void	iMesh_dtor (iMesh_Instance instance, int *err)
	Destroy an iMesh instance.
void	iMesh_load (iMesh_Instance instance, const iBase_EntitySetHandle handle, const char name, const char options, int *err, int name_len, int options_len)
	Load a mesh from a file.
void	iMesh_save (iMesh_Instance instance, const iBase_EntitySetHandle handle, const char name, const char options, int *err, const int name_len, int options_len)
	Save a mesh to a file.
void	iMesh_getRootSet (iMesh_Instance instance, iBase_EntitySetHandle root_set, int err)
	Get handle of the root set for this instance.
void	iMesh_getGeometricDimension (iMesh_Instance instance, int geom_dim, int err)
	Get the geometric dimension of mesh represented in this instance.
void	iMesh_setGeometricDimension (iMesh_Instance instance, int geom_dim, int *err)
	Set geometric dimension of vertex coordinates.
void	iMesh_getDfltStorage (iMesh_Instance instance, int order, int err)
	Get the default storage order used by this implementation.
void	iMesh_getAdjTable (iMesh_Instance instance, int *adjacency_table, int adjacency_table_allocated, int adjacency_table_size, int err)
	Get the adjacency table for this implementation.
void	iMesh_setAdjTable (iMesh_Instance instance, int adj_table, int adj_table_size, int err)
	Set the adjacency table as requested by the application.
void	iMesh_getNumOfType (iMesh_Instance instance, const iBase_EntitySetHandle entity_set_handle, const int entity_type, int num_type, int err)
	Get the number of entities of specified type in the instance or set.
void	iMesh_getNumOfTopo (iMesh_Instance instance, const iBase_EntitySetHandle entity_set_handle, const int entity_topology, int num_topo, int err)
	Get the number of entities of specified topology in instance or set.
void	iMesh_optimize (iMesh_Instance instance, int handles_invalidated, int err)
	Permit implementation to 'optimize' the mesh instance.
void	iMesh_getEntities (iMesh_Instance instance, const iBase_EntitySetHandle entity_set_handle, const int entity_type, const int entity_topology, iBase_EntityHandle *entity_handles, int entity_handles_allocated, int entity_handles_size, int err)
	Get entities of specific type and/or topology in set or instance.
void	iMesh_getVtxArrCoords (iMesh_Instance instance, const iBase_EntityHandle vertex_handles, const int vertex_handles_size, int storage_order, double coords, int coords_allocated, int coords_size, int err)
	Get coordinates of specified vertices.
void	iMesh_initEntArrIter (iMesh_Instance instance, const iBase_EntitySetHandle entity_set_handle, const int requested_entity_type, const int requested_entity_topology, const int requested_array_size, const int resilient, iBase_EntityArrIterator entArr_iterator, int err)
	Initialize an array iterator over specified entity type, topology, and size.
void	iMesh_getNextEntArrIter (iMesh_Instance instance, iBase_EntityArrIterator entArr_iterator, iBase_EntityHandle *entity_handles, int entity_handles_allocated, int entity_handles_size, int has_data, int *err)
	Get entities contained in array iterator and increment iterator.
void	iMesh_resetEntArrIter (iMesh_Instance instance, iBase_EntityArrIterator entArr_iterator, int *err)
	Reset the array iterator.
void	iMesh_endEntArrIter (iMesh_Instance instance, iBase_EntityArrIterator entArr_iterator, int *err)
	Destroy the specified array iterator.
void	iMesh_getEntArrTopo (iMesh_Instance instance, const iBase_EntityHandle entity_handles, const int entity_handles_size, int topology, int topology_allocated, int topology_size, int err)
	Get the entity topology for the specified entities.
void	iMesh_getEntArrType (iMesh_Instance instance, const iBase_EntityHandle entity_handles, const int entity_handles_size, int etype, int etype_allocated, int etype_size, int err)
	Get the entity type for the specified entities.
void	iMesh_getEntArrAdj (iMesh_Instance instance, const iBase_EntityHandle entity_handles, const int entity_handles_size, const int entity_type_requested, iBase_EntityHandle adjacentEntityHandles, int adjacentEntityHandles_allocated, int adjacentEntityHandles_size, int offset, int offset_allocated, int offset_size, int err)
	Get entities of specified type adjacent to entities.
void	iMesh_getEntArr2ndAdj (iMesh_Instance instance, iBase_EntityHandle const entity_handles, int entity_handles_size, int bridge_entity_type, int requested_entity_type, iBase_EntityHandle adj_entity_handles, int adj_entity_handles_allocated, int adj_entity_handles_size, int offset, int offset_allocated, int offset_size, int err)
	Get "2nd order" adjacencies to an array of entities.
void	iMesh_getAdjEntIndices (iMesh_Instance instance, iBase_EntitySetHandle entity_set_handle, int entity_type_requestor, int entity_topology_requestor, int entity_type_requested, iBase_EntityHandle *entity_handles, int entity_handles_allocated, int entity_handles_size, iBase_EntityHandle adj_entity_handles, int adj_entity_handles_allocated, int adj_entity_handles_size, int adj_entity_indices, int adj_entity_indices_allocated, int adj_entity_indices_size, int offset, int offset_allocated, int offset_size, int err)
	Get indexed representation of mesh or subset of mesh.
void	iMesh_createEntSet (iMesh_Instance instance, const int isList, iBase_EntitySetHandle entity_set_created, int err)
	Create an entity set.
void	iMesh_destroyEntSet (iMesh_Instance instance, iBase_EntitySetHandle entity_set, int *err)
	Destroy an entity set.
void	iMesh_isList (iMesh_Instance instance, const iBase_EntitySetHandle entity_set, int is_list, int err)
	Return whether a specified set is ordered or unordered.
void	iMesh_getNumEntSets (iMesh_Instance instance, const iBase_EntitySetHandle entity_set_handle, const int num_hops, int num_sets, int err)
void	iMesh_getEntSets (iMesh_Instance instance, const iBase_EntitySetHandle entity_set_handle, const int num_hops, iBase_EntitySetHandle *contained_entset_handles, int contained_entset_handles_allocated, int contained_entset_handles_size, int err)
void	iMesh_addEntArrToSet (iMesh_Instance instance, const iBase_EntityHandle entity_handles, int entity_handles_size, iBase_EntitySetHandle entity_set, int err)
	Add an array of entities to a set.
void	iMesh_addEntToSet (iMesh_Instance instance, iBase_EntityHandle entity_handle, iBase_EntitySetHandle entity_set, int *err)
	Add an entity to a set.
void	iMesh_rmvEntArrFromSet (iMesh_Instance instance, const iBase_EntityHandle entity_handles, int entity_handles_size, iBase_EntitySetHandle entity_set, int err)
	Remove an array of entities from a set.
void	iMesh_rmvEntFromSet (iMesh_Instance instance, iBase_EntityHandle entity_handle, iBase_EntitySetHandle entity_set, int *err)
	Remove an entity from a set.
void	iMesh_addEntSet (iMesh_Instance instance, iBase_EntitySetHandle entity_set_to_add, iBase_EntitySetHandle entity_set_handle, int *err)
	Add an entity set to a set.
void	iMesh_rmvEntSet (iMesh_Instance instance, iBase_EntitySetHandle entity_set_to_remove, iBase_EntitySetHandle entity_set_handle, int *err)
	Remove an entity set from a set.
void	iMesh_isEntContained (iMesh_Instance instance, iBase_EntitySetHandle containing_entity_set, iBase_EntityHandle contained_entity, int is_contained, int err)
	Return whether an entity is contained in another set.
void	iMesh_isEntArrContained (iMesh_Instance instance, iBase_EntitySetHandle containing_set, const iBase_EntityHandle entity_handles, int num_entity_handles, int is_contained, int is_contained_allocated, int is_contained_size, int err)
	Return whether entities are contained in a set.
void	iMesh_isEntSetContained (iMesh_Instance instance, const iBase_EntitySetHandle containing_entity_set, const iBase_EntitySetHandle contained_entity_set, int is_contained, int err)
	Return whether an entity set is contained in another set.
void	iMesh_addPrntChld (iMesh_Instance instance, iBase_EntitySetHandle parent_entity_set, iBase_EntitySetHandle child_entity_set, int *err)
	Add parent/child links between two sets.
void	iMesh_rmvPrntChld (iMesh_Instance instance, iBase_EntitySetHandle parent_entity_set, iBase_EntitySetHandle child_entity_set, int *err)
	Remove parent/child links between two sets.
void	iMesh_isChildOf (iMesh_Instance instance, const iBase_EntitySetHandle parent_entity_set, const iBase_EntitySetHandle child_entity_set, int is_child, int err)
	Return whether two sets are related by parent/child links.
void	iMesh_getNumChld (iMesh_Instance instance, const iBase_EntitySetHandle entity_set, const int num_hops, int num_child, int err)
	Get the number of child sets linked from a specified set.
void	iMesh_getNumPrnt (iMesh_Instance instance, const iBase_EntitySetHandle entity_set, const int num_hops, int num_parent, int err)
	Get the number of parent sets linked from a specified set.
void	iMesh_getChldn (iMesh_Instance instance, const iBase_EntitySetHandle from_entity_set, const int num_hops, iBase_EntitySetHandle *entity_set_handles, int entity_set_handles_allocated, int entity_set_handles_size, int err)
	Get the child sets linked from a specified set.
void	iMesh_getPrnts (iMesh_Instance instance, const iBase_EntitySetHandle from_entity_set, const int num_hops, iBase_EntitySetHandle *entity_set_handles, int entity_set_handles_allocated, int entity_set_handles_size, int err)
	Get the parent sets linked from a specified set.
void	iMesh_setVtxArrCoords (iMesh_Instance instance, const iBase_EntityHandle vertex_handles, const int vertex_handles_size, const int storage_order, const double new_coords, const int new_coords_size, int *err)
	Set coordinates for an array of vertices.
void	iMesh_createVtxArr (iMesh_Instance instance, const int num_verts, const int storage_order, const double new_coords, const int new_coords_size, iBase_EntityHandle new_vertex_handles, int new_vertex_handles_allocated, int new_vertex_handles_size, int err)
	Create an array of new vertices at specified coordinates.
void	iMesh_createEntArr (iMesh_Instance instance, const int new_entity_topology, const iBase_EntityHandle lower_order_entity_handles, const int lower_order_entity_handles_size, iBase_EntityHandle new_entity_handles, int new_entity_handles_allocated, int new_entity_handles_size, int status, int status_allocated, int status_size, int err)
	Create an array of new entities with specified lower-order topology.
void	iMesh_deleteEntArr (iMesh_Instance instance, const iBase_EntityHandle entity_handles, const int entity_handles_size, int err)
	Delete specified entities.
void	iMesh_createTag (iMesh_Instance instance, const char tag_name, const int tag_size, const int tag_type, iBase_TagHandle tag_handle, int *err, const int tag_name_size)
	Create a tag with specified name, size, and type.
void	iMesh_destroyTag (iMesh_Instance instance, iBase_TagHandle tag_handle, const int forced, int *err)
	Destroy a tag.
void	iMesh_getTagName (iMesh_Instance instance, const iBase_TagHandle tag_handle, char out_data, int err, int out_data_len)
	Get the name for a given tag handle.
void	iMesh_getTagType (iMesh_Instance instance, const iBase_TagHandle tag_handle, int value_type, int err)
	Get the data type of the specified tag handle.
void	iMesh_getTagSizeValues (iMesh_Instance instance, const iBase_TagHandle tag_handle, int tag_size_val, int err)
	Get size of a tag in units of numbers of tag data type.
void	iMesh_getTagSizeBytes (iMesh_Instance instance, const iBase_TagHandle tag_handle, int tag_size_bytes, int err)
	Get size of a tag in units of bytes.
void	iMesh_getTagHandle (iMesh_Instance instance, const char tag_name, iBase_TagHandle tag_handle, int *err, const int tag_name_len)
	Get a the handle of an existing tag with the specified name.
void	iMesh_getAllIfaceTags (iMesh_Instance instance, iBase_TagHandle *tag_handles, int tag_handles_allocated, int tag_handles_size, int err)
	Get all the tags associated with the entire interface.
void	iMesh_setEntSetData (iMesh_Instance instance, iBase_EntitySetHandle entity_set_handle, const iBase_TagHandle tag_handle, const void tag_value, const int, int err)
	Set a tag value of arbitrary type on an entity set.
void	iMesh_setEntSetIntData (iMesh_Instance instance, iBase_EntitySetHandle entity_set, const iBase_TagHandle tag_handle, const int tag_value, int *err)
void	iMesh_setEntSetDblData (iMesh_Instance instance, iBase_EntitySetHandle entity_set, const iBase_TagHandle tag_handle, const double tag_value, int *err)
void	iMesh_setEntSetEHData (iMesh_Instance instance, iBase_EntitySetHandle entity_set, const iBase_TagHandle tag_handle, const iBase_EntityHandle tag_value, int *err)
void	iMesh_setEntSetESHData (iMesh_Instance instance, iBase_EntitySetHandle entity_set, const iBase_TagHandle tag_handle, const iBase_EntitySetHandle tag_value, int *err)
	Set a tag value of entity set handle type on an.
void	iMesh_getEntSetData (iMesh_Instance instance, const iBase_EntitySetHandle entity_set_handle, const iBase_TagHandle tag_handle, void tag_value, int tag_value_allocated, int tag_value_size, int err)
	Get the value of a tag of arbitrary type on an entity set.
void	iMesh_getEntSetIntData (iMesh_Instance instance, const iBase_EntitySetHandle entity_set, const iBase_TagHandle tag_handle, int out_data, int err)
void	iMesh_getEntSetDblData (iMesh_Instance instance, const iBase_EntitySetHandle entity_set, const iBase_TagHandle tag_handle, double out_data, int err)
void	iMesh_getEntSetEHData (iMesh_Instance instance, const iBase_EntitySetHandle entity_set, const iBase_TagHandle tag_handle, iBase_EntityHandle out_data, int err)
void	iMesh_getEntSetESHData (iMesh_Instance instance, const iBase_EntitySetHandle entity_set, const iBase_TagHandle tag_handle, iBase_EntitySetHandle out_data, int err)
	Get the value of a tag of entity set handle type on an.
void	iMesh_getAllEntSetTags (iMesh_Instance instance, const iBase_EntitySetHandle entity_set_handle, iBase_TagHandle *tag_handles, int tag_handles_allocated, int tag_handles_size, int err)
	Get all the tags associated with a specified entity set.
void	iMesh_rmvEntSetTag (iMesh_Instance instance, iBase_EntitySetHandle entity_set_handle, const iBase_TagHandle tag_handle, int *err)
	Remove a tag value from an entity set.
void	iMesh_setVtxCoord (iMesh_Instance instance, iBase_EntityHandle vertex_handle, const double x, const double y, const double z, int *err)
	Set coordinates for a vertex.
void	iMesh_createVtx (iMesh_Instance instance, const double x, const double y, const double z, iBase_EntityHandle new_vertex_handle, int err)
	Create a new vertex at specified coordinates.
void	iMesh_createEnt (iMesh_Instance instance, const int new_entity_topology, const iBase_EntityHandle lower_order_entity_handles, const int lower_order_entity_handles_size, iBase_EntityHandle new_entity_handle, int status, int err)
	Create a new entity with specified lower-order topology.
void	iMesh_deleteEnt (iMesh_Instance instance, iBase_EntityHandle entity_handle, int *err)
	Delete specified entity.
void	iMesh_getArrData (iMesh_Instance instance, const iBase_EntityHandle entity_handles, const int entity_handles_size, const iBase_TagHandle tag_handle, void tag_values, int tag_values_allocated, int tag_values_size, int *err)
	Get tag values of arbitrary type for an array of entities.
void	iMesh_getIntArrData (iMesh_Instance instance, const iBase_EntityHandle entity_handles, const int entity_handles_size, const iBase_TagHandle tag_handle, int tag_values, int tag_values_allocated, int tag_values_size, int err)
void	iMesh_getDblArrData (iMesh_Instance instance, const iBase_EntityHandle entity_handles, const int entity_handles_size, const iBase_TagHandle tag_handle, double tag_values, int tag_values_allocated, int tag_values_size, int err)
void	iMesh_getEHArrData (iMesh_Instance instance, const iBase_EntityHandle entity_handles, const int entity_handles_size, const iBase_TagHandle tag_handle, iBase_EntityHandle tag_value, int tag_value_allocated, int tag_value_size, int err)
void	iMesh_getESHArrData (iMesh_Instance instance, const iBase_EntityHandle entity_handles, const int entity_handles_size, const iBase_TagHandle tag_handle, iBase_EntitySetHandle tag_value, int tag_value_allocated, int tag_value_size, int err)
	Get tag values of entity set handle type for an array of.
void	iMesh_setArrData (iMesh_Instance instance, const iBase_EntityHandle entity_handles, const int entity_handles_size, const iBase_TagHandle tag_handle, const void tag_values, const int tag_values_size, int *err)
	Set tag values of arbitrary type on an array of entities.
void	iMesh_setIntArrData (iMesh_Instance instance, const iBase_EntityHandle entity_handles, const int entity_handles_size, const iBase_TagHandle tag_handle, const int tag_values, const int tag_values_size, int *err)
void	iMesh_setDblArrData (iMesh_Instance instance, const iBase_EntityHandle entity_handles, const int entity_handles_size, const iBase_TagHandle tag_handle, const double tag_values, const int tag_values_size, int *err)
void	iMesh_setEHArrData (iMesh_Instance instance, const iBase_EntityHandle entity_handles, const int entity_handles_size, const iBase_TagHandle tag_handle, const iBase_EntityHandle tag_values, const int tag_values_size, int *err)
void	iMesh_setESHArrData (iMesh_Instance instance, const iBase_EntityHandle entity_handles, const int entity_handles_size, const iBase_TagHandle tag_handle, const iBase_EntitySetHandle tag_values, const int tag_values_size, int *err)
	Set tag values of entity set handle type on an array of.
void	iMesh_rmvArrTag (iMesh_Instance instance, const iBase_EntityHandle entity_handles, const int entity_handles_size, const iBase_TagHandle tag_handle, int err)
	Remove a tag value from an array of entities.
void	iMesh_getData (iMesh_Instance instance, const iBase_EntityHandle entity_handle, const iBase_TagHandle tag_handle, void tag_value, int tag_value_allocated, int tag_value_size, int err)
	Get the value of a tag of arbitrary type on an entity.
void	iMesh_getIntData (iMesh_Instance instance, const iBase_EntityHandle entity_handle, const iBase_TagHandle tag_handle, int out_data, int err)
void	iMesh_getDblData (iMesh_Instance instance, const iBase_EntityHandle entity_handle, const iBase_TagHandle tag_handle, double out_data, int err)
void	iMesh_getEHData (iMesh_Instance instance, const iBase_EntityHandle entity_handle, const iBase_TagHandle tag_handle, iBase_EntityHandle out_data, int err)
void	iMesh_getESHData (iMesh_Instance instance, const iBase_EntityHandle entity_handle, const iBase_TagHandle tag_handle, iBase_EntitySetHandle out_data, int err)
	Get the value of a tag of entity set handle type on an.
void	iMesh_setData (iMesh_Instance instance, iBase_EntityHandle entity_handle, const iBase_TagHandle tag_handle, const void tag_value, const int tag_value_size, int err)
	Set a tag value of arbitrary type on an entity.
void	iMesh_setIntData (iMesh_Instance instance, iBase_EntityHandle entity_handle, const iBase_TagHandle tag_handle, const int tag_value, int *err)
void	iMesh_setDblData (iMesh_Instance instance, iBase_EntityHandle entity_handle, const iBase_TagHandle tag_handle, const double tag_value, int *err)
void	iMesh_setEHData (iMesh_Instance instance, iBase_EntityHandle entity_handle, const iBase_TagHandle tag_handle, const iBase_EntityHandle tag_value, int *err)
void	iMesh_setESHData (iMesh_Instance instance, iBase_EntityHandle entity_handle, const iBase_TagHandle tag_handle, const iBase_EntitySetHandle tag_value, int *err)
void	iMesh_getAllTags (iMesh_Instance instance, const iBase_EntityHandle entity_handle, iBase_TagHandle *tag_handles, int tag_handles_allocated, int tag_handles_size, int err)
	Get all the tags associated with a specified entity handle.
void	iMesh_rmvTag (iMesh_Instance instance, iBase_EntityHandle entity_handle, const iBase_TagHandle tag_handle, int *err)
	Remove a tag value from an entity.
void	iMesh_initEntIter (iMesh_Instance instance, const iBase_EntitySetHandle entity_set_handle, const int requested_entity_type, const int requested_entity_topology, const int resilient, iBase_EntityIterator entity_iterator, int err)
	Initialize an iterator over specified entity type, topology, and size.
void	iMesh_getNextEntIter (iMesh_Instance instance, iBase_EntityIterator entity_iterator, iBase_EntityHandle entity_handle, int is_end, int *err)
	Get entity corresponding to an iterator and increment iterator.
void	iMesh_resetEntIter (iMesh_Instance instance, iBase_EntityIterator entity_iterator, int *err)
	Reset the iterator.
void	iMesh_endEntIter (iMesh_Instance instance, iBase_EntityIterator entity_iterator, int *err)
	Destroy the specified iterator.
void	iMesh_getEntTopo (iMesh_Instance instance, const iBase_EntityHandle entity_handle, int out_topo, int err)
	Get the entity topology for the specified entity.
void	iMesh_getEntType (iMesh_Instance instance, const iBase_EntityHandle entity_handle, int out_type, int err)
	Get the entity type for the specified entity.
void	iMesh_getVtxCoord (iMesh_Instance instance, const iBase_EntityHandle vertex_handle, double x, double y, double z, int err)
	Get coordinates of specified vertex.
void	iMesh_getEntAdj (iMesh_Instance instance, const iBase_EntityHandle entity_handle, const int entity_type_requested, iBase_EntityHandle *adj_entity_handles, int adj_entity_handles_allocated, int adj_entity_handles_size, int err)
	Get entities of specified type adjacent to an entity.
void	iMesh_getEnt2ndAdj (iMesh_Instance instance, iBase_EntityHandle entity_handle, int order_adjacent_key, int requested_entity_type, iBase_EntityHandle *adj_entities, int adj_entities_allocated, int adj_entities_size, int err)
	Get "2nd order" adjacencies to an entity.
void	iMesh_subtract (iMesh_Instance instance, const iBase_EntitySetHandle entity_set_1, const iBase_EntitySetHandle entity_set_2, iBase_EntitySetHandle result_entity_set, int err)
	Subtract contents of one entity set from another.
void	iMesh_intersect (iMesh_Instance instance, const iBase_EntitySetHandle entity_set_1, const iBase_EntitySetHandle entity_set_2, iBase_EntitySetHandle result_entity_set, int err)
	Intersect contents of one entity set with another.
void	iMesh_unite (iMesh_Instance instance, const iBase_EntitySetHandle entity_set_1, const iBase_EntitySetHandle entity_set_2, iBase_EntitySetHandle result_entity_set, int err)
	Unite contents of one entity set with another.
void	iMesh_getEntitiesRec (iMesh_Instance instance, const iBase_EntitySetHandle entity_set_handle, const int entity_type, const int entity_topology, const int recursive, iBase_EntityHandle *entity_handles, int entity_handles_allocated, int entity_handles_size, int err)
	Get entities of specific type and/or topology in set or instance, recursive.
void	iMesh_getNumOfTypeRec (iMesh_Instance instance, const iBase_EntitySetHandle entity_set_handle, const int entity_type, const int recursive, int num_type, int err)
	Get the number of entities with the specified type in the instance or set, recursive.
void	iMesh_getNumOfTopoRec (iMesh_Instance instance, const iBase_EntitySetHandle entity_set_handle, const int entity_topology, const int recursive, int num_topo, int err)
	Get the number of entities with the specified topology in the instance or set.
void	iMesh_getEntsByTagsRec (iMesh_Instance instance, const iBase_EntitySetHandle entity_set_handle, const int entity_type, const int entity_topology, const iBase_TagHandle tag_handles, const char const tag_vals, const int num_tags_vals, const int recursive, iBase_EntityHandle entity_handles, int entity_handles_allocated, int entity_handles_size, int err)
	Get entities with specified type, topology, tag(s) and (optionally) tag value(s)
void	iMesh_getEntSetsByTagsRec (iMesh_Instance instance, const iBase_EntitySetHandle entity_set_handle, const iBase_TagHandle tag_handles, const char const tag_vals, const int num_tags_vals, const int recursive, iBase_EntitySetHandle set_handles, int set_handles_allocated, int set_handles_size, int err)
	Get entity sets with specified tag(s) and (optionally) tag value(s)
void	iMesh_MBCNType (const int imesh_entity_topology, int *mbcn_type)
	Get MBCN type corresponding to iMesh topology value.
void	iMesh_tagIterate (iMesh_Instance instance, const iBase_TagHandle tag_handle, iBase_EntityArrIterator entArr_iterator, void data, int count, int *err)
	Access tag data via direct pointer into contiguous blocks.
void	iMesh_connectIterate (iMesh_Instance instance, iBase_EntityArrIterator entArr_iterator, iBase_EntityHandle *connect, int verts_per_entity, int count, int err)
	Access connectivity data via direct pointer into contiguous blocks.
void	iMesh_coordsIterate (iMesh_Instance instance, iBase_EntityArrIterator entArr_iterator, double xcoords_ptr, double ycoords_ptr, double *zcoords_ptr, int count, int *err)
	Access coordinates data via direct pointer into contiguous blocks.
void	iMesh_stepEntIter (iMesh_Instance instance, iBase_EntityIterator ent_iterator, int step_length, int at_end, int err)
	Step the iterator a specified number of entities.
void	iMesh_stepEntArrIter (iMesh_Instance instance, iBase_EntityArrIterator entArr_iterator, int step_length, int at_end, int err)
void	iMesh_initEntArrIterRec (iMesh_Instance instance, const iBase_EntitySetHandle entity_set_handle, const int requested_entity_type, const int requested_entity_topology, const int requested_array_size, const int resilient, const int recursive, iBase_EntityArrIterator entArr_iterator, int err)
	Initialize an array iterator over specified entity type, topology, and size, with an optional recursive flag.
void	iMesh_createTagWithOptions (iMesh_Instance instance, const char tag_name, const char tmp_tag_options, const int tag_size, const int tag_type, iBase_TagHandle tag_handle, int err, const int tag_name_len, const int tag_options_len)
	Create a tag with options.
void	iMesh_createStructuredMesh (iMesh_Instance instance, int local_dims, int global_dims, double i_vals, double j_vals, double k_vals, int resolve_shared, int ghost_dim, int bridge_dim, int num_layers, int addl_ents, int vert_gids, int elem_gids, iBase_EntitySetHandle set_handle, int *err)
	Create a structured mesh.
void	iMesh_freeMemory (iMesh_Instance, void **ptrToMem)
	Free memory allocated with malloc.
Variables
const iMesh_EntityTopology	tstt_topology_table []
const iBase_EntityType	tstt_type_table []
const EntityType	mb_topology_table []
const DataType	mb_data_type_table []
const iBase_TagValueType	tstt_data_type_table []
const iBase_ErrorType	iBase_ERROR_MAP [MB_FAILURE+1]

Define Documentation

#define CAST_TO_VOID ( ptr ) ( reinterpret_cast< void* >( ptr ) )

Definition at line 48 of file iMesh_MOAB.cpp.

#define CONST_ENTITY_HANDLE ( handle ) reinterpret_cast< const EntityHandle >( handle )

Definition at line 47 of file iMesh_MOAB.cpp.

#define CONST_HANDLE_ARRAY_PTR ( array ) reinterpret_cast< const EntityHandle* >( array )

Definition at line 43 of file iMesh_MOAB.cpp.

Referenced by iMesh_addEntArrToSet(), iMesh_createEnt(), iMesh_createEntArr(), iMesh_deleteEntArr(), iMesh_getVtxArrCoords(), iMesh_rmvArrTag(), iMesh_rmvEntArrFromSet(), iMesh_setArrData(), and iMesh_setVtxArrCoords().

#define CONST_TAG_HANDLE ( handle ) static_cast< const Tag >( handle )

Definition at line 45 of file iMesh_MOAB.cpp.

#define ENTITY_HANDLE ( handle ) reinterpret_cast< EntityHandle >( handle )

Definition at line 46 of file iMesh_MOAB.cpp.

Referenced by iMesh_addEntArrToSet(), iMesh_addEntSet(), iMesh_addPrntChld(), iMesh_createStructuredMesh(), iMesh_destroyEntSet(), iMesh_getAllEntSetTags(), iMesh_getAllTags(), iMesh_getChldn(), iMesh_getEntArrTopo(), iMesh_getEntArrType(), iMesh_getEntitiesRec(), iMesh_getEntsByTagsRec(), iMesh_getEntSetData(), iMesh_getEntSets(), iMesh_getEntSetsByTagsRec(), iMesh_getEntTopo(), iMesh_getEntType(), iMesh_getNumChld(), iMesh_getNumEntSets(), iMesh_getNumOfTopoRec(), iMesh_getNumOfTypeRec(), iMesh_getNumPrnt(), iMesh_getPrnts(), iMesh_initEntArrIterRec(), iMesh_intersect(), iMesh_isChildOf(), iMesh_isEntArrContained(), iMesh_isList(), iMesh_rmvEntArrFromSet(), iMesh_rmvEntSet(), iMesh_rmvEntSetTag(), iMesh_rmvPrntChld(), iMesh_save(), iMesh_setEntSetData(), iMesh_subtract(), and iMesh_unite().

#define HANDLE_ARRAY_PTR ( array ) ( reinterpret_cast< EntityHandle* >( array ) )

Definition at line 42 of file iMesh_MOAB.cpp.

Referenced by iMesh_createEntArr(), iMesh_createVtxArr(), iMesh_getChldn(), and iMesh_getPrnts().

#define IS_BUILDING_MB

Definition at line 12 of file iMesh_MOAB.cpp.

#define MIN	(	a,
		b
	)	( ( a ) < ( b ) ? ( a ) : ( b ) )

Definition at line 35 of file iMesh_MOAB.cpp.

Referenced by iMesh_getDescription().

#define STRINGIFY ( X ) STRINGIFY_( X )

Definition at line 22 of file iMesh_MOAB.cpp.

#define STRINGIFY_ ( X ) #X

Definition at line 21 of file iMesh_MOAB.cpp.

#define TAG_HANDLE ( handle ) reinterpret_cast< Tag >( handle )

Definition at line 44 of file iMesh_MOAB.cpp.

Referenced by iMesh_destroyTag(), iMesh_getArrData(), iMesh_getEntSetData(), iMesh_getTagHandle(), iMesh_getTagName(), iMesh_getTagSizeBytes(), iMesh_getTagSizeValues(), iMesh_getTagType(), iMesh_rmvArrTag(), iMesh_rmvEntSetTag(), iMesh_setArrData(), iMesh_setEntSetData(), and iMesh_tagIterate().

Function Documentation

static ErrorCode check_handle_tag_type	(	Tag	t,
		MBiMesh *	mbi
	)		`[static]`

Definition at line 136 of file iMesh_MOAB.cpp.

References moab::Range::begin(), moab::Range::end(), ErrorCode, moab::Interface::get_entities_by_type_and_tag(), ht_content_type(), mb, MB_SUCCESS, MB_TYPE_HANDLE, MB_TYPE_OUT_OF_RANGE, MBiMesh::mbImpl, MBMAXTYPE, MBiMesh::note_ent_handle_tag(), MBiMesh::note_set_handle_tag(), size, moab::Interface::tag_get_data(), moab::Interface::tag_get_data_type(), moab::Interface::tag_get_default_value(), and moab::Interface::tag_get_length().

Referenced by iMesh_getTagType().

{
    Interface* mb = mbi->mbImpl;
    ErrorCode rval;
    int size;
    DataType type;
    rval = mb->tag_get_data_type( t, type );
    if( MB_SUCCESS != rval ) return rval;
    if( MB_TYPE_HANDLE != type ) return MB_TYPE_OUT_OF_RANGE;
    rval = mb->tag_get_length( t, size );
    if( MB_SUCCESS != rval ) return rval;
    std::vector< EntityHandle > data( size );

    // check for global/mesh value
    bool saw_set = false, saw_ent = false, saw_root = false;
    EntityHandle root = 0;
    rval              = mb->tag_get_data( t, &root, 1, &data[0] );
    if( MB_SUCCESS == rval ) ht_content_type( data, saw_ent, saw_set, saw_root );

    // check default value
    rval = mb->tag_get_default_value( t, &data[0] );
    if( MB_SUCCESS == rval ) ht_content_type( data, saw_ent, saw_set, saw_root );

    // check all tagged entities
    Range r;
    rval = mb->get_entities_by_type_and_tag( 0, MBMAXTYPE, &t, 0, 1, r );
    if( MB_SUCCESS != rval ) return rval;
    for( Range::iterator i = r.begin(); i != r.end(); ++i )
    {
        rval = mb->tag_get_data( t, &*i, 1, &data[0] );
        if( MB_SUCCESS != rval ) return rval;
        ht_content_type( data, saw_ent, saw_set, saw_root );
    }

    // If tag values were only entities, note type accordingly.
    // Similarly if all are entity sets, note accordingly.
    // Because root set (zero handle) is sometimes used to mean NULL
    // rather than the actual root set, treat that specially.  If
    // all values are either root set or an entity handle, then
    // treat as if all values were non-set handles.
    if( saw_set && !saw_ent )
        mbi->note_set_handle_tag( t );
    else if( !saw_set && saw_ent )
        mbi->note_ent_handle_tag( t );
    else if( saw_root && !saw_ent )
        mbi->note_set_handle_tag( t );

    return MB_SUCCESS;
}

ErrorCode create_int_ents	(	MBiMesh *	mbimesh,
		Range &	from_ents,
		const EntityHandle *	in_set = `0`
	)		`[static]`

Definition at line 3191 of file iMesh_MOAB.cpp.

References moab::Interface::add_entities(), MBiMesh::AdjTable, moab::Range::clear(), ErrorCode, moab::Interface::get_adjacencies(), MB_SUCCESS, MBiMesh::mbImpl, moab::Range::merge(), moab::Range::size(), and smoab::UNION.

Referenced by iMesh_createEnt(), iMesh_createEntArr(), and iMesh_load().

{
    // MBiMesh* mbimesh = dynamic_cast<MBiMesh*>(instance);
    assert( mbimesh );
    assert( mbimesh->AdjTable[10] || mbimesh->AdjTable[5] );
    Range int_ents;
    ErrorCode result;
    Interface* instance = mbimesh->mbImpl;
    if( mbimesh->AdjTable[10] )
    {
        result = instance->get_adjacencies( from_ents, 2, true, int_ents, Interface::UNION );
        if( MB_SUCCESS != result ) return result;
        unsigned int old_size = from_ents.size();
        from_ents.merge( int_ents );
        if( old_size != from_ents.size() && in_set )
        {
            result = instance->add_entities( *in_set, int_ents );
            if( MB_SUCCESS != result ) return result;
        }
    }

    if( mbimesh->AdjTable[5] )
    {
        int_ents.clear();
        result = instance->get_adjacencies( from_ents, 1, true, int_ents, Interface::UNION );
        if( MB_SUCCESS != result ) return result;
        unsigned int old_size = from_ents.size();
        from_ents.merge( int_ents );
        if( old_size != from_ents.size() && in_set )
        {
            result = instance->add_entities( *in_set, int_ents );
            if( MB_SUCCESS != result ) return result;
        }
    }

    return MB_SUCCESS;
}

void eatwhitespace ( std::string & this_string ) [static]

Definition at line 3229 of file iMesh_MOAB.cpp.

Referenced by iMesh_createTagWithOptions(), iMesh_getTagHandle(), iMesh_load(), and iMesh_save().

{
    std::string::size_type p = this_string.find_last_not_of( " " );
    if( p != this_string.npos ) this_string.resize( p + 1 );
}

static void ht_content_type	(	const std::vector< EntityHandle > &	h,
		bool &	saw_ent,
		bool &	saw_set,
		bool &	saw_root
	)		`[inline, static]`

Definition at line 119 of file iMesh_MOAB.cpp.

References MBENTITYSET, and moab::TYPE_FROM_HANDLE().

Referenced by check_handle_tag_type().

{
    std::vector< EntityHandle >::const_iterator i;
    for( i = h.begin(); i != h.end(); ++i )
    {
        if( *i == 0 )
            saw_root = true;
        else if( TYPE_FROM_HANDLE( *i ) == MBENTITYSET )
            saw_set = true;
        else
            saw_ent = true;
    }
}

void iMesh_addEntArrToSet	(	iMesh_Instance	instance,
		const iBase_EntityHandle *	entity_handles,
		int	entity_handles_size,
		iBase_EntitySetHandle	entity_set,
		int *	err
	)

Add an array of entities to a set.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_handles	Array of entities being added
[in]	entity_handles_size	Number of entities in entity_handles array
[in]	entity_set	Pointer to the set being added to
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1022 of file iMesh_MOAB.cpp.

References CHKERR, CONST_HANDLE_ARRAY_PTR, ENTITY_HANDLE, ErrorCode, iBase_SUCCESS, MOABI, and RETURN.

{
    const EntityHandle* ents = CONST_HANDLE_ARRAY_PTR( entity_handles );
    ErrorCode result         = MOABI->add_entities( ENTITY_HANDLE( entity_set ), ents, entity_handles_size );

    CHKERR( result, "iMesh_addEntArrToSet:ERROR adding entities in EntitySet." );
    RETURN( iBase_SUCCESS );
}

void iMesh_addEntSet	(	iMesh_Instance	instance,
		iBase_EntitySetHandle	entity_set_to_add,
		iBase_EntitySetHandle	entity_set_handle,
		int *	err
	)

Add an entity set to a set.

Add an entity set to a set (Cycles)

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set_to_add	The entity set being added
[in]	entity_set_handle	Pointer to the set being added to
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1065 of file iMesh_MOAB.cpp.

References CHKERR, ENTITY_HANDLE, ERROR, ErrorCode, iBase_INVALID_ARGUMENT, iBase_SUCCESS, MOABI, and RETURN.

{
    if( !entity_set_to_add || !entity_set_handle )
        ERROR( iBase_INVALID_ARGUMENT, "iMesh_addEntSet: ERROR invalid argument" );

    EntityHandle to_add = ENTITY_HANDLE( entity_set_to_add );
    ErrorCode result    = MOABI->add_entities( ENTITY_HANDLE( entity_set_handle ), &to_add, 1 );

    CHKERR( result, "iMesh_addEntSet:ERROR adding entitysets." );
    RETURN( iBase_SUCCESS );
}

void iMesh_addEntToSet	(	iMesh_Instance	instance,
		iBase_EntityHandle	entity_handle,
		iBase_EntitySetHandle	entity_set,
		int *	err
	)

Add an entity to a set.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_handle	The entity being added
[in]	entity_set	Pointer to the set being added to
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1035 of file iMesh_MOAB.cpp.

References iMesh_addEntArrToSet.

{
    iMesh_addEntArrToSet( instance, &entity_handle, 1, entity_set, err );
}

void iMesh_addPrntChld	(	iMesh_Instance	instance,
		iBase_EntitySetHandle	parent_entity_set,
		iBase_EntitySetHandle	child_entity_set,
		int *	err
	)

Add parent/child links between two sets.

ParentChildLinks Add parent/child links between two sets. Makes parent point to child and child point to parent. (Cycles)

Parameters:

[in]	instance	iMesh instance handle
[in]	parent_entity_set	Pointer to parent set
[in]	child_entity_set	Pointer to child set
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1145 of file iMesh_MOAB.cpp.

References CHKERR, ENTITY_HANDLE, ERROR, ErrorCode, iBase_INVALID_ENTITYSET_HANDLE, iBase_SUCCESS, MB_ENTITY_NOT_FOUND, MOABI, and RETURN.

{
    ErrorCode result = MOABI->add_parent_child( ENTITY_HANDLE( parent_entity_set ), ENTITY_HANDLE( child_entity_set ) );

    if( result == MB_ENTITY_NOT_FOUND )
        ERROR( iBase_INVALID_ENTITYSET_HANDLE, "iMesh_addPrntChld: ERROR invalid entity set." );CHKERR( result, "iMesh_addPrntChld: ERROR addParentChild failed." );
    RETURN( iBase_SUCCESS );
}

void iMesh_connectIterate	(	iMesh_Instance	instance,
		iBase_EntityArrIterator	entArr_iterator,
		iBase_EntityHandle **	connect,
		int *	verts_per_entity,
		int *	count,
		int *	err
	)

Access connectivity data via direct pointer into contiguous blocks.

Iteratively obtain direct access to contiguous blocks of connectivity storage.

Parameters:

[in]	instance	iMesh instance
[in]	entArr_iterator	Iterator being queried
[out]	connect	Pointer to pointer that will be set to connectivity data memory
[out]	verts_per_entity	Pointer to integer set to number of vertices per entity
[out]	count	Number of contiguous entities in this subrange
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2912 of file iMesh_MOAB.cpp.

References CHKERR, MBIter< Container >::end(), ErrorCode, iBase_SUCCESS, MOABI, MBIter< Container >::position(), and RETURN.

{
    MBRangeIter* ri = dynamic_cast< MBRangeIter* >( entArr_iterator );
    if( !ri ) CHKERR( MB_FAILURE, "Wrong type of iterator, need a range-based iterator for iMesh_connectIterate." );

    ErrorCode result =
        MOABI->connect_iterate( ri->position(), ri->end(), reinterpret_cast< EntityHandle*& >( *connect ),
                                *verts_per_entity, *count );CHKERR( result, "Problem getting connect iterator." );

    RETURN( iBase_SUCCESS );
}

void iMesh_coordsIterate	(	iMesh_Instance	instance,
		iBase_EntityArrIterator	entArr_iterator,
		double **	coordsx,
		double **	coordsy,
		double **	coordsz,
		int *	count,
		int *	err
	)

Access coordinates data via direct pointer into contiguous blocks.

Iteratively obtain direct access to contiguous blocks of coordinate storage.

Parameters:

[in]	instance	iMesh instance
[in]	entArr_iterator	Iterator being queried
[out]	xcoords_ptr	Pointer to pointer that will be set to x coordinate data memory
[out]	ycoords_ptr	Pointer to pointer that will be set to y coordinate data memory
[out]	zcoords_ptr	Pointer to pointer that will be set to z coordinate data memory
[out]	count	Number of contiguous entities in this subrange
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2935 of file iMesh_MOAB.cpp.

References CHKERR, MBIter< Container >::end(), ErrorCode, iBase_SUCCESS, MOABI, MBIter< Container >::position(), and RETURN.

{
    MBRangeIter* ri = dynamic_cast< MBRangeIter* >( entArr_iterator );
    if( !ri ) CHKERR( MB_FAILURE, "Wrong type of iterator, need a range-based iterator for iMesh_coordsIterate." );

    ErrorCode result =
        MOABI->coords_iterate( ri->position(), ri->end(), *xcoords_ptr, *ycoords_ptr, *zcoords_ptr, *count );CHKERR( result, "Problem getting coords iterator." );

    RETURN( iBase_SUCCESS );
}

void iMesh_createEntSet	(	iMesh_Instance	instance,
		const int	isList,
		iBase_EntitySetHandle *	entity_set_created,
		int *	err
	)

Create an entity set.

Create an entity set, either ordered (isList=1) or unordered (isList=0). Unordered entity sets can contain a given entity or set only once.

An entity set in iMesh supports managing its contained members in one of two modes. When an entitiy set is first created, the caller is required to indicate which mode of membership the set will support. The two modes that are supported are a) order-preserving (isList=1) or b) duplicate-preventing (isList=0).

For order-preserving membership, the implementation will permit duplicate entities. However, the implementation will guarantee that the order in which entities are added to the set will be the same as the order in which they are queried by the various methods that return the entities of a set. This order preserving guarantee holds across removals. However, it does not hold across removals followed by re-additions of the previously removed entities. This kind of an entity set behaves like an STL vector or STL list and is created by setting isList=1 when creating an entity set.

For duplicate-preventing membership, the implementation will guarantee that duplicate entities are prevented. Any attempts to add duplicate entities to such a set will be detected, prevented and silently ignored by the implementation. This kind of entity set behaves like an STL set and is created by setting isList=0 when creating an entity set.

Finally, all of the above comments apply only to entity members of an entity set and do not apply to the entity set members. Order-preserving and duplicate preventing behavior for entity set members is unspecified. Each implementation may behave differently for entity set members. This design was chosen because we could not identify any use cases where order-preserving behavior for set members was necessary. However, if users encounter situations where such behavior is desirable or necessary, then the ITAPS development team can certainly consider adjusting the interface specification to support it.

Parameters:

[in]	instance	iMesh instance handle
[in]	isList	If non-zero, an ordered list is created, otherwise an unordered set is created.
[out]	entity_set_created	Entity set created by function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 946 of file iMesh_MOAB.cpp.

References CHKERR, ErrorCode, iBase_SUCCESS, MESHSET_SET, MOABI, and RETURN.

{
    // create the entity set
    EntityHandle meshset;
    ErrorCode result;

    if( isList )
        result = MOABI->create_meshset( MESHSET_ORDERED, meshset );
    else
        result = MOABI->create_meshset( MESHSET_SET, meshset );

    CHKERR( result, "iMesh_createEntSet: ERROR creating a entityset instance" );

    // return EntitySet_Handle
    *entity_set_created = (iBase_EntitySetHandle)meshset;
    RETURN( iBase_SUCCESS );
}

void iMesh_createVtx	(	iMesh_Instance	instance,
		const double	x,
		const double	y,
		const double	z,
		iBase_EntityHandle *	new_vertex_handle,
		int *	err
	)

Create a new vertex at specified coordinates.

VertexEntities Create a new vertex at specified coordinates.

Parameters:

[in]	instance	iMesh instance handle
[in]	x	x coordinate of new vertex
[in]	y	y coordinate of new vertex
[in]	z	z coordinate of new vertex
[out]	new_vertex_handle	Pointer to new vertex handles returned from
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1817 of file iMesh_MOAB.cpp.

References moab::dum, iBase_BLOCKED, iMesh_createVtxArr, and MOABI.

{
    int dum             = 1;
    const double xyz[3] = { x, y, z };
    int geom_dim;
    MOABI->get_dimension( geom_dim );
    iMesh_createVtxArr( instance, 1, iBase_BLOCKED, xyz, geom_dim, &new_vertex_handle, &dum, &dum, err );
}

void iMesh_createVtxArr	(	iMesh_Instance	instance,
		const int	num_verts,
		const int	storage_order,
		const double *	new_coords,
		const int	new_coords_size,
		iBase_EntityHandle **	new_vertex_handles,
		int *	new_vertex_handles_allocated,
		int *	new_vertex_handles_size,
		int *	err
	)

Create an array of new vertices at specified coordinates.

VertexEntities Create an array of new vertices at specified coordinates. Value of storage_order must be either iBase_INTERLEAVED or iBase_BLOCKED.

Parameters:

[in]	instance	iMesh instance handle
[in]	num_verts	Number of new vertices to be created
[in]	storage_order	Storage order of coordinates in new_coords array (see iBase_StorageOrder)
[in]	new_coords	Array of coordinates of new vertices. Should be G*num_verts in length where G is geometric dimension of the mesh.
[in]	new_coords_size	Number of coordinates in new_coords array, should
[in,out]	new_vertex_handles	Pointer to array of new vertex handles Array pointer, allocated and occupied sizes argument trio)
[in,out]	new_vertex_handles_allocated	Pointer to allocated size of
[out]	new_vertex_handles_size	Pointer to occupied size of
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1325 of file iMesh_MOAB.cpp.

References ALLOC_CHECK_ARRAY, CHKERR, ERROR, ErrorCode, HANDLE_ARRAY_PTR, iBase_INTERLEAVED, iBase_INVALID_ARGUMENT, iBase_SUCCESS, KEEP_ARRAY, MOABI, and RETURN.

{
    int geom_dim;
    MOABI->get_dimension( geom_dim );
    if( new_coords_size != geom_dim * num_verts )
    {
        ERROR( iBase_INVALID_ARGUMENT, "iMesh_createVtxArr: Didn't get the right # coordinates." );
    }

    // if there aren't any elements in the array, allocate it
    ALLOC_CHECK_ARRAY( new_vertex_handles, num_verts );

    // make the entities
    EntityHandle* new_verts = HANDLE_ARRAY_PTR( *new_vertex_handles );

    if( storage_order == iBase_INTERLEAVED )
    {
        if( 3 == geom_dim )
        {
            for( int i = 0; i < num_verts; i++ )
            {
                ErrorCode result = MOABI->create_vertex( &new_coords[3 * i], new_verts[i] );CHKERR( result, "iMesh_createVtxArr: couldn't create vertex." );
            }
        }
        else
        {
            double tmp[3] = { 0, 0, 0 };
            for( int i = 0; i < num_verts; i++ )
            {
                for( int j = 0; j < geom_dim; j++ )
                    tmp[j] = new_coords[geom_dim * i + j];
                ErrorCode result = MOABI->create_vertex( tmp, new_verts[i] );CHKERR( result, "iMesh_createVtxArr: couldn't create vertex." );
            }
        }
    }
    else
    {
        double tmp[3] = { 0, 0, 0 };
        for( int i = 0; i < num_verts; i++ )
        {
            for( int j = 0; j < geom_dim; j++ )
                tmp[j] = new_coords[j * num_verts + i];

            ErrorCode result = MOABI->create_vertex( tmp, new_verts[i] );CHKERR( result, "iMesh_createVtxArr: couldn't create vertex." );
        }
    }

    KEEP_ARRAY( new_vertex_handles );
    RETURN( iBase_SUCCESS );
}

void iMesh_destroyEntSet	(	iMesh_Instance	instance,
		iBase_EntitySetHandle	entity_set,
		int *	err
	)

Destroy an entity set.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set	Entity set to be destroyed
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 967 of file iMesh_MOAB.cpp.

References CHKERR, ENTITY_HANDLE, ErrorCode, iBase_SUCCESS, MOABI, and RETURN.

{
    EntityHandle set = ENTITY_HANDLE( entity_set );
    ErrorCode result = MOABI->delete_entities( &set, 1 );CHKERR( result, "iMesh_destroyEntSet: couldn't delete the set." );

    RETURN( iBase_SUCCESS );
}

void iMesh_dtor	(	iMesh_Instance	instance,
		int *	err
	)

Destroy an iMesh instance.

Initialization

Parameters:

[in]	instance	iMesh instance handle
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 287 of file iMesh_MOAB.cpp.

References iBase_SUCCESS, and MBIMESHI.

{
    delete MBIMESHI;
    *err = iBase_SUCCESS;
}

void iMesh_endEntArrIter	(	iMesh_Instance	instance,
		iBase_EntityArrIterator	entArr_iterator,
		int *	err
	)

Destroy the specified array iterator.

EntityIterators

Parameters:

[in]	instance	iMesh instance handle
[in]	entArr_iterator	Iterator which gets destroyed
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 550 of file iMesh_MOAB.cpp.

References iBase_SUCCESS, and RETURN.

{
    delete entArr_iterator;
    RETURN( iBase_SUCCESS );
}

void iMesh_endEntIter	(	iMesh_Instance	instance,
		iBase_EntityIterator	entity_iterator,
		int *	err
	)

Destroy the specified iterator.

EntityIterators Destroy the specified iterator

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_iterator	Iterator which gets destroyed
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2277 of file iMesh_MOAB.cpp.

References iMesh_endEntArrIter.

{
    iMesh_endEntArrIter( instance, reinterpret_cast< iBase_EntityArrIterator >( entity_iterator ), err );
}

void iMesh_freeMemory	(	iMesh_Instance	,
		void **	ptrToMem
	)

Free memory allocated with malloc.

Definition at line 3386 of file iMesh_MOAB.cpp.

{
    free( *ptrToMem );
    *ptrToMem = 0;
    return;
}

void iMesh_getAdjEntIndices	(	iMesh_Instance	instance,
		iBase_EntitySetHandle	entity_set_handle,
		int	entity_type_requester,
		int	entity_topology_requester,
		int	entity_type_requested,
		iBase_EntityHandle **	entity_handles,
		int *	entity_handles_allocated,
		int *	entity_handles_size,
		iBase_EntityHandle **	adj_entity_handles,
		int *	adj_entity_handles_allocated,
		int *	adj_entity_handles_size,
		int **	adj_entity_indices,
		int *	adj_entity_indices_allocated,
		int *	adj_entity_indices_size,
		int **	offset,
		int *	offset_allocated,
		int *	offset_size,
		int *	err
	)

Get indexed representation of mesh or subset of mesh.

Adjacencies Given an entity set and optionally a type or topology, return:

The entities in the set of the specified type or topology
The entities adjacent to those entities with a specified type, as a list of unique handles.
For each entity in the first list, the adjacent entities, specified as indices into the second list.

Note 1: Because 'adjacent' as defined by the iMesh data model refers to those entities that bound another, the entities being queried here (in entity_set_handle arg) are NEVER ALSO returned in adj_entity_handles even if the entity_type_requested matches the entity type(s) in entity_set_handle. Note 2: The entities adjacent to the ith entity in entity_handles are found in adj_entity_handles running from offset[i] to offset[i+1]

1. This implies that the offset_size will be entity_handles_size + 1. Note 3: This function will fail and return an error if the caller passes a combination of entity_type and entity_topology that are not consistent.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set_handle	The set of entities from which to query
[in]	entity_type_requestor	If not iBase_ALL_TYPES, act only on the subset of entities contained in entity_set_handle of the specified type.
[in]	entity_topology_requestor	If not iMesh_ALL_TOPOLOGIES, act only on the subset of entities contained in entity_set_handle of specified topology.
[in]	entity_type_requested	The type of the adjacent entities to return
[in,out]	entity_handles	The handles of the (non-struct) subset of the entities contained in entity_set_handle indicated by the optional type and topology filtering arguments. Array pointer, allocated and occupied sizes argument trio)
[in,out]	entity_handles_allocated	Allocated size of entity_handles array
[out]	entity_handles_size	Occupied size of entity_handles array
[in,out]	adj_entity_handles	The union of the unique entities of type requested_entity_type adjacent to each entity in entity_handles. Note that the implicit INTERLEAVED storage order rule applies (see iBase_StorageOrder) Array pointer, allocated and occupied sizes argument trio)
[in,out]	adj_entity_handles_allocated	Allocated size of adj_entity_handles array
[out]	adj_entity_handles_size	Occupied size of adj_entity_handles array
[in,out]	adj_entity_indices	For each entity in entity_handles, the adjacent entities of type entity_type_requested, specified as indices into adj_entity_handles. The values are concatenated into a single array in the order of the entity handles in entity_handles. Array pointer, allocated and occupied sizes argument trio)
[in,out]	adj_entity_indices_allocated	Allocated size of adj_entity_indices array
[out]	adj_entity_indices_size	Occupied size of adj_entity_indices array
[in,out]	offset	For each entity in the corresponding position in entity_handles, the position in adj_entity_indices at which values for that entity are stored Array pointer, allocated and occupied sizes argument trio)
[in,out]	offset_allocated	Allocated size of offset array
[out]	offset_size	Occipied size of offset array
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 799 of file iMesh_MOAB.cpp.

References iBase_BAD_ARRAY_DIMENSION, iBase_MEMORY_ALLOCATION_FAILED, iBase_SUCCESS, iMesh_getEntArrAdj, iMesh_getEntities, and size.

{
    const int allocated_entity_handles = ( *entity_handles_allocated == 0 );
    const int allocated_indices        = ( *adj_entity_indices_allocated == 0 );
    const int allocated_offset         = ( *offset_allocated == 0 );

    // get source entities
    iMesh_getEntities( instance, entity_set_handle, entity_type_requestor, entity_topology_requestor, entity_handles,
                       entity_handles_allocated, entity_handles_size, err );
    if( iBase_SUCCESS != *err ) return;

    // get adjacencies
    iBase_EntityHandle* all_adj_handles = 0;
    int size = 0, alloc = 0;
    iMesh_getEntArrAdj( instance, *entity_handles, *entity_handles_size, entity_type_requested, &all_adj_handles,
                        &alloc, &size, offset, offset_allocated, offset_size, err );
    if( *err != iBase_SUCCESS )
    {
        if( allocated_entity_handles )
        {
            free( *entity_handles );
            *entity_handles           = 0;
            *entity_handles_allocated = 0;
        }
        return;
    }

    // allocate or check size of adj_entity_indices
    *adj_entity_indices_size = size;
    if( allocated_indices )
    {
        *adj_entity_indices = (int*)malloc( sizeof( iBase_EntityHandle ) * size );
        if( !*adj_entity_indices )
            *err = iBase_MEMORY_ALLOCATION_FAILED;
        else
            *adj_entity_indices_allocated = size;
    }
    else if( *adj_entity_indices_allocated < size )
    {
        *err = iBase_BAD_ARRAY_DIMENSION;
    }
    if( iBase_SUCCESS != *err )
    {
        free( all_adj_handles );
        if( allocated_entity_handles )
        {
            free( *entity_handles );
            *entity_handles           = 0;
            *entity_handles_allocated = 0;
        }
        if( allocated_offset )
        {
            free( *offset );
            *offset           = 0;
            *offset_allocated = 0;
        }
        return;
    }

    // Now create an array of unique sorted handles from all_adj_handles.
    // We need to create a copy because we still need all_adj_handles.  We
    // will eventually need to copy the resulting unique list into
    // adj_entity_handles, so if adj_entity_handles is already allocated and
    // of sufficient size, use it rather than allocating another temporary.
    iBase_EntityHandle* unique_adj = 0;
    if( *adj_entity_handles_allocated >= size )
    {
        unique_adj = *adj_entity_handles;
    }
    else
    {
        unique_adj = (iBase_EntityHandle*)malloc( sizeof( iBase_EntityHandle ) * size );
    }
    std::copy( all_adj_handles, all_adj_handles + size, unique_adj );
    std::sort( unique_adj, unique_adj + size );
    *adj_entity_handles_size = std::unique( unique_adj, unique_adj + size ) - unique_adj;

    // If we created a temporary array for unique_adj rather than using
    // already allocated space in adj_entity_handles, allocate adj_entity_handles
    // and copy the unique handle list into it
    if( *adj_entity_handles != unique_adj )
    {
        if( !*adj_entity_handles_allocated )
        {
            *adj_entity_handles =
                (iBase_EntityHandle*)malloc( sizeof( iBase_EntityHandle ) * *adj_entity_handles_size );
            if( !*adj_entity_handles )
                *err = iBase_MEMORY_ALLOCATION_FAILED;
            else
                *adj_entity_handles_allocated = *adj_entity_handles_size;
        }
        else if( *adj_entity_handles_allocated < *adj_entity_handles_size )
            *err = iBase_BAD_ARRAY_DIMENSION;
        if( iBase_SUCCESS != *err )
        {
            free( unique_adj );
            free( all_adj_handles );
            if( allocated_entity_handles )
            {
                free( *entity_handles );
                *entity_handles           = 0;
                *entity_handles_allocated = 0;
            }
            if( allocated_offset )
            {
                free( *offset );
                *offset           = 0;
                *offset_allocated = 0;
            }
            if( allocated_indices )
            {
                free( *adj_entity_indices );
                *adj_entity_indices           = 0;
                *adj_entity_indices_allocated = 0;
            }
            return;
        }

        std::copy( unique_adj, unique_adj + *adj_entity_handles_size, *adj_entity_handles );
        free( unique_adj );
        unique_adj = *adj_entity_handles;
    }

    // convert from adjacency list to indices into unique_adj
    for( int i = 0; i < *adj_entity_indices_size; ++i )
        ( *adj_entity_indices )[i] =
            std::lower_bound( unique_adj, unique_adj + *adj_entity_handles_size, all_adj_handles[i] ) - unique_adj;
    free( all_adj_handles );
}

void iMesh_getAdjTable	(	iMesh_Instance	instance,
		int **	adjacency_table,
		int *	adjacency_table_allocated,
		int *	adjacency_table_size,
		int *	err
	)

Get the adjacency table for this implementation.

Adjacencies Get the adjacency table for this implementation. This table is a 4x4 array whose entries characterize how the implementation behaves when adjacent and intermediate entities are queried. Entry [i,j] (i=row, j=col, 0-based indexing) will have one of the values in the iBase_AdjacencyCost enumeration. Off-diagonal entres, i!=j, represents the relative cost of retrieving entities of dimension i adjacent to entities of dimension j. Diagonal entries, i==j, indicate whether or not handles to ALL entities of that dimension are obtainable from calls that return entity handles. This is always true by definition for i==j==0 as well as for i==j==2 in a 2D mesh and i==j==3 in a 3D mesh. However, diagonal entries [1,1] for a 2D mesh and both [1,1] and [2,2] for a 3D mesh indicate whether or not handles to ALL intermediate dimensioned entities (ALL edges in a 2D mesh or ALL edges and ALL faces in a 3D mesh) are obtainable from calls that return entity handles. A value of iBase_AVAILABLE for a diagonal entry indicates that handles are obtainable for ALL entities of that dimension while a value of iBase_UNAVAILABLE indicates that handles are not obtainable for ALL entities of that dimension.

Parameters:

[in]	instance	iMesh instance handle
[out]	adjacency_table	Pointer to array representing adjacency table Array pointer, allocated and occupied sizes argument trio)
[in,out]	adjacency_table_allocated	Pointer to allocated size of adjacency_table
[out]	adjacency_table_size	Pointer to occupied size of adjacency_table
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 381 of file iMesh_MOAB.cpp.

References ALLOC_CHECK_ARRAY_NOFAIL, iBase_SUCCESS, iMesh_getGeometricDimension, MBIMESHI, munge_adj_table(), and RETURN.

{
    int geom_dim;
    iMesh_getGeometricDimension( instance, &geom_dim, err );

    ALLOC_CHECK_ARRAY_NOFAIL( adjacency_table, 16 );
    memcpy( *adjacency_table, MBIMESHI->AdjTable, 16 * sizeof( int ) );
    munge_adj_table( *adjacency_table, geom_dim );
    RETURN( iBase_SUCCESS );
}

void iMesh_getChldn	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	from_entity_set,
		const int	num_hops,
		iBase_EntitySetHandle **	entity_set_handles,
		int *	entity_set_handles_allocated,
		int *	entity_set_handles_size,
		int *	err
	)

Get the child sets linked from a specified set.

ParentChildLinks Get the child sets linked from a specified set.

Parameters:

[in]	instance	iMesh instance handle
[in]	from_entity_set	Entity set being queried
[in]	num_hops	Maximum hops from entity_set_handle to child set, Indirection in Set-Inclusion and Parent-Child structures)
[in,out]	entity_set_handles	Pointer to array of child sets Array pointer, allocated and occupied sizes argument trio)
[in,out]	entity_set_handles_allocated	Pointer to allocated size of
[out]	entity_set_handles_size	Pointer to occupied size of
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1223 of file iMesh_MOAB.cpp.

References ALLOC_CHECK_ARRAY_NOFAIL, children, CHKERR, ENTITY_HANDLE, ERROR, ErrorCode, HANDLE_ARRAY_PTR, iBase_INVALID_ENTITYSET_HANDLE, iBase_SUCCESS, MB_ENTITY_NOT_FOUND, MOABI, and RETURN.

{
    std::vector< EntityHandle > children;

    ErrorCode result = MOABI->get_child_meshsets( ENTITY_HANDLE( from_entity_set ), children, num_hops + 1 );

    if( result == MB_ENTITY_NOT_FOUND )
        ERROR( iBase_INVALID_ENTITYSET_HANDLE, "iMesh_getChldn: ERROR invalid entity set." );CHKERR( result, "ERROR getChildren failed." );
    ALLOC_CHECK_ARRAY_NOFAIL( entity_set_handles, children.size() );

    EntityHandle* ents = HANDLE_ARRAY_PTR( *entity_set_handles );
    // use a memcpy for efficiency
    memcpy( ents, &children[0], children.size() * sizeof( EntityHandle ) );

    RETURN( iBase_SUCCESS );
}

void iMesh_getData	(	iMesh_Instance	instance,
		const iBase_EntityHandle	entity_handle,
		const iBase_TagHandle	tag_handle,
		void *	tag_value,
		int *	tag_value_allocated,
		int *	tag_value_size,
		int *	err
	)

Get the value of a tag of arbitrary type on an entity.

Get the value of a tag of arbitrary type on an entity. Tag data is passed back as void*. tag_value_size specifies the size of the memory pointed to by tag_value in terms of bytes. Applications may use this function to get data of any type, not just iBase_BYTES. However, because this function supports arbitrary type, in all cases the size specified by tag_value_size is always in terms of bytes.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_handle	Entity on which tag is being set
[in]	tag_handle	Tag being set on an entity
[in,out]	tag_value	Pointer to tag data array being queried Array pointer, allocated and occupied sizes argument trio)
[in,out]	tag_value_allocated	Pointer to tag data array allocated size
[out]	tag_value_size	Pointer to occupied size in bytes of tag data
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2104 of file iMesh_MOAB.cpp.

References iMesh_getArrData.

{
    iMesh_getArrData( instance, &entity_handle, 1, tag_handle, tag_value, tag_value_allocated, tag_value_size, err );
}

void iMesh_getDblData	(	iMesh_Instance	instance,
		const iBase_EntityHandle	entity_handle,
		const iBase_TagHandle	tag_handle,
		double *	out_data,
		int *	err
	)

Get the value of a tag of double type on an entity.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_handle	Entity on which tag is being set
[in]	tag_handle	Tag being set on an entity
[out]	out_data	Pointer to tag value returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2127 of file iMesh_MOAB.cpp.

References CHKTAGTYPE, iBase_DOUBLE, and iMesh_getArrData.

{
    CHKTAGTYPE( tag_handle, iBase_DOUBLE );
    void* val_ptr = out_data;
    int val_size  = sizeof( double );
    iMesh_getArrData( instance, &entity_handle, 1, tag_handle, &val_ptr, &val_size, &val_size, err );
}

void iMesh_getDescription	(	iMesh_Instance	instance,
		char *	descr,
		int	descr_len
	)

Get a description of the error returned from the last iMesh function.

ErrorHandling

Parameters:

[in]	instance	iMesh instance handle
[in,out]	descr	Pointer to a character string to be filled with a description of the error from the last iMesh function
[in]	descr_len	Length of the character string pointed to by descr (String Length Arguments)

Definition at line 228 of file iMesh_MOAB.cpp.

References MBIMESHI, and MIN.

{
    if( instance == NULL )
    {
        strcpy( descr, "iMesh_getDescription: Invalid instance" );
    }
    else
    {
        unsigned int len = MIN( strlen( MBIMESHI->lastErrorDescription ), static_cast< unsigned int >( descr_len ) );
        strncpy( descr, MBIMESHI->lastErrorDescription, len );
        descr[len] = '\0';
    }
}

void iMesh_getDfltStorage	(	iMesh_Instance	instance,
		int *	order,
		int *	err
	)

Get the default storage order used by this implementation.

Initialization Get the default storage order used by this implementation. Value returned is a member of the iBase_StorageOrder enumeration.

Parameters:

[in]	instance	iMesh instance handle
[out]	order	Pointer to storage order returned from function (

See also:: iBase_StorageOrder)

Parameters:

[out] err Returned Error status (see iBase_ErrorType)

Definition at line 375 of file iMesh_MOAB.cpp.

References iBase_BLOCKED, iBase_SUCCESS, and RETURN.

{
    *order = iBase_BLOCKED;
    RETURN( iBase_SUCCESS );
}

void iMesh_getEHData	(	iMesh_Instance	instance,
		const iBase_EntityHandle	entity_handle,
		const iBase_TagHandle	tag_handle,
		iBase_EntityHandle *	out_data,
		int *	err
	)

Get the value of a tag of entity handle type on an entity.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_handle	Entity on which tag is being set
[in]	tag_handle	Tag being set on an entity
[out]	out_data	Pointer to tag value returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2139 of file iMesh_MOAB.cpp.

References CHKTAGTYPE, moab::dum, iBase_ENTITY_HANDLE, and iMesh_getArrData.

{
    CHKTAGTYPE( tag_handle, iBase_ENTITY_HANDLE );
    void* val_ptr = out_data;
    int dum       = sizeof( iBase_EntityHandle );
    iMesh_getArrData( instance, &entity_handle, 1, tag_handle, &val_ptr, &dum, &dum, err );
}

void iMesh_getEnt2ndAdj	(	iMesh_Instance	instance,
		iBase_EntityHandle	entity_handle,
		int	bridge_entity_type,
		int	requested_entity_type,
		iBase_EntityHandle **	adjacent_entities,
		int *	adjacent_entities_allocated,
		int *	adjacent_entities_size,
		int *	err
	)

Get "2nd order" adjacencies to an entity.

Adjacencies Get "2nd order" adjacencies to an entity, that is, from an entity, through other entities of a specified "bridge" dimension, to other entities of another specified "to" dimension. Note 1: If the "bridge" dimension is the same as the "to" dimension or the dimension of the input entity, the output will be empty (and an error code of iBase_INVALID_ARGUMENT returned). This is consistent with the definition of adjacencies and the behavior of iMesh first adjacency calls. Note 2: An entity will never be returned as a second adjacency of itself, on the grounds that this is the most likely expectation of applications, and that it is easier for an application to add the original entity to the returned data than to find and remove it.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_handle	Entity from which adjacencies are requested
[in]	order_adjacent_key	Type of bridge entity for 2nd order adjacencies
[in]	requested_entity_type	Type of adjacent entities returned
[in,out]	adj_entities	Adjacent entities Array pointer, allocated and occupied sizes argument trio)
[in,out]	adj_entities_allocated	Allocated size of returned array
[out]	adj_entities_size	Occupied size of returned array
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2339 of file iMesh_MOAB.cpp.

References iMesh_getEntArr2ndAdj.

{
    int offsets[2];
    int* offsets_ptr = offsets;
    int offset_size, offset_allocated = 2;

    iMesh_getEntArr2ndAdj( instance, &entity_handle, 1, order_adjacent_key, requested_entity_type, adj_entities,
                           adj_entities_allocated, adj_entities_size, &offsets_ptr, &offset_allocated, &offset_size,
                           err );
}

void iMesh_getEntAdj	(	iMesh_Instance	instance,
		const iBase_EntityHandle	entity_handle,
		const int	entity_type_requested,
		iBase_EntityHandle **	adj_entity_handles,
		int *	adj_entity_handles_allocated,
		int *	adj_entity_handles_size,
		int *	err
	)

Get entities of specified type adjacent to an entity.

Adjacencies Get entities of specified type adjacent to an entity. Specified type must be value in the iBase_EntityType enumeration.

Note 1: Because 'adjacent' as defined by the iMesh data model refers to those entities that bound another, the entity being queried here (in entity_handle arg) is NEVER ALSO returned in adj_entity_handles even if the entity_type_requested matches the entity type in entity_handle.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_handle	Entity handle being queried
[in]	entity_type_requested	Type of adjacent entities requested
[in,out]	adj_entity_handles	Pointer to array of adjacent entities Array pointer, allocated and occupied sizes argument trio)
[in,out]	adj_entity_handles_allocated	Pointer to allocated size of adj_entity_handles
[out]	adj_entity_handles_size	Pointer to occupied size of adj_entity_handles
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2322 of file iMesh_MOAB.cpp.

References iMesh_getEntArrAdj.

{
    int offsets[2];
    int* offsets_ptr = offsets;
    int offset_size, offset_allocated = 2;

    iMesh_getEntArrAdj( instance, &entity_handle, 1, entity_type_requested, adj_entity_handles,
                        adj_entity_handles_allocated, adj_entity_handles_size, &offsets_ptr, &offset_allocated,
                        &offset_size, err );
}

void iMesh_getEntArr2ndAdj	(	iMesh_Instance	instance,
		iBase_EntityHandle const *	entity_handles,
		int	entity_handles_size,
		int	bridge_entity_type,
		int	requested_entity_type,
		iBase_EntityHandle **	adj_entity_handles,
		int *	adj_entity_handles_allocated,
		int *	adj_entity_handles_size,
		int **	offset,
		int *	offset_allocated,
		int *	offset_size,
		int *	err
	)

Get "2nd order" adjacencies to an array of entities.

Adjacencies Get "2nd order" adjacencies to an array of entities, that is, from each entity, through other entities of a specified "bridge" dimension, to other entities of another specified "to" dimension. Note 1: If the "bridge" dimension is the same as the "to" dimension, the output will be empty (and an error code of iBase_INVALID_ARGUMENT returned). If the type of a particular entity matches the "bridge" dimension, there will be no entities returned for that input entity. This is consistent with the definition of adjacencies and the behavior of iMesh first adjacency calls. Note 2: An entity will never be returned as a second adjacency of itself, on the grounds that this is the most likely expectation of applications, and that it is easier for an application to add the original entity to the returned data than to find and remove it. Note 3: The entities adjacent to the ith entity in entity_handles are found in adj_entity_handles running from offset[i] to offset[i+1] - 1. This implies that the offset_size will be entity_handles_size + 1.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_handles	Entities from which adjacencies are requested
[in]	entity_handles_size	Number of entities whose adjacencies are requested
[in]	bridge_entity_type	Type of bridge entity for 2nd order adjacencies
[in]	requested_entity_type	Type of adjacent entities returned
[in,out]	adj_entity_handles	Adjacent entities. Note that the implicit INTERLEAVED storage order rule applies (see iBase_StorageOrder) Array pointer, allocated and occupied sizes argument trio)
[in,out]	adj_entity_handles_allocated	Allocated size of returned array
[out]	adj_entity_handles_size	Occupied size of returned array
[in,out]	offset	Offset[i] is offset into adj_entity_handles of 2nd order adjacencies of ith entity in entity_handles Array pointer, allocated and occupied sizes argument trio)
[in,out]	offset_allocated	Allocated size of offset array
[out]	offset_size	Occupied size of offset array
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 731 of file iMesh_MOAB.cpp.

References ALLOC_CHECK_ARRAY, ALLOC_CHECK_ARRAY_NOFAIL, moab::Range::begin(), CHKENUM, CHKERR, moab::Range::end(), ERROR, ErrorCode, moab::MeshTopoUtil::get_bridge_adjacencies(), iBase_ALL_TYPES, iBase_INVALID_ARGUMENT, iBase_INVALID_ENTITY_TYPE, iBase_REGION, iBase_SUCCESS, iBase_VERTEX, KEEP_ARRAY, MB_SUCCESS, MOABI, RETURN, moab::Range::size(), and moab::TYPE_FROM_HANDLE().

{
    CHKENUM( bridge_entity_type, iBase_EntityType, iBase_INVALID_ENTITY_TYPE );
    CHKENUM( requested_entity_type, iBase_EntityType, iBase_INVALID_ENTITY_TYPE );

    ErrorCode result = MB_SUCCESS;

    ALLOC_CHECK_ARRAY( offset, entity_handles_size + 1 );

    const EntityHandle* entity_iter      = (const EntityHandle*)entity_handles;
    const EntityHandle* const entity_end = entity_iter + entity_handles_size;
    int* off_iter                        = *offset;
    int prev_off                         = 0;

    std::vector< EntityHandle > all_adj_ents;
    MeshTopoUtil mtu( MOABI );

    int min_bridge = iBase_VERTEX, max_bridge = iBase_REGION;
    int min_req = iBase_VERTEX, max_req = iBase_REGION;
    if( iBase_ALL_TYPES != bridge_entity_type ) min_bridge = max_bridge = bridge_entity_type;
    if( iBase_ALL_TYPES != requested_entity_type ) min_req = max_req = requested_entity_type;

    for( ; entity_iter != entity_end; ++entity_iter )
    {
        *off_iter = prev_off;
        off_iter++;
        Range adj_ents;

        int source = CN::Dimension( TYPE_FROM_HANDLE( *entity_iter ) );
        for( int bridge = min_bridge; bridge <= max_bridge; ++bridge )
        {
            if( source == bridge ) continue;
            for( int requested = min_req; requested <= max_req; ++requested )
            {
                if( bridge == requested ) continue;
                result = mtu.get_bridge_adjacencies( *entity_iter, bridge, requested, adj_ents );CHKERR( result, "iMesh_getEntArr2ndAdj: trouble getting adjacency list." );
            }
        }

        std::copy( adj_ents.begin(), adj_ents.end(), std::back_inserter( all_adj_ents ) );
        prev_off += adj_ents.size();
    }
    *off_iter = prev_off;

    ALLOC_CHECK_ARRAY_NOFAIL( adj_entity_handles, all_adj_ents.size() );
    memcpy( *adj_entity_handles, &all_adj_ents[0], sizeof( EntityHandle ) * all_adj_ents.size() );

    KEEP_ARRAY( offset );

    // Return an error if the bridge and requested entity types are different
    if( iBase_ALL_TYPES != bridge_entity_type && bridge_entity_type == requested_entity_type )
        ERROR( iBase_INVALID_ARGUMENT, "iMesh_getEntArr2ndAdj: bridge and "
                                       "requested entity types must be different." );
    else
        RETURN( iBase_SUCCESS );
}

void iMesh_getEntArrAdj	(	iMesh_Instance	instance,
		const iBase_EntityHandle *	entity_handles,
		const int	entity_handles_size,
		const int	entity_type_requested,
		iBase_EntityHandle **	adjacentEntityHandles,
		int *	adjacentEntityHandles_allocated,
		int *	adj_entity_handles_size,
		int **	offset,
		int *	offset_allocated,
		int *	offset_size,
		int *	err
	)

Get entities of specified type adjacent to entities.

Adjacencies Get entities of specified type adjacent to entities. Specified type must be value in the iBase_EntityType enumeration. offset(i) is index of first entity in adjacentEntityHandles array adjacent to entity_handles[i]. More precisely, the entities adjacent to the ith entity in entity_handles are found in adjacentEntityHandles running from offset[i] to offset[i+1] - 1. This implies that the offset_size will be entity_handles_size + 1.

Note 1: Because 'adjacent' as defined by the iMesh data model refers to those entities that bound another, the entities being queried here (in entity_handles arg) are NEVER ALSO returned in adjacentEntityHandles even if the entity_type_requested matches the entity type(s) in entity_handles.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_handles	Array of entity handles being queried
[in]	entity_handles_size	Number of entities in entity_handles array
[in]	entity_type_requested	Type of adjacent entities requested
[in,out]	adjacentEntityHandles	Pointer to array of adjacentEntityHandles Array pointer, allocated and occupied sizes argument trio) returned from function. Note that the implicit INTERLEAVED storage order rule applies (see iBase_StorageOrder)
[in,out]	adjacentEntityHandles_allocated	Pointer to allocated size of adjacentEntityHandles array
[out]	adjacentEntityHandles_size	Pointer to occupied size of adjacentEntityHandles array
[in,out]	offset	Pointer to array of offsets returned from function Array pointer, allocated and occupied sizes argument trio)
[in,out]	offset_allocated	Pointer to allocated size of offset array
[out]	offset_size	Pointer to occupied size of offset array
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 596 of file iMesh_MOAB.cpp.

References ALLOC_CHECK_ARRAY, dim, ERROR, ErrorCode, iBase_ALL_TYPES, iBase_BAD_ARRAY_SIZE, iBase_MEMORY_ALLOCATION_FAILED, iBase_SUCCESS, iBase_VERTEX, KEEP_ARRAY, MB_SUCCESS, MBPOLYHEDRON, MOABI, RETURN, moab::TYPE_FROM_HANDLE(), and smoab::UNION.

{
    ErrorCode result = MB_SUCCESS;

    ALLOC_CHECK_ARRAY( offset, entity_handles_size + 1 );

    const EntityHandle* entity_iter      = (const EntityHandle*)entity_handles;
    const EntityHandle* const entity_end = entity_iter + entity_handles_size;
    int* off_iter                        = *offset;
    int prev_off                         = 0;

    std::vector< EntityHandle > conn_storage;
    std::vector< EntityHandle > adj_ents;
    const EntityHandle* connect;
    int num_connect;

    EntityHandle* array;  // ptr to working array of result handles
    int array_alloc;      // allocated size of 'array'
    const bool allocated_array = !*adjacentEntityHandles_allocated || !*adjacentEntityHandles;
    if( allocated_array )
    {
        array       = 0;
        array_alloc = 0;
    }
    else
    {
        array       = reinterpret_cast< EntityHandle* >( *adjacentEntityHandles );
        array_alloc = *adjacentEntityHandles_allocated;
    }

    for( ; entity_iter != entity_end; ++entity_iter )
    {
        *off_iter = prev_off;
        off_iter++;

        if( iBase_VERTEX == entity_type_requested && TYPE_FROM_HANDLE( *entity_iter ) != MBPOLYHEDRON )
        {
            if( CN::Dimension( TYPE_FROM_HANDLE( *entity_iter ) ) == 0 ) continue;
            result = MOABI->get_connectivity( *entity_iter, connect, num_connect, false, &conn_storage );
            if( MB_SUCCESS != result )
            {
                if( allocated_array ) free( array );
                ERROR( result, "iMesh_getEntArrAdj: trouble getting adjacency list." );
            }
        }
        else if( iBase_ALL_TYPES == entity_type_requested )
        {
            adj_ents.clear();
            for( int dim = 0; dim < 4; ++dim )
            {
                if( CN::Dimension( TYPE_FROM_HANDLE( *entity_iter ) ) == dim ) continue;
                result = MOABI->get_adjacencies( entity_iter, 1, dim, false, adj_ents, Interface::UNION );
                if( MB_SUCCESS != result )
                {
                    if( allocated_array ) free( array );
                    ERROR( result, "iMesh_getEntArrAdj: trouble getting adjacency list." );
                }
            }
            connect     = &adj_ents[0];
            num_connect = adj_ents.size();
        }
        else
        {
            if( CN::Dimension( TYPE_FROM_HANDLE( *entity_iter ) ) == entity_type_requested ) continue;
            adj_ents.clear();
            result = MOABI->get_adjacencies( entity_iter, 1, entity_type_requested, false, adj_ents );
            if( MB_SUCCESS != result )
            {
                if( allocated_array ) free( array );
                ERROR( result, "iMesh_getEntArrAdj: trouble getting adjacency list." );
            }
            connect     = &adj_ents[0];
            num_connect = adj_ents.size();
        }

        if( prev_off + num_connect <= array_alloc )
        {
            std::copy( connect, connect + num_connect, array + prev_off );
        }
        else if( allocated_array )
        {
            // if array is not allocated yet, guess at initial size
            // as the number of adjacencies for the first entity times
            // the number of input entities.  This will result in a single
            // exact allocation if one input entity or typical queries
            // such as connectivity of a non-mixed mesh or regions adjacent
            // to faces.
            if( !array_alloc )
                array_alloc = entity_handles_size * num_connect;
            else
                array_alloc = std::max( array_alloc * 2, prev_off + num_connect );
            EntityHandle* new_array = (EntityHandle*)realloc( array, array_alloc * sizeof( EntityHandle ) );
            if( !new_array )
            {
                free( array );
                RETURN( iBase_MEMORY_ALLOCATION_FAILED );
            }
            else
                array = new_array;
            std::copy( connect, connect + num_connect, array + prev_off );
        }
        // else do nothing.  Will catch error later when comparing
        //  occupied to allocated sizes.  Continue here because
        //  must pass back required size.

        prev_off += num_connect;
    }
    *off_iter                   = prev_off;
    *adjacentEntityHandles_size = prev_off;

    if( *adjacentEntityHandles_size > array_alloc )
    {
        if( allocated_array ) free( array );
        RETURN( iBase_BAD_ARRAY_SIZE );
    }
    else if( allocated_array )
    {
        *adjacentEntityHandles           = reinterpret_cast< iBase_EntityHandle* >( array );
        *adjacentEntityHandles_allocated = array_alloc;
    }

    KEEP_ARRAY( offset );
    RETURN( iBase_SUCCESS );
}

void iMesh_getEntitiesRec	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set_handle,
		const int	entity_type,
		const int	entity_topology,
		const int	recursive,
		iBase_EntityHandle **	entity_handles,
		int *	entity_handles_allocated,
		int *	entity_handles_size,
		int *	err
	)

Get entities of specific type and/or topology in set or instance, recursive.

Get entities of specific type and/or topology in set or instance. If recursive is passed in non-zero, includes entities in owned sets. All entities of a given type or topology are requested by specifying iBase_ALL_TOPOLOGIES or iBase_ALL_TYPES, respectively. Specified type or topology must be a value in the iBase_EntityType or iMesh_EntityTopology enumeration, respectively.

Parameters:

instance	iMesh instance handle
entity_set_handle	Entity set being queried
entity_type	Type of entities being requested
entity_topology	Topology of entities being requested
recursive	If non-zero, gets entities in owned sets too
*entity_handles	Pointer to array of entity handles returned from function
*entity_handles_allocated	Pointer to allocated size of entity_handles array
*entity_handles_size	Pointer to occupied size of entity_handles array
*err	Pointer to error type returned from function

Definition at line 2555 of file iMesh_MOAB.cpp.

References ALLOC_CHECK_ARRAY_NOFAIL, CHKENUM, CHKERR, ENTITY_HANDLE, ERROR, ErrorCode, iBase_ALL_TYPES, iBase_BAD_TYPE_AND_TOPO, iBase_INVALID_ENTITY_TOPOLOGY, iBase_INVALID_ENTITY_TYPE, iBase_REGION, iBase_SUCCESS, iMesh_ALL_TOPOLOGIES, iMesh_SEPTAHEDRON, MB_SUCCESS, mb_topology_table, MBENTITYSET, MOABI, RETURN, and moab::TYPE_FROM_HANDLE().

{
    CHKENUM( entity_type, iBase_EntityType, iBase_INVALID_ENTITY_TYPE );
    CHKENUM( entity_topology, iMesh_EntityTopology, iBase_INVALID_ENTITY_TOPOLOGY );

    bool use_top = false;
    // initialize just to get rid of compiler warning
    EntityType type = mb_topology_table[iMesh_ALL_TOPOLOGIES];
    std::vector< EntityHandle > out_entities;

    if( entity_topology != iMesh_ALL_TOPOLOGIES )
    {
        type    = mb_topology_table[entity_topology];
        use_top = true;

        if( entity_type != iBase_ALL_TYPES )
        {
            if( entity_topology != iMesh_SEPTAHEDRON && entity_type != CN::Dimension( type ) )
                ERROR( iBase_BAD_TYPE_AND_TOPO, "type and topology are inconsistant" );

            // Special-case handling for septahedra since we don't support them
            else if( entity_topology == iMesh_SEPTAHEDRON && entity_type != iBase_REGION )
                ERROR( iBase_BAD_TYPE_AND_TOPO, "type and topology are inconsistant" );
        }
    }

    EntityHandle handle = ENTITY_HANDLE( entity_set_handle );
    ErrorCode result;

    if( use_top )
    {
        if( entity_topology == iMesh_SEPTAHEDRON )
            result = MB_SUCCESS;  // MOAB doesn't do septahedrons, so there are never any.
        else
            result = MOABI->get_entities_by_type( handle, type, out_entities, recursive );
    }
    else if( entity_type != iBase_ALL_TYPES )
        result = MOABI->get_entities_by_dimension( handle, entity_type, out_entities, recursive );
    else
        result = MOABI->get_entities_by_handle( handle, out_entities, recursive );

    CHKERR( result, "iMesh_GetEntities:ERROR getting entities." );

    // remove entity sets from the result list
    std::vector< EntityHandle >::iterator iter, end_iter;
    if( iBase_ALL_TYPES == entity_type && iMesh_ALL_TOPOLOGIES == entity_topology )
    {
        for( iter = out_entities.begin(); iter != out_entities.end() && TYPE_FROM_HANDLE( *iter ) != MBENTITYSET;
             ++iter )
            ;
        for( end_iter = iter; iter != out_entities.end(); ++iter )
            if( TYPE_FROM_HANDLE( *iter ) != MBENTITYSET ) *( end_iter++ ) = *iter;
        out_entities.erase( end_iter, out_entities.end() );
    }

    int num_ents = out_entities.size();

    ALLOC_CHECK_ARRAY_NOFAIL( entity_handles, num_ents );

    int k = 0;

    // filter out entity sets here
    for( iter = out_entities.begin(); iter != out_entities.end(); ++iter )
        ( *entity_handles )[k++] = (iBase_EntityHandle)*iter;

    // now it's safe to set the size; set it to k, not out_entities.size(), to
    // account for sets which might have been removed
    *entity_handles_size = k;

    RETURN( iBase_SUCCESS );
}

void iMesh_getEntsByTagsRec	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set_handle,
		const int	entity_type,
		const int	entity_topology,
		const iBase_TagHandle *	tag_handles,
		const char const	tag_vals,
		const int	num_tags_vals,
		const int	recursive,
		iBase_EntityHandle **	entity_handles,
		int *	entity_handles_allocated,
		int *	entity_handles_size,
		int *	err
	)

Get entities with specified type, topology, tag(s) and (optionally) tag value(s)

Get entities with the specified type, topology, tag(s), and optionally tag value(s). If tag values pointer is input as zero, entities with specified tag(s) are returned, regardless of their value.

Parameters:

instance	iMesh instance handle
entity_set_handle	Entity set being queried
entity_type	Type of entities being requested
entity_topology	Topology of entities being requested
tag_handles	Array of tag handles
tag_vals	Array of tag values (zero if values not requested)
num_tags_vals	Number of tags and optionally values
recursive	If non-zero, gets entities in owned sets too
*entity_handles	Pointer to array of entity handles returned from function
*entity_handles_allocated	Pointer to allocated size of entity_handles array
*entity_handles_size	Pointer to occupied size of entity_handles array
*err	Pointer to error type returned from function

Definition at line 2759 of file iMesh_MOAB.cpp.

References ALLOC_CHECK_ARRAY_NOFAIL, moab::Range::begin(), CHKENUM, CHKERR, moab::Range::end(), ENTITY_HANDLE, ERROR, ErrorCode, iBase_ALL_TYPES, iBase_BAD_TYPE_AND_TOPO, iBase_INVALID_ENTITY_TOPOLOGY, iBase_INVALID_ENTITY_TYPE, iBase_REGION, iBase_SUCCESS, iMesh_ALL_TOPOLOGIES, iMesh_SEPTAHEDRON, INTERSECT, MB_SUCCESS, mb_topology_table, MBENTITYSET, moab::Range::merge(), MOABI, RETURN, and moab::Range::size().

{
    CHKENUM( entity_type, iBase_EntityType, iBase_INVALID_ENTITY_TYPE );
    CHKENUM( entity_topology, iMesh_EntityTopology, iBase_INVALID_ENTITY_TOPOLOGY );

    bool use_top = false;
    // initialize just to get rid of compiler warning
    EntityType type = mb_topology_table[iMesh_ALL_TOPOLOGIES];
    Range out_entities;

    if( entity_topology != iMesh_ALL_TOPOLOGIES )
    {
        type    = mb_topology_table[entity_topology];
        use_top = true;

        if( entity_type != iBase_ALL_TYPES )
        {
            if( entity_topology != iMesh_SEPTAHEDRON && entity_type != CN::Dimension( type ) )
                ERROR( iBase_BAD_TYPE_AND_TOPO, "type and topology are inconsistant" );

            // Special-case handling for septahedra since we don't support them
            else if( entity_topology == iMesh_SEPTAHEDRON && entity_type != iBase_REGION )
                ERROR( iBase_BAD_TYPE_AND_TOPO, "type and topology are inconsistant" );
        }
    }

    EntityHandle handle = ENTITY_HANDLE( entity_set_handle );
    ErrorCode result    = MB_SUCCESS;

    if( use_top )
    {
        if( entity_topology == iMesh_SEPTAHEDRON )
            result = MB_SUCCESS;  // MOAB doesn't do septahedrons, so there are never any.
        else
            result =
                MOABI->get_entities_by_type_and_tag( handle, type, (Tag*)tag_handles, (const void* const*)tag_vals,
                                                     num_tags_vals, out_entities, Interface::INTERSECT, recursive );
    }
    else if( entity_type != iBase_ALL_TYPES )
    {
        // need to loop over all types of this dimension
        DimensionPair dimpair = CN::getDimPair( entity_type );
        for( EntityType tp = dimpair.first; tp <= dimpair.second; tp++ )
        {
            Range tmp_range;
            ErrorCode tmp_result =
                MOABI->get_entities_by_type_and_tag( handle, type, (Tag*)tag_handles, (const void* const*)tag_vals,
                                                     num_tags_vals, tmp_range, Interface::INTERSECT, recursive );
            if( MB_SUCCESS != tmp_result )
                result = tmp_result;
            else
                out_entities.merge( tmp_range );
        }
    }
    else
        result = MOABI->get_entities_by_type_and_tag( handle, type, (Tag*)tag_handles, (const void* const*)tag_vals,
                                                      num_tags_vals, out_entities, Interface::INTERSECT, recursive );

    CHKERR( result, "iMesh_GetEntities:ERROR getting entities." );

    ALLOC_CHECK_ARRAY_NOFAIL( entity_handles, out_entities.size() );

    Range::iterator iter     = out_entities.begin();
    Range::iterator end_iter = out_entities.end();
    int k                    = 0;

    // filter out entity sets here
    if( iBase_ALL_TYPES == entity_type && iMesh_ALL_TOPOLOGIES == entity_topology )
    {
        for( ; iter != end_iter && MOABI->type_from_handle( *iter ) != MBENTITYSET; ++iter )
            ( *entity_handles )[k++] = (iBase_EntityHandle)*iter;
    }
    else
    {
        for( ; iter != end_iter; ++iter )
            ( *entity_handles )[k++] = (iBase_EntityHandle)*iter;
    }

    // now it's safe to set the size; set it to k, not out_entities.size(), to
    // account for sets which might have been removed
    *entity_handles_size = k;

    RETURN( iBase_SUCCESS );
}

void iMesh_getEntSetData	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set_handle,
		const iBase_TagHandle	tag_handle,
		void *	tag_value,
		int *	tag_value_allocated,
		int *	tag_value_size,
		int *	err
	)

Get the value of a tag of arbitrary type on an entity set.

Get the value of a tag of arbitrary type on an entity set. Tag data is returned back as void*. tag_value_size specifies the size of the memory pointed to by tag_value in terms of bytes. Applications may use this function to get data of any type, not just iBase_BYTES. However because this function supports data of arbitrary type, in all cases the size specified by tag_value_size is always in terms of bytes.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set_handle	Entity set on which tag is being set
[in]	tag_handle	Tag being set on an entity set
[in,out]	tag_value	Pointer to tag data array being queried Array pointer, allocated and occupied sizes argument trio)
[in,out]	tag_value_allocated	Pointer allocated size, in bytes, of tag_value array.
[out]	tag_value_size	Pointer to occupied size, in bytes, of tag_value array.
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1694 of file iMesh_MOAB.cpp.

References ALLOC_CHECK_TAG_ARRAY, CHKERR, ENTITY_HANDLE, ErrorCode, iBase_SUCCESS, KEEP_ARRAY, MOABI, RETURN, and TAG_HANDLE.

{
    EntityHandle eh = ENTITY_HANDLE( entity_set_handle );
    Tag tag         = TAG_HANDLE( tag_handle );

    int tag_size;
    ErrorCode result = MOABI->tag_get_bytes( tag, tag_size );CHKERR( result, "iMesh_getEntSetData: couldn't get tag size." );

    ALLOC_CHECK_TAG_ARRAY( tag_value, tag_size );

    result = MOABI->tag_get_data( tag, &eh, 1, *static_cast< void** >( tag_value ) );

    CHKERR( result, "iMesh_getEntSetData didn't succeed." );
    KEEP_ARRAY( tag_value );
    RETURN( iBase_SUCCESS );
}

void iMesh_getEntSetDblData	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set,
		const iBase_TagHandle	tag_handle,
		double *	out_data,
		int *	err
	)

Get the value of a tag of double type on an entity set.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set	Entity set on which tag is being set
[in]	tag_handle	Tag being set on an entity set
[out]	out_data	Pointer to tag value returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1729 of file iMesh_MOAB.cpp.

References CHKTAGTYPE, iBase_DOUBLE, and iMesh_getEntSetData.

{
    CHKTAGTYPE( tag_handle, iBase_DOUBLE );
    void* tag_ptr = out_data;
    int tag_size  = sizeof( double );
    iMesh_getEntSetData( instance, entity_set, tag_handle, &tag_ptr, &tag_size, &tag_size, err );
}

void iMesh_getEntSetEHData	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set,
		const iBase_TagHandle	tag_handle,
		iBase_EntityHandle *	out_data,
		int *	err
	)

Get the value of a tag of entity handle type on an entity set.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set	Entity set on which tag is being set
[in]	tag_handle	Tag being set on an entity set
[out]	out_data	Pointer to tag value returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1741 of file iMesh_MOAB.cpp.

References CHKTAGTYPE, iBase_ENTITY_HANDLE, and iMesh_getEntSetData.

{
    CHKTAGTYPE( tag_handle, iBase_ENTITY_HANDLE );
    void* tag_ptr = out_data;
    int tag_size  = sizeof( EntityHandle );
    iMesh_getEntSetData( instance, entity_set, tag_handle, &tag_ptr, &tag_size, &tag_size, err );
}

void iMesh_getEntSetESHData	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set,
		const iBase_TagHandle	tag_handle,
		iBase_EntitySetHandle *	out_data,
		int *	err
	)

Get the value of a tag of entity set handle type on an.

entity set Get the value of a tag of entity set handle type on an entity set.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set	Entity set on which tag is being set
[in]	tag_handle	Tag being set on an entity set
[out]	out_data	Pointer to tag value returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1753 of file iMesh_MOAB.cpp.

References CHKTAGTYPE, iBase_ENTITY_SET_HANDLE, and iMesh_getEntSetData.

{
    CHKTAGTYPE( tag_handle, iBase_ENTITY_SET_HANDLE );
    void* tag_ptr = out_data;
    int tag_size  = sizeof( EntityHandle );
    iMesh_getEntSetData( instance, entity_set, tag_handle, &tag_ptr, &tag_size, &tag_size, err );
}

void iMesh_getEntSetIntData	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set,
		const iBase_TagHandle	tag_handle,
		int *	out_data,
		int *	err
	)

Get the value of a tag of integer type on an entity set.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set	Entity set on which tag is being set
[in]	tag_handle	Tag being set on an entity set
[out]	out_data	Pointer to tag value returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1717 of file iMesh_MOAB.cpp.

References CHKTAGTYPE, iBase_INTEGER, and iMesh_getEntSetData.

{
    CHKTAGTYPE( tag_handle, iBase_INTEGER );
    void* tag_ptr = out_data;
    int dum_size  = sizeof( int );
    iMesh_getEntSetData( instance, entity_set, tag_handle, &tag_ptr, &dum_size, &dum_size, err );
}

void iMesh_getEntSets	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set_handle,
		const int	num_hops,
		iBase_EntitySetHandle **	contained_set_handles,
		int *	contained_set_handles_allocated,
		int *	contained_set_handles_size,
		int *	err
	)

Get the entity sets contained in a set or interface.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set_handle	Entity set being queried
[in]	num_hops	Maximum hops from entity_set_handle to contained set, not inclusive of the contained set Indirection in Set-Inclusion and Parent-Child structures)
[in,out]	contained_entset_handles	Pointer to array of set handles returned Array pointer, allocated and occupied sizes argument trio)
[in,out]	contained_entset_handles_allocated	Pointer to allocated length of
[out]	contained_entset_handles_size	Pointer to occupied length of
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1004 of file iMesh_MOAB.cpp.

References ALLOC_CHECK_ARRAY_NOFAIL, CHKERR, ENTITY_HANDLE, ErrorCode, iBase_SUCCESS, MOABI, and RETURN.

{
    std::vector< EntityHandle > sets;
    ErrorCode rval =
        MOABI->get_contained_meshsets( ENTITY_HANDLE( entity_set_handle ), sets, std::max( num_hops + 1, 0 ) );CHKERR( rval, "iMesh_entitysetGetEntitySets: problem getting entities by type." );
    ALLOC_CHECK_ARRAY_NOFAIL( contained_entset_handles, sets.size() );

    std::copy( sets.begin(), sets.end(), (EntityHandle*)*contained_entset_handles );
    *contained_entset_handles_size = sets.size();
    RETURN( iBase_SUCCESS );
}

void iMesh_getEntSetsByTagsRec	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set_handle,
		const iBase_TagHandle *	tag_handles,
		const char const	tag_vals,
		const int	num_tags_vals,
		const int	recursive,
		iBase_EntitySetHandle **	set_handles,
		int *	set_handles_allocated,
		int *	set_handles_size,
		int *	err
	)

Get entity sets with specified tag(s) and (optionally) tag value(s)

Get entity sets with the specified tag(s) and optionally tag value(s). If tag values pointer is input as zero, entities with specified tag(s) are returned, regardless of their value.

Parameters:

instance	iMesh instance handle
entity_set_handle	Entity set being queried
tag_handles	Array of tag handles
tag_vals	Array of tag values (zero if values not requested)
num_tags_vals	Number of tags and optionally values
recursive	If non-zero, gets entities in owned sets too
*set_handles	Pointer to array of entity handles returned from function
*set_handles_allocated	Pointer to allocated size of set_handles array
*set_handles_size	Pointer to occupied size of entity_handles array
*err	Pointer to error type returned from function

Definition at line 2855 of file iMesh_MOAB.cpp.

References ALLOC_CHECK_ARRAY_NOFAIL, moab::Range::begin(), CHKERR, moab::Range::end(), ENTITY_HANDLE, ErrorCode, iBase_SUCCESS, INTERSECT, MBENTITYSET, MOABI, RETURN, and moab::Range::size().

{
    Range out_entities;

    EntityHandle handle = ENTITY_HANDLE( entity_set_handle );
    ErrorCode result;

    result = MOABI->get_entities_by_type_and_tag( handle, MBENTITYSET, (Tag*)tag_handles, (const void* const*)tag_vals,
                                                  num_tags_vals, out_entities, Interface::INTERSECT, recursive );CHKERR( result, "ERROR getting entities." );

    ALLOC_CHECK_ARRAY_NOFAIL( set_handles, out_entities.size() );

    std::copy( out_entities.begin(), out_entities.end(), ( (EntityHandle*)*set_handles ) );

    RETURN( iBase_SUCCESS );
}

void iMesh_getErrorType	(	iMesh_Instance	instance,
		int *	error_type
	)

Get the error type returned from the last iMesh function.

ErrorHandling

Parameters:

[in]	instance	iMesh instance handle
[out]	error_type	Error type returned from last iMesh function (see iBase_ErrorType)

Definition at line 220 of file iMesh_MOAB.cpp.

References iBase_FAILURE, and MBIMESHI.

{
    if( instance == NULL )
        *error_type = iBase_FAILURE;
    else
        *error_type = MBIMESHI->lastErrorType;
}

void iMesh_getESHData	(	iMesh_Instance	instance,
		const iBase_EntityHandle	entity_handle,
		const iBase_TagHandle	tag_handle,
		iBase_EntitySetHandle *	out_data,
		int *	err
	)

Get the value of a tag of entity set handle type on an.

entity Get the value of a tag of entity set handle type on an entity.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_handle	Entity on which tag is being set
[in]	tag_handle	Tag being set on an entity
[out]	out_data	Pointer to tag value returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2151 of file iMesh_MOAB.cpp.

References CHKTAGTYPE, moab::dum, iBase_ENTITY_SET_HANDLE, and iMesh_getArrData.

{
    CHKTAGTYPE( tag_handle, iBase_ENTITY_SET_HANDLE );
    void* val_ptr = out_data;
    int dum       = sizeof( iBase_EntityHandle );
    iMesh_getArrData( instance, &entity_handle, 1, tag_handle, &val_ptr, &dum, &dum, err );
}

void iMesh_getGeometricDimension	(	iMesh_Instance	instance,
		int *	geom_dim,
		int *	err
	)

Get the geometric dimension of mesh represented in this instance.

Initialization

Parameters:

[in]	instance	iMesh instance handle
[out]	geom_dim	Pointer to dimension returned from this function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 362 of file iMesh_MOAB.cpp.

References iBase_SUCCESS, MOABI, and RETURN.

{
    MOABI->get_dimension( *geom_dim );
    RETURN( iBase_SUCCESS );
}

void iMesh_getIntData	(	iMesh_Instance	instance,
		const iBase_EntityHandle	entity_handle,
		const iBase_TagHandle	tag_handle,
		int *	out_data,
		int *	err
	)

Get the value of a tag of integer type on an entity.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_handle	Entity on which tag is being set
[in]	tag_handle	Tag being set on an entity
[out]	out_data	Pointer to tag value returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2115 of file iMesh_MOAB.cpp.

References CHKTAGTYPE, iBase_INTEGER, and iMesh_getArrData.

{
    CHKTAGTYPE( tag_handle, iBase_INTEGER );
    void* val_ptr = out_data;
    int val_size  = sizeof( int );
    iMesh_getArrData( instance, &entity_handle, 1, tag_handle, &val_ptr, &val_size, &val_size, err );
}

void iMesh_getNextEntArrIter	(	iMesh_Instance	instance,
		iBase_EntityArrIterator	entArr_iterator,
		iBase_EntityHandle **	entity_handles,
		int *	entity_handles_allocated,
		int *	entity_handles_size,
		int *	has_data,
		int *	err
	)

Get entities contained in array iterator and increment iterator.

Method: getEntArrNextIter[]

Parameters:

[in]	instance	iMesh instance handle
[in]	entArr_iterator	Iterator being queried
[in,out]	entity_handles	Pointer to array of entity handles contained in current value of iterator Array pointer, allocated and occupied sizes argument trio)
[in,out]	entity_handles_allocated	Pointer to allocated size of entity_handles
[out]	entity_handles_size	Pointer to occupied size of entity_handles
[out]	has_data	Pointer to a flag indicating if the value(s) returned in entity_handles are valid. A non-zero value indicates the value(s) are valid. A zero value indicates the value(s) are NOT valid.
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 523 of file iMesh_MOAB.cpp.

References ALLOC_CHECK_ARRAY_NOFAIL, iBase_EntityArrIterator_Private::array_size(), iBase_EntityArrIterator_Private::get_entities(), iBase_SUCCESS, MOABI, and RETURN.

{
    // check the size of the destination array
    ALLOC_CHECK_ARRAY_NOFAIL( entity_handles, entArr_iterator->array_size() );
    entArr_iterator->get_entities( dynamic_cast< Core* >( MOABI ), (EntityHandle*)*entity_handles,
                                   *entity_handles_size );
    *has_data = ( *entity_handles_size != 0 );
    RETURN( iBase_SUCCESS );
}

void iMesh_getNextEntIter	(	iMesh_Instance	instance,
		iBase_EntityIterator	entity_iterator,
		iBase_EntityHandle *	entity_handle,
		int *	has_data,
		int *	err
	)

Get entity corresponding to an iterator and increment iterator.

EntityIterators Get the entity corresponding to an iterator (that is, dereference the iterator), and increment the iterator. The dereferenced value is returned in 'entity_handle'. If the iterator is at the end of the iteration, the dereferenced value will be undefined and 'has_data' will have a value of zero. Otherwise, 'has_data' will have a non-zero value.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_iterator	Iterator being queried
[out]	entity_handle	Pointer to an entity handle corresponding to the current value of iterator just prior to the call.
[out]	is_end	Pointer to a flag indicating if the value returned in entity_handle is valid. A non-zero value indicates the value is valid. A zero value indicates the value is NOT valid.
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2259 of file iMesh_MOAB.cpp.

References iMesh_getNextEntArrIter.

{
    int eh_size = 1;
    iMesh_getNextEntArrIter( instance, reinterpret_cast< iBase_EntityArrIterator >( entity_iterator ), &entity_handle,
                             &eh_size, &eh_size, is_end, err );
}

void iMesh_getNumChld	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set,
		const int	num_hops,
		int *	num_child,
		int *	err
	)

Get the number of child sets linked from a specified set.

ParentChildLinks Get the number of child sets linked from a specified set.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set	Entity set being queried
[in]	num_hops	Maximum hops from entity_set_handle to child set, not inclusive of the child set. Indirection in Set-Inclusion and Parent-Child structures)
[out]	num_child	Pointer to number of children returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1194 of file iMesh_MOAB.cpp.

References CHKERR, ENTITY_HANDLE, ERROR, ErrorCode, iBase_INVALID_ENTITYSET_HANDLE, iBase_SUCCESS, MB_ENTITY_NOT_FOUND, MOABI, and RETURN.

{
    *num_child       = 0;
    ErrorCode result = MOABI->num_child_meshsets( ENTITY_HANDLE( entity_set ), num_child, num_hops + 1 );

    if( result == MB_ENTITY_NOT_FOUND )
        ERROR( iBase_INVALID_ENTITYSET_HANDLE, "iMesh_getNumChld: ERROR invalid entity set." );CHKERR( result, "iMesh_getNumChld: ERROR GetNumChildren failed." );

    RETURN( iBase_SUCCESS );
}

void iMesh_getNumEntSets	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set_handle,
		const int	num_hops,
		int *	num_sets,
		int *	err
	)

Get the number of entity sets contained in a set or interface.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set_handle	Entity set being queried
[in]	num_hops	Maximum hops from entity_set_handle to contained set, not inclusive of the contained set. Indirection in Set-Inclusion and Parent-Child structures)
[out]	num_sets	Pointer to the number of sets returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 992 of file iMesh_MOAB.cpp.

References CHKERR, ENTITY_HANDLE, ErrorCode, iBase_SUCCESS, MOABI, and RETURN.

{
    ErrorCode rval =
        MOABI->num_contained_meshsets( ENTITY_HANDLE( entity_set_handle ), num_sets, std::max( 0, num_hops + 1 ) );CHKERR( rval, "iMesh_entitysetGetNumberEntitySets:ERROR getting number of entitysets." );

    RETURN( iBase_SUCCESS );
}

void iMesh_getNumOfTopo	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set_handle,
		const int	entity_topology,
		int *	num_topo,
		int *	err
	)

Get the number of entities of specified topology in instance or set.

Get the number of entities with the specified topology in the instance or set. If entity set handle is root set, return information for instance, otherwise for set. Value of entity topology must be from the iMesh_EntityTopology enumeration. If iMesh_ALL_TOPOLOGIES is specified, total number of entities (excluding entity sets) is returned.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set_handle	Entity set being queried
[in]	entity_topology	Topology of entity requested
[out]	num_topo	Pointer to number of entities, returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 423 of file iMesh_MOAB.cpp.

References iMesh_getNumOfTopoRec.

{
    iMesh_getNumOfTopoRec( instance, entity_set_handle, entity_topology, false, num_topo, err );
}

void iMesh_getNumOfTopoRec	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set_handle,
		const int	entity_topology,
		const int	recursive,
		int *	num_topo,
		int *	err
	)

Get the number of entities with the specified topology in the instance or set.

Get the number of entities with the specified topology in the instance or set. If recursive is passed in non-zero, includes entities in owned sets. If entity set handle is zero, return information for instance, otherwise for set. Value of entity topology must be from the iMesh_EntityTopology enumeration. If iMesh_ALL_TOPOLOGIES is specified, total number of entities (excluding entity sets) is returned.

Parameters:

instance	iMesh instance handle
entity_set_handle	Entity set being queried
entity_topology	Topology of entity requested
recursive	If non-zero, includes entities in owned sets too
num_topo	Pointer to number of entities, returned from function
*err	Pointer to error type returned from function

Definition at line 2699 of file iMesh_MOAB.cpp.

References CHKENUM, CHKERR, ENTITY_HANDLE, ErrorCode, iBase_INVALID_ENTITY_TOPOLOGY, iBase_SUCCESS, iMesh_ALL_TOPOLOGIES, iMesh_SEPTAHEDRON, MB_SUCCESS, mb_topology_table, MBENTITYSET, MOABI, and RETURN.

{
    CHKENUM( entity_topology, iMesh_EntityTopology, iBase_INVALID_ENTITY_TOPOLOGY );

    if( entity_topology == iMesh_SEPTAHEDRON )
    {
        *num_topo = 0;
        RETURN( iBase_SUCCESS );
    }

    *num_topo = 0;
    ErrorCode result;
    if( iMesh_ALL_TOPOLOGIES == entity_topology )
    {
        result = MOABI->get_number_entities_by_handle( ENTITY_HANDLE( entity_set_handle ), *num_topo, recursive );

        if( !recursive && MB_SUCCESS == result )
        {  // remove entity sets from count
            int num_sets;
            result = MOABI->get_number_entities_by_type( ENTITY_HANDLE( entity_set_handle ), MBENTITYSET, num_sets,
                                                         recursive );
            *num_topo -= num_sets;
        }
    }
    else
    {
        result = MOABI->get_number_entities_by_type( ENTITY_HANDLE( entity_set_handle ),
                                                     mb_topology_table[entity_topology], *num_topo, recursive );
    }

    CHKERR( result, "iMesh_entitysetGetNumberEntityOfTopology: ERROR getting "
                    "number of entities by topology." );
    RETURN( iBase_SUCCESS );
}

void iMesh_getNumOfType	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set_handle,
		const int	entity_type,
		int *	num_type,
		int *	err
	)

Get the number of entities of specified type in the instance or set.

Get the number of entities with the specified type in the instance or set. If entity set handle is root set, return information for instance, otherwise for set. Value of entity type must be from the iBase_EntityType enumeration. If iBase_ALL_TYPES is specified, total number of entities (excluding entity sets) is returned.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set_handle	Entity set being queried
[in]	entity_type	Type of entity requested
[out]	num_type	Pointer to number of entities, returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 414 of file iMesh_MOAB.cpp.

References iMesh_getNumOfTypeRec.

{
    iMesh_getNumOfTypeRec( instance, entity_set_handle, entity_type, false, num_type, err );
}

void iMesh_getNumOfTypeRec	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set_handle,
		const int	entity_type,
		const int	recursive,
		int *	num_type,
		int *	err
	)

Get the number of entities with the specified type in the instance or set, recursive.

Get the number of entities with the specified type in the instance or set. If recursive is passed in non-zero, includes entities in owned sets. If entity set handle is zero, return information for instance, otherwise for set. Value of entity type must be from the iBase_EntityType enumeration. If iBase_ALL_TYPES is specified, total number of entities (excluding entity sets) is returned.

Parameters:

instance	iMesh instance handle
entity_set_handle	Entity set being queried
entity_type	Type of entity requested
recursive	If non-zero, includes entities in owned sets too
num_type	Pointer to number of entities, returned from function
*err	Pointer to error type returned from function

Definition at line 2650 of file iMesh_MOAB.cpp.

References CHKENUM, CHKERR, ENTITY_HANDLE, ErrorCode, iBase_ALL_TYPES, iBase_INVALID_ENTITY_TYPE, iBase_SUCCESS, MB_SUCCESS, MBENTITYSET, MOABI, and RETURN.

{
    CHKENUM( entity_type, iBase_EntityType, iBase_INVALID_ENTITY_TYPE );

    *num_type = 0;
    ErrorCode result;
    if( entity_type == iBase_ALL_TYPES )
    {
        result = MOABI->get_number_entities_by_handle( ENTITY_HANDLE( entity_set_handle ), *num_type, recursive );
        if( MB_SUCCESS == result && !recursive )
        {
            int num_sets = 0;
            result = MOABI->get_number_entities_by_type( ENTITY_HANDLE( entity_set_handle ), MBENTITYSET, num_sets,
                                                         recursive );
            *num_type -= num_sets;
        }
    }
    else
    {
        result = MOABI->get_number_entities_by_dimension( ENTITY_HANDLE( entity_set_handle ), entity_type, *num_type,
                                                          recursive );
    }

    CHKERR( result, "iMesh_entitysetGetNumberEntityOfType: "
                    "ERROR getting number of entities by type." );

    RETURN( iBase_SUCCESS );
}

void iMesh_getNumPrnt	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set,
		const int	num_hops,
		int *	num_parent,
		int *	err
	)

Get the number of parent sets linked from a specified set.

ParentChildLinks Get the number of parent sets linked from a specified set.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set	Entity set being queried
[in]	num_hops	Maximum hops from entity_set_handle to parent set, not inclusive of the parent set. Indirection in Set-Inclusion and Parent-Child structures)
[out]	num_parent	Pointer to number of parents returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1209 of file iMesh_MOAB.cpp.

References CHKERR, ENTITY_HANDLE, ERROR, ErrorCode, iBase_INVALID_ENTITYSET_HANDLE, iBase_SUCCESS, MB_ENTITY_NOT_FOUND, MOABI, and RETURN.

{
    *num_parent      = 0;
    ErrorCode result = MOABI->num_parent_meshsets( ENTITY_HANDLE( entity_set ), num_parent, num_hops + 1 );

    if( result == MB_ENTITY_NOT_FOUND )
        ERROR( iBase_INVALID_ENTITYSET_HANDLE, "iMesh_getNumPrnt: ERROR invalid entity set." );CHKERR( result, "iMesh_getNumPrnt: ERROR GetNumParents failed." );
    RETURN( iBase_SUCCESS );
}

void iMesh_getPrnts	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	from_entity_set,
		const int	num_hops,
		iBase_EntitySetHandle **	entity_set_handles,
		int *	entity_set_handles_allocated,
		int *	entity_set_handles_size,
		int *	err
	)

Get the parent sets linked from a specified set.

ParentChildLinks Get the parent sets linked from a specified set.

Parameters:

[in]	instance	iMesh instance handle
[in]	from_entity_set	Entity set being queried
[in]	num_hops	Maximum hops from entity_set_handle to parent set, Indirection in Set-Inclusion and Parent-Child structures)
[in,out]	entity_set_handles	Pointer to array of parent sets Array pointer, allocated and occupied sizes argument trio)
[in,out]	entity_set_handles_allocated	Pointer to allocated size of
[out]	entity_set_handles_size	Pointer to occupied size of
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1246 of file iMesh_MOAB.cpp.

References ALLOC_CHECK_ARRAY_NOFAIL, CHKERR, ENTITY_HANDLE, ERROR, ErrorCode, HANDLE_ARRAY_PTR, iBase_INVALID_ENTITYSET_HANDLE, iBase_SUCCESS, MB_ENTITY_NOT_FOUND, MOABI, and RETURN.

{
    std::vector< EntityHandle > parents;

    ErrorCode result = MOABI->get_parent_meshsets( ENTITY_HANDLE( from_entity_set ), parents, num_hops + 1 );

    if( result == MB_ENTITY_NOT_FOUND )
        ERROR( iBase_INVALID_ENTITYSET_HANDLE, "iMesh_getPrnts: ERROR invalid entity set." );CHKERR( result, "ERROR getParents failed." );

    ALLOC_CHECK_ARRAY_NOFAIL( entity_set_handles, parents.size() );

    EntityHandle* ents = HANDLE_ARRAY_PTR( *entity_set_handles );
    // use a memcpy for efficiency
    memcpy( ents, &parents[0], parents.size() * sizeof( EntityHandle ) );

    RETURN( iBase_SUCCESS );
}

void iMesh_getRootSet	(	iMesh_Instance	instance,
		iBase_EntitySetHandle *	root_set,
		int *	err
	)

Get handle of the root set for this instance.

Initialization Get handle of the root set for this instance. All mesh entities in this instance can be accessed from this set.

Parameters:

[in]	instance	iMesh instance handle
[out]	root_set	Pointer to set handle returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 355 of file iMesh_MOAB.cpp.

References iBase_SUCCESS, and RETURN.

{
    *root_set = 0;
    // return CAST_TO_VOID(MOABI->get_root_set());
    RETURN( iBase_SUCCESS );
}

void iMesh_getVtxArrCoords	(	iMesh_Instance	instance,
		const iBase_EntityHandle *	vertex_handles,
		const int	vertex_handles_size,
		const int	storage_order,
		double **	coords,
		int *	coords_allocated,
		int *	coords_size,
		int *	err
	)

Get coordinates of specified vertices.

VertexEntities Get coordinates of specified vertices. Coordinates are returned in the storage order indicated by the storage_order argument.

Parameters:

[in]	instance	iMesh instance handle
[in]	vertex_handles	Array of mesh vertex handles whose coordinates are being requested
[in]	vertex_handles_size	Number of vertices in vertex_handles array
[in]	storage_order	Requested storage order of returned coordinates (see iBase_StorageOrder)
[in,out]	coords	Pointer to array of coordinates returned from function Array pointer, allocated and occupied sizes argument trio)
[in,out]	coords_allocated	Pointer to allocated size of coords array
[out]	coords_size	Pointer to occupied size of coords array
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 452 of file iMesh_MOAB.cpp.

References ALLOC_CHECK_ARRAY, CHKERR, CONST_HANDLE_ARRAY_PTR, ErrorCode, iBase_INTERLEAVED, iBase_SUCCESS, KEEP_ARRAY, MOABI, and RETURN.

{
    int geom_dim;
    MOABI->get_dimension( geom_dim );

    // make sure we can hold them all
    ALLOC_CHECK_ARRAY( coords, geom_dim * vertex_handles_size );

    // now get all the coordinates
    // coords will come back interleaved by default
    ErrorCode result;
    if( storage_order == iBase_INTERLEAVED )
    {
        if( 3 == geom_dim )
        {
            result = MOABI->get_coords( CONST_HANDLE_ARRAY_PTR( vertex_handles ), vertex_handles_size, *coords );
        }
        else
        {
            std::vector< double > dum_coords( 3 * vertex_handles_size );
            result = MOABI->get_coords( CONST_HANDLE_ARRAY_PTR( vertex_handles ), vertex_handles_size, &dum_coords[0] );

            for( int i = 0; i < vertex_handles_size; i++ )
            {
                for( int j = 0; j < geom_dim; j++ )
                    ( *coords )[geom_dim * i + j] = dum_coords[3 * i + j];
            }
        }
    }
    else
    {
        std::vector< double > dum_coords( 3 * vertex_handles_size );
        result = MOABI->get_coords( CONST_HANDLE_ARRAY_PTR( vertex_handles ), vertex_handles_size, &dum_coords[0] );CHKERR( result, "iMesh_getVtxArrCoords: problem getting vertex coords" );

        for( int i = 0; i < vertex_handles_size; i++ )
        {
            for( int j = 0; j < geom_dim; j++ )
                ( *coords )[i + vertex_handles_size * j] = dum_coords[3 * i + j];
        }
    }

    KEEP_ARRAY( coords );
    RETURN( iBase_SUCCESS );
}

void iMesh_getVtxCoord	(	iMesh_Instance	instance,
		const iBase_EntityHandle	vertex_handle,
		double *	x,
		double *	y,
		double *	z,
		int *	err
	)

Get coordinates of specified vertex.

VertexEntities Get coordinates of specified vertex.

Parameters:

[in]	instance	iMesh instance handle
[in]	vertex_handle	Mesh vertex being queried
[out]	x	Pointer to x coordinate returned from function
[out]	y	Pointer to y coordinate returned from function
[out]	z	Pointer to z coordinate returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2302 of file iMesh_MOAB.cpp.

References moab::dum, iBase_BLOCKED, iBase_SUCCESS, and iMesh_getVtxArrCoords.

{
    int order     = iBase_BLOCKED;
    double xyz[3] = { 0 }, *tmp_xyz = xyz;
    int dum = 3;

    iMesh_getVtxArrCoords( instance, &vertex_handle, 1, order, &tmp_xyz, &dum, &dum, err );
    if( iBase_SUCCESS == *err )
    {
        *x = xyz[0];
        *y = xyz[1];
        *z = xyz[2];
    }
}

void iMesh_initEntArrIter	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set_handle,
		const int	requested_entity_type,
		const int	requested_entity_topology,
		const int	requested_array_size,
		const int	resilient,
		iBase_EntityArrIterator *	entArr_iterator,
		int *	err
	)

Initialize an array iterator over specified entity type, topology, and size.

Method: initEntArrIter[]

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set_handle	Entity set being iterated
[in]	requested_entity_type	Type of entity to iterate
[in]	requested_entity_topology	Topology of entity to iterate
[in]	requested_array_size	Size of chunks of handles returned for each value of the iterator
[in]	resilient	If zero, return a non-resilient iterator. Otherwise, a resilient iterator (Resilient and Non-Resilient Iterators)
[out]	entArr_iterator	Pointer to iterator returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 507 of file iMesh_MOAB.cpp.

References iMesh_initEntArrIterRec.

{
    iMesh_initEntArrIterRec( instance, entity_set_handle, requested_entity_type, requested_entity_topology,
                             requested_array_size, resilient, false, entArr_iterator, err );
}

void iMesh_initEntArrIterRec	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set_handle,
		const int	requested_entity_type,
		const int	requested_entity_topology,
		const int	requested_array_size,
		const int	resilient,
		const int	recursive,
		iBase_EntityArrIterator *	entArr_iterator,
		int *	err
	)

Initialize an array iterator over specified entity type, topology, and size, with an optional recursive flag.

Method: initEntArrIter[]

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set_handle	Entity set being iterated
[in]	requested_entity_type	Type of entity to iterate
[in]	requested_entity_topology	Topology of entity to iterate
[in]	requested_array_size	Size of chunks of handles returned for each value of the iterator
[in]	resilient	If zero, return a non-resilient iterator. Otherwise, a resilient iterator (Resilient and Non-Resilient Iterators)
[in]	recursive	If non-zero, entities retrieved recursively
[out]	entArr_iterator	Pointer to iterator returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2996 of file iMesh_MOAB.cpp.

References CHKENUM, CHKERR, ENTITY_HANDLE, ERROR, ErrorCode, iBase_ALL_TYPES, iBase_BAD_TYPE_AND_TOPO, iBase_INVALID_ENTITY_TOPOLOGY, iBase_INVALID_ENTITY_TYPE, iBase_NOT_SUPPORTED, iBase_REGION, iBase_SUCCESS, iMesh_ALL_TOPOLOGIES, iMesh_SEPTAHEDRON, MB_SUCCESS, mb_topology_table, MOABI, and RETURN.

{
    CHKENUM( requested_entity_type, iBase_EntityType, iBase_INVALID_ENTITY_TYPE );
    CHKENUM( requested_entity_topology, iMesh_EntityTopology, iBase_INVALID_ENTITY_TOPOLOGY );
    if( resilient ) ERROR( iBase_NOT_SUPPORTED, "reslient iterators not supported" );

    EntityType req_type = mb_topology_table[requested_entity_topology];

    if( requested_entity_topology != iMesh_ALL_TOPOLOGIES )
    {
        if( requested_entity_type != iBase_ALL_TYPES )
        {
            if( requested_entity_topology != iMesh_SEPTAHEDRON && requested_entity_type != CN::Dimension( req_type ) )
                ERROR( iBase_BAD_TYPE_AND_TOPO, "type and topology are inconsistant" );

            // Special-case handling for septahedra since we don't support them
            else if( requested_entity_topology == iMesh_SEPTAHEDRON && requested_entity_type != iBase_REGION )
                ERROR( iBase_BAD_TYPE_AND_TOPO, "type and topology are inconsistant" );
        }
    }

    ErrorCode result;
    unsigned flags;
    result = MOABI->get_meshset_options( ENTITY_HANDLE( entity_set_handle ), flags );CHKERR( result, "Invalid entity set handle" );

    if( flags & MESHSET_ORDERED )
        *entArr_iterator =
            new MBListIter( (iBase_EntityType)requested_entity_type, (iMesh_EntityTopology)requested_entity_topology,
                            ENTITY_HANDLE( entity_set_handle ), requested_array_size, recursive );
    else
        *entArr_iterator =
            new MBRangeIter( (iBase_EntityType)requested_entity_type, (iMesh_EntityTopology)requested_entity_topology,
                             ENTITY_HANDLE( entity_set_handle ), requested_array_size, recursive );
    result = ( *entArr_iterator )->reset( MOABI );
    if( MB_SUCCESS != result ) delete *entArr_iterator;CHKERR( result, "iMesh_initEntArrIter: ERROR getting entities of proper type or topology." );
    RETURN( iBase_SUCCESS );
}

void iMesh_initEntIter	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set_handle,
		const int	requested_entity_type,
		const int	requested_entity_topology,
		const int	resilient,
		iBase_EntityIterator *	entity_iterator,
		int *	err
	)

Initialize an iterator over specified entity type, topology, and size.

EntityIterators Initialize an iterator over specified entity type, topology, and size, for a specified set or instance. Iterator returned can be used as input to functions returning the entity for the iterator. If all entities of a specified type and/or topology are to be iterated, specify iBase_ALL_TYPES or iMesh_ALL_TOPOLOGIES, respectively. Specified type or topology must be a value in the iBase_EntityType or iMesh_EntityTopology enumerations, respectively.

Note: This function will fail and return an error if the caller passes a combination of entity_type and entity_topology that are not consistent.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set_handle	Entity set being iterated
[in]	requested_entity_type	Type of entity to iterate
[in]	requested_entity_topology	Topology of entity to iterate
[in]	resilient	If zero, return a non-resilient iterator. Otherwise, a resilient iterator (Resilient and Non-Resilient Iterators)
[out]	entity_iterator	Pointer to iterator returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2247 of file iMesh_MOAB.cpp.

References iMesh_initEntArrIterRec.

{
    iMesh_initEntArrIterRec( instance, entity_set_handle, requested_entity_type, requested_entity_topology, 1,
                             resilient, false, reinterpret_cast< iBase_EntityArrIterator* >( entity_iterator ), err );
}

void iMesh_intersect	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set_1,
		const iBase_EntitySetHandle	entity_set_2,
		iBase_EntitySetHandle *	result_entity_set,
		int *	err
	)

Intersect contents of one entity set with another.

EntitySetOperators Intersect contents of one entity set with another

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set_1	Entity set being intersected with another
[in]	entity_set_2	Entity set being intersected with another
[out]	result_entity_set	Pointer to entity set returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2404 of file iMesh_MOAB.cpp.

References CHKERR, entities, ENTITY_HANDLE, ERROR, ErrorCode, iBase_SUCCESS, iMesh_isList, MB_SUCCESS, MESHSET_SET, MOABI, and RETURN.

{
    EntityHandle temp_set;
    EntityHandle set1 = ENTITY_HANDLE( entity_set_1 ), set2 = ENTITY_HANDLE( entity_set_2 );

    int isList1 = 0, isList2 = 0;
    iMesh_isList( instance, entity_set_1, &isList1, err );
    if( *err != iBase_SUCCESS ) return;
    iMesh_isList( instance, entity_set_2, &isList2, err );
    if( *err != iBase_SUCCESS ) return;

    ErrorCode result;
    if( isList1 && isList2 )
        result = MOABI->create_meshset( MESHSET_ORDERED, temp_set );
    else
        result = MOABI->create_meshset( MESHSET_SET, temp_set );

    if( MB_SUCCESS != result ) ERROR( result, "iMesh_intersect: couldn't create result set." );

    if( !entity_set_1 && !entity_set_2 )
    {
        // intersecting the root set with itself, so get everything...
        Range entities;
        result = MOABI->get_entities_by_handle( 0, entities );
        if( MB_SUCCESS == result ) result = MOABI->add_entities( temp_set, entities );
        // ...but not the newly-created set!
        if( MB_SUCCESS == result ) result = MOABI->remove_entities( temp_set, &temp_set, 1 );
    }
    else if( !entity_set_1 )
    {
        result = MOABI->unite_meshset( temp_set, set2 );
    }
    else if( !entity_set_2 )
    {
        result = MOABI->unite_meshset( temp_set, set1 );
    }
    else
    {
        if( isList1 && isList2 )
        {
            // ITAPS has very specific rules about the behavior of intersection on
            // list-type sets. Since MOAB doesn't (and likely will never) work
            // exactly this way, we implement our own algorithm here.

#ifdef MOAB_HAVE_UNORDERED_MAP
            typedef MOAB_UNORDERED_MAP_NS::unordered_map< EntityHandle, size_t > lookup_t;
#else
            typedef std::map< EntityHandle, size_t > lookup_t;
#endif

            // First, build a lookup table for the second set.
            lookup_t lookup;
            {
                std::vector< EntityHandle > contents2;
                result = MOABI->get_entities_by_handle( set2, contents2 );CHKERR( result, "iMesh_intersect: ERROR intersect failed." );

                for( std::vector< EntityHandle >::iterator i = contents2.begin(); i != contents2.end(); ++i )
                {
#ifdef MOAB_HAVE_UNORDERED_MAP
                    lookup_t::iterator j = lookup.find( *i );
#else
                    lookup_t::iterator j = lookup.lower_bound( *i );
#endif
                    if( j != lookup.end() && j->first == *i )
                        ++j->second;
                    else
                        lookup.insert( j, lookup_t::value_type( *i, 1 ) );
                }
            }

            // Then, iterate over the contents of the first set and check for
            // their existence in the second set.
            std::vector< EntityHandle > contents1;
            result = MOABI->get_entities_by_handle( set1, contents1 );CHKERR( result, "iMesh_intersect: ERROR intersect failed." );

            std::vector< EntityHandle >::iterator w = contents1.begin();
            for( std::vector< EntityHandle >::iterator i = contents1.begin(); i != contents1.end(); ++i )
            {
                lookup_t::iterator j = lookup.find( *i );
                if( j != lookup.end() && j->second )
                {
                    --j->second;
                    *w = *i;
                    ++w;
                }
            }

            result = MOABI->add_entities( temp_set, &contents1[0], w - contents1.begin() );
        }
        else
        {
            result = MOABI->unite_meshset( temp_set, set1 );
            if( MB_SUCCESS == result ) result = MOABI->intersect_meshset( temp_set, set2 );
        }
    }

    CHKERR( result, "iMesh_intersect: ERROR intersect failed." );
    *result_entity_set = (iBase_EntitySetHandle)temp_set;

    RETURN( iBase_SUCCESS );
}

void iMesh_isChildOf	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	parent_entity_set,
		const iBase_EntitySetHandle	child_entity_set,
		int *	is_child,
		int *	err
	)

Return whether two sets are related by parent/child links.

ParentChildLinks Return whether two sets are related (*is_child=1) or not (*is_child=0) by parent/child links

Parameters:

[in]	instance	iMesh instance handle
[in]	parent_entity_set	Pointer to parent set
[in]	child_entity_set	Pointer to child set
[out]	is_child	Pointer to flag returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1170 of file iMesh_MOAB.cpp.

References children, CHKERR, ENTITY_HANDLE, ERROR, ErrorCode, iBase_INVALID_ENTITYSET_HANDLE, iBase_SUCCESS, MB_ENTITY_NOT_FOUND, MOABI, and RETURN.

{
    if( !child_entity_set ) ERROR( iBase_INVALID_ENTITYSET_HANDLE, "iMesh_isChildOf: ERROR invalid entity set." );

    std::vector< EntityHandle > children;

    ErrorCode result = MOABI->get_child_meshsets( ENTITY_HANDLE( parent_entity_set ), children );

    if( result == MB_ENTITY_NOT_FOUND )
        ERROR( iBase_INVALID_ENTITYSET_HANDLE, "iMesh_rmvPrntChld: ERROR invalid entity set." );CHKERR( result, "iMesh_isChildOf: ERROR IsParentChildRelated failed." );

    if( std::find( children.begin(), children.end(), ENTITY_HANDLE( child_entity_set ) ) != children.end() )
        *is_child = true;

    else
        *is_child = false;

    RETURN( iBase_SUCCESS );
}

void iMesh_isEntArrContained	(	iMesh_Instance	instance,
		iBase_EntitySetHandle	containing_set,
		const iBase_EntityHandle *	entity_handles,
		int	num_entity_handles,
		int **	is_contained,
		int *	is_contained_allocated,
		int *	is_contained_size,
		int *	err
	)

Return whether entities are contained in a set.

Parameters:

[in]	instance	iMesh instance handle
[in]	containing_set	Entity set being queried
[in]	entity_handles	List of entities for which to check containment.
[in]	num_entity_handles	Size of entity_handles array of entities to be checked.
[in,out]	is_contained	One value for each input entity, 1 if contained in set, zero otherwise. Array pointer, allocated and occupied sizes argument trio)
[in,out]	is_contained_allocated	Allocated size of is_contained array
[out]	is_contained_size	Occupied size of is_contained array
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1106 of file iMesh_MOAB.cpp.

References ALLOC_CHECK_ARRAY_NOFAIL, ENTITY_HANDLE, iBase_SUCCESS, MOABI, and RETURN.

{
    EntityHandle set = ENTITY_HANDLE( containing_set );
    ALLOC_CHECK_ARRAY_NOFAIL( is_contained, num_entity_handles );
    *is_contained_size = num_entity_handles;

    if( containing_set )
    {
        for( int i = 0; i < num_entity_handles; ++i )
        {
            EntityHandle h       = ENTITY_HANDLE( entity_handles[i] );
            ( *is_contained )[i] = MOABI->contains_entities( set, &h, 1 );
        }
    }
    else
    {
        std::fill( *is_contained, ( *is_contained ) + num_entity_handles, 1 );
    }
    RETURN( iBase_SUCCESS );
}

void iMesh_isEntContained	(	iMesh_Instance	instance,
		iBase_EntitySetHandle	containing_entity_set,
		iBase_EntityHandle	contained_entity,
		int *	is_contained,
		int *	err
	)

Return whether an entity is contained in another set.

Return whether an entity is contained (*is_contained=1) or not contained (*is_contained=0) in another set

Parameters:

[in]	instance	iMesh instance handle
[in]	containing_entity_set	Entity set being queried
[in]	contained_entity	Entity potentially contained in containing_entity_set
[out]	is_contained	Pointer to flag returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1095 of file iMesh_MOAB.cpp.

References iMesh_isEntArrContained.

{
    int junk1 = 1, junk2 = 1;
    iMesh_isEntArrContained( instance, containing_entity_set, &contained_entity, 1, &is_contained, &junk1, &junk2,
                             err );
}

void iMesh_isEntSetContained	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	containing_entity_set,
		const iBase_EntitySetHandle	contained_entity_set,
		int *	is_contained,
		int *	err
	)

Return whether an entity set is contained in another set.

Return whether a set is contained (*is_contained=1) or not contained (*is_contained=0) in another set

Parameters:

[in]	instance	iMesh instance handle
[in]	containing_entity_set	Entity set being queried
[in]	contained_entity_set	Entity set potentially contained in containing_entity_set
[out]	is_contained	Pointer to flag returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1135 of file iMesh_MOAB.cpp.

References iMesh_isEntContained.

{
    iMesh_isEntContained( instance, containing_entity_set,
                          reinterpret_cast< iBase_EntityHandle >( contained_entity_set ), is_contained, err );
}

void iMesh_isList	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set,
		int *	is_list,
		int *	err
	)

Return whether a specified set is ordered or unordered.

Return whether a specified set is ordered (*is_list=1) or unordered (*is_list=0)

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set	Entity set being queried
[out]	is_list	Pointer to flag returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 977 of file iMesh_MOAB.cpp.

References CHKERR, ENTITY_HANDLE, ErrorCode, iBase_SUCCESS, MOABI, and RETURN.

{
    unsigned int options;
    ErrorCode result = MOABI->get_meshset_options( ENTITY_HANDLE( entity_set ), options );CHKERR( result, "iMesh_isList: couldn't query set." );
    if( options & MESHSET_ORDERED )
        *is_list = true;
    else
        *is_list = false;

    RETURN( iBase_SUCCESS );
}

void iMesh_load	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set_handle,
		const char *	name,
		const char *	options,
		int *	err,
		int	name_len,
		int	options_len
	)

Load a mesh from a file.

Initialization Load a mesh from a file. If entity set is specified, loaded mesh is added to that set; specify root set if that is not desired.

Parameters:

[in]	instance	iMesh instance handle
[in]	handle	Set to which loaded mesh will be added, otherwise root
[in]	name	File name from which mesh is to be loaded
[in]	options	Pointer to implementation-specific options string (Option Strings)
[out]	err	Returned Error status (see iBase_ErrorType)
[in]	name_len	Length of the file name character string (String Length Arguments)
[in]	options_len	Length of the options character string (String Length Arguments)

Definition at line 293 of file iMesh_MOAB.cpp.

References CHKERR, create_int_ents(), eatwhitespace(), ErrorCode, filename, filter_options(), iBase_SUCCESS, MBENTITYSET, MBIMESHI, MOABI, RETURN, and moab::subtract().

{
    // get filename, option & null-terminate
    std::string filename( name, name_len );
    eatwhitespace( filename );

    std::string opts = filter_options( options, options + options_len );

    Range orig_ents;
    ErrorCode result = MOABI->get_entities_by_handle( 0, orig_ents );CHKERR( result, "Internal error" );

    const EntityHandle* file_set = 0;
    if( handle != 0 /*root_set*/ )
    {
        const iBase_EntitySetHandle* ptr = &handle;
        file_set                         = reinterpret_cast< const EntityHandle* >( ptr );
    }

    result = MOABI->load_file( filename.c_str(), file_set, opts.c_str() );

    CHKERR( result, "iMesh_load:ERROR loading a mesh." );

    // create interior edges/faces if requested
    if( MBIMESHI->AdjTable[5] || MBIMESHI->AdjTable[10] )
    {
        Range set_ents;
        result = MOABI->get_entities_by_handle( 0, set_ents );CHKERR( result, "" );
        Range sets;
        result = MOABI->get_entities_by_type( 0, MBENTITYSET, sets );CHKERR( result, "" );
        set_ents = subtract( set_ents, sets );
        set_ents = subtract( set_ents, orig_ents );
        result   = create_int_ents( MBIMESHI, set_ents, file_set );CHKERR( result, "" );
    }
    RETURN( iBase_SUCCESS );
}

void iMesh_MBCNType	(	const int	imesh_entity_topology,
		int *	mbcn_type
	)

Get MBCN type corresponding to iMesh topology value.

Get MBCN type corresponding to iMesh topology value. Required for input to MBCN canonical numbering functions, which are written in terms of MBCN entity types. Returns -1 for type if entity topology is out of bounds, or MBMAXTYPE if no corresponding MBCN type exists.

Parameters:

imesh_entity_topology	iMesh_EntityTopology value
mbcn_type	MBEntityType corresponding to entity topology

Definition at line 2881 of file iMesh_MOAB.cpp.

References iMesh_ALL_TOPOLOGIES, iMesh_POINT, and mb_topology_table.

{
    if( iMesh_POINT > imesh_entity_topology || iMesh_ALL_TOPOLOGIES <= imesh_entity_topology )
        *mbcn_type = -1;
    else
        *mbcn_type = mb_topology_table[imesh_entity_topology];
}

void iMesh_newMesh	(	const char *	options,
		iMesh_Instance *	instance,
		int *	err,
		int	options_len
	)

Construct a new iMesh instance.

Initialization

Parameters:

[in]	options	Pointer to implementation-specific options string (Option Strings)
[in]	instance	iMesh instance handle
[out]	err	Returned Error status (see iBase_ErrorType)
[in]	options_len	Length of the character string pointed to by options (String Length Arguments)

Definition at line 242 of file iMesh_MOAB.cpp.

References ErrorCode, filter_options(), iBase_FAILURE, iBase_SUCCESS, MB_NOT_IMPLEMENTED, MB_SUCCESS, and MBiMesh::set_last_error().

{
    std::string tmp_options = filter_options( options, options + options_len );
    FileOptions opts( tmp_options.c_str() );

    MBiMesh** mbi = reinterpret_cast< MBiMesh** >( instance );
    *mbi          = NULL;

    ErrorCode result = opts.get_null_option( "PARALLEL" );
    if( MB_SUCCESS == result )
    {
#ifdef MOAB_HAVE_MPI
        int flag   = 1;
        int retval = MPI_Initialized( &flag );
        if( MPI_SUCCESS != retval || !flag )
        {
            int argc    = 0;
            char** argv = NULL;

            // mpi not initialized yet - initialize here
            retval = MPI_Init( &argc, &argv );
            assert( MPI_SUCCESS == retval );
        }
        *mbi = new( std::nothrow ) MBiMesh( NULL );
#else
        // mError->set_last_error( "PARALLEL option not valid, this instance"
        //                        " compiled for serial execution.\n" );
        *mbi = new( std::nothrow ) MBiMesh( NULL );
        *err = ( *mbi )->set_last_error( MB_NOT_IMPLEMENTED, "Not configured with parallel support" );
        return;
#endif
    }
    else
    {
        *mbi = new( std::nothrow ) MBiMesh( NULL );
    }
    if( NULL == *mbi )
    {
        *err = iBase_FAILURE;
        return;
    }

    *err = iBase_SUCCESS;
}

void iMesh_optimize	(	iMesh_Instance	instance,
		int *	handles_invalidated,
		int *	err
	)

Permit implementation to 'optimize' the mesh instance.

MeshModification Its concievable that after a series of operations modifying the mesh instance, the implementation's internal representation of the mesh may include data and tie up memory resources that could be 'optimized' away. For example, if the implementation only marks removed entities for deletion but does not actually free up memory resources associated those entities, a call to this function gives the implementation the 'ok' to go ahead and free up such memory.

Depending on the implementation as well as the amount and kind of changes to the mesh that have been made prior to calling it, this call may be very expensive in time complexity. On the other hand, it is also perfectly acceptable that an implementation basically treat this operation as a no-op.

In any event, any entity, entity set, iterator or tag handle obtained prior to calling this method will may be invalidated as a result of this call. In that case, the caller must re-acquire handles after making this call. A return argument indicates if handles have been invalidated.

Parameters:

[in]	instance	iMesh instance handle
[out]	handles_invalidated	Returned flag indicating if any handles the caller held before calling this function have been invalidated as a result of this call. A value of non-zero returned here indicates that any handles the caller had prior to this call must not be trusted and must be re-acquired by caller.
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 432 of file iMesh_MOAB.cpp.

References iBase_SUCCESS, and RETURN.

{
    // TODO: implement this for real
    *handles_invalidated = 0;
    RETURN( iBase_SUCCESS );
}

void iMesh_resetEntArrIter	(	iMesh_Instance	instance,
		iBase_EntityArrIterator	entArr_iterator,
		int *	err
	)

Reset the array iterator.

Method: resetEntArrIter[]

Parameters:

[in]	instance	iMesh instance handle
[in]	entArr_iterator	Iterator to reset
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 542 of file iMesh_MOAB.cpp.

References CHKERR, ErrorCode, iBase_SUCCESS, MOABI, iBase_EntityArrIterator_Private::reset(), and RETURN.

{
    ErrorCode result = entArr_iterator->reset( MOABI );CHKERR( result, "Re-query of iterator data for iMesh_resetEntArrIter failed" );
    RETURN( iBase_SUCCESS );
}

void iMesh_resetEntIter	(	iMesh_Instance	instance,
		iBase_EntityIterator	entity_iterator,
		int *	err
	)

Reset the iterator.

EntityIterators Reset the iterator

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_iterator	Iterator to reset
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2270 of file iMesh_MOAB.cpp.

References iMesh_resetEntArrIter.

{
    iMesh_resetEntArrIter( instance, reinterpret_cast< iBase_EntityArrIterator >( entity_iterator ), err );
}

void iMesh_rmvEntArrFromSet	(	iMesh_Instance	instance,
		const iBase_EntityHandle *	entity_handles,
		int	entity_handles_size,
		iBase_EntitySetHandle	entity_set,
		int *	err
	)

Remove an array of entities from a set.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_handles	Array of entities being remove
[in]	entity_handles_size	Number of entities in entity_handles array
[in]	entity_set	Pointer to the set being removed from
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1043 of file iMesh_MOAB.cpp.

References CHKERR, CONST_HANDLE_ARRAY_PTR, ENTITY_HANDLE, ErrorCode, iBase_SUCCESS, MOABI, and RETURN.

{
    const EntityHandle* ents = CONST_HANDLE_ARRAY_PTR( entity_handles );

    ErrorCode result = MOABI->remove_entities( ENTITY_HANDLE( entity_set ), ents, entity_handles_size );

    CHKERR( result, "iMesh_rmvEntArrFromSet:ERROR removing entities in EntitySet." );
    RETURN( iBase_SUCCESS );
}

void iMesh_rmvEntFromSet	(	iMesh_Instance	instance,
		iBase_EntityHandle	entity_handle,
		iBase_EntitySetHandle	entity_set,
		int *	err
	)

Remove an entity from a set.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_handle	The entity being removed
[in]	entity_set	Pointer to the set being removed from
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1057 of file iMesh_MOAB.cpp.

References iMesh_rmvEntArrFromSet.

{
    iMesh_rmvEntArrFromSet( instance, &entity_handle, 1, entity_set, err );
}

void iMesh_rmvEntSet	(	iMesh_Instance	instance,
		iBase_EntitySetHandle	entity_set_to_remove,
		iBase_EntitySetHandle	entity_set_handle,
		int *	err
	)

Remove an entity set from a set.

Remove an entity set from a set

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set_to_remove	The entity set being removed
[in]	entity_set_handle	Pointer to the set being removed from
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1080 of file iMesh_MOAB.cpp.

References CHKERR, ENTITY_HANDLE, ERROR, ErrorCode, iBase_INVALID_ARGUMENT, iBase_SUCCESS, MOABI, and RETURN.

{
    if( !entity_set_to_remove || !entity_set_handle )
        ERROR( iBase_INVALID_ARGUMENT, "iMesh_rmvEntSet: ERROR invalid argument" );

    EntityHandle to_remove = ENTITY_HANDLE( entity_set_to_remove );
    ErrorCode result       = MOABI->remove_entities( ENTITY_HANDLE( entity_set_handle ), &to_remove, 1 );

    CHKERR( result, "iMesh_rmvEntSet:ERROR removing entitysets in EntitySet." );
    RETURN( iBase_SUCCESS );
}

void iMesh_rmvPrntChld	(	iMesh_Instance	instance,
		iBase_EntitySetHandle	parent_entity_set,
		iBase_EntitySetHandle	child_entity_set,
		int *	err
	)

Remove parent/child links between two sets.

ParentChildLinks Remove parent/child links between two sets.

Parameters:

[in]	instance	iMesh instance handle
[in]	parent_entity_set	Pointer to parent set
[in]	child_entity_set	Pointer to child set
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1157 of file iMesh_MOAB.cpp.

References CHKERR, ENTITY_HANDLE, ERROR, ErrorCode, iBase_INVALID_ENTITYSET_HANDLE, iBase_SUCCESS, MB_ENTITY_NOT_FOUND, MOABI, and RETURN.

{
    ErrorCode result =
        MOABI->remove_parent_child( ENTITY_HANDLE( parent_entity_set ), ENTITY_HANDLE( child_entity_set ) );

    if( result == MB_ENTITY_NOT_FOUND )
        ERROR( iBase_INVALID_ENTITYSET_HANDLE, "iMesh_rmvPrntChld: ERROR invalid entity set." );CHKERR( result, "iMesh_rmvPrntChld: ERROR RemoveParentChild failed." );
    RETURN( iBase_SUCCESS );
}

void iMesh_save	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set_handle,
		const char *	name,
		const char *	options,
		int *	err,
		const int	name_len,
		int	options_len
	)

Save a mesh to a file.

Initialization Save a mesh to a file. If entity set is specified, save only the mesh contained in that set.

Parameters:

[in]	instance	iMesh instance handle
[in]	handle	Entity set being saved
[in]	name	File name to which mesh is to be saved
[in]	options	Pointer to implementation-specific options string (Option Strings)
[out]	err	Returned Error status (see iBase_ErrorType)
[in]	name_len	Length of the file name character string (String Length Arguments)
[in]	options_len	Length of the options character string (String Length Arguments)

Definition at line 335 of file iMesh_MOAB.cpp.

References CHKERR, eatwhitespace(), ENTITY_HANDLE, ErrorCode, filename, filter_options(), iBase_SUCCESS, MOABI, and RETURN.

{
    // get filename & attempt to NULL-terminate
    std::string filename( name, name_len );
    eatwhitespace( filename );
    std::string opts = filter_options( options, options + options_len );

    EntityHandle set = ENTITY_HANDLE( handle );
    ErrorCode result = MOABI->write_file( filename.c_str(), NULL, opts.c_str(), &set, 1 );

    CHKERR( result, "iMesh_save:ERROR saving a mesh." );
    RETURN( iBase_SUCCESS );
}

void iMesh_setAdjTable	(	iMesh_Instance	instance,
		int *	adjacency_table,
		int	adjacency_table_size,
		int *	err
	)

Set the adjacency table as requested by the application.

Adjacencies Set the adjacency table as requested by the application. See iMesh_getAdjTable for a description of the meaning of the entries in this table. This call to set the adjacency table allows an application to request how it would like an implementation to behave when adjacent and/or intermediate entities are queried. If the implementation is not able to accommodate the requested query behavior associated with ANY entry in the table, the call will fail and return an error of iBase_NOT_SUPPORTED. Otherwise, the implementation is able to accommodate the requested query behavior associated with ALL table entries and the call will succeed. In either case, however, the implementation will over-write the entries in the adjacency_table argument with the same values that would be obtained in a succeeding call to iMesh_getAdjTable.

Parameters:

[in]	instance	iMesh instance handle
[in,out]	adj_table	Array representing adjacency table requested by application
[in]	adj_table_size	Size of adj table array
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 396 of file iMesh_MOAB.cpp.

References iBase_INVALID_ARGUMENT, iBase_SUCCESS, iMesh_getGeometricDimension, MBIMESHI, munge_adj_table(), and RETURN.

{
    if( 16 != adj_table_size )
    {
        RETURN( iBase_INVALID_ARGUMENT );
    }

    int geom_dim;
    iMesh_getGeometricDimension( instance, &geom_dim, err );

    memcpy( MBIMESHI->AdjTable, adj_table, 16 * sizeof( int ) );
    munge_adj_table( adj_table, geom_dim );
    RETURN( iBase_SUCCESS );
}

void iMesh_setData	(	iMesh_Instance	instance,
		iBase_EntityHandle	entity_handle,
		const iBase_TagHandle	tag_handle,
		const void *	tag_value,
		const int	tag_value_size,
		int *	err
	)

Set a tag value of arbitrary type on an entity.

Set a tag value of arbitrary type on an entity. Tag data is passed as void*. tag_value_size specifies the size of the memory pointed to by tag_value in terms of bytes. Applications may use this function to set data of any type, not just iBase_BYTES. However, because this function supports data of arbitrary type, in all cases the size specified by tag_value_size is always in terms of bytes.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_handle	Entity on which tag is being set
[in]	tag_handle	Tag being set on an entity
[in]	tag_value	Pointer to tag data being set on entity
[in]	tag_value_size	Size in bytes of tag data
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2163 of file iMesh_MOAB.cpp.

References iMesh_setArrData.

{
    iMesh_setArrData( instance, &entity_handle, 1, tag_handle, tag_value, tag_value_size, err );
}

void iMesh_setDblData	(	iMesh_Instance	instance,
		iBase_EntityHandle	entity_handle,
		const iBase_TagHandle	tag_handle,
		const double	tag_value,
		int *	err
	)

Set a tag value of double type on an entity.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_handle	Entity on which tag is being set
[in]	tag_handle	Tag being set on an entity
[in]	tag_value	Tag value being set on entity
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2184 of file iMesh_MOAB.cpp.

References CHKTAGTYPE, iBase_DOUBLE, and iMesh_setArrData.

{
    CHKTAGTYPE( tag_handle, iBase_DOUBLE );
    iMesh_setArrData( instance, &entity_handle, 1, tag_handle, reinterpret_cast< const char* >( &tag_value ),
                      sizeof( double ), err );
}

void iMesh_setEHData	(	iMesh_Instance	instance,
		iBase_EntityHandle	entity_handle,
		const iBase_TagHandle	tag_handle,
		const iBase_EntityHandle	tag_value,
		int *	err
	)

Set a tag value of entity handle type on an entity.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_handle	Entity on which tag is being set
[in]	tag_handle	Tag being set on an entity
[in]	tag_value	Tag value being set on entity
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2196 of file iMesh_MOAB.cpp.

References CHKTAGTYPE, iBase_ENTITY_HANDLE, and iMesh_setArrData.

{
    CHKTAGTYPE( tag_handle, iBase_ENTITY_HANDLE );
    iMesh_setArrData( instance, &entity_handle, 1, tag_handle, reinterpret_cast< const char* >( &tag_value ),
                      sizeof( iBase_EntityHandle ), err );
}

void iMesh_setEntSetData	(	iMesh_Instance	instance,
		iBase_EntitySetHandle	entity_set_handle,
		const iBase_TagHandle	tag_handle,
		const void *	tag_value,
		const int	tag_value_size,
		int *	err
	)

Set a tag value of arbitrary type on an entity set.

Set a tag value of arbitrary type on an entity set. The tag data is passed as void*. tag_value_size specifies the size of the memory pointed to by tag_value in terms of bytes. Applications are free to use this function to set data of any type, not just iBase_BYTES. However, in all cases, the size specified by tag_value_size is always in terms of bytes.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set_handle	Entity set on which tag is being set
[in]	tag_handle	Tag being set on an entity set
[in]	tag_value	Pointer to tag data being set on entity set
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1637 of file iMesh_MOAB.cpp.

References CHKERR, ENTITY_HANDLE, ErrorCode, iBase_SUCCESS, MOABI, RETURN, and TAG_HANDLE.

{
    ErrorCode result;

    EntityHandle set = ENTITY_HANDLE( entity_set_handle );
    result           = MOABI->tag_set_data( TAG_HANDLE( tag_handle ), &set, 1, tag_value );CHKERR( result, "iMesh_setEntSetData: error" );

    RETURN( iBase_SUCCESS );
}

void iMesh_setEntSetDblData	(	iMesh_Instance	instance,
		iBase_EntitySetHandle	entity_set,
		const iBase_TagHandle	tag_handle,
		const double	tag_value,
		int *	err
	)

Set a tag value of double type on an entity set.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set	Entity set on which tag is being set
[in]	tag_handle	Tag being set on an entity set
[in]	tag_value	Tag value being set on entity set
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1662 of file iMesh_MOAB.cpp.

References CHKTAGTYPE, iBase_DOUBLE, and iMesh_setEntSetData.

{
    CHKTAGTYPE( tag_handle, iBase_DOUBLE );
    iMesh_setEntSetData( instance, entity_set, tag_handle, &tag_value, sizeof( double ), err );
}

void iMesh_setEntSetEHData	(	iMesh_Instance	instance,
		iBase_EntitySetHandle	entity_set,
		const iBase_TagHandle	tag_handle,
		const iBase_EntityHandle	tag_value,
		int *	err
	)

Set a tag value of entity handle type on an entity set.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set	Entity set on which tag is being set
[in]	tag_handle	Tag being set on an entity set
[in]	tag_value	Tag value being set on entity set
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1672 of file iMesh_MOAB.cpp.

References CHKNONEMPTY, CHKTAGTYPE, iBase_ENTITY_HANDLE, and iMesh_setEntSetData.

{
    // XXX: decide how best to handle validating entity handles as tag data
    CHKNONEMPTY();
    CHKTAGTYPE( tag_handle, iBase_ENTITY_HANDLE );
    iMesh_setEntSetData( instance, entity_set, tag_handle, &tag_value, sizeof( iBase_EntityHandle ), err );
}

void iMesh_setEntSetESHData	(	iMesh_Instance	instance,
		iBase_EntitySetHandle	entity_set,
		const iBase_TagHandle	tag_handle,
		const iBase_EntitySetHandle	tag_value,
		int *	err
	)

Set a tag value of entity set handle type on an.

entity set Set a tag value of entity set handle type on an entity set.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set	Entity set on which tag is being set
[in]	tag_handle	Tag being set on an entity set
[in]	tag_value	Tag value being set on entity set
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1684 of file iMesh_MOAB.cpp.

References CHKTAGTYPE, iBase_ENTITY_SET_HANDLE, and iMesh_setEntSetData.

{
    CHKTAGTYPE( tag_handle, iBase_ENTITY_SET_HANDLE );
    iMesh_setEntSetData( instance, entity_set, tag_handle, &tag_value, sizeof( iBase_EntitySetHandle ), err );
}

void iMesh_setEntSetIntData	(	iMesh_Instance	instance,
		iBase_EntitySetHandle	entity_set,
		const iBase_TagHandle	tag_handle,
		const int	tag_value,
		int *	err
	)

Set a tag value of integer type on an entity set.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set	Entity set on which tag is being set
[in]	tag_handle	Tag being set on an entity set
[in]	tag_value	Tag value being set on entity set
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1652 of file iMesh_MOAB.cpp.

References CHKTAGTYPE, iBase_INTEGER, and iMesh_setEntSetData.

{
    CHKTAGTYPE( tag_handle, iBase_INTEGER );
    iMesh_setEntSetData( instance, entity_set, tag_handle, &tag_value, sizeof( int ), err );
}

void iMesh_setESHData	(	iMesh_Instance	instance,
		iBase_EntityHandle	entity_handle,
		const iBase_TagHandle	tag_handle,
		const iBase_EntitySetHandle	tag_value,
		int *	err
	)

Set a tag value of entity set handle type on an entity.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_handle	Entity on which tag is being set
[in]	tag_handle	Tag being set on an entity
[in]	tag_value	Tag value being set on entity
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2207 of file iMesh_MOAB.cpp.

References CHKTAGTYPE, iBase_ENTITY_SET_HANDLE, and iMesh_setArrData.

{
    CHKTAGTYPE( tag_handle, iBase_ENTITY_SET_HANDLE );
    iMesh_setArrData( instance, &entity_handle, 1, tag_handle, reinterpret_cast< const char* >( &tag_value ),
                      sizeof( iBase_EntityHandle ), err );
}

void iMesh_setGeometricDimension	(	iMesh_Instance	instance,
		int	geom_dim,
		int *	err
	)

Set geometric dimension of vertex coordinates.

Initialization Set the geometric dimension of the mesh. Note: An application should not expect this function to succeed unless the mesh instance is empty. An empty mesh instance is any mesh instance in which there are no vertex entities.

Parameters:

[in]	instance	iMesh instance handle
[in]	geom_dim	Requested geometric dimension.
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 368 of file iMesh_MOAB.cpp.

References CHKERR, ErrorCode, iBase_SUCCESS, MOABI, and RETURN.

{
    ErrorCode rval = MOABI->set_dimension( geom_dim );CHKERR( rval, "iMesh_setGeometricDimension: failed" );

    RETURN( iBase_SUCCESS );
}

void iMesh_setIntData	(	iMesh_Instance	instance,
		iBase_EntityHandle	entity_handle,
		const iBase_TagHandle	tag_handle,
		const int	tag_value,
		int *	err
	)

Set a tag value of integer type on an entity.

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_handle	Entity on which tag is being set
[in]	tag_handle	Tag being set on an entity
[in]	tag_value	Tag value being set on entity
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2173 of file iMesh_MOAB.cpp.

References CHKTAGTYPE, iBase_INTEGER, and iMesh_setArrData.

{
    CHKTAGTYPE( tag_handle, iBase_INTEGER );
    iMesh_setArrData( instance, &entity_handle, 1, tag_handle, reinterpret_cast< const char* >( &tag_value ),
                      sizeof( int ), err );
}

void iMesh_setVtxArrCoords	(	iMesh_Instance	instance,
		const iBase_EntityHandle *	vertex_handles,
		const int	vertex_handles_size,
		const int	storage_order,
		const double *	new_coords,
		const int	new_coords_size,
		int *	err
	)

Set coordinates for an array of vertices.

VertexEntities Set coordinates for an array of vertices. Specified storage order must be either iBase_INTERLEAVED or iBase_BLOCKED, and indicates order of x, y, and z coordinates in coordinate array.

Parameters:

[in]	instance	iMesh instance handle
[in]	vertex_handles	Array of vertex handles
[in]	vertex_handles_size	Number of vertex handles in array
[in]	storage_order	Storage order of coordinates in coordinate array
[in]	new_coords	Coordinate array
[in]	new_coords_size	Size of coordinate array; should be
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1270 of file iMesh_MOAB.cpp.

References CHKENUM, CHKERR, CONST_HANDLE_ARRAY_PTR, ERROR, ErrorCode, iBase_INTERLEAVED, iBase_INVALID_ARGUMENT, iBase_SUCCESS, MB_SUCCESS, MOABI, and RETURN.

{
    CHKENUM( storage_order, iBase_StorageOrder, iBase_INVALID_ARGUMENT );

    int geom_dim;
    MOABI->get_dimension( geom_dim );
    if( new_coords_size != geom_dim * vertex_handles_size )
    {
        ERROR( iBase_INVALID_ARGUMENT, "iMesh_setVtxArrCoords: Didn't get the right # coordinates." );
    }

    ErrorCode result = MB_SUCCESS, tmp_result;
    if( storage_order == iBase_INTERLEAVED )
    {
        if( 3 == geom_dim )
        {
            result = MOABI->set_coords( CONST_HANDLE_ARRAY_PTR( vertex_handles ), vertex_handles_size, new_coords );
        }
        else
        {
            const EntityHandle* verts = CONST_HANDLE_ARRAY_PTR( vertex_handles );
            double dummy[3]           = { 0, 0, 0 };
            for( int i = 0; i < vertex_handles_size; i++ )
            {
                for( int j = 0; j < geom_dim; j++ )
                    dummy[j] = new_coords[geom_dim * i + j];
                tmp_result = MOABI->set_coords( &verts[i], 1, dummy );
                if( MB_SUCCESS != tmp_result ) result = tmp_result;
            }
        }
    }
    else
    {
        const EntityHandle* verts = CONST_HANDLE_ARRAY_PTR( vertex_handles );
        double dummy[3]           = { 0, 0, 0 };
        for( int i = 0; i < vertex_handles_size; i++ )
        {
            for( int j = 0; j < geom_dim; j++ )
                dummy[j] = new_coords[i + vertex_handles_size * j];
            tmp_result = MOABI->set_coords( &verts[i], 1, dummy );
            if( MB_SUCCESS != tmp_result ) result = tmp_result;
        }
    }

    CHKERR( result, "iMesh_setVtxArrCoords: problem setting coordinates." );

    RETURN( iBase_SUCCESS );
}

void iMesh_setVtxCoord	(	iMesh_Instance	instance,
		iBase_EntityHandle	vertex_handle,
		const double	x,
		const double	y,
		const double	z,
		int *	err
	)

Set coordinates for a vertex.

VertexEntities Set coordinates for a vertex.

Parameters:

[in]	instance	iMesh instance handle
[in]	vertex_handle	vertex handle being set
[in]	x	x coordinate being set
[in]	y	y coordinate being set
[in]	z	z coordinate being set
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 1802 of file iMesh_MOAB.cpp.

References iBase_BLOCKED, iMesh_setVtxArrCoords, and MOABI.

{
    const double xyz[3] = { x, y, z };
    int geom_dim;
    MOABI->get_dimension( geom_dim );

    iMesh_setVtxArrCoords( instance, &vertex_handle, 1, iBase_BLOCKED, xyz, geom_dim, err );
}

void iMesh_stepEntArrIter	(	iMesh_Instance	instance,
		iBase_EntityArrIterator	entArr_iterator,
		int	step_length,
		int *	at_end,
		int *	err
	)

Parameters:

[in]	instance	iMesh instance handle
[in]	entArr_iterator	Iterator being queried
[in]	step_length	Number of entities to step the iterator
[out]	at_end	Non-zero if iterator is at the end of the iteration
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2975 of file iMesh_MOAB.cpp.

References CHKERR, ErrorCode, iBase_SUCCESS, RETURN, and iBase_EntityArrIterator_Private::step().

{
    bool tmp;
    ErrorCode result = entArr_iterator->step( step_length, tmp );CHKERR( result, "Problem stepping iterator." );
    *at_end = tmp;
    RETURN( iBase_SUCCESS );
}

void iMesh_stepEntIter	(	iMesh_Instance	instance,
		iBase_EntityIterator	ent_iterator,
		int	step_length,
		int *	at_end,
		int *	err
	)

Step the iterator a specified number of entities.

EntityIterators Step the iterator a specified number of entities. If this number is greater than the number of entities left in the iterator, the iterator is placed at the end and at_end is returned non-zero; otherwise at_end is returned zero.

Parameters:

[in]	instance	iMesh instance handle
[in]	ent_iterator	Iterator being queried
[in]	step_length	Number of entities to step the iterator
[out]	at_end	Non-zero if iterator is at the end of the iteration
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2959 of file iMesh_MOAB.cpp.

References iMesh_stepEntArrIter.

{
    iMesh_stepEntArrIter( instance, reinterpret_cast< iBase_EntityArrIterator >( ent_iterator ), step_length, at_end,
                          err );
}

void iMesh_subtract	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set_1,
		const iBase_EntitySetHandle	entity_set_2,
		iBase_EntitySetHandle *	result_entity_set,
		int *	err
	)

Subtract contents of one entity set from another.

EntitySetOperators Subtract contents of one entity set from another

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set_1	Entity set from which other set is being subtracted
[in]	entity_set_2	Entity set being subtracted from other set
[out]	result_entity_set	Pointer to entity set returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2357 of file iMesh_MOAB.cpp.

References CHKERR, entities, ENTITY_HANDLE, ERROR, ErrorCode, iBase_SUCCESS, iMesh_isList, MB_SUCCESS, MESHSET_SET, MOABI, and RETURN.

{
    EntityHandle temp_set;
    EntityHandle set1 = ENTITY_HANDLE( entity_set_1 ), set2 = ENTITY_HANDLE( entity_set_2 );

    int isList1 = 0, isList2 = 0;
    iMesh_isList( instance, entity_set_1, &isList1, err );
    if( *err != iBase_SUCCESS ) return;
    iMesh_isList( instance, entity_set_2, &isList2, err );
    if( *err != iBase_SUCCESS ) return;

    ErrorCode result;
    if( isList1 && isList2 )
        result = MOABI->create_meshset( MESHSET_ORDERED, temp_set );
    else
        result = MOABI->create_meshset( MESHSET_SET, temp_set );

    if( MB_SUCCESS != result ) ERROR( result, "iMesh_subtract: couldn't create result set." );

    // if the second set is the root set, the result is always the empty set
    if( entity_set_2 )
    {
        if( !entity_set_1 )
        {
            // subtracting from the root set, so get everything first...
            Range entities;
            result = MOABI->get_entities_by_handle( 0, entities );
            if( MB_SUCCESS == result ) result = MOABI->add_entities( temp_set, entities );
            // ...but not the newly-created set!
            if( MB_SUCCESS == result ) result = MOABI->remove_entities( temp_set, &temp_set, 1 );
        }
        else
            result = MOABI->unite_meshset( temp_set, set1 );

        if( MB_SUCCESS == result ) result = MOABI->subtract_meshset( temp_set, set2 );
    }

    CHKERR( result, "iMesh_subtract: ERROR subtract failed." );
    *result_entity_set = (iBase_EntitySetHandle)temp_set;

    RETURN( iBase_SUCCESS );
}

void iMesh_tagIterate	(	iMesh_Instance	instance,
		const iBase_TagHandle	tag_handle,
		iBase_EntityArrIterator	entArr_iterator,
		void *	tag_value,
		int *	count,
		int *	err
	)

Access tag data via direct pointer into contiguous blocks.

Iteratively obtain direct access to contiguous blocks of tag storage. This function cannot be used with bit tags because of the compressed bit storage. This function cannot be used with variable length tags because it does not provide a mechanism to determine the length of the value for each entity. This function may be used with sparse tags, but if it is used, it will return data for a single entity at a time.

If this function is called for entities for which no tag value has been set, but for which a default value exists, it will force the allocation of explicit storage for each such entity even though MOAB would normally not explicitly store tag values for such entities.

:

Parameters:

[in]	instance	iMesh instance
[in]	tag_handle	Tag being queried
[in]	entArr_iterator	Iterator being queried
[out]	data	Pointer to pointer that will be set to tag data memory Array pointer, allocated and occupied sizes argument trio)
[out]	count	Number of contiguous entities in this subrange
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2890 of file iMesh_MOAB.cpp.

References CHKERR, MBIter< Container >::end(), ErrorCode, iBase_SUCCESS, MOABI, MBIter< Container >::position(), RETURN, and TAG_HANDLE.

{
    MBRangeIter* ri = dynamic_cast< MBRangeIter* >( entArr_iterator );
    if( !ri ) CHKERR( MB_FAILURE, "Wrong type of iterator, need a range-based iterator for iMesh_tagIterate." );

    ErrorCode result = MOABI->tag_iterate( TAG_HANDLE( tag_handle ), ri->position(), ri->end(), *count,
                                           *static_cast< void** >( data ) );CHKERR( result, "Problem getting tag iterator." );

    RETURN( iBase_SUCCESS );
}

void iMesh_unite	(	iMesh_Instance	instance,
		const iBase_EntitySetHandle	entity_set_1,
		const iBase_EntitySetHandle	entity_set_2,
		iBase_EntitySetHandle *	result_entity_set,
		int *	err
	)

Unite contents of one entity set with another.

EntitySetOperators

Parameters:

[in]	instance	iMesh instance handle
[in]	entity_set_1	Entity set being united with another
[in]	entity_set_2	Entity set being united with another
[out]	result_entity_set	Pointer to entity set returned from function
[out]	err	Returned Error status (see iBase_ErrorType)

Definition at line 2510 of file iMesh_MOAB.cpp.

References CHKERR, entities, ENTITY_HANDLE, ERROR, ErrorCode, iBase_SUCCESS, iMesh_isList, MB_SUCCESS, MESHSET_SET, MOABI, and RETURN.

{
    EntityHandle temp_set;
    EntityHandle set1 = ENTITY_HANDLE( entity_set_1 ), set2 = ENTITY_HANDLE( entity_set_2 );

    int isList1 = 0, isList2 = 0;
    iMesh_isList( instance, entity_set_1, &isList1, err );
    if( *err != iBase_SUCCESS ) return;
    iMesh_isList( instance, entity_set_2, &isList2, err );
    if( *err != iBase_SUCCESS ) return;

    ErrorCode result;
    if( isList1 && isList2 )
        result = MOABI->create_meshset( MESHSET_ORDERED, temp_set );
    else
        result = MOABI->create_meshset( MESHSET_SET, temp_set );

    if( MB_SUCCESS != result ) ERROR( result, "iMesh_unite: couldn't create result set." );

    if( entity_set_1 && entity_set_2 )
    {
        result = MOABI->unite_meshset( temp_set, set1 );
        if( MB_SUCCESS == result ) result = MOABI->unite_meshset( temp_set, set2 );
    }
    else
    {
        // uniting with the root set, so get everything...
        Range entities;
        result = MOABI->get_entities_by_handle( 0, entities );
        if( MB_SUCCESS == result ) result = MOABI->add_entities( temp_set, entities );
        // ...but not the newly-created set!
        if( MB_SUCCESS == result ) result = MOABI->remove_entities( temp_set, &temp_set, 1 );
    }

    CHKERR( result, "iMesh_unite: ERROR unite failed." );

    *result_entity_set = (iBase_EntitySetHandle)temp_set;

    RETURN( iBase_SUCCESS );
}

static void munge_adj_table	(	int *	adjTable,
		int	geom_dim
	)		`[static]`

Definition at line 196 of file iMesh_MOAB.cpp.

References iBase_AVAILABLE, and iBase_UNAVAILABLE.

Referenced by iMesh_getAdjTable(), and iMesh_setAdjTable().

{
    // If geom_dim is 2, 3D adjacencies are unavailable. This may change!
    if( geom_dim == 2 )
    {
        for( size_t i = 0; i < 16; ++i )
        {
            if( i % 4 == 3 || i >= 12 ) adjTable[i] = iBase_UNAVAILABLE;
        }
    }

    // Ensure that diagonal entries are only available/unavailable.
    for( size_t i = 0; i < 16; i += 5 )
    {
        if( adjTable[i] != iBase_UNAVAILABLE ) adjTable[i] = iBase_AVAILABLE;
    }
}

static void remove_var_len_tags	(	Interface *	mb,
		std::vector< Tag > &	tags
	)		`[static]`

Definition at line 186 of file iMesh_MOAB.cpp.

References MB_SUCCESS, size, and moab::Interface::tag_get_length().

Referenced by iMesh_getAllEntSetTags(), iMesh_getAllIfaceTags(), and iMesh_getAllTags().

{
    int size;
    size_t r, w = 0;
    for( r = 0; r < tags.size(); ++r )
        if( MB_SUCCESS == mb->tag_get_length( tags[r], size ) ) tags[w++] = tags[r];
    tags.resize( w );
}

Variable Documentation

const iBase_ErrorType iBase_ERROR_MAP[MB_FAILURE+1]

Initial value:

 {
    iBase_SUCCESS,                   
    iBase_INVALID_ENTITY_HANDLE,     
    iBase_INVALID_ENTITY_TYPE,       
    iBase_MEMORY_ALLOCATION_FAILED,  
    iBase_INVALID_ENTITY_HANDLE,     
    iBase_NOT_SUPPORTED,             
    iBase_TAG_NOT_FOUND,             
    iBase_FILE_NOT_FOUND,            
    iBase_FILE_WRITE_ERROR,          
    iBase_NOT_SUPPORTED,             
    iBase_TAG_ALREADY_EXISTS,        
    iBase_FAILURE,                   
    iBase_FAILURE,                   
    iBase_NOT_SUPPORTED,             
    iBase_INVALID_ARGUMENT,          
    iBase_INVALID_ENTITY_TYPE,       
    iBase_FAILURE                    
}

Definition at line 96 of file iMesh_MOAB.cpp.

const DataType mb_data_type_table[]

Initial value:

 { MB_TYPE_OPAQUE, MB_TYPE_INTEGER, MB_TYPE_DOUBLE, MB_TYPE_HANDLE,
                                        MB_TYPE_HANDLE }

Definition at line 89 of file iMesh_MOAB.cpp.

Referenced by iMesh_createTagWithOptions().

const EntityType mb_topology_table[]

Initial value:

 { MBVERTEX, MBEDGE, MBPOLYGON, MBTRI,     MBQUAD,    MBPOLYHEDRON,
                                         MBTET,    MBHEX,  MBPRISM,   MBPYRAMID, MBMAXTYPE, MBMAXTYPE }

Definition at line 85 of file iMesh_MOAB.cpp.

Referenced by get_entities(), iMesh_createEnt(), iMesh_createEntArr(), iMesh_getEntitiesRec(), iMesh_getEntsByTagsRec(), iMesh_getNumOfTopoRec(), iMesh_initEntArrIterRec(), iMesh_MBCNType(), iMeshP_pushTags(), and MBIter< Container >::reset().

const iBase_TagValueType tstt_data_type_table[]

Initial value:

 { iBase_BYTES, iBase_INTEGER, iBase_DOUBLE, iBase_BYTES,
                                                    iBase_ENTITY_HANDLE }

Definition at line 93 of file iMesh_MOAB.cpp.

Referenced by iMesh_getTagType().

const iMesh_EntityTopology tstt_topology_table[]

Initial value:

 {
    iMesh_POINT,           
    iMesh_LINE_SEGMENT,    
    iMesh_TRIANGLE,        
    iMesh_QUADRILATERAL,   
    iMesh_POLYGON,         
    iMesh_TETRAHEDRON,     
    iMesh_PYRAMID,         
    iMesh_PRISM,           
    iMesh_ALL_TOPOLOGIES,  
    iMesh_HEXAHEDRON,      
    iMesh_POLYHEDRON,      
    iMesh_ALL_TOPOLOGIES,  
    iMesh_ALL_TOPOLOGIES,  
}

Definition at line 51 of file iMesh_MOAB.cpp.

Referenced by iMesh_getEntArrTopo(), and iMesh_getEntTopo().

const iBase_EntityType tstt_type_table[]

Initial value:

 {
    iBase_VERTEX,     
    iBase_EDGE,       
    iBase_FACE,       
    iBase_FACE,       
    iBase_FACE,       
    iBase_REGION,     
    iBase_REGION,     
    iBase_REGION,     
    iBase_REGION,     
    iBase_REGION,     
    iBase_REGION,     
    iBase_ALL_TYPES,  
    iBase_ALL_TYPES   
}

Definition at line 68 of file iMesh_MOAB.cpp.

Referenced by iMesh_getEntArrType(), and iMesh_getEntType().

Defines

Functions

Variables

Define Documentation

Function Documentation

Variable Documentation