moab::Core Class Reference

Implementation of MOAB Interface Implementation of the MOAB Interface class. You shouldn't call functions directly on an object of type Core (use Interface instead), unless you really have to access non-API functionality. More...

#include <Core.hpp>

Inheritance diagram for moab::Core:

Collaboration diagram for moab::Core:

Classes
class	HONodeAddedRemoved
	function object for recieving events from MB of higher order nodes added to entities More...

Public Types
typedef unsigned long long	type_memstorage
Public Types inherited from moab::Interface
enum	{ INTERSECT , UNION }
	Enumerated type used in get_adjacencies() and other functions. More...

Public Member Functions
	Core ()
	constructor More...
	~Core ()
	destructor More...
virtual ErrorCode	query_interface_type (const std::type_info &interface_type, void *&ptr)
	Get a pointer to an internal MOAB interface. More...
virtual ErrorCode	release_interface_type (const std::type_info &interface_type, void *iface)
	Release reference to MB interface. More...
virtual int	QueryInterface (const MBuuid &uuid, UnknownInterface **iface)
virtual float	impl_version (std::string *version_string=NULL)
	Returns the major.minor version number of the implementation. More...
virtual EntityType	type_from_handle (const EntityHandle handle) const
	get the type from a handle, returns type More...
virtual EntityID	id_from_handle (const EntityHandle handle) const
	get the id from a handle, returns id More...
virtual ErrorCode	handle_from_id (const EntityType type, const EntityID id, EntityHandle &handle) const
	get a handle from an id and type More...
virtual int	dimension_from_handle (const EntityHandle) const
	Returns the topological dimension of an entity. More...
virtual ErrorCode	load_mesh (const char *file_name, const int *active_block_id_list=NULL, const int num_blocks=0)
	load mesh from data in file NOTE: if there is mesh already present, the new mesh will be added More...
virtual ErrorCode	load_file (const char *file_name, const EntityHandle *file_set=0, const char *options=0, const char *set_tag_name=0, const int *set_tag_vals=0, int num_set_tag_vals=0)
ErrorCode	serial_load_file (const char *file_name, const EntityHandle *file_set, const FileOptions &opts, const ReaderIface::SubsetList *subsets=0, const Tag *file_id_tag=0)
ErrorCode	serial_read_tag (const char *file_name, const char *tag_name, const FileOptions &opts, std::vector< int > &tag_vals, const ReaderIface::SubsetList *subsets=0)
virtual ErrorCode	write_mesh (const char *file_name, const EntityHandle *output_list=NULL, const int num_sets=0)
	Writes mesh to a file. More...
virtual ErrorCode	write_file (const char *file_name, const char *file_type=0, const char *options=0, const EntityHandle *output_sets=0, int num_output_sets=0, const Tag *tag_list=0, int num_tags=0)
virtual ErrorCode	write_file (const char *file_name, const char *file_type, const char *options, const Range &output_sets, const Tag *tag_list=0, int num_tags=0)
virtual ErrorCode	delete_mesh ()
	deletes all mesh entities from this datastore More...
virtual ErrorCode	get_dimension (int &dim) const
	get overall geometric dimension More...
virtual ErrorCode	set_dimension (const int dim)
	set overall geometric dimension More...
virtual ErrorCode	get_vertex_coordinates (std::vector< double > &coords) const
	get blocked vertex coordinates for all vertices More...
virtual ErrorCode	coords_iterate (Range::const_iterator iter, Range::const_iterator end, double *&xcoords_ptr, double *&ycoords_ptr, double *&zcoords_ptr, int &count)
	get pointers to coordinate data More...
virtual ErrorCode	get_coords (const Range &entities, double *coords) const
	get the coordinate information for this handle if it is of type Vertex otherwise, return an error More...
virtual ErrorCode	get_coords (const EntityHandle *entities, const int num_entities, double *coords) const
	Gets xyz coordinate information for vector of vertices. More...
virtual ErrorCode	get_coords (const EntityHandle entity_handle, const double *&x, const double *&y, const double *&z) const
virtual ErrorCode	get_coords (const Range &entities, double *x_coords, double *y_coords, double *z_coords) const
virtual ErrorCode	set_coords (const EntityHandle *entity_handles, const int num_entities, const double *coords)
	set the coordinate information for this handle if it is of type Vertex otherwise, return an error More...
virtual ErrorCode	set_coords (Range entity_handles, const double *coords)
	set the coordinate information for this handle if it is of type Vertex otherwise, return an error More...
virtual ErrorCode	get_connectivity_by_type (const EntityType type, std::vector< EntityHandle > &connect) const
	get global connectivity array for specified entity type More...
virtual ErrorCode	connect_iterate (Range::const_iterator iter, Range::const_iterator end, EntityHandle *&connect, int &verts_per_entity, int &count)
	get pointer to connectivity data More...
virtual ErrorCode	get_connectivity (const EntityHandle *entity_handles, const int num_handles, std::vector< EntityHandle > &connectivity, bool corners_only=false, std::vector< int > *offsets=NULL) const
	Gets the connectivity for an element EntityHandle. More...
virtual ErrorCode	get_connectivity (const EntityHandle *entity_handles, const int num_handles, Range &connectivity, bool corners_only=false) const
	Gets the connectivity for a vector of elements. More...
virtual ErrorCode	get_connectivity (const Range &from_entities, Range &adj_entities, bool corners_only=false) const
	Gets the connectivity for elements. More...
virtual ErrorCode	get_connectivity (const EntityHandle entity_handle, const EntityHandle *&connectivity, int &number_nodes, bool corners_only=false, std::vector< EntityHandle > *storage=0) const
	Gets a pointer to constant connectivity data of entity_handle More...
virtual ErrorCode	set_connectivity (const EntityHandle entity_handle, EntityHandle *connect, const int num_connect)
	Sets the connectivity for an EntityHandle. For non-element handles, return an error. More...
virtual ErrorCode	get_adjacencies (const EntityHandle *from_entities, const int num_entities, const int to_dimension, const bool create_if_missing, std::vector< EntityHandle > &adj_entities, const int operation_type=Interface::INTERSECT)
	get the adjacencies associated with a set of entities More...
virtual ErrorCode	get_adjacencies (const EntityHandle *from_entities, const int num_entities, const int to_dimension, const bool create_if_missing, Range &adj_entities, const int operation_type=Interface::INTERSECT)
	Get the adjacencies associated with a vector of entities to entities of a specfied dimension. More...
virtual ErrorCode	get_adjacencies (const Range &from_entities, const int to_dimension, const bool create_if_missing, Range &adj_entities, const int operation_type=Interface::INTERSECT)
	Get the adjacencies associated with a range of entities to entities of a specfied dimension. More...
ErrorCode	adjacencies_iterate (Range::const_iterator iter, Range::const_iterator end, const std::vector< EntityHandle > **&adjs_ptr, int &count)
	Get a ptr to adjacency lists Get a pointer to adjacency lists. These lists are std::vector<EntityHandle>, which are pointed to by adjs[i]. Adjacencies are not guaranteed to be in order of increasing dimension. Only a const version of this function is given, because adjacency data is managed more carefully in MOAB and should be treated as read-only by applications. If adjacencies have not yet been initialized, adjs_ptr will be NULL (i.e. adjs_ptr == NULL). There may also be NULL entries for individual entities, i.e. adjs_ptr[i] == NULL. More...
virtual ErrorCode	get_vertices (const Range &from_entities, Range &vertices)
	Get all vertices for input entities. More...
virtual ErrorCode	get_entities_by_dimension (const EntityHandle meshset, const int dimension, Range &entities, const bool recursive=false) const
	Adds adjacencies. More...
virtual ErrorCode	get_entities_by_dimension (const EntityHandle meshset, const int dimension, std::vector< EntityHandle > &entities, const bool recursive=false) const
	Retrieves all entities of a given topological dimension in the database or meshset. More...
virtual ErrorCode	get_entities_by_type (const EntityHandle meshset, const EntityType type, Range &entities, const bool recursive=false) const
	Retrieves all entities in the data base of given type. More...
virtual ErrorCode	get_entities_by_type (const EntityHandle meshset, const EntityType type, std::vector< EntityHandle > &entities, const bool recursive=false) const
	Retrieves all entities in the data base of given type. More...
virtual ErrorCode	get_entities_by_type_and_tag (const EntityHandle meshset, const EntityType type, const Tag *tags, const void *const *values, const int num_tags, Range &entities, const int condition=Interface::INTERSECT, const bool recursive=false) const
	Retrieve entities in the database or meshset which have any or all of the tag(s) and (optionally) value(s) specified. More...
virtual ErrorCode	get_entities_by_handle (const EntityHandle meshset, Range &entities, const bool recursive=false) const
	Retrieves all entities in the data base. More...
virtual ErrorCode	get_entities_by_handle (const EntityHandle meshset, std::vector< EntityHandle > &entities, const bool recursive=false) const
	Retrieves all entities in the data base. More...
virtual ErrorCode	get_number_entities_by_dimension (const EntityHandle meshset, const int dimension, int &number, const bool recursive=false) const
	Retrieves all entities in the database of given dimension. More...
virtual ErrorCode	get_number_entities_by_type (const EntityHandle meshset, const EntityType type, int &num_entities, const bool recursive=false) const
	Retrieves all entities in the data base of given type. More...
virtual ErrorCode	get_number_entities_by_type_and_tag (const EntityHandle meshset, const EntityType type, const Tag *tag_handles, const void *const *values, const int num_tags, int &num_entities, const int condition=Interface::INTERSECT, const bool recursive=false) const
	Retrieve number of entities in the database or meshset which have any or all of the tag(s) and (optionally) value(s) specified. More...
virtual ErrorCode	get_number_entities_by_handle (const EntityHandle meshset, int &num_entities, const bool recursive=false) const
	Retrieves all entities in the data base. More...
virtual ErrorCode	create_element (const EntityType type, const EntityHandle *connectivity, const int num_nodes, EntityHandle &element_handle)
	Creates an element based on the type and connectivity. More...
virtual ErrorCode	create_vertex (const double coords[3], EntityHandle &entity_handle)
	Creates a vertex based on coordinates. More...
virtual ErrorCode	create_vertices (const double *coordinates, const int nverts, Range &entity_handles)
	Create a set of vertices with the specified coordinates. More...
virtual ErrorCode	merge_entities (EntityHandle entity_to_keep, EntityHandle entity_to_remove, bool auto_merge, bool delete_removed_entity)
	merges two entities More...
virtual ErrorCode	delete_entities (const EntityHandle *entities, const int num_entities)
	Removes entities in a vector from the data base. More...
virtual ErrorCode	delete_entities (const Range &range)
	Removes entities in a range from the data base. More...
virtual ErrorCode	list_entities (const Range &temp_range) const
	List entities to standard output. More...
virtual ErrorCode	list_entities (const EntityHandle *entities, const int num_entities) const
	List entities, or number of entities in database, to standard output. More...
virtual ErrorCode	list_entity (const EntityHandle entity) const
	List a single entity; no header printed. More...
virtual ErrorCode	convert_entities (const EntityHandle meshset, const bool mid_side, const bool mid_face, const bool mid_volume, Interface::HONodeAddedRemoved *function_object=0)
	Convert entities to higher-order elements by adding mid nodes. More...
virtual ErrorCode	side_number (const EntityHandle parent, const EntityHandle child, int &sd_number, int &sense, int &offset) const
	function to get the side number given two elements; returns MB_FAILURE if child not related to parent; does not create adjacencies between parent and child More...
virtual ErrorCode	high_order_node (const EntityHandle parent_handle, const EntityHandle *subfacet_conn, const EntityType subfacet_type, EntityHandle &hon) const
	given an entity and the connectivity and type of one of its subfacets, find the high order node on that subfacet, if any More...
virtual ErrorCode	side_element (const EntityHandle source_entity, const int dim, const int sd_number, EntityHandle &target_entity) const
	given an entity and a target dimension & side number, get that entity More...
virtual ErrorCode	tag_get_handle (const char *name, int size, DataType type, Tag &tag_handle, unsigned flags=0, const void *default_value=0, bool *created=0)
	Get a tag handle, possibly creating the tag. More...
virtual ErrorCode	tag_get_handle (const char *name, int size, DataType type, Tag &tag_handle, unsigned flags=0, const void *default_value=0) const
	same as non-const version, except that TAG_CREAT flag is ignored. More...
virtual ErrorCode	tag_get_name (const Tag tag_handle, std::string &tag_name) const
	Gets the tag name string of the tag_handle. More...
virtual ErrorCode	tag_get_handle (const char *tag_name, Tag &tag_handle) const
	Gets the tag handle corresponding to a name. More...
virtual ErrorCode	tag_get_tags_on_entity (const EntityHandle entity, std::vector< Tag > &tag_handles) const
	Get handles for all tags defined on this entity. More...
virtual ErrorCode	tag_get_bytes (const Tag tag, int &tag_size) const
	Get the size of the specified tag in bytes. More...
virtual ErrorCode	tag_get_length (const Tag tag, int &tag_size) const
	Get the array length of a tag. More...
virtual ErrorCode	tag_get_default_value (const Tag tag, void *def_val) const
	Get the default value of the specified tag. More...
virtual ErrorCode	tag_get_default_value (Tag tag, const void *&ptr, int &size) const
	Get a tag handle, possibly creating the tag. More...
virtual ErrorCode	tag_get_type (const Tag, TagType &tag_type) const
	get type of tag (sparse, dense, etc.; 0 = dense, 1 = sparse, 2 = bit, 3 = mesh) More...
virtual ErrorCode	tag_get_data_type (const Tag handle, DataType &type) const
	Get data type of tag. More...
virtual ErrorCode	tag_get_tags (std::vector< Tag > &tag_handles) const
	get handles for all tags defined More...
virtual ErrorCode	tag_get_data (const Tag tag_handle, const EntityHandle *entity_handles, const int num_entities, void *tag_data) const
	return the tag data for a given EntityHandle and Tag More...
virtual ErrorCode	tag_get_data (const Tag tag_handle, const Range &entity_handles, void *tag_data) const
	return the tag data for a given EntityHandle and Tag More...
virtual ErrorCode	tag_set_data (Tag tag_handle, const EntityHandle *entity_handles, int num_entities, const void *tag_data)
	Sets the data of a given EntityHandle and Tag. More...
virtual ErrorCode	tag_set_data (Tag tag_handle, const Range &entity_handles, const void *tag_data)
	set the data for given EntityHandles and Tag More...
virtual ErrorCode	tag_get_by_ptr (const Tag tag_handle, const EntityHandle *entity_handles, int num_entities, const void **tag_data, int *tag_sizes=0) const
	Get pointers to tag data. More...
virtual ErrorCode	tag_get_by_ptr (const Tag tag_handle, const Range &entity_handles, const void **tag_data, int *tag_sizes=0) const
	Get pointers to tag data. More...
virtual ErrorCode	tag_set_by_ptr (Tag tag_handle, const EntityHandle *entity_handles, int num_entities, void const *const *tag_data, const int *tag_sizes=0)
	Set tag data given an array of pointers to tag values. More...
virtual ErrorCode	tag_set_by_ptr (Tag tag_handle, const Range &entity_handles, void const *const *tag_data, const int *tag_sizes=0)
	Set tag data given an array of pointers to tag values. More...
virtual ErrorCode	tag_clear_data (Tag tag_handle, const Range &entity_handles, const void *tag_data, int tag_size=0)
	Set tag data given value. More...
virtual ErrorCode	tag_clear_data (Tag tag_handle, const EntityHandle *entity_handles, int num_entities, const void *tag_data, int tag_size=0)
	Set tag data given value. More...
virtual ErrorCode	tag_delete_data (Tag tag_handle, const EntityHandle *entity_handles, int num_entities)
	Delete the data of a vector of entity handles and sparse tag. More...
virtual ErrorCode	tag_delete_data (Tag tag_handle, const Range &entity_handles)
	Delete the data of a range of entity handles and sparse tag. More...
virtual ErrorCode	tag_delete (Tag tag_handle)
	Removes the tag from the database and deletes all of its associated data. More...
virtual ErrorCode	tag_iterate (Tag tag_handle, Range::const_iterator iter, Range::const_iterator end, int &count, void *&data_ptr, bool allocate=true)
	Access tag data via direct pointer into contiguous blocks. More...
virtual ErrorCode	create_meshset (const unsigned int options, EntityHandle &ms_handle, int start_id=0)
	creates a mesh set More...
virtual ErrorCode	clear_meshset (const EntityHandle *ms_handles, const int num_meshsets)
	Empty a vector of mesh set. More...
virtual ErrorCode	clear_meshset (const Range &ms_handles)
	Empty a range of mesh set. More...
virtual ErrorCode	get_meshset_options (const EntityHandle ms_handle, unsigned int &options) const
	get the options of a mesh set More...
virtual ErrorCode	set_meshset_options (const EntityHandle ms_handle, const unsigned int options)
	set the options of a mesh set More...
virtual ErrorCode	subtract_meshset (EntityHandle meshset1, const EntityHandle meshset2)
	subtracts meshset2 from meshset1 - modifies meshset1 More...
virtual ErrorCode	intersect_meshset (EntityHandle meshset1, const EntityHandle meshset2)
	intersects meshset2 with meshset1 - modifies meshset1 More...
virtual ErrorCode	unite_meshset (EntityHandle meshset1, const EntityHandle meshset2)
	unites meshset2 with meshset1 - modifies meshset1 More...
virtual ErrorCode	add_entities (EntityHandle meshset, const Range &entities)
	add entities to meshset More...
virtual ErrorCode	add_entities (EntityHandle meshset, const EntityHandle *entities, const int num_entities)
	add entities to meshset More...
virtual ErrorCode	remove_entities (EntityHandle meshset, const Range &entities)
	remove entities from meshset More...
virtual ErrorCode	remove_entities (EntityHandle meshset, const EntityHandle *entities, const int num_entities)
	remove entities from meshset More...
virtual bool	contains_entities (EntityHandle meshset, const EntityHandle *entities, int num_entities, const int operation_type=Interface::INTERSECT)
	return true if all entities are contained in set More...
virtual ErrorCode	replace_entities (EntityHandle meshset, const EntityHandle *old_entities, const EntityHandle *new_entities, int num_entities)
	replace entities More...
virtual ErrorCode	get_parent_meshsets (const EntityHandle meshset, std::vector< EntityHandle > &parents, const int num_hops=1) const
	get parent meshsets More...
virtual ErrorCode	get_parent_meshsets (const EntityHandle meshset, Range &parents, const int num_hops=1) const
	get parent meshsets More...
virtual ErrorCode	get_child_meshsets (const EntityHandle meshset, std::vector< EntityHandle > &children, const int num_hops=1) const
	get child meshsets More...
virtual ErrorCode	get_child_meshsets (const EntityHandle meshset, Range &children, const int num_hops=1) const
	get child meshsets More...
virtual ErrorCode	get_contained_meshsets (const EntityHandle meshset, std::vector< EntityHandle > &children, const int num_hops=1) const
	get contained meshsets More...
virtual ErrorCode	get_contained_meshsets (const EntityHandle meshset, Range &children, const int num_hops=1) const
	get contained meshsets More...
virtual ErrorCode	num_parent_meshsets (const EntityHandle meshset, int *number, const int num_hops=1) const
	gets number of parent meshsets More...
virtual ErrorCode	num_child_meshsets (const EntityHandle meshset, int *number, const int num_hops=1) const
	gets number of child meshsets More...
virtual ErrorCode	num_contained_meshsets (const EntityHandle meshset, int *number, const int num_hops=1) const
	gets number of contained meshsets More...
virtual ErrorCode	add_parent_meshset (EntityHandle meshset, const EntityHandle parent_meshset)
	add a parent meshset More...
virtual ErrorCode	add_parent_meshsets (EntityHandle meshset, const EntityHandle *parents, int count)
	add parent meshsets More...
virtual ErrorCode	add_child_meshset (EntityHandle meshset, const EntityHandle child_meshset)
	add a child meshset More...
virtual ErrorCode	add_child_meshsets (EntityHandle meshset, const EntityHandle *children, int count)
	add parent meshsets More...
virtual ErrorCode	add_parent_child (EntityHandle parent, EntityHandle child)
	adds 'parent' to child's parent list and adds 'child' to parent's child list More...
virtual ErrorCode	remove_parent_child (EntityHandle parent, EntityHandle child)
	removes 'parent' to child's parent list and removes 'child' to parent's child list More...
virtual ErrorCode	remove_parent_meshset (EntityHandle meshset, const EntityHandle parent_meshset)
	remove parent meshset More...
virtual ErrorCode	remove_child_meshset (EntityHandle meshset, const EntityHandle child_meshset)
	remove child meshset More...
Tag	material_tag ()
	return various specific tag handles More...
Tag	neumannBC_tag ()
Tag	dirichletBC_tag ()
Tag	globalId_tag ()
	Get parent mesh sets of a mesh set. More...
Tag	geom_dimension_tag ()
SequenceManager *	sequence_manager ()
	get/set the number of nodes More...
const SequenceManager *	sequence_manager () const
ErrorCode	create_scd_sequence (const HomCoord &coord_min, const HomCoord &coord_max, EntityType type, EntityID start_id_hint, EntityHandle &first_handle_out, EntitySequence *&sequence_out)
	create structured sequence More...
ErrorCode	add_vsequence (EntitySequence *vert_seq, EntitySequence *elem_seq, const HomCoord &p1, const HomCoord &q1, const HomCoord &p2, const HomCoord &q2, const HomCoord &p3, const HomCoord &q3, bool bb_input=false, const HomCoord *bb_min=NULL, const HomCoord *bb_max=NULL)
AEntityFactory *	a_entity_factory ()
	return the a_entity_factory pointer More...
const AEntityFactory *	a_entity_factory () const
ReaderWriterSet *	reader_writer_set ()
	return set of registered IO tools More...
void	print (const EntityHandle handle, const char *prefix, bool first_call=true) const
ErrorCode	print_entity_tags (std::string indent_prefix, const EntityHandle handle, TagType tp) const
virtual ErrorCode	get_last_error (std::string &info) const
	Return information about the last error. More...
virtual std::string	get_error_string (const ErrorCode code) const
	Return string representation of given error code. More...
ErrorCode	check_adjacencies ()
	check all adjacencies for consistency More...
ErrorCode	check_adjacencies (const EntityHandle *ents, int num_ents)
	check some adjacencies for consistency More...
bool	is_valid (const EntityHandle this_ent) const
	return whether the input handle is valid or not More...
virtual ErrorCode	create_set_iterator (EntityHandle meshset, EntityType ent_type, int ent_dim, int chunk_size, bool check_valid, SetIterator *&set_iter)
	Create an iterator over the set Create a new iterator that iterates over entities with the specified type or dimension. Only one of ent_type or dim can be set; use dim=-1 or ent_type=MBMAXTYPE for the other. Iterators for list-type (ordered) sets are stable over set modification, unless entity removed or deleted is the one at the current position of the iterator. If the check_valid parameter is passed as true, entities are checked for validity before being passed back by get_next_entities function (checking entity validity can have a non-negligible cost). More...
ErrorCode	remove_set_iterator (SetIterator *set_iter)
	Remove the set iterator from the instance's list. More...
ErrorCode	get_set_iterators (EntityHandle meshset, std::vector< SetIterator * > &set_iters)
	Get all set iterators associated with the set passed in. More...
void	estimated_memory_use (const EntityHandle *ent_array=0, unsigned long num_ents=0, unsigned long long *total_storage=0, unsigned long long *total_amortized_storage=0, unsigned long long *entity_storage=0, unsigned long long *amortized_entity_storage=0, unsigned long long *adjacency_storage=0, unsigned long long *amortized_adjacency_storage=0, const Tag *tag_array=0, unsigned num_tags=0, unsigned long long *tag_storage=0, unsigned long long *amortized_tag_storage=0)
	Calculate amount of memory used to store MOAB data. More...
void	estimated_memory_use (const Range &ents, unsigned long long *total_storage=0, unsigned long long *total_amortized_storage=0, unsigned long long *entity_storage=0, unsigned long long *amortized_entity_storage=0, unsigned long long *adjacency_storage=0, unsigned long long *amortized_adjacency_storage=0, const Tag *tag_array=0, unsigned num_tags=0, unsigned long long *tag_storage=0, unsigned long long *amortized_tag_storage=0)
	Calculate amount of memory used to store MOAB data. More...
void	print_database () const
Sequence Option controllers
virtual double	get_sequence_multiplier () const
	Interface to control memory allocation for sequences Provide a factor that controls the size of the sequence that gets allocated. This is typically useful in the parallel setting when a-priori, the number of ghost entities and the memory required for them within the same sequence as the owned entities are unknown. The default factor is 1.0 but this can be appropriately updated at runtime so that we do not have broken sequences. More...
virtual void	set_sequence_multiplier (double factor)
	Interface to control memory allocation for sequences Provide a factor that controls the size of the sequence that gets allocated. This is typically useful in the parallel setting when a-priori, the number of ghost entities and the memory required for them within the same sequence as the owned entities are unknown. The default factor is 1.0 but this can be appropriately updated at runtime so that we do not have broken sequences. More...
Public Member Functions inherited from moab::Interface
	Interface ()
	constructor More...
virtual	~Interface ()
	destructor More...
template<class IFace >
ErrorCode	query_interface (IFace *&ptr)
	Get a pointer to an internal MOAB interface. More...
template<class IFace >
ErrorCode	release_interface (IFace *interface)
	constructor More...
virtual float	api_version (std::string *version_string=NULL)
	Release reference to MB interface. More...
virtual ErrorCode	add_adjacencies (const EntityHandle from_handle, const EntityHandle *to_handles, const int num_handles, bool both_ways)=0
	Adds adjacencies between "from" and "to" entities. More...
virtual ErrorCode	add_adjacencies (const EntityHandle from_handle, Range &adjacencies, bool both_ways)=0
	Adds adjacencies; same as vector-based, but with range instead. More...
virtual ErrorCode	remove_adjacencies (const EntityHandle from_handle, const EntityHandle *to_handles, const int num_handles)=0
	Removes adjacencies between handles. More...
Public Member Functions inherited from moab::UnknownInterface
virtual	~UnknownInterface ()

Private Member Functions
	Core (const Core &copy)
	Do not allow copying. More...
Core &	operator= (const Core &copy)
	Do not allow copying. More...
void	estimated_memory_use_internal (const Range *ents, unsigned long long *total_storage, unsigned long long *total_amortized_storage, unsigned long long *entity_storage, unsigned long long *amortized_entity_storage, unsigned long long *adjacency_storage, unsigned long long *amortized_adjacency_storage, const Tag *tag_array, unsigned num_tags, unsigned long long *tag_storage, unsigned long long *amortized_tag_storage)
ErrorCode	initialize ()
	database init and de-init routines More...
void	deinitialize ()
EntityHandle	get_root_set ()
	return the entity set representing the whole mesh More...
void	clean_up_failed_read (const Range &initial_ents, std::vector< Tag > initial_tags)
	Clean up after a file reader returns failure. More...
bool	valid_tag_handle (const TagInfo *t) const

Private Attributes
WriteUtil *	mMBWriteUtil
ReadUtil *	mMBReadUtil
ScdInterface *	scdInterface
int	geometricDimension
	store the total number of elements defined in this interface More...
Tag	materialTag
Tag	neumannBCTag
Tag	dirichletBCTag
Tag	geomDimensionTag
Tag	globalIdTag
std::list< TagInfo * >	tagList
	tag server for this interface More...
SequenceManager *	sequenceManager
AEntityFactory *	aEntityFactory
ReaderWriterSet *	readerWriterSet
Error *	mError
bool	mpiFinalize
int	writeMPELog
bool	initErrorHandlerInCore
std::vector< SetIterator * >	setIterators
	list of iterators More...

Friends
class	SetIterator

Detailed Description

Implementation of MOAB Interface Implementation of the MOAB Interface class. You shouldn't call functions directly on an object of type Core (use Interface instead), unless you really have to access non-API functionality.

Examples

ComputeTriDual.cpp.

Definition at line 49 of file Core.hpp.

Member Typedef Documentation

type_memstorage

typedef unsigned long long moab::Core::type_memstorage

Definition at line 558 of file Core.hpp.

Constructor & Destructor Documentation

Core() [1/2]

moab::Core::Core

(

)

constructor

Constructor.

Definition at line 170 of file Core.cpp.

{
 if( initialize() != MB_SUCCESS )
 {
 printf( "Error initializing moab::Core\n" );
 exit( 1 );
 }
}

References GaussIntegration::initialize(), and MB_SUCCESS.

~Core()

moab::Core::~Core

(

)

destructor

Definition at line 180 of file Core.cpp.

{
 if( mMBWriteUtil ) delete mMBWriteUtil;
 if( mMBReadUtil ) delete mMBReadUtil;
 if( scdInterface ) delete scdInterface;
 
 mMBWriteUtil = NULL;
 mMBReadUtil = NULL;
 scdInterface = NULL;
 
 deinitialize();
}

Core() [2/2]

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

private

Do not allow copying.

Member Function Documentation

a_entity_factory() [1/2]

AEntityFactory* moab::Core::a_entity_factory ( )

inline

return the a_entity_factory pointer

Definition at line 1069 of file Core.hpp.

 {
 return aEntityFactory;
 }

References aEntityFactory.

Referenced by moab::HigherOrderFactory::center_node_exist(), moab::Skinner::find_skin(), moab::WriteUtil::get_adjacencies(), moab::HigherOrderFactory::tag_for_deletion(), and moab::ReadUtil::update_adjacencies().

a_entity_factory() [2/2]

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

inline

Definition at line 1073 of file Core.hpp.

 {
 return aEntityFactory;
 }

References aEntityFactory.

add_child_meshset()

ErrorCode moab::Core::add_child_meshset ( EntityHandle  meshset, const EntityHandle  child_meshset  )

virtual

add a child meshset

Implements moab::Interface.

Definition at line 3551 of file Core.cpp.

{
 MeshSet* set_ptr = get_mesh_set( sequence_manager(), meshset );
 MeshSet* child_ptr = get_mesh_set( sequence_manager(), child_meshset );
 if( !set_ptr || !child_ptr ) return MB_ENTITY_NOT_FOUND;
 
 set_ptr->add_child( child_meshset );
 return MB_SUCCESS;
}

References moab::MeshSet::add_child(), moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and MB_SUCCESS.

add_child_meshsets()

ErrorCode moab::Core::add_child_meshsets ( EntityHandle  meshset, const EntityHandle *  children, int  count  )

virtual

add parent meshsets

Implements moab::Interface.

Definition at line 3561 of file Core.cpp.

{
 MeshSet* set_ptr = get_mesh_set( sequence_manager(), meshset );
 if( !set_ptr ) return MB_ENTITY_NOT_FOUND;
 
 for( int i = 0; i < count; ++i )
 if( !get_mesh_set( sequence_manager(), children[i] ) ) return MB_ENTITY_NOT_FOUND;
 
 for( int i = 0; i < count; ++i )
 set_ptr->add_child( children[i] );
 return MB_SUCCESS;
}

References moab::MeshSet::add_child(), children, moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and MB_SUCCESS.

add_entities() [1/2]

ErrorCode moab::Core::add_entities ( EntityHandle  meshset, const EntityHandle *  entities, const int  num_entities  )

virtual

add entities to meshset

Implements moab::Interface.

Definition at line 3352 of file Core.cpp.

{
 MeshSet* set = get_mesh_set( sequence_manager(), meshset );
 if( set )
 return set->add_entities( entities, num_entities, meshset, a_entity_factory() );
 else
 return MB_ENTITY_NOT_FOUND;
}

References moab::MeshSet::add_entities(), entities, moab::get_mesh_set(), and MB_ENTITY_NOT_FOUND.

add_entities() [2/2]

ErrorCode moab::Core::add_entities ( EntityHandle  meshset, const Range &  entities  )

virtual

add entities to meshset

Implements moab::Interface.

Definition at line 3343 of file Core.cpp.

{
 MeshSet* set = get_mesh_set( sequence_manager(), meshset );
 if( set )
 return set->add_entities( entities, meshset, a_entity_factory() );
 else
 return MB_ENTITY_NOT_FOUND;
}

References moab::MeshSet::add_entities(), entities, moab::get_mesh_set(), and MB_ENTITY_NOT_FOUND.

Referenced by create_coarse_mesh(), create_fine_mesh(), moab::NestedRefine::create_hm_storage_single_level(), create_lagr_mesh(), IntxUtilsCSLAM::create_span_quads(), IntxUtilsCSLAM::deep_copy_set(), moab::NestedRefine::exchange_ghosts(), main(), manufacture_lagrange_mesh_on_sphere(), process_partition_file(), moab::ReorderTool::update_set_contents(), and moab::NestedRefine::update_special_tags().

add_parent_child()

ErrorCode moab::Core::add_parent_child ( EntityHandle  parent, EntityHandle  child  )

virtual

adds 'parent' to child's parent list and adds 'child' to parent's child list

Implements moab::Interface.

Definition at line 3574 of file Core.cpp.

{
 MeshSet* parent_ptr = get_mesh_set( sequence_manager(), parent );
 MeshSet* child_ptr = get_mesh_set( sequence_manager(), child );
 if( !parent_ptr || !child_ptr ) return MB_ENTITY_NOT_FOUND;
 
 parent_ptr->add_child( child );
 child_ptr->add_parent( parent );
 return MB_SUCCESS;
}

References moab::MeshSet::add_child(), moab::MeshSet::add_parent(), child, moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and MB_SUCCESS.

Referenced by main().

add_parent_meshset()

ErrorCode moab::Core::add_parent_meshset ( EntityHandle  meshset, const EntityHandle  parent_meshset  )

virtual

add a parent meshset

Implements moab::Interface.

Definition at line 3528 of file Core.cpp.

{
 MeshSet* set_ptr = get_mesh_set( sequence_manager(), meshset );
 MeshSet* parent_ptr = get_mesh_set( sequence_manager(), parent_meshset );
 if( !set_ptr || !parent_ptr ) return MB_ENTITY_NOT_FOUND;
 
 set_ptr->add_parent( parent_meshset );
 return MB_SUCCESS;
}

References moab::MeshSet::add_parent(), moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and MB_SUCCESS.

add_parent_meshsets()

ErrorCode moab::Core::add_parent_meshsets ( EntityHandle  meshset, const EntityHandle *  parents, int  count  )

virtual

add parent meshsets

Implements moab::Interface.

Definition at line 3538 of file Core.cpp.

{
 MeshSet* set_ptr = get_mesh_set( sequence_manager(), meshset );
 if( !set_ptr ) return MB_ENTITY_NOT_FOUND;
 
 for( int i = 0; i < count; ++i )
 if( !get_mesh_set( sequence_manager(), parents[i] ) ) return MB_ENTITY_NOT_FOUND;
 
 for( int i = 0; i < count; ++i )
 set_ptr->add_parent( parents[i] );
 return MB_SUCCESS;
}

References moab::MeshSet::add_parent(), moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and MB_SUCCESS.

add_vsequence()

ErrorCode moab::Core::add_vsequence	(	EntitySequence *	vert_seq,
		EntitySequence *	elem_seq,
		const HomCoord &	p1,
		const HomCoord &	q1,
		const HomCoord &	p2,
		const HomCoord &	q2,
		const HomCoord &	p3,
		const HomCoord &	q3,
		bool	bb_input = false,
		const HomCoord *	bb_min = NULL,
		const HomCoord *	bb_max = NULL
	)

Definition at line 4262 of file Core.cpp.

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

adjacencies_iterate()

ErrorCode moab::Core::adjacencies_iterate ( Range::const_iterator  iter, Range::const_iterator  end, const std::vector< EntityHandle > **&  adjs_ptr, int &  count  )

virtual

Get a ptr to adjacency lists Get a pointer to adjacency lists. These lists are std::vector<EntityHandle>, which are pointed to by adjs[i]. Adjacencies are not guaranteed to be in order of increasing dimension. Only a const version of this function is given, because adjacency data is managed more carefully in MOAB and should be treated as read-only by applications. If adjacencies have not yet been initialized, adjs_ptr will be NULL (i.e. adjs_ptr == NULL). There may also be NULL entries for individual entities, i.e. adjs_ptr[i] == NULL.

Parameters

iter	Iterator to beginning of entity range desired
end	End iterator for which adjacencies are requested
adjs_ptr	Pointer to pointer to const std::vector<EntityHandle>; each member of that array is the vector of adjacencies for this entity
count	Number of entities in the contiguous chunk starting from *iter

Implements moab::Interface.

Definition at line 1804 of file Core.cpp.

{
 // Make sure the entity should have a connectivity.
 EntityType entity_type = TYPE_FROM_HANDLE( *iter );
 
 // WARNING: This is very dependent on the ordering of the EntityType enum
 if( entity_type < MBVERTEX || entity_type > MBENTITYSET ) return MB_TYPE_OUT_OF_RANGE;
 
 EntitySequence* seq = NULL;
 
 // We know that connectivity is stored in an EntitySequence so jump straight
 // to the entity sequence
 ErrorCode rval = sequence_manager()->find( *iter, seq );
 if( !seq || rval != MB_SUCCESS ) return MB_ENTITY_NOT_FOUND;
 
 adjs_ptr = const_cast< const std::vector< EntityHandle >** >( seq->data()->get_adjacency_data() );
 if( !adjs_ptr ) return rval;
 
 adjs_ptr += *iter - seq->data()->start_handle();
 
 EntityHandle real_end = *( iter.end_of_block() );
 if( *end ) real_end = std::min( real_end, *end );
 count = real_end - *iter + 1;
 
 return MB_SUCCESS;
}

References moab::EntitySequence::data(), moab::Range::const_iterator::end_of_block(), ErrorCode, moab::SequenceData::get_adjacency_data(), MB_ENTITY_NOT_FOUND, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MBENTITYSET, moab::SequenceData::start_handle(), and moab::TYPE_FROM_HANDLE().

check_adjacencies() [1/2]

ErrorCode moab::Core::check_adjacencies

(

)

check all adjacencies for consistency

Definition at line 3763 of file Core.cpp.

{
 // run through all entities, checking adjacencies and reverse-evaluating them
 Range all_ents;
 ErrorCode result = get_entities_by_handle( 0, all_ents );MB_CHK_ERR( result );
 
 for( Range::iterator rit = all_ents.begin(); rit != all_ents.end(); ++rit )
 {
 result = check_adjacencies( &( *rit ), 1 );MB_CHK_ERR( result );
 }
 
 return MB_SUCCESS;
}

References moab::Range::begin(), moab::Range::end(), ErrorCode, MB_CHK_ERR, and MB_SUCCESS.

check_adjacencies() [2/2]

ErrorCode moab::Core::check_adjacencies	(	const EntityHandle *	ents,
		int	num_ents
	)

check some adjacencies for consistency

Definition at line 3777 of file Core.cpp.

{
 
 ErrorCode result = MB_SUCCESS, tmp_result;
 std::ostringstream oss;
 
 for( int i = 0; i < num_ents; i++ )
 {
 EntityHandle this_ent = ents[i];
 std::ostringstream ent_str;
 ent_str << CN::EntityTypeName( TYPE_FROM_HANDLE( this_ent ) ) << " " << ID_FROM_HANDLE( this_ent ) << ": ";
 int this_dim = dimension_from_handle( this_ent );
 
 if( !is_valid( this_ent ) )
 {
 std::cerr << ent_str.str() << "Not a valid entity." << std::endl;
 result = MB_FAILURE;
 }
 
 else
 {
 if( TYPE_FROM_HANDLE( this_ent ) == MBENTITYSET ) continue;
 
 // get adjacencies for this entity
 Range adjs;
 for( int dim = 0; dim <= 3; dim++ )
 {
 if( dim == this_dim ) continue;
 tmp_result = get_adjacencies( &this_ent, 1, dim, false, adjs, Interface::UNION );
 if( MB_SUCCESS != tmp_result )
 {
 oss << ent_str.str() << "Failed to get adjacencies for dimension " << dim << "." << std::endl;
 result = tmp_result;
 }
 }
 if( !oss.str().empty() )
 {
 std::cerr << oss.str();
 oss.str( "" );
 }
 
 // now check and reverse-evaluate them
 for( Range::iterator rit = adjs.begin(); rit != adjs.end(); ++rit )
 {
 EntitySequence* seq = 0;
 tmp_result = sequence_manager()->find( *rit, seq );
 if( seq == 0 || tmp_result != MB_SUCCESS )
 {
 oss << ent_str.str() << "Adjacent entity " << CN::EntityTypeName( TYPE_FROM_HANDLE( *rit ) ) << " "
 << ID_FROM_HANDLE( *rit ) << " is invalid." << std::endl;
 result = tmp_result;
 }
 else
 {
 Range rev_adjs;
 tmp_result = get_adjacencies( &( *rit ), 1, this_dim, false, rev_adjs );
 if( MB_SUCCESS != tmp_result )
 {
 oss << ent_str.str() << "Failed to get reverse adjacency from "
 << CN::EntityTypeName( TYPE_FROM_HANDLE( *rit ) ) << " " << ID_FROM_HANDLE( *rit );
 if( MB_MULTIPLE_ENTITIES_FOUND == tmp_result )
 oss << " (MULTIPLE)" << std::endl;
 else
 oss << " (" << tmp_result << ")" << std::endl;
 result = tmp_result;
 }
 else if( rev_adjs.find( this_ent ) == rev_adjs.end() )
 {
 oss << ent_str.str() << "Failed to find adjacency to this entity from "
 << CN::EntityTypeName( TYPE_FROM_HANDLE( *rit ) ) << " " << ID_FROM_HANDLE( *rit ) << "."
 << std::endl;
 result = tmp_result;
 }
 }
 if( !oss.str().empty() )
 {
 std::cerr << oss.str();
 oss.str( "" );
 }
 }
 }
 }
 
 return result;
}

References moab::Range::begin(), dim, moab::Range::end(), moab::CN::EntityTypeName(), ErrorCode, moab::Range::find(), moab::ID_FROM_HANDLE(), MB_MULTIPLE_ENTITIES_FOUND, MB_SUCCESS, MBENTITYSET, moab::TYPE_FROM_HANDLE(), and moab::Interface::UNION.

clean_up_failed_read()

void moab::Core::clean_up_failed_read ( const Range &  initial_ents, std::vector< Tag >  initial_tags  )

private

Clean up after a file reader returns failure.

Delete all entities not contained in initial_entities and all tags not contained in initial_tags.

Definition at line 491 of file Core.cpp.

{
 Range new_ents;
 get_entities_by_handle( 0, new_ents );
 new_ents = subtract( new_ents, initial_ents );
 delete_entities( new_ents );
 
 std::vector< Tag > all_tags, new_tags;
 tag_get_tags( all_tags );
 std::sort( initial_tags.begin(), initial_tags.end() );
 std::sort( all_tags.begin(), all_tags.end() );
 std::set_difference( all_tags.begin(), all_tags.end(), initial_tags.begin(), initial_tags.end(),
 std::back_inserter( new_tags ) );
 while( !new_tags.empty() )
 {
 tag_delete( new_tags.back() );
 new_tags.pop_back();
 }
}

References moab::subtract().

clear_meshset() [1/2]

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

virtual

Empty a vector of mesh set.

Empty a mesh set.

Parameters

ms_handles	1d vector of handles of sets being emptied
num_meshsets	Number of entities in 1d vector

Implements moab::Interface.

Definition at line 3286 of file Core.cpp.

{
 ErrorCode result = MB_SUCCESS;
 for( int i = 0; i < num_meshsets; ++i )
 {
 MeshSet* set = get_mesh_set( sequence_manager(), ms_handles[i] );
 if( set )
 set->clear( ms_handles[i], a_entity_factory() );
 else
 result = MB_ENTITY_NOT_FOUND;
 }
 
 return result;
}

References moab::MeshSet::clear(), ErrorCode, moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and MB_SUCCESS.

Referenced by cleanup_after_intersection(), compute_tracer_case1(), main(), process_partition_file(), moab::AEntityFactory::remove_all_adjacencies(), and moab::ReorderTool::update_set_contents().

clear_meshset() [2/2]

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

virtual

Empty a range of mesh set.

Empty a mesh set.

Parameters

ms_handles

Range of handles of sets being emptied

Implements moab::Interface.

Definition at line 3301 of file Core.cpp.

{
 ErrorCode result = MB_SUCCESS;
 for( Range::iterator i = ms_handles.begin(); i != ms_handles.end(); ++i )
 {
 MeshSet* set = get_mesh_set( sequence_manager(), *i );
 if( set )
 set->clear( *i, a_entity_factory() );
 else
 result = MB_ENTITY_NOT_FOUND;
 }
 
 return result;
}

References moab::Range::begin(), moab::MeshSet::clear(), moab::Range::end(), ErrorCode, moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and MB_SUCCESS.

connect_iterate()

ErrorCode moab::Core::connect_iterate ( Range::const_iterator  iter, Range::const_iterator  end, EntityHandle *&  connect, int &  verts_per_entity, int &  count  )

virtual

get pointer to connectivity data

Implements moab::Interface.

Definition at line 1682 of file Core.cpp.

{
 // Make sure the entity should have a connectivity.
 EntityType entity_type = TYPE_FROM_HANDLE( *iter );
 
 // WARNING: This is very dependent on the ordering of the EntityType enum
 if( entity_type <= MBVERTEX || entity_type >= MBENTITYSET ) return MB_TYPE_OUT_OF_RANGE;
 
 EntitySequence* seq = NULL;
 
 // We know that connectivity is stored in an EntitySequence so jump straight
 // to the entity sequence
 ErrorCode rval = sequence_manager()->find( *iter, seq );
 if( !seq || rval != MB_SUCCESS ) return MB_ENTITY_NOT_FOUND;
 
 ElementSequence* eseq = dynamic_cast< ElementSequence* >( seq );
 assert( eseq != NULL );
 
 connect = eseq->get_connectivity_array();
 if( !connect )
 {
 MB_SET_ERR( MB_FAILURE, "Couldn't find connectivity array for start handle" );
 }
 
 connect += eseq->nodes_per_element() * ( *iter - eseq->start_handle() );
 
 EntityHandle real_end = std::min( eseq->end_handle(), *( iter.end_of_block() ) );
 if( *end ) real_end = std::min( real_end, *end );
 count = real_end - *iter + 1;
 
 verts_per_entity = eseq->nodes_per_element();
 
 return MB_SUCCESS;
}

References moab::EntitySequence::end_handle(), moab::Range::const_iterator::end_of_block(), ErrorCode, moab::ElementSequence::get_connectivity_array(), MB_ENTITY_NOT_FOUND, MB_SET_ERR, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MBENTITYSET, moab::ElementSequence::nodes_per_element(), moab::EntitySequence::start_handle(), and moab::TYPE_FROM_HANDLE().

contains_entities()

bool moab::Core::contains_entities ( EntityHandle  meshset, const EntityHandle *  entities, int  num_entities, const int  operation_type = Interface::INTERSECT  )

virtual

return true if all entities are contained in set

Implements moab::Interface.

Definition at line 3382 of file Core.cpp.

{
 if( !meshset ) // root
 return true;
 else if( MeshSet* set = get_mesh_set( sequence_manager(), meshset ) )
 return set->contains_entities( entities, num_entities, operation_type );
 else
 return false;
}

References entities, and moab::get_mesh_set().

Referenced by moab::numAdjTriInSet().

convert_entities()

ErrorCode moab::Core::convert_entities ( const EntityHandle  meshset, const bool  mid_edge, const bool  mid_face, const bool  mid_region, Interface::HONodeAddedRemoved *  function_object = 0  )

virtual

Convert entities to higher-order elements by adding mid nodes.

This function causes MB to create mid-nodes on all edges, faces, and element interiors for all entities in meshset. Higher order nodes appear in an element's connectivity array according to the algorithm described in the documentation for Mesh. If HONodeAddedRemoved function is input, this function is called to notify the application of nodes being added/removed from the mesh.

Parameters

meshset	The set of entities being converted
mid_edge	If true, mid-edge nodes are created
mid_face	If true, mid-face nodes are created
mid_region	If true, mid-element nodes are created
function_object	If non-NULL, the node_added or node_removed functions on this object are called when nodes are added or removed from an entity, respectively

Implements moab::Interface.

Definition at line 2998 of file Core.cpp.

{
 HigherOrderFactory fact( this, function_object );
 return fact.convert( meshset, mid_side, mid_face, mid_volume );
}

References moab::HigherOrderFactory::convert().

Referenced by main().

coords_iterate()

ErrorCode moab::Core::coords_iterate ( Range::const_iterator  iter, Range::const_iterator  end, double *&  xcoords_ptr, double *&  ycoords_ptr, double *&  zcoords_ptr, int &  count  )

virtual

get pointers to coordinate data

Implements moab::Interface.

Definition at line 827 of file Core.cpp.

{
 EntitySequence* seq;
 ErrorCode rval = sequence_manager()->find( *iter, seq );
 if( MB_SUCCESS != rval )
 {
 xcoords_ptr = ycoords_ptr = zcoords_ptr = NULL;
 MB_SET_ERR( rval, "Couldn't find sequence for start handle" );
 }
 VertexSequence* vseq = dynamic_cast< VertexSequence* >( seq );
 if( !vseq )
 {
 MB_SET_ERR( MB_ENTITY_NOT_FOUND, "Couldn't find sequence for start handle" );
 }
 
 unsigned int offset = *iter - vseq->data()->start_handle();
 xcoords_ptr = reinterpret_cast< double* >( vseq->data()->get_sequence_data( 0 ) ) + offset;
 ycoords_ptr = reinterpret_cast< double* >( vseq->data()->get_sequence_data( 1 ) ) + offset;
 zcoords_ptr = reinterpret_cast< double* >( vseq->data()->get_sequence_data( 2 ) ) + offset;
 
 EntityHandle real_end = std::min( seq->end_handle(), *( iter.end_of_block() ) );
 if( *end ) real_end = std::min( real_end, *end );
 count = real_end - *iter + 1;
 
 return MB_SUCCESS;
}

References moab::EntitySequence::data(), moab::EntitySequence::end_handle(), moab::Range::const_iterator::end_of_block(), ErrorCode, moab::SequenceData::get_sequence_data(), MB_ENTITY_NOT_FOUND, MB_SET_ERR, MB_SUCCESS, and moab::SequenceData::start_handle().

Referenced by main().

create_element()

ErrorCode moab::Core::create_element ( const EntityType  type, const EntityHandle *  connectivity, const int  num_nodes, EntityHandle &  element_handle  )

virtual

Creates an element based on the type and connectivity.

creates an element based on the type and connectivity. returns a handle and error code

If connectivity vector is not correct for EntityType type (ie, a vector with 3 vertices is passed in to make an MBQUAD), the function returns MB_FAILURE.

Parameters

type	Type of element to create. (MBTET, MBTRI, MBKNIFE, etc.)
connectivity	Vector containing connectivity of element to create.
handle	EntityHandle representing the newly created element in the database.

Example:

EntityType type = MBQUAD;
std::vector<EntityHandle> connectivity(4);
quad_conn[0] = vertex0;
quad_conn[1] = vertex1;
quad_conn[2] = vertex2;
quad_conn[3] = vertex3;
EntityHandle element_handle;
create_element( type, connectivity, element_handle ); 

Implements moab::Interface.

Definition at line 2640 of file Core.cpp.

{
 // make sure we have enough vertices for this entity type
 if( num_nodes < CN::VerticesPerEntity( entity_type ) ) return MB_FAILURE;
 
 ErrorCode status = sequence_manager()->create_element( entity_type, connectivity, num_nodes, handle );
 if( MB_SUCCESS == status ) status = aEntityFactory->notify_create_entity( handle, connectivity, num_nodes );
 
#ifdef MOAB_HAVE_AHF
 mesh_modified = true;
#endif
 
 return status;
}

References ErrorCode, MB_SUCCESS, and moab::CN::VerticesPerEntity().

Referenced by create_lagr_mesh(), IntxUtilsCSLAM::deep_copy_set(), moab::AEntityFactory::get_down_adjacency_elements_poly(), moab::AEntityFactory::get_element(), main(), manufacture_lagrange_mesh_on_sphere(), and obbvis_create().

create_meshset()

ErrorCode moab::Core::create_meshset ( const unsigned int  options, EntityHandle &  ms_handle, int  start_id = 0  )

virtual

creates a mesh set

Implements moab::Interface.

Definition at line 3258 of file Core.cpp.

{
 return sequence_manager()->create_mesh_set( setoptions, ms_handle );
}

Referenced by moab::ReadUtil::create_gather_set(), moab::NestedRefine::create_hm_storage_single_level(), create_mesh(), IntxUtilsCSLAM::create_span_quads(), main(), manufacture_lagrange_mesh_on_sphere(), process_partition_file(), RuntimeContext::RuntimeContext(), test_intx_in_parallel_elem_based(), and update_tracer().

create_scd_sequence()

ErrorCode moab::Core::create_scd_sequence	(	const HomCoord &	coord_min,
		const HomCoord &	coord_max,
		EntityType	type,
		EntityID	start_id_hint,
		EntityHandle &	first_handle_out,
		EntitySequence *&	sequence_out
	)

create structured sequence

Definition at line 4239 of file Core.cpp.

{
 // NR: Previously, the structured element sequences were created via direct call to
 // the sequence manager instead of using the same from the ScdInterface which
 // creates the associated scd bounding box after element sequence creation.
 
 if( !scdInterface ) scdInterface = new ScdInterface( this );
 ScdBox* newBox = NULL;
 ErrorCode rval = scdInterface->create_scd_sequence( coord_min, coord_max, entity_type,
 /*starting_id*/ (int)start_id_hint, newBox );MB_CHK_ERR( rval );
 
 if( MBVERTEX == entity_type )
 first_handle_out = newBox->get_vertex( coord_min );
 else
 first_handle_out = newBox->get_element( coord_min );
 return sequence_manager()->find( first_handle_out, sequence_out );
}

References ErrorCode, moab::ScdBox::get_element(), moab::ScdBox::get_vertex(), MB_CHK_ERR, and MBVERTEX.

create_set_iterator()

ErrorCode moab::Core::create_set_iterator ( EntityHandle  meshset, EntityType  ent_type, int  ent_dim, int  chunk_size, bool  check_valid, SetIterator *&  set_iter  )

virtual

Create an iterator over the set Create a new iterator that iterates over entities with the specified type or dimension. Only one of ent_type or dim can be set; use dim=-1 or ent_type=MBMAXTYPE for the other. Iterators for list-type (ordered) sets are stable over set modification, unless entity removed or deleted is the one at the current position of the iterator. If the check_valid parameter is passed as true, entities are checked for validity before being passed back by get_next_entities function (checking entity validity can have a non-negligible cost).

Iterators returned by this function can be deleted using the normal C++ delete function. After creating the iterator through this function, further interactions are through methods on the SetIterator class.

Parameters

meshset	The entity set associated with this iterator (use 0 for whole instance)
ent_type	Entity type associated with this iterator
ent_dim	Dimension associated with this iterator
chunk_size	Chunk size of the iterator
check_valid	If true, entities are checked for validity before being returned

Implements moab::Interface.

Definition at line 3870 of file Core.cpp.

{
 // check the type of set
 unsigned int setoptions;
 ErrorCode rval = MB_SUCCESS;
 if( meshset )
 {
 rval = get_meshset_options( meshset, setoptions );MB_CHK_ERR( rval );
 }
 
 if( !meshset || ( setoptions & MESHSET_SET ) )
 set_iter = new( std::nothrow ) RangeSetIterator( this, meshset, chunk_size, ent_type, ent_dim, check_valid );
 else
 set_iter = new( std::nothrow ) VectorSetIterator( this, meshset, chunk_size, ent_type, ent_dim, check_valid );
 
 setIterators.push_back( set_iter );
 return MB_SUCCESS;
}

References ErrorCode, MB_CHK_ERR, MB_SUCCESS, and MESHSET_SET.

create_vertex()

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

virtual

Creates a vertex based on coordinates.

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

Parameters

coordinates	Array that has 3 doubles in it.
entity_handle	EntityHandle representing the newly created vertex in the database.

Example:

double *coordinates = double[3];
coordinates[0] = 1.034;
coordinates[1] = 23.23;
coordinates[2] = -0.432;
EntityHandle entity_handle = 0;
create_vertex( coordinates, entity_handle ); 

Implements moab::Interface.

Definition at line 2659 of file Core.cpp.

{
 // get an available vertex handle
 return sequence_manager()->create_vertex( coords, handle );
}

Referenced by moab::HigherOrderFactory::add_mid_edge_nodes(), moab::HigherOrderFactory::add_mid_face_nodes(), moab::HigherOrderFactory::add_mid_volume_nodes(), create_lagr_mesh(), IntxUtilsCSLAM::deep_copy_set(), and manufacture_lagrange_mesh_on_sphere().

create_vertices()

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

virtual

Create a set of vertices with the specified coordinates.

Parameters

coordinates	Array that has 3*n doubles in it.
nverts	Number of vertices to create
entity_handles	Range passed back with new vertex handles

Implements moab::Interface.

Definition at line 2665 of file Core.cpp.

{
 // Create vertices
 ReadUtilIface* read_iface;
 ErrorCode result = Interface::query_interface( read_iface );MB_CHK_ERR( result );
 
 std::vector< double* > arrays;
 EntityHandle start_handle_out = 0;
 result = read_iface->get_node_coords( 3, nverts, MB_START_ID, start_handle_out, arrays );
 Interface::release_interface( read_iface );MB_CHK_ERR( result );
 // Cppcheck warning (false positive): variable arrays is assigned a value that is never used
 for( int i = 0; i < nverts; i++ )
 {
 arrays[0][i] = coordinates[3 * i];
 arrays[1][i] = coordinates[3 * i + 1];
 arrays[2][i] = coordinates[3 * i + 2];
 }
 
 entity_handles.clear();
 entity_handles.insert( start_handle_out, start_handle_out + nverts - 1 );
 
 return MB_SUCCESS;
}

References moab::Range::clear(), ErrorCode, moab::ReadUtilIface::get_node_coords(), moab::Range::insert(), MB_CHK_ERR, MB_START_ID, MB_SUCCESS, moab::Interface::query_interface(), and moab::Interface::release_interface().

Referenced by main(), obbvis_create(), and TestErrorHandling_4().

deinitialize()

void moab::Core::deinitialize ( )

private

Definition at line 261 of file Core.cpp.

{
 
#ifdef MOAB_HAVE_MPI
 std::vector< ParallelComm* > pc_list;
 ParallelComm::get_all_pcomm( this, pc_list );
 for( std::vector< ParallelComm* >::iterator vit = pc_list.begin(); vit != pc_list.end(); ++vit )
 delete *vit;
#endif
 
#ifdef MOAB_HAVE_AHF
 delete ahfRep;
 ahfRep = 0;
#endif
 
 if( aEntityFactory ) delete aEntityFactory;
 
 aEntityFactory = 0;
 
 while( !tagList.empty() )
 tag_delete( tagList.front() );
 
 if( sequenceManager ) delete sequenceManager;
 
 sequenceManager = 0;
 
 delete readerWriterSet;
 readerWriterSet = 0;
 
 if( mError ) delete mError;
 mError = 0;
 
#ifdef MOAB_HAVE_MPI
 if( writeMPELog )
 {
 const char* default_log = MOAB_MPE_LOG;
 const char* logfile = getenv( "MPE_LOG_FILE" );
 if( !logfile ) logfile = default_log;
 MPE_Finish_log( logfile );
 }
#endif
 
 if( initErrorHandlerInCore ) MBErrorHandler_Finalize();
}

References moab::ParallelComm::get_all_pcomm(), moab::MBErrorHandler_Finalize(), MOAB_MPE_LOG, and MPE_Finish_log.

delete_entities() [1/2]

ErrorCode moab::Core::delete_entities ( const EntityHandle *  entities, const int  num_entities  )

virtual

Removes entities in a vector from the data base.

deletes an entity vector

If any of the entities are contained in any meshsets, it is removed from those meshsets which were created with MESHSET_TRACK_OWNER option bit set. Tags for entity< > are removed as part of this function.

Parameters

entities	1d vector of entities to delete
num_entities	Number of entities in 1d vector

Implements moab::Interface.

Definition at line 2793 of file Core.cpp.

{
 ErrorCode result = MB_SUCCESS, temp_result;
 Range failed_ents;
 
 for( std::list< TagInfo* >::iterator i = tagList.begin(); i != tagList.end(); ++i )
 {
 temp_result = ( *i )->remove_data( sequenceManager, mError, entities, num_entities );
 // ok if the error is tag_not_found, some ents may not have every tag on them
 if( MB_SUCCESS != temp_result && MB_TAG_NOT_FOUND != temp_result ) result = temp_result;
 }
 
 for( int i = 0; i < num_entities; i++ )
 {
 
 // tell AEntityFactory that this element is going away
 bool failed = false;
 temp_result = aEntityFactory->notify_delete_entity( entities[i] );
 if( MB_SUCCESS != temp_result )
 {
 result = temp_result;
 failed = true;
 }
 
 if( TYPE_FROM_HANDLE( entities[i] ) == MBENTITYSET )
 {
 if( MeshSet* ptr = get_mesh_set( sequence_manager(), entities[i] ) )
 {
 int j, count;
 const EntityHandle* rel;
 ptr->clear( entities[i], a_entity_factory() );
 rel = ptr->get_parents( count );
 for( j = 0; j < count; ++j )
 remove_child_meshset( rel[j], entities[i] );
 rel = ptr->get_children( count );
 for( j = 0; j < count; ++j )
 remove_parent_meshset( rel[j], entities[i] );
 }
 }
 
 if( failed )
 // don't test for success, since we'll return failure in this case
 sequence_manager()->delete_entity( mError, entities[i] );
 else
 {
 // now delete the entity
 temp_result = sequence_manager()->delete_entity( mError, entities[i] );
 if( MB_SUCCESS != temp_result ) result = temp_result;
 }
 }
 
 return result;
}

References moab::Range::clear(), entities, ErrorCode, moab::get_mesh_set(), MB_SUCCESS, MB_TAG_NOT_FOUND, MBENTITYSET, and moab::TYPE_FROM_HANDLE().

Referenced by cleanup_after_intersection(), compute_tracer_case1(), moab::HigherOrderFactory::convert_sequence(), IntxUtilsCSLAM::create_span_quads(), and main().

delete_entities() [2/2]

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

virtual

Removes entities in a range from the data base.

deletes an entity range

If any of the entities are contained in any meshsets, it is removed from those meshsets which were created with MESHSET_TRACK_OWNER option bit set. Tags for entity< > are removed as part of this function.

Parameters

entities

Range of entities to delete

Implements moab::Interface.

Definition at line 2738 of file Core.cpp.

{
 ErrorCode result = MB_SUCCESS, temp_result;
 Range failed_ents;
 
 for( std::list< TagInfo* >::iterator i = tagList.begin(); i != tagList.end(); ++i )
 {
 temp_result = ( *i )->remove_data( sequenceManager, mError, range );
 // ok if the error is tag_not_found, some ents may not have every tag on them
 if( MB_SUCCESS != temp_result && MB_TAG_NOT_FOUND != temp_result ) result = temp_result;
 }
 
 for( Range::const_reverse_iterator rit = range.rbegin(); rit != range.rend(); ++rit )
 {
 
 // tell AEntityFactory that this element is going away
 temp_result = aEntityFactory->notify_delete_entity( *rit );
 if( MB_SUCCESS != temp_result )
 {
 result = temp_result;
 failed_ents.insert( *rit );
 continue;
 }
 
 if( TYPE_FROM_HANDLE( *rit ) == MBENTITYSET )
 {
 if( MeshSet* ptr = get_mesh_set( sequence_manager(), *rit ) )
 {
 int j, count;
 const EntityHandle* rel;
 ptr->clear( *rit, a_entity_factory() );
 rel = ptr->get_parents( count );
 for( j = 0; j < count; ++j )
 remove_child_meshset( rel[j], *rit );
 rel = ptr->get_children( count );
 for( j = 0; j < count; ++j )
 remove_parent_meshset( rel[j], *rit );
 }
 }
 }
 
 if( !failed_ents.empty() )
 {
 Range dum_range = subtract( range, failed_ents );
 // don't test for success, since we'll return failure in this case
 sequence_manager()->delete_entities( mError, dum_range );
 }
 else
 // now delete the entities
 result = sequence_manager()->delete_entities( mError, range );
 
 return result;
}

References moab::Range::empty(), ErrorCode, moab::get_mesh_set(), moab::Range::insert(), MB_SUCCESS, MB_TAG_NOT_FOUND, MBENTITYSET, moab::Range::rbegin(), moab::Range::rend(), moab::subtract(), and moab::TYPE_FROM_HANDLE().

delete_mesh()

ErrorCode moab::Core::delete_mesh ( )

virtual

deletes all mesh entities from this datastore

Implements moab::Interface.

Definition at line 747 of file Core.cpp.

{
 
 ErrorCode result = MB_SUCCESS;
 
 // perform all deinitialization procedures to clean up
 if( aEntityFactory ) delete aEntityFactory;
 aEntityFactory = new AEntityFactory( this );
 
 for( std::list< TagInfo* >::iterator i = tagList.begin(); i != tagList.end(); ++i )
 {
 result = ( *i )->release_all_data( sequenceManager, mError, false );MB_CHK_ERR( result );
 }
 
 sequenceManager->clear();
 
 return MB_SUCCESS;
}

References ErrorCode, MB_CHK_ERR, and MB_SUCCESS.

Referenced by main().

dimension_from_handle()

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

virtual

Returns the topological dimension of an entity.

Returns the topological dimension of an entity.

Parameters

handle

The EntityHandle you want to find the dimension of.

Returns

type The topological dimension of handle.

Example:

int dim = dimension_from_handle( handle);
if( dim == 0 ) ... 

Implements moab::Interface.

Definition at line 400 of file Core.cpp.

{
 if( !handle ) // root set
 return 4;
 else
 return CN::Dimension( TYPE_FROM_HANDLE( handle ) );
}

References moab::CN::Dimension(), and moab::TYPE_FROM_HANDLE().

Referenced by moab::AEntityFactory::check_equiv_entities(), moab::AEntityFactory::create_explicit_adjs(), moab::HalfFacetRep::get_adjacencies(), moab::HalfFacetRep::get_down_adjacencies(), moab::AEntityFactory::get_element(), moab::HalfFacetRep::get_neighbor_adjacencies(), moab::HalfFacetRep::get_up_adjacencies(), and moab::HigherOrderFactory::tag_for_deletion().

dirichletBC_tag()

Tag moab::Core::dirichletBC_tag

(

)

Definition at line 2613 of file Core.cpp.

{
 const int negone = -1;
 if( 0 == dirichletBCTag )
 tag_get_handle( DIRICHLET_SET_TAG_NAME, 1, MB_TYPE_INTEGER, dirichletBCTag, MB_TAG_CREAT | MB_TAG_SPARSE,
 &negone );
 return dirichletBCTag;
}

References DIRICHLET_SET_TAG_NAME, MB_TAG_CREAT, MB_TAG_SPARSE, and MB_TYPE_INTEGER.

estimated_memory_use() [1/2]

void moab::Core::estimated_memory_use ( const EntityHandle *  ent_array = 0, unsigned long  num_ents = 0, unsigned long long *  total_storage = 0, unsigned long long *  total_amortized_storage = 0, unsigned long long *  entity_storage = 0, unsigned long long *  amortized_entity_storage = 0, unsigned long long *  adjacency_storage = 0, unsigned long long *  amortized_adjacency_storage = 0, const Tag *  tag_array = 0, unsigned  num_tags = 0, unsigned long long *  tag_storage = 0, unsigned long long *  amortized_tag_storage = 0  )

virtual

Calculate amount of memory used to store MOAB data.

This function calculates the amount of memory used to store MOAB data.

There are two possible values for each catagory of memory use. The exact value and the amortized value. The exact value is the amount of memory used to store the data for the specified entities. The amortized value includes the exact value and an amortized estimate of the memory consumed in overhead for storing the values (indexing structures, access structures, etc.)

Note: If ent_array is NULL, the total memory used by MOAB for storing data will be returned in the address pointed to by total_amortized_storage, if total_amortized_storage is not NULL.

Parameters

ent_array	Array of entities for which to estimate the memory use. If NULL, estimate is done for all entities.
num_ents	The length of ent_array. Not used if ent_rray is NULL.
total_(amortized_)storage	The sum of the memory entity, adjacency, and all tag storage.
(amortized_)entity_storage	The storage for the entity definitions (connectivity arrays for elements, coordinates for vertices, list storage within sets, etc.)
(amortized_)adjacency_storage	The storage for adjacency data.
tag_array	An array of tags for which to calculate the memory use.
num_tags	The lenght of tag_array
(amortized_)tag_storage	If tag_array is not NULL, then one value for each tag specifying the memory used for storing that tag. If tag_array is NULL and this value is not, the location at which to store the total memory used for all tags.

Implements moab::Interface.

Definition at line 4074 of file Core.cpp.

{
 Range range;
 
 // If non-empty entity list, call range version of function
 if( ent_array )
 {
 if( num_ents > 20 )
 {
 std::vector< EntityHandle > list( num_ents );
 std::copy( ent_array, ent_array + num_ents, list.begin() );
 std::sort( list.begin(), list.end() );
 Range::iterator j = range.begin();
 for( std::vector< EntityHandle >::reverse_iterator i = list.rbegin(); i != list.rend(); ++i )
 j = range.insert( j, *i, *i );
 }
 else
 {
 std::copy( ent_array, ent_array + num_ents, range_inserter( range ) );
 }
 }
 
 estimated_memory_use_internal( ent_array ? &range : 0, total_storage, total_amortized_storage, entity_storage,
 amortized_entity_storage, adjacency_storage, amortized_adjacency_storage, tag_array,
 num_tags, tag_storage, amortized_tag_storage );
}

References moab::Range::begin(), and moab::Range::insert().

estimated_memory_use() [2/2]

void moab::Core::estimated_memory_use ( const Range &  ents, unsigned long long *  total_storage = 0, unsigned long long *  total_amortized_storage = 0, unsigned long long *  entity_storage = 0, unsigned long long *  amortized_entity_storage = 0, unsigned long long *  adjacency_storage = 0, unsigned long long *  amortized_adjacency_storage = 0, const Tag *  tag_array = 0, unsigned  num_tags = 0, unsigned long long *  tag_storage = 0, unsigned long long *  amortized_tag_storage = 0  )

virtual

Calculate amount of memory used to store MOAB data.

This function calculates the amount of memory used to store MOAB data.

There are two possible values for each catagory of memory use. The exact value and the amortized value. The exact value is the amount of memory used to store the data for the specified entities. The amortized value includes the exact value and an amortized estimate of the memory consumed in overhead for storing the values (indexing structures, access structures, etc.)

Parameters

ents	Entities for which to estimate the memory use.
total_(amortized_)storage	The sum of the memory entity, adjacency, and all tag storage.
(amortized_)entity_storage	The storage for the entity definitions (connectivity arrays for elements, coordinates for vertices, list storage within sets, etc.)
(amortized_)adjacency_storage	The storage for adjacency data.
tag_array	An array of tags for which to calculate the memory use.
num_tags	The lenght of tag_array
(amortized_)tag_storage	If tag_array is not NULL, then one value for each tag specifying the memory used for storing that tag. If tag_array is NULL and this value is not, the location at which to store the total memory used for all tags.

Implements moab::Interface.

Definition at line 4112 of file Core.cpp.

{
 estimated_memory_use_internal( &ents, total_storage, total_amortized_storage, entity_storage,
 amortized_entity_storage, adjacency_storage, amortized_adjacency_storage, tag_array,
 num_tags, tag_storage, amortized_tag_storage );
}

estimated_memory_use_internal()

void moab::Core::estimated_memory_use_internal ( const Range *  ents, unsigned long long *  total_storage, unsigned long long *  total_amortized_storage, unsigned long long *  entity_storage, unsigned long long *  amortized_entity_storage, unsigned long long *  adjacency_storage, unsigned long long *  amortized_adjacency_storage, const Tag *  tag_array, unsigned  num_tags, unsigned long long *  tag_storage, unsigned long long *  amortized_tag_storage  )

private

Definition at line 3923 of file Core.cpp.

{
 // Figure out which values we need to calculate
 type_memstorage i_entity_storage, ia_entity_storage, i_adjacency_storage, ia_adjacency_storage, i_tag_storage,
 ia_tag_storage;
 type_memstorage *total_tag_storage = 0, *amortized_total_tag_storage = 0;
 if( !tag_array )
 {
 total_tag_storage = tag_storage;
 amortized_total_tag_storage = amortized_tag_storage;
 }
 if( total_storage || total_amortized_storage )
 {
 if( !entity_storage ) entity_storage = &i_entity_storage;
 if( !amortized_entity_storage ) amortized_entity_storage = &ia_entity_storage;
 if( !adjacency_storage ) adjacency_storage = &i_adjacency_storage;
 if( !amortized_adjacency_storage ) amortized_adjacency_storage = &ia_adjacency_storage;
 }
 else
 {
 if( entity_storage || amortized_entity_storage )
 {
 if( !amortized_entity_storage )
 amortized_entity_storage = &ia_entity_storage;
 else if( !entity_storage )
 entity_storage = &i_entity_storage;
 }
 if( adjacency_storage || amortized_adjacency_storage )
 {
 if( !amortized_adjacency_storage )
 amortized_adjacency_storage = &ia_adjacency_storage;
 else if( !adjacency_storage )
 adjacency_storage = &i_adjacency_storage;
 }
 }
 if( !total_tag_storage && total_storage ) total_tag_storage = &i_tag_storage;
 if( !amortized_total_tag_storage && total_amortized_storage ) amortized_total_tag_storage = &ia_tag_storage;
 
 // get entity storage
 if( amortized_entity_storage )
 {
 if( ents )
 sequenceManager->get_memory_use( *ents, *entity_storage, *amortized_entity_storage );
 else
 sequenceManager->get_memory_use( *entity_storage, *amortized_entity_storage );
 }
 
 // get adjacency storage
 if( amortized_adjacency_storage )
 {
 if( ents )
 aEntityFactory->get_memory_use( *ents, *adjacency_storage, *amortized_adjacency_storage );
 else
#ifdef MOAB_HAVE_AHF
 ahfRep->get_memory_use( *adjacency_storage, *amortized_adjacency_storage );
#else
 aEntityFactory->get_memory_use( *adjacency_storage, *amortized_adjacency_storage );
#endif
 }
 
 // get storage for requested list of tags
 if( tag_array )
 {
 for( unsigned i = 0; i < num_tags; ++i )
 {
 if( !valid_tag_handle( tag_array[i] ) ) continue;
 
 unsigned long total = 0, per_ent = 0;
 tag_array[i]->get_memory_use( sequenceManager, total, per_ent );
 
 if( ents )
 {
 size_t count = 0, count2 = 0;
 tag_array[i]->num_tagged_entities( sequenceManager, count, MBMAXTYPE, ents );
 if( tag_storage ) tag_storage[i] = count * per_ent;
 if( amortized_tag_storage )
 {
 tag_array[i]->num_tagged_entities( sequenceManager, count2 );
 if( count2 )
 amortized_tag_storage[i] = static_cast< type_memstorage >( total * count * 1.0 / count2 );
 }
 }
 else
 {
 size_t count = 0;
 if( tag_storage )
 {
 tag_array[i]->num_tagged_entities( sequenceManager, count );
 tag_storage[i] = count * per_ent;
 }
 if( amortized_tag_storage ) amortized_tag_storage[i] = total;
 }
 }
 }
 
 // get storage for all tags
 if( total_tag_storage || amortized_total_tag_storage )
 {
 if( amortized_total_tag_storage ) *amortized_total_tag_storage = 0;
 if( total_tag_storage ) *total_tag_storage = 0;
 
 std::vector< Tag > tags;
 tag_get_tags( tags );
 for( std::list< TagInfo* >::const_iterator i = tagList.begin(); i != tagList.end(); ++i )
 {
 unsigned long total = 0, per_ent = 0;
 ( *i )->get_memory_use( sequenceManager, total, per_ent );
 
 if( ents )
 {
 size_t count = 0, count2 = 0;
 ( *i )->num_tagged_entities( sequenceManager, count, MBMAXTYPE, ents );
 if( total_tag_storage ) *total_tag_storage += count * per_ent;
 if( amortized_total_tag_storage )
 {
 ( *i )->num_tagged_entities( sequenceManager, count2 );
 if( count2 )
 *amortized_total_tag_storage += static_cast< type_memstorage >( total * count * 1.0 / count2 );
 }
 }
 else
 {
 size_t count = 0;
 if( total_tag_storage )
 {
 ( *i )->num_tagged_entities( sequenceManager, count );
 *total_tag_storage += count * per_ent;
 }
 if( amortized_total_tag_storage ) *amortized_total_tag_storage += total;
 }
 }
 }
 
 // calculate totals
 if( total_storage ) *total_storage = *entity_storage + *adjacency_storage + *total_tag_storage;
 
 if( total_amortized_storage )
 *total_amortized_storage =
 *amortized_entity_storage + *amortized_adjacency_storage + *amortized_total_tag_storage;
}

References moab::TagInfo::get_memory_use(), MBMAXTYPE, and moab::TagInfo::num_tagged_entities().

geom_dimension_tag()

Tag moab::Core::geom_dimension_tag

(

)

Definition at line 2630 of file Core.cpp.

{
 const int negone = -1;
 if( 0 == geomDimensionTag )
 tag_get_handle( GEOM_DIMENSION_TAG_NAME, 1, MB_TYPE_INTEGER, geomDimensionTag, MB_TAG_CREAT | MB_TAG_SPARSE,
 &negone );
 return geomDimensionTag;
}

References GEOM_DIMENSION_TAG_NAME, MB_TAG_CREAT, MB_TAG_SPARSE, and MB_TYPE_INTEGER.

get_adjacencies() [1/3]

ErrorCode moab::Core::get_adjacencies ( const EntityHandle *  from_entities, const int  num_entities, const int  to_dimension, const bool  create_if_missing, Range &  adj_entities, const int  operation_type = Interface::INTERSECT  )

virtual

Get the adjacencies associated with a vector of entities to entities of a specfied dimension.

Identical to vector-based get_adjacencies function, except results are returned in a range instead of a vector.

Implements moab::Interface.

Definition at line 1608 of file Core.cpp.

{
 if( operation_type == Interface::INTERSECT )
 return get_adjacencies_intersection( this, from_entities, from_entities + num_entities, to_dimension,
 create_if_missing, adj_entities );
 else if( operation_type == Interface::UNION )
 return get_adjacencies_union( this, from_entities, from_entities + num_entities, to_dimension,
 create_if_missing, adj_entities );
 else
 return MB_FAILURE;
}

References moab::get_adjacencies_intersection(), moab::get_adjacencies_union(), moab::Interface::INTERSECT, and moab::Interface::UNION.

get_adjacencies() [2/3]

ErrorCode moab::Core::get_adjacencies ( const EntityHandle *  from_entities, const int  num_entities, const int  to_dimension, const bool  create_if_missing, std::vector< EntityHandle > &  adj_entities, const int  operation_type = Interface::INTERSECT  )

virtual

get the adjacencies associated with a set of entities

Parameters

from_entities	vector of EntityHandle to get adjacencies of.
to_dimension	Dimension of desired adjacency information.
adj_entities	Vector in which adjacent EntityHandles are returned.
operation_type	enum of INTERSECT or UNION. Defines whether to take the intersection or union of the set of adjacencies recovered for the from_entities.

The adjacent entities in vector adjacencies are not in any particular order.

Example:

// get the set of edges that are adjacent to all entities in the from_entities list
std::vector<EntityHandle> from_entities = {hex1, hex2};
std::vector<EntityHandle> adjacencies;
get_adjacencies( from_entities, MB_1D_ENTITY, adjacencies );

Implements moab::Interface.

Definition at line 1513 of file Core.cpp.

{
 
#ifdef MOAB_HAVE_AHF
 bool can_handle = true;
 
 if( to_dimension == 4 )
 can_handle = false; // NOT SUPPORTED: meshsets
 else if( create_if_missing )
 can_handle = false; // NOT SUPPORTED: create_if_missing
 
 bool mixed = ahfRep->check_mixed_entity_type(); // NOT SUPPORTED: mixed entity types or
 // polygonal/hedrals types
 if( mixed ) can_handle = false;
 
 if( mesh_modified ) // NOT SUPPORTED: modified mesh
 can_handle = false;
 
 if( can_handle )
 {
 ErrorCode result;
 if( operation_type == Interface::INTERSECT )
 return get_adjacencies_intersection_ahf( this, from_entities, from_entities + num_entities, to_dimension,
 adj_entities );
 else if( operation_type != Interface::UNION )
 return MB_FAILURE;
 
 // do union
 
 std::vector< EntityHandle > tmp_storage;
 const EntityHandle* conn;
 int len;
 for( int i = 0; i < num_entities; ++i )
 {
 if( to_dimension == 0 && TYPE_FROM_HANDLE( from_entities[0] ) != MBPOLYHEDRON )
 {
 result = get_connectivity( from_entities[i], conn, len, false, &tmp_storage );
 adj_entities.insert( adj_entities.end(), conn, conn + len );
 if( MB_SUCCESS != result ) return result;
 }
 else
 {
 result = ahfRep->get_adjacencies( from_entities[i], to_dimension, adj_entities );
 if( MB_SUCCESS != result ) return result;
 }
 }
 std::sort( adj_entities.begin(), adj_entities.end() );
 adj_entities.erase( std::unique( adj_entities.begin(), adj_entities.end() ), adj_entities.end() );
 }
 else
 {
 
#endif
 
 if( operation_type == Interface::INTERSECT )
 return get_adjacencies_intersection( this, from_entities, from_entities + num_entities, to_dimension,
 create_if_missing, adj_entities );
 else if( operation_type != Interface::UNION )
 return MB_FAILURE;
 
 // do union
 ErrorCode result;
 std::vector< EntityHandle > tmp_storage;
 const EntityHandle* conn;
 int len;
 for( int i = 0; i < num_entities; ++i )
 {
 if( to_dimension == 0 && TYPE_FROM_HANDLE( from_entities[0] ) != MBPOLYHEDRON )
 {
 result = get_connectivity( from_entities[i], conn, len, false, &tmp_storage );MB_CHK_ERR( result );
 adj_entities.insert( adj_entities.end(), conn, conn + len );
 }
 else
 {
 result =
 aEntityFactory->get_adjacencies( from_entities[i], to_dimension, create_if_missing, adj_entities );MB_CHK_ERR( result );
 }
 }
 std::sort( adj_entities.begin(), adj_entities.end() );
 adj_entities.erase( std::unique( adj_entities.begin(), adj_entities.end() ), adj_entities.end() );
 
 // return MB_SUCCESS;
 
#ifdef MOAB_HAVE_AHF
 }
#endif
 
 return MB_SUCCESS;
}

References ErrorCode, moab::get_adjacencies_intersection(), moab::Interface::INTERSECT, MB_CHK_ERR, MB_SUCCESS, MBPOLYHEDRON, moab::TYPE_FROM_HANDLE(), and moab::Interface::UNION.

Referenced by moab::DualTool::check_dual_equiv_edges(), moab::AEntityFactory::check_equiv_entities(), create_coarse_mesh(), moab::AEntityFactory::create_explicit_adjs(), create_fine_mesh(), IntxUtilsCSLAM::create_span_quads(), moab::NestedRefine::exchange_ghosts(), fill_coord_on_edges(), moab::ReadUtil::gather_related_ents(), gather_set_stats(), get_adjacent_elems(), moab::AEntityFactory::get_down_adjacency_elements_poly(), get_linear_reconstruction(), moab::AEntityFactory::get_polyhedron_vertices(), moab::AEntityFactory::get_up_adjacency_elements(), moab::AEntityFactory::get_vertices(), hcFilter(), moab::ReorderTool::int_order_from_sets_and_adj(), laplacianFilter(), main(), moab::AEntityFactory::merge_adjust_adjacencies(), moab::numAdjTriInSet(), perform_lloyd_relaxation(), tag_depth(), and moab::HiReconstruction::vertex_get_incident_elements().

get_adjacencies() [3/3]

ErrorCode moab::Core::get_adjacencies ( const Range &  from_entities, const int  to_dimension, const bool  create_if_missing, Range &  adj_entities, const int  operation_type = Interface::INTERSECT  )

virtual

Get the adjacencies associated with a range of entities to entities of a specfied dimension.

Identical to vector-based get_adjacencies function, except "from" entities specified in a range instead of a vector.

Implements moab::Interface.

Definition at line 1744 of file Core.cpp.

{
 if( operation_type == Interface::INTERSECT )
 return get_adjacencies_intersection( this, from_entities.begin(), from_entities.end(), to_dimension,
 create_if_missing, adj_entities );
 else if( operation_type != Interface::UNION )
 return MB_FAILURE;
 else if( to_dimension == 0 )
 return get_vertices( from_entities, adj_entities );
 else
 return get_adjacencies_union( this, from_entities.begin(), from_entities.end(), to_dimension, create_if_missing,
 adj_entities );
}

References moab::Range::begin(), moab::Range::end(), moab::get_adjacencies_intersection(), moab::get_adjacencies_union(), moab::Interface::INTERSECT, and moab::Interface::UNION.

get_child_meshsets() [1/2]

ErrorCode moab::Core::get_child_meshsets ( const EntityHandle  meshset, Range &  children, const int  num_hops = 1  ) const

virtual

get child meshsets

Implements moab::Interface.

Definition at line 3447 of file Core.cpp.

{
 if( 0 == meshset ) return MB_ENTITY_NOT_FOUND;
 
 std::vector< EntityHandle > child_vec;
 ErrorCode result = get_child_meshsets( meshset, child_vec, num_hops );MB_CHK_ERR( result );
 std::sort( child_vec.begin(), child_vec.end() );
 std::copy( child_vec.rbegin(), child_vec.rend(), range_inserter( children ) );
 return MB_SUCCESS;
}

References children, ErrorCode, MB_CHK_ERR, MB_ENTITY_NOT_FOUND, and MB_SUCCESS.

get_child_meshsets() [2/2]

ErrorCode moab::Core::get_child_meshsets ( const EntityHandle  meshset, std::vector< EntityHandle > &  children, const int  num_hops = 1  ) const

virtual

get child meshsets

Implements moab::Interface.

Definition at line 3433 of file Core.cpp.

{
 if( 0 == meshset ) return MB_ENTITY_NOT_FOUND;
 
 const EntitySequence* seq;
 ErrorCode rval = sequence_manager()->find( meshset, seq );
 if( MB_SUCCESS != rval ) return MB_ENTITY_NOT_FOUND;
 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
 
 return mseq->get_children( sequence_manager(), meshset, children, num_hops );
}

References children, ErrorCode, moab::MeshSetSequence::get_children(), MB_ENTITY_NOT_FOUND, and MB_SUCCESS.

Referenced by moab::ReadUtil::gather_related_ents().

get_connectivity() [1/4]

ErrorCode moab::Core::get_connectivity ( const EntityHandle *  entity_handles, const int  num_handles, Range &  connectivity, bool  corners_only = false  ) const

virtual

Gets the connectivity for a vector of elements.

get the connectivity for element /handles. For non-element handles, return an error

Same as vector-based version except range is returned (unordered!)

Implements moab::Interface.

Definition at line 1143 of file Core.cpp.

{
 std::vector< EntityHandle > tmp_connect;
 ErrorCode result = get_connectivity( entity_handles, num_handles, tmp_connect, corners_only );MB_CHK_ERR( result );
 
 std::sort( tmp_connect.begin(), tmp_connect.end() );
 std::copy( tmp_connect.rbegin(), tmp_connect.rend(), range_inserter( connectivity ) );
 return result;
}

References ErrorCode, and MB_CHK_ERR.

get_connectivity() [2/4]

ErrorCode moab::Core::get_connectivity ( const EntityHandle *  entity_handles, const int  num_handles, std::vector< EntityHandle > &  connectivity, bool  corners_only = false, std::vector< int > *  offsets = NULL  ) const

virtual

Gets the connectivity for an element EntityHandle.

get the connectivity for element /handles. For non-element handles, return an error

For non-element handles (ie, MeshSets), returns an error. Connectivity data is copied from the database into the vector connectivity. The nodes in connectivity are properly ordered.

Parameters

entity_handle	EntityHandle to get connectivity of.
connectivity	Vector in which connectivity of entity_handle is returned. Should contain MeshVertices.
corners_only	If true, returns only corner vertices, otherwise returns all of them (including any higher-order vertices)

Example:

std::vector<EntityHandle> conn;
get_connectivity( entity_handle, conn ); 

Implements moab::Interface.

Definition at line 1157 of file Core.cpp.

{
 connectivity.clear(); // this seems wrong as compared to other API functions,
 // but changing it breaks lost of code, so I'm leaving
 // it in. - j.kraftcheck 2009-11-06
 
 ErrorCode rval;
 std::vector< EntityHandle > tmp_storage; // used only for structured mesh
 const EntityHandle* conn;
 int len;
 if( offsets ) offsets->push_back( 0 );
 for( int i = 0; i < num_handles; ++i )
 {
 rval = get_connectivity( entity_handles[i], conn, len, corners_only, &tmp_storage );MB_CHK_ERR( rval );
 connectivity.insert( connectivity.end(), conn, conn + len );
 if( offsets ) offsets->push_back( connectivity.size() );
 }
 return MB_SUCCESS;
}

References ErrorCode, MB_CHK_ERR, and MB_SUCCESS.

Referenced by moab::HalfFacetRep::add_cells_of_single_component(), add_field_value(), moab::HalfFacetRep::another_halfedge(), moab::HiReconstruction::average_vertex_normal(), moab::HiReconstruction::average_vertex_tangent(), moab::HigherOrderFactory::center_node_exist(), cleanup_after_intersection(), moab::HalfFacetRep::collect_and_compare(), compute_lagrange_mesh_on_sphere(), compute_tracer_case1(), compute_velocity_case1(), create_fine_mesh(), create_lagr_mesh(), IntxUtilsCSLAM::create_span_quads(), IntxUtilsCSLAM::deep_copy_set(), moab::HalfFacetRep::determine_border_vertices(), moab::HalfFacetRep::determine_incident_halfedges(), moab::HalfFacetRep::determine_incident_halffaces(), moab::HalfFacetRep::determine_incident_halfverts(), moab::HalfFacetRep::determine_sibling_halfedges(), moab::HalfFacetRep::determine_sibling_halffaces(), moab::HalfFacetRep::determine_sibling_halfverts(), moab::AEntityFactory::entities_equivalent(), moab::NestedRefine::exchange_ghosts(), moab::HalfFacetRep::find_matching_halfedge(), moab::HalfFacetRep::find_matching_halfface(), moab::HalfFacetRep::find_matching_implicit_edge_in_cell(), moab::WriteUtil::gather_nodes_from_elements(), gather_set_stats(), moab::AEntityFactory::get_adjacencies(), get_barycenters(), moab::NestedRefine::get_connectivity(), moab::HalfFacetRep::get_down_adjacencies_2d(), moab::HalfFacetRep::get_down_adjacencies_edg_3d(), moab::HalfFacetRep::get_down_adjacencies_face_3d(), moab::AEntityFactory::get_down_adjacency_elements(), moab::AEntityFactory::get_down_adjacency_elements_poly(), moab::HalfFacetRep::get_face_edges(), get_gnomonic_plane(), moab::HalfFacetRep::get_half_facet_in_comp(), get_intersection_weights(), get_linear_reconstruction(), moab::ReadUtil::get_ordered_vertices(), moab::AEntityFactory::get_polyhedron_vertices(), moab::HalfFacetRep::get_up_adjacencies_2d(), moab::HalfFacetRep::get_up_adjacencies_edg_3d(), moab::HalfFacetRep::get_up_adjacencies_edg_3d_comp(), moab::HalfFacetRep::get_up_adjacencies_vert_3d(), moab::AEntityFactory::get_up_adjacency_elements(), moab::AEntityFactory::get_vertices(), hcFilter(), moab::HiReconstruction::hiproj_walf_in_element(), laplacianFilter(), main(), manufacture_lagrange_mesh_on_sphere(), moab::HalfFacetRep::mark_halfedges(), moab::AEntityFactory::merge_adjust_adjacencies(), moab::HiReconstruction::obtain_nring_ngbvs(), perform_laplacian_smoothing(), perform_lloyd_relaxation(), moab::ReorderTool::reorder_entities(), set_departure_points_position(), moab::HigherOrderFactory::tag_for_deletion(), test_linear_reconstruction(), test_spectral_quad(), moab::NestedRefine::update_global_ahf_3D(), and moab::NestedRefine::update_special_tags().

get_connectivity() [3/4]

ErrorCode moab::Core::get_connectivity ( const EntityHandle  entity_handle, const EntityHandle *&  connectivity, int &  number_nodes, bool  corners_only = false, std::vector< EntityHandle > *  storage = 0  ) const

virtual

Gets a pointer to constant connectivity data of entity_handle

get the connectivity for element handles. For non-element handles, return an error

Sets number_nodes equal to the number of nodes of the entity_handle . Faster then the other get_connectivity function. The nodes in 'connectivity' are properly ordered.

Parameters

entity_handle	EntityHandle to get connectivity of.
connectivity	Array in which connectivity of entity_handle is returned. Should contain MBVERTEX's.
num_nodes	Number of MeshVertices in array connectivity.

Example:

const EntityHandle* conn;
int number_nodes = 0;
get_connectivity( entity_handle, conn, number_nodes ); 

Example2:

std::vector<EntityHandle> sm_storage;
const EntityHandle* conn;
int number_nodes;
get_connectivity( handle, conn, number_nodes, false, &sm_storage );
if (conn == &sm_storage[0])
 std::cout << "Structured mesh element" << std::endl;

Implements moab::Interface.

Definition at line 1182 of file Core.cpp.

{
 ErrorCode status;
 
 // Make sure the entity should have a connectivity.
 EntityType entity_type = TYPE_FROM_HANDLE( entity_handle );
 
 // WARNING: This is very dependent on the ordering of the EntityType enum
 if( entity_type < MBVERTEX || entity_type >= MBENTITYSET )
 return MB_TYPE_OUT_OF_RANGE;
 
 else if( entity_type == MBVERTEX )
 {
 return MB_FAILURE;
 }
 
 const EntitySequence* seq = 0;
 
 // We know that connectivity is stored in an EntitySequence so jump straight
 // to the entity sequence
 status = sequence_manager()->find( entity_handle, seq );
 if( seq == 0 || status != MB_SUCCESS ) return MB_ENTITY_NOT_FOUND;
 
 return static_cast< const ElementSequence* >( seq )->get_connectivity( entity_handle, connectivity, number_nodes,
 corners_only, storage );
}

References ErrorCode, MB_ENTITY_NOT_FOUND, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MBENTITYSET, MBVERTEX, and moab::TYPE_FROM_HANDLE().

get_connectivity() [4/4]

ErrorCode moab::Core::get_connectivity ( const Range &  from_entities, Range &  adj_entities, bool  corners_only = false  ) const

virtual

Gets the connectivity for elements.

Same as vector-based version except range is returned (unordered!)

Implements moab::Interface.

Definition at line 1625 of file Core.cpp.

{
 const size_t DEFAULT_MAX_BLOCKS_SIZE = 4000;
 const size_t MAX_OUTER_ITERATIONS = 100;
 
 std::vector< EntityHandle > temp_vec, storage;
 std::vector< EntityHandle >::const_iterator ti;
 ErrorCode result = MB_SUCCESS, tmp_result;
 Range::const_iterator i = from_entities.begin();
 Range::iterator ins;
 const EntityHandle* conn;
 int conn_len;
 
 // Just copy any vertices from the input range into the output
 size_t remaining = from_entities.size();
 for( ; i != from_entities.end() && TYPE_FROM_HANDLE( *i ) == MBVERTEX; ++i )
 --remaining;
 adj_entities.merge( from_entities.begin(), i );
 
 // How many entities to work with at once? 2000 or so shouldn't require
 // too much memory, but don't iterate in outer loop more than a
 // 1000 times (make it bigger if many input entiites.)
 const size_t block_size = std::max( DEFAULT_MAX_BLOCKS_SIZE, remaining / MAX_OUTER_ITERATIONS );
 while( remaining > 0 )
 {
 const size_t count = remaining > block_size ? block_size : remaining;
 remaining -= count;
 temp_vec.clear();
 for( size_t j = 0; j < count; ++i, ++j )
 {
 tmp_result = get_connectivity( *i, conn, conn_len, corners_only, &storage );
 if( MB_SUCCESS != tmp_result )
 {
 result = tmp_result;
 continue;
 }
 
 const size_t oldsize = temp_vec.size();
 temp_vec.resize( oldsize + conn_len );
 memcpy( &temp_vec[oldsize], conn, sizeof( EntityHandle ) * conn_len );
 }
 
 std::sort( temp_vec.begin(), temp_vec.end() );
 ins = adj_entities.begin();
 ti = temp_vec.begin();
 while( ti != temp_vec.end() )
 {
 EntityHandle first = *ti;
 EntityHandle second = *ti;
 for( ++ti; ti != temp_vec.end() && ( *ti - second <= 1 ); ++ti )
 second = *ti;
 ins = adj_entities.insert( ins, first, second );
 }
 }
 return result;
}

References moab::Range::begin(), moab::Range::end(), ErrorCode, moab::GeomUtil::first(), moab::Range::insert(), MB_SUCCESS, MBVERTEX, moab::Range::merge(), moab::Range::size(), and moab::TYPE_FROM_HANDLE().

get_connectivity_by_type()

ErrorCode moab::Core::get_connectivity_by_type ( const EntityType  entity_type, std::vector< EntityHandle > &  connect  ) const

virtual

get global connectivity array for specified entity type

Assumes just vertices, no higher order nodes

Implements moab::Interface.

Definition at line 1120 of file Core.cpp.

{
 // inefficient implementation until we get blocked tag access
 
 // get the range of entities of this type
 Range this_range;
 ErrorCode result = get_entities_by_type( 0, entity_type, this_range );
 
 int num_ents = this_range.size();
 connect.reserve( num_ents * CN::VerticesPerEntity( entity_type ) );
 
 // now loop over these entities, getting connectivity for each
 for( Range::iterator this_it = this_range.begin(); this_it != this_range.end(); ++this_it )
 {
 const EntityHandle* connect_vec = NULL;
 result = get_connectivity( *this_it, connect_vec, num_ents, true );MB_CHK_ERR( result );
 connect.insert( connect.end(), &connect_vec[0], &connect_vec[num_ents] );
 }
 
 return MB_SUCCESS;
}

References moab::Range::begin(), moab::Range::end(), ErrorCode, MB_CHK_ERR, MB_SUCCESS, moab::Range::size(), and moab::CN::VerticesPerEntity().

get_contained_meshsets() [1/2]

ErrorCode moab::Core::get_contained_meshsets ( const EntityHandle  meshset, Range &  children, const int  num_hops = 1  ) const

virtual

get contained meshsets

Implements moab::Interface.

Definition at line 3475 of file Core.cpp.

{
 if( 0 == meshset )
 {
 return get_entities_by_type( meshset, MBENTITYSET, children );
 }
 
 std::vector< EntityHandle > child_vec;
 ErrorCode result = get_contained_meshsets( meshset, child_vec, num_hops );MB_CHK_ERR( result );
 std::sort( child_vec.begin(), child_vec.end() );
 std::copy( child_vec.rbegin(), child_vec.rend(), range_inserter( children ) );
 return MB_SUCCESS;
}

References children, ErrorCode, MB_CHK_ERR, MB_SUCCESS, and MBENTITYSET.

get_contained_meshsets() [2/2]

ErrorCode moab::Core::get_contained_meshsets ( const EntityHandle  meshset, std::vector< EntityHandle > &  children, const int  num_hops = 1  ) const

virtual

get contained meshsets

Implements moab::Interface.

Definition at line 3458 of file Core.cpp.

{
 if( 0 == meshset )
 {
 return get_entities_by_type( meshset, MBENTITYSET, children );
 }
 
 const EntitySequence* seq;
 ErrorCode rval = sequence_manager()->find( meshset, seq );
 if( MB_SUCCESS != rval ) return MB_ENTITY_NOT_FOUND;
 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
 
 return mseq->get_contained_sets( sequence_manager(), meshset, children, num_hops );
}

References children, ErrorCode, moab::MeshSetSequence::get_contained_sets(), MB_ENTITY_NOT_FOUND, MB_SUCCESS, and MBENTITYSET.

get_coords() [1/4]

ErrorCode moab::Core::get_coords ( const EntityHandle *  entity_handles, const int  num_entities, double *  coords  ) const

virtual

Gets xyz coordinate information for vector of vertices.

Identical to range-based function, except entity handles are specified using a 1d vector and vector length.

Implements moab::Interface.

Definition at line 974 of file Core.cpp.

{
 const EntitySequence* seq = NULL;
 const VertexSequence* vseq = NULL;
 const EntityHandle* const end = entities + num_entities;
 const EntityHandle* iter = entities;
 ErrorCode status = MB_SUCCESS;
 
 while( iter != end )
 {
 if( TYPE_FROM_HANDLE( *iter ) == MBVERTEX )
 {
 if( !seq )
 {
 seq = sequence_manager()->get_last_accessed_sequence( MBVERTEX );
 vseq = static_cast< const VertexSequence* >( seq );
 }
 if( !vseq )
 return MB_ENTITY_NOT_FOUND;
 else if( vseq->start_handle() > *iter || vseq->end_handle() < *iter )
 {
 if( MB_SUCCESS != sequence_manager()->find( *iter, seq ) ) return MB_ENTITY_NOT_FOUND;
 vseq = static_cast< const VertexSequence* >( seq );
 }
 vseq->get_coordinates( *iter, coords );
 }
 else
 {
 static std::vector< EntityHandle > dum_conn( CN::MAX_NODES_PER_ELEMENT );
 static std::vector< double > dum_pos( 3 * CN::MAX_NODES_PER_ELEMENT );
 static const EntityHandle* conn;
 static int num_conn;
 status = get_connectivity( *iter, conn, num_conn, false, &dum_conn );MB_CHK_ERR( status );
 status = get_coords( conn, num_conn, &dum_pos[0] );MB_CHK_ERR( status );
 coords[0] = coords[1] = coords[2] = 0.0;
 for( int i = 0; i < num_conn; i++ )
 {
 coords[0] += dum_pos[3 * i];
 coords[1] += dum_pos[3 * i + 1];
 coords[2] += dum_pos[3 * i + 2];
 }
 coords[0] /= num_conn;
 coords[1] /= num_conn;
 coords[2] /= num_conn;
 }
 coords += 3;
 ++iter;
 }
 
 return status;
}

References moab::EntitySequence::end_handle(), entities, ErrorCode, moab::VertexSequence::get_coordinates(), moab::CN::MAX_NODES_PER_ELEMENT, MB_CHK_ERR, MB_ENTITY_NOT_FOUND, MB_SUCCESS, MBVERTEX, moab::EntitySequence::start_handle(), and moab::TYPE_FROM_HANDLE().

get_coords() [2/4]

ErrorCode moab::Core::get_coords ( const EntityHandle  entity_handle, const double *&  x, const double *&  y, const double *&  z  ) const

virtual

Definition at line 1026 of file Core.cpp.

{
 ErrorCode status = MB_TYPE_OUT_OF_RANGE;
 
 if( TYPE_FROM_HANDLE( entity_handle ) == MBVERTEX )
 {
 const EntitySequence* seq = 0;
 status = sequence_manager()->find( entity_handle, seq );
 
 if( seq == 0 || status != MB_SUCCESS ) return MB_ENTITY_NOT_FOUND;
 
 status = static_cast< const VertexSequence* >( seq )->get_coordinates_ref( entity_handle, x, y, z );
 }
 
 return status;
}

References ErrorCode, MB_ENTITY_NOT_FOUND, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MBVERTEX, and moab::TYPE_FROM_HANDLE().

get_coords() [3/4]

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

virtual

get the coordinate information for this handle if it is of type Vertex otherwise, return an error

Implements moab::Interface.

Definition at line 859 of file Core.cpp.

{
 const TypeSequenceManager& vert_data = sequence_manager()->entity_map( MBVERTEX );
 TypeSequenceManager::const_iterator seq_iter;
 
 Range::const_pair_iterator i = entities.const_pair_begin();
 EntityHandle first = i->first;
 while( i != entities.const_pair_end() && TYPE_FROM_HANDLE( i->first ) == MBVERTEX )
 {
 
 seq_iter = vert_data.lower_bound( first );
 if( seq_iter == vert_data.end() || first < ( *seq_iter )->start_handle() ) return MB_ENTITY_NOT_FOUND;
 const VertexSequence* vseq = reinterpret_cast< const VertexSequence* >( *seq_iter );
 
 EntityID offset = first - vseq->start_handle();
 EntityID count;
 if( i->second <= vseq->end_handle() )
 {
 count = i->second - first + 1;
 ++i;
 if( i != entities.const_pair_end() ) first = i->first;
 }
 else
 {
 count = vseq->end_handle() - first + 1;
 first = vseq->end_handle() + 1;
 }
 
 double const *x, *y, *z;
 ErrorCode rval = vseq->get_coordinate_arrays( x, y, z );MB_CHK_ERR( rval );
 x += offset;
 y += offset;
 z += offset;
 for( EntityID j = 0; j < count; ++j )
 {
 coords[3 * j] = x[j];
 coords[3 * j + 1] = y[j];
 coords[3 * j + 2] = z[j];
 }
 coords = &coords[3 * count];
 }
 
 // for non-vertices...
 ErrorCode rval = MB_SUCCESS;
 for( Range::const_iterator rit( &( *i ), i->first ); rit != entities.end(); ++rit )
 {
 rval = get_coords( &( *rit ), 1, coords );MB_CHK_ERR( rval );
 coords += 3;
 }
 
 return rval;
}

References moab::TypeSequenceManager::end(), moab::EntitySequence::end_handle(), entities, ErrorCode, moab::GeomUtil::first(), moab::VertexSequence::get_coordinate_arrays(), moab::TypeSequenceManager::lower_bound(), MB_CHK_ERR, MB_ENTITY_NOT_FOUND, MB_SUCCESS, MBVERTEX, moab::EntitySequence::start_handle(), and moab::TYPE_FROM_HANDLE().

Referenced by add_field_value(), moab::HiReconstruction::average_vertex_normal(), moab::HiReconstruction::average_vertex_tangent(), RuntimeContext::compute_centroids(), compute_lagrange_mesh_on_sphere(), compute_tracer_case1(), compute_velocity_case1(), moab::NestedRefine::copy_vertices_from_prev_level(), create_lagr_mesh(), IntxUtilsCSLAM::deep_copy_set(), gather_set_stats(), get_barycenters(), moab::NestedRefine::get_coordinates(), get_departure_grid(), get_gnomonic_plane(), get_intersection_weights(), moab::WriteUtil::get_node_coords(), moab::HiReconstruction::hiproj_walf_around_vertex(), moab::HiReconstruction::hiproj_walf_in_element(), main(), manufacture_lagrange_mesh_on_sphere(), perform_laplacian_smoothing(), perform_lloyd_relaxation(), moab::HiReconstruction::polyfit3d_walf_curve_vertex(), moab::HiReconstruction::polyfit3d_walf_surf_vertex(), moab::ReorderTool::reorder_entities(), test_linear_reconstruction(), and test_spectral_quad().

get_coords() [4/4]

ErrorCode moab::Core::get_coords ( const Range &  entities, double *  x_coords, double *  y_coords, double *  z_coords  ) const

virtual

Author

Jason Kraftcheck kraft.nosp@m.che@.nosp@m.cae.w.nosp@m.isc..nosp@m.edu - 2007-5-15

Implements moab::Interface.

Definition at line 913 of file Core.cpp.

{
 const TypeSequenceManager& vert_data = sequence_manager()->entity_map( MBVERTEX );
 TypeSequenceManager::const_iterator seq_iter;
 
 Range::const_pair_iterator i = entities.const_pair_begin();
 EntityHandle first = i->first;
 while( i != entities.const_pair_end() && TYPE_FROM_HANDLE( i->first ) == MBVERTEX )
 {
 
 seq_iter = vert_data.lower_bound( first );
 if( seq_iter == vert_data.end() || first < ( *seq_iter )->start_handle() ) return MB_ENTITY_NOT_FOUND;
 const VertexSequence* vseq = reinterpret_cast< const VertexSequence* >( *seq_iter );
 
 EntityID offset = first - vseq->start_handle();
 EntityID count;
 if( i->second <= vseq->end_handle() )
 {
 count = i->second - first + 1;
 ++i;
 if( i != entities.const_pair_end() ) first = i->first;
 }
 else
 {
 count = vseq->end_handle() - first + 1;
 first = vseq->end_handle() + 1;
 }
 
 double const *x, *y, *z;
 ErrorCode rval = vseq->get_coordinate_arrays( x, y, z );MB_CHK_ERR( rval );
 if( x_coords )
 {
 memcpy( x_coords, x + offset, count * sizeof( double ) );
 x_coords += count;
 }
 if( y_coords )
 {
 memcpy( y_coords, y + offset, count * sizeof( double ) );
 y_coords += count;
 }
 if( z_coords )
 {
 memcpy( z_coords, z + offset, count * sizeof( double ) );
 z_coords += count;
 }
 }
 
 // for non-vertices...
 ErrorCode rval = MB_SUCCESS;
 double xyz[3];
 for( Range::const_iterator rit( &( *i ), i->first ); rit != entities.end(); ++rit )
 {
 rval = get_coords( &( *rit ), 1, xyz );MB_CHK_ERR( rval );
 *x_coords++ = xyz[0];
 *y_coords++ = xyz[1];
 *z_coords++ = xyz[2];
 }
 
 return rval;
}

References moab::TypeSequenceManager::end(), moab::EntitySequence::end_handle(), entities, ErrorCode, moab::GeomUtil::first(), moab::VertexSequence::get_coordinate_arrays(), moab::TypeSequenceManager::lower_bound(), MB_CHK_ERR, MB_ENTITY_NOT_FOUND, MB_SUCCESS, MBVERTEX, moab::EntitySequence::start_handle(), and moab::TYPE_FROM_HANDLE().

get_dimension()

ErrorCode moab::Core::get_dimension ( int &  dim ) const

virtual

get overall geometric dimension

Implements moab::Interface.

Definition at line 767 of file Core.cpp.

{
 dim = geometricDimension;
 return MB_SUCCESS;
}

References dim, and MB_SUCCESS.

get_entities_by_dimension() [1/2]

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

virtual

Adds adjacencies.

Parameters

from_handle	entities
both_ways	add the adjacency information to both the to_handle and and the from_from :handle

Example:

 /
virtual ErrorCode add_adjacencies( const EntityHandle entity_handle,
 const EntityHandle* adjacencies,
 const int num_handles,
 bool both_ways );
 
//! Adds adjacencies; same as vector-based, but with range instead
virtual ErrorCode add_adjacencies( const EntityHandle entity_handle, Range& adjacencies, bool both_ways );
 
//! Removes adjacencies
/** \param handle EntityHandle to get adjacencies of.
 
Example: \code
*/
virtual ErrorCode remove_adjacencies( const EntityHandle entity_handle,
 const EntityHandle* adjacencies,
 const int num_handles );
 
//! Retrieves all entities in the database of given dimension.
/** \param dimension Dimension of entities desired.
 \param entities Range in which entities of dimension <em>dimension</em> are returned.
 
 Example: \code
 int dimension = 2;
 Range entities;
 get_entities_by_dimension( dimension, entities ); //get 2D EntityHandles in the database

Implements moab::Interface.

Examples

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

Definition at line 1834 of file Core.cpp.

{
 ErrorCode result = MB_SUCCESS;
 if( meshset )
 {
 const EntitySequence* seq;
 result = sequence_manager()->find( meshset, seq );MB_CHK_ERR( result );
 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
 result = mseq->get_dimension( sequence_manager(), meshset, dimension, entities, recursive );MB_CHK_ERR( result );
 }
 else if( dimension > 3 )
 {
 sequence_manager()->get_entities( MBENTITYSET, entities );
 }
 else
 {
 for( EntityType this_type = CN::TypeDimensionMap[dimension].first;
 this_type <= CN::TypeDimensionMap[dimension].second; this_type++ )
 {
 sequence_manager()->get_entities( this_type, entities );
 }
 }
 
 return MB_SUCCESS;
}

References entities, ErrorCode, moab::GeomUtil::first(), moab::MeshSetSequence::get_dimension(), MB_CHK_ERR, MB_SUCCESS, MBENTITYSET, and moab::CN::TypeDimensionMap.

Referenced by add_field_value(), moab::HalfFacetRep::check_mixed_entity_type(), cleanup_after_intersection(), compute_tracer_case1(), compute_velocity_case1(), moab::NestedRefine::count_subentities(), create_fine_mesh(), create_lagr_mesh(), IntxUtilsCSLAM::create_span_quads(), IntxUtilsCSLAM::deep_copy_set(), moab::NestedRefine::exchange_ghosts(), get_barycenters(), get_departure_grid(), get_gnomonic_plane(), get_intersection_weights(), get_linear_reconstruction(), moab::HalfFacetRep::initialize(), moab::HiReconstruction::initialize(), moab::ReorderTool::int_order_from_sets_and_adj(), main(), process_partition_file(), set_density(), tag_depth(), test_linear_reconstruction(), test_spectral_hex(), update_density(), and moab::HalfFacetRep::update_entity_ranges().

get_entities_by_dimension() [2/2]

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

virtual

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

Appends entities to list passed in.

Parameters

meshset	Meshset whose entities are being queried (zero if query is for entire mesh).
dimension	Topological dimension of entities desired.
entities	Range in which entities of dimension dimension are returned.
recursive	If true, meshsets containing meshsets are queried recursively. Returns the contents of meshsets, but not the meshsets themselves if true.

Example:

// get 1d (edge) elements in the entire mesh
Range edges;
get_entities_by_dimension( 0, 1, edges );

Implements moab::Interface.

Definition at line 1863 of file Core.cpp.

{
 ErrorCode result = MB_SUCCESS;
 if( meshset )
 {
 const EntitySequence* seq;
 result = sequence_manager()->find( meshset, seq );MB_CHK_ERR( result );
 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
 result = mseq->get_dimension( sequence_manager(), meshset, dimension, entities, recursive );MB_CHK_ERR( result );
 }
 else if( dimension > 3 )
 {
 sequence_manager()->get_entities( MBENTITYSET, entities );
 }
 else
 {
 for( EntityType this_type = CN::TypeDimensionMap[dimension].first;
 this_type <= CN::TypeDimensionMap[dimension].second; this_type++ )
 {
 sequence_manager()->get_entities( this_type, entities );
 }
 }
 
 return MB_SUCCESS;
}

References entities, ErrorCode, moab::GeomUtil::first(), moab::MeshSetSequence::get_dimension(), MB_CHK_ERR, MB_SUCCESS, MBENTITYSET, and moab::CN::TypeDimensionMap.

get_entities_by_handle() [1/2]

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

virtual

Retrieves all entities in the data base.

Parameters

entities

Range in which entities of EntityType type are returned.

Example:

Range entities;
get_entities( entities ); //get MBTET type EntityHandles in the database

Implements moab::Interface.

Definition at line 1992 of file Core.cpp.

{
 ErrorCode result = MB_SUCCESS;
 if( meshset )
 {
 const EntitySequence* seq;
 result = sequence_manager()->find( meshset, seq );MB_CHK_ERR( result );
 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
 result = mseq->get_entities( sequence_manager(), meshset, entities, recursive );MB_CHK_ERR( result );
 }
 else
 {
 // iterate backwards so range insertion is quicker
 for( EntityType entity_type = MBENTITYSET; entity_type >= MBVERTEX; --entity_type )
 sequence_manager()->get_entities( entity_type, entities );
 }
 
 return MB_SUCCESS;
}

References entities, ErrorCode, moab::MeshSetSequence::get_entities(), MB_CHK_ERR, MB_SUCCESS, MBENTITYSET, and MBVERTEX.

Referenced by moab::RangeSetIterator::build_pair_vec(), moab::HigherOrderFactory::convert(), moab::WriteUtil::gather_entities(), moab::ReadUtil::gather_related_ents(), get_max_volume(), main(), moab::ReorderTool::update_set_contents(), and moab::NestedRefine::update_special_tags().

get_entities_by_handle() [2/2]

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

virtual

Retrieves all entities in the data base.

Parameters

entities

Range in which entities of EntityType type are returned.

Example:

Range entities;
get_entities( entities ); //get MBTET type EntityHandles in the database

Implements moab::Interface.

Definition at line 2012 of file Core.cpp.

{
 ErrorCode result;
 if( recursive || !meshset )
 {
 Range tmp_range;
 result = get_entities_by_handle( meshset, tmp_range, recursive );
 size_t offset = entities.size();
 entities.resize( offset + tmp_range.size() );
 std::copy( tmp_range.begin(), tmp_range.end(), entities.begin() + offset );
 }
 else
 {
 const EntitySequence* seq;
 result = sequence_manager()->find( meshset, seq );MB_CHK_ERR( result );
 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
 result = mseq->get_entities( meshset, entities );MB_CHK_ERR( result );
 }
 return MB_SUCCESS;
}

References moab::Range::begin(), moab::Range::end(), entities, ErrorCode, moab::MeshSetSequence::get_entities(), MB_CHK_ERR, MB_SUCCESS, and moab::Range::size().

get_entities_by_type() [1/2]

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

virtual

Retrieves all entities in the data base of given type.

Parameters

type	EntityType of entities desired (ie, MBHEX, MBEDGE, MBTRI, etc )
entities	Range in which entities of EntityType type are returned.

Example:

EntityType type = MBTET;
Range entities;
get_entities_by_dimension( type, entities ); //get MBTET type EntityHandles in the database

Implements moab::Interface.

Definition at line 1892 of file Core.cpp.

{
 ErrorCode result = MB_SUCCESS;
 if( meshset )
 {
 const EntitySequence* seq;
 result = sequence_manager()->find( meshset, seq );MB_CHK_ERR( result );
 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
 result = mseq->get_type( sequence_manager(), meshset, entity_type, entities, recursive );MB_CHK_ERR( result );
 }
 else
 {
 sequence_manager()->get_entities( entity_type, entities );
 }
 
 return MB_SUCCESS;
}

References entities, ErrorCode, moab::MeshSetSequence::get_type(), MB_CHK_ERR, and MB_SUCCESS.

Referenced by compute_lagrange_mesh_on_sphere(), moab::AEntityFactory::create_vert_elem_adjacencies(), dot_contained(), dot_nodes(), moab::ReadUtil::gather_related_ents(), gather_set_stats(), initialize_area_and_tracer(), main(), manufacture_lagrange_mesh_on_sphere(), set_departure_points_position(), test_spectral_quad(), moab::ReorderTool::update_set_contents(), and update_tracer_test().

get_entities_by_type() [2/2]

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

virtual

Retrieves all entities in the data base of given type.

Parameters

type	EntityType of entities desired (ie, MBHEX, MBEDGE, MBTRI, etc )
entities	Range in which entities of EntityType type are returned.

Example:

EntityType type = MBTET;
Range entities;
get_entities_by_dimension( type, entities ); //get MBTET type EntityHandles in the database

Implements moab::Interface.

Definition at line 1913 of file Core.cpp.

{
 ErrorCode result = MB_SUCCESS;
 if( meshset )
 {
 const EntitySequence* seq;
 result = sequence_manager()->find( meshset, seq );MB_CHK_ERR( result );
 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
 result = mseq->get_type( sequence_manager(), meshset, entity_type, entities, recursive );MB_CHK_ERR( result );
 }
 else
 {
 sequence_manager()->get_entities( entity_type, entities );
 }
 
 return MB_SUCCESS;
}

References entities, ErrorCode, moab::MeshSetSequence::get_type(), MB_CHK_ERR, and MB_SUCCESS.

get_entities_by_type_and_tag()

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

virtual

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

Parameters

meshset	Meshset whose entities are being queried (zero if query is for entire mesh).
type	Type of entities to be returned
tag_handles	Vector of tag handles entities must have
values	Vector of pointers to values of tags in tag_handles
num_tags	Number of tags and values in tag_handles and values
entities	Range in which entities are returned.
condition	Boolean condition, either Interface::UNION or Interface::INTERSECT
recursive	If true, meshsets containing meshsets are queried recursively. Returns the contents of meshsets, but not the meshsets themselves. Specifying both recursive=true and type=MBENTITYSET is an error, as it would always result in an empty list.

If Interface::UNION is specified as the condition, entities with any of the tags and values specified are returned. If Interface::INTERSECT is specified, only entities with all of the tags/values are returned.

If values is NULL, entities with the specified tags and any corresponding values are returned. Note that if values is non-NULL, it is a vector of pointers to tag values.

Example:

// get the dirichlet sets in a mesh
Range dir_sets;
Tag dir_tag;
tag_get_handle(DIRICHLET_SET_TAG_NAME, dir_tag, 1, MB_TYPE_INTEGER);
get_entities_by_type_and_tag(0, MBENTITYSET, &dir_tag, NULL, 1, dir_sets,
Interface::UNION);

Implements moab::Interface.

Definition at line 1934 of file Core.cpp.

{
 ErrorCode result;
 Range range;
 
 result = get_entities_by_type( meshset, entity_type, range, recursive );MB_CHK_ERR( result );
 if( !entities.empty() && Interface::INTERSECT == condition ) range = intersect( entities, range );
 
 // For each tag:
 // if operation is INTERSECT remove from 'range' any non-tagged entities
 // if operation is UNION add to 'entities' any tagged entities
 for( int it = 0; it < num_tags && !range.empty(); it++ )
 {
 if( !valid_tag_handle( tags[it] ) ) return MB_TAG_NOT_FOUND;
 
 // Of the entities in 'range', put in 'tmp_range' the subset
 // that are tagged as requested for this tag.
 Range tmp_range;
 
 // get the entities with this tag/value combo
 if( NULL == values || NULL == values[it] )
 {
 result = tags[it]->get_tagged_entities( sequenceManager, tmp_range, entity_type, &range );MB_CHK_ERR( result );
 }
 else
 {
 result = tags[it]->find_entities_with_value( sequenceManager, mError, tmp_range, values[it], 0, entity_type,
 &range );MB_CHK_ERR( result );
 // if there is a default value, then we should return all entities
 // that are untagged
 if( tags[it]->equals_default_value( values[it] ) )
 {
 Range all_tagged, untagged;
 result = tags[it]->get_tagged_entities( sequenceManager, all_tagged, entity_type, &range );MB_CHK_ERR( result );
 // add to 'tmp_range' any untagged entities in 'range'
 tmp_range.merge( subtract( range, all_tagged ) );
 }
 }
 
 // The above calls should have already done the intersect for us.
 if( Interface::INTERSECT == condition )
 range.swap( tmp_range );
 else
 entities.merge( tmp_range );
 }
 
 if( Interface::INTERSECT == condition ) entities.swap( range );
 
 return MB_SUCCESS;
}

References moab::Range::empty(), entities, ErrorCode, moab::TagInfo::find_entities_with_value(), moab::TagInfo::get_tagged_entities(), moab::intersect(), moab::Interface::INTERSECT, MB_CHK_ERR, MB_SUCCESS, MB_TAG_NOT_FOUND, moab::Range::merge(), moab::subtract(), and moab::Range::swap().

Referenced by moab::HigherOrderFactory::convert_sequence(), dot_get_sets(), moab::ReadUtil::get_gather_set(), moab::ReadParallel::load_file(), main(), process_partition_file(), moab::ReorderTool::reorder_tag_data(), test_spectral_hex(), and moab::NestedRefine::update_special_tags().

get_error_string()

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

virtual

Return string representation of given error code.

Parameters

code	Error code for which string is wanted

Implements moab::Interface.

Definition at line 3618 of file Core.cpp.

{
 return (unsigned)code <= (unsigned)MB_FAILURE ? ErrorCodeStr[code] : "INVALID ERROR CODE";
}

Referenced by main().

get_last_error()

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

virtual

Return information about the last error.

Parameters

info	std::string into which information on the last error is written.

Implements moab::Interface.

Definition at line 3612 of file Core.cpp.

{
 MBErrorHandler_GetLastError( info );
 return MB_SUCCESS;
}

References MB_SUCCESS, and moab::MBErrorHandler_GetLastError().

Referenced by main().

get_meshset_options()

ErrorCode moab::Core::get_meshset_options ( const EntityHandle  ms_handle, unsigned int &  options  ) const

virtual

get the options of a mesh set

Implements moab::Interface.

Definition at line 3263 of file Core.cpp.

{
 if( !ms_handle )
 { // root set
 setoptions = MESHSET_SET | MESHSET_TRACK_OWNER;
 return MB_SUCCESS;
 }
 
 const MeshSet* set = get_mesh_set( sequence_manager(), ms_handle );
 if( !set ) return MB_ENTITY_NOT_FOUND;
 
 setoptions = set->flags();
 return MB_SUCCESS;
}

References moab::MeshSet::flags(), moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, MB_SUCCESS, MESHSET_SET, and MESHSET_TRACK_OWNER.

Referenced by moab::ReorderTool::update_set_contents().

get_number_entities_by_dimension()

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

virtual

Retrieves all entities in the database of given dimension.

get # entities of a given dimension

Parameters

dimension	Dimension of entities desired.
entities	Range in which entities of dimension dimension are returned.

Example:

int dimension = 2;
Range entities;
get_entities_by_dimension( dimension, entities ); //get 2D EntityHandles in the database

Implements moab::Interface.

Definition at line 2036 of file Core.cpp.

{
 ErrorCode result = MB_SUCCESS;
 
 if( !meshset )
 {
 number = 0;
 for( EntityType this_type = CN::TypeDimensionMap[dim].first; this_type <= CN::TypeDimensionMap[dim].second;
 this_type++ )
 {
 number += sequence_manager()->get_number_entities( this_type );
 }
 }
 else
 {
 const EntitySequence* seq;
 result = sequence_manager()->find( meshset, seq );MB_CHK_ERR( result );
 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
 result = mseq->num_dimension( sequence_manager(), meshset, dim, number, recursive );MB_CHK_ERR( result );
 }
 
 return MB_SUCCESS;
}

References dim, ErrorCode, moab::GeomUtil::first(), MB_CHK_ERR, MB_SUCCESS, moab::MeshSetSequence::num_dimension(), and moab::CN::TypeDimensionMap.

Referenced by main().

get_number_entities_by_handle()

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

virtual

Retrieves all entities in the data base.

Parameters

entities

Range in which entities of EntityType type are returned.

Example:

Range entities;
get_entities( entities ); //get MBTET type EntityHandles in the database

Implements moab::Interface.

Definition at line 2105 of file Core.cpp.

{
 ErrorCode result;
 if( meshset )
 {
 const EntitySequence* seq;
 result = sequence_manager()->find( meshset, seq );MB_CHK_ERR( result );
 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
 return mseq->num_entities( sequence_manager(), meshset, num_ent, recursive );
 }
 
 num_ent = 0;
 for( EntityType this_type = MBVERTEX; this_type < MBMAXTYPE; this_type++ )
 {
 int dummy = 0;
 result = get_number_entities_by_type( 0, this_type, dummy );
 if( result != MB_SUCCESS )
 {
 num_ent = 0;
 return result;
 }
 num_ent += dummy;
 }
 
 return MB_SUCCESS;
}

References ErrorCode, MB_CHK_ERR, MB_SUCCESS, MBMAXTYPE, MBVERTEX, and moab::MeshSetSequence::num_entities().

get_number_entities_by_type()

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

virtual

Retrieves all entities in the data base of given type.

returns the number of entities with a given type and tag

Parameters

type	EntityType of entities desired (ie, MBHEX, MBEDGE, MBTRI, etc )
entities	Range in which entities of EntityType type are returned.

Example:

EntityType type = MBTET;
Range entities;
get_entities_by_dimension( type, entities ); //get MBTET type EntityHandles in the database

Implements moab::Interface.

Definition at line 2064 of file Core.cpp.

{
 ErrorCode result = MB_SUCCESS;
 
 if( recursive && entity_type == MBENTITYSET ) // will never return anything
 return MB_TYPE_OUT_OF_RANGE;
 
 if( meshset )
 {
 const EntitySequence* seq;
 result = sequence_manager()->find( meshset, seq );MB_CHK_ERR( result );
 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
 result = mseq->num_type( sequence_manager(), meshset, entity_type, num_ent, recursive );MB_CHK_ERR( result );
 }
 else
 {
 num_ent = sequence_manager()->get_number_entities( entity_type );
 }
 
 return MB_SUCCESS;
}

References ErrorCode, MB_CHK_ERR, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MBENTITYSET, and moab::MeshSetSequence::num_type().

Referenced by gather_set_stats().

get_number_entities_by_type_and_tag()

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

virtual

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

Identical to get_entities_by_type_and_tag, except number instead of entities are returned

Parameters

meshset	Meshset whose entities are being queried (zero if query is for entire mesh).
type	Type of entities to be returned
tag_handles	Vector of tag handles entities must have
values	Vector of pointers to values of tags in tag_handles
num_tags	Number of tags and values in tag_handles and values
num_entities	Range in which number of entities are returned.
recursive	If true, meshsets containing meshsets are queried recursively. Returns the contents of meshsets, but not the meshsets themselves. Specifying both recursive=true and type=MBENTITYSET is an error, as it would always result in an empty list.

Implements moab::Interface.

Definition at line 2089 of file Core.cpp.

{
 Range dum_ents;
 ErrorCode result = get_entities_by_type_and_tag( meshset, entity_type, tag_handles, values, num_tags, dum_ents,
 condition, recursive );
 num_entities = dum_ents.size();
 return result;
}

References ErrorCode, and moab::Range::size().

Referenced by gather_tag_counts().

get_parent_meshsets() [1/2]

ErrorCode moab::Core::get_parent_meshsets ( const EntityHandle  meshset, Range &  parents, const int  num_hops = 1  ) const

virtual

get parent meshsets

Implements moab::Interface.

Definition at line 3422 of file Core.cpp.

{
 if( 0 == meshset ) return MB_ENTITY_NOT_FOUND;
 
 std::vector< EntityHandle > parent_vec;
 ErrorCode result = get_parent_meshsets( meshset, parent_vec, num_hops );MB_CHK_ERR( result );
 std::sort( parent_vec.begin(), parent_vec.end() );
 std::copy( parent_vec.rbegin(), parent_vec.rend(), range_inserter( parents ) );
 return MB_SUCCESS;
}

References ErrorCode, MB_CHK_ERR, MB_ENTITY_NOT_FOUND, and MB_SUCCESS.

get_parent_meshsets() [2/2]

ErrorCode moab::Core::get_parent_meshsets ( const EntityHandle  meshset, std::vector< EntityHandle > &  parents, const int  num_hops = 1  ) const

virtual

get parent meshsets

Implements moab::Interface.

Definition at line 3408 of file Core.cpp.

{
 if( 0 == meshset ) return MB_ENTITY_NOT_FOUND;
 
 const EntitySequence* seq;
 ErrorCode rval = sequence_manager()->find( meshset, seq );
 if( MB_SUCCESS != rval ) return MB_ENTITY_NOT_FOUND;
 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
 
 return mseq->get_parents( sequence_manager(), meshset, parents, num_hops );
}

References ErrorCode, moab::MeshSetSequence::get_parents(), MB_ENTITY_NOT_FOUND, and MB_SUCCESS.

Referenced by dot_children(), and moab::ReadUtil::gather_related_ents().

get_root_set()

EntityHandle moab::Core::get_root_set ( )

privatevirtual

return the entity set representing the whole mesh

Implements moab::Interface.

Definition at line 256 of file Core.cpp.

{
 return 0;
}

get_sequence_multiplier()

double moab::Core::get_sequence_multiplier ( ) const

virtual

Interface to control memory allocation for sequences Provide a factor that controls the size of the sequence that gets allocated. This is typically useful in the parallel setting when a-priori, the number of ghost entities and the memory required for them within the same sequence as the owned entities are unknown. The default factor is 1.0 but this can be appropriately updated at runtime so that we do not have broken sequences.

Implements moab::Interface.

Definition at line 1106 of file Core.cpp.

{
 return sequenceManager->get_sequence_multiplier();
}

get_set_iterators()

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

Get all set iterators associated with the set passed in.

Parameters

meshset	Meshset for which iterators are requested
set_iters	Set iterators for the set

Definition at line 3916 of file Core.cpp.

{
 for( std::vector< SetIterator* >::const_iterator vit = setIterators.begin(); vit != setIterators.end(); ++vit )
 if( ( *vit )->ent_set() == meshset ) set_iters.push_back( *vit );
 return MB_SUCCESS;
}

References MB_SUCCESS.

get_vertex_coordinates()

ErrorCode moab::Core::get_vertex_coordinates ( std::vector< double > &  coords ) const

virtual

get blocked vertex coordinates for all vertices

Blocked = all x, then all y, etc.

Implements moab::Interface.

Definition at line 801 of file Core.cpp.

{
 // INEFFICIENT implementation for now, until we get blocked tag access
 Range vertices;
 ErrorCode result = get_entities_by_type( 0, MBVERTEX, vertices );MB_CHK_ERR( result );
 
 // the least we can do is resize the vector and only go through the
 // vertex list once
 int num_verts = vertices.size();
 int vec_pos = 0;
 double xyz[3];
 coords.resize( geometricDimension * num_verts );
 for( Range::iterator it = vertices.begin(); it != vertices.end(); ++it )
 {
 result = get_coords( &( *it ), 1, xyz );MB_CHK_ERR( result );
 
 coords[vec_pos] = xyz[0];
 coords[num_verts + vec_pos] = xyz[1];
 coords[2 * num_verts + vec_pos] = xyz[2];
 
 vec_pos++;
 }
 
 return MB_SUCCESS;
}

References moab::Range::begin(), moab::Range::end(), ErrorCode, MB_CHK_ERR, MB_SUCCESS, MBVERTEX, and moab::Range::size().

get_vertices()

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

virtual

Get all vertices for input entities.

Special case of get_adjacencies where to_dimension == 0 and operation_type == Interface::UNION. \Note This is not a variation of get_connectivity because the behavior is different for polyhedra.

Definition at line 1721 of file Core.cpp.

{
 Range range;
 ErrorCode rval = get_connectivity( from_entities, range );MB_CHK_ERR( rval );
 
 // If input contained polyhedra, connectivity will contain faces.
 // Get vertices from faces.
 if( !range.all_of_dimension( 0 ) )
 {
 Range::iterator it = range.upper_bound( MBVERTEX );
 Range polygons;
 polygons.merge( it, range.end() );
 range.erase( it, range.end() );
 rval = get_connectivity( polygons, range );MB_CHK_ERR( rval );
 }
 
 if( vertices.empty() )
 vertices.swap( range );
 else
 vertices.merge( range );
 return MB_SUCCESS;
}

References moab::Range::all_of_dimension(), moab::Range::empty(), moab::Range::end(), moab::Range::erase(), ErrorCode, MB_CHK_ERR, MB_SUCCESS, MBVERTEX, moab::Range::merge(), moab::Range::swap(), and moab::Range::upper_bound().

globalId_tag()

Tag moab::Core::globalId_tag ( )

virtual

Get parent mesh sets of a mesh set.

If num_hops is 1, only immediate parents are returned. If num_hops is zero, all ancenstors are returned. Otherwise, num_hops specifies the maximum number of generations to traverse.

Parameters

meshset	The mesh set whose parents are being queried
parents	STL vector holding the parents returned by this function
num_hops	Number of generations to traverse (0 = all)

Implements moab::Interface.

Examples

ExtractLand.cpp, and copyPartition.cpp.

Definition at line 2622 of file Core.cpp.

{
 const int negone = -1;
 if( 0 == globalIdTag )
 tag_get_handle( GLOBAL_ID_TAG_NAME, 1, MB_TYPE_INTEGER, globalIdTag, MB_TAG_CREAT | MB_TAG_DENSE, &negone );
 return globalIdTag;
}

References GLOBAL_ID_TAG_NAME, MB_TAG_CREAT, MB_TAG_DENSE, and MB_TYPE_INTEGER.

Referenced by moab::WriteUtil::assign_ids(), create_coarse_mesh(), create_lagr_mesh(), IntxUtilsCSLAM::deep_copy_set(), and main().

handle_from_id()

ErrorCode moab::Core::handle_from_id ( const EntityType  type, const EntityID  id, EntityHandle &  handle  ) const

virtual

get a handle from an id and type

Implements moab::Interface.

Definition at line 389 of file Core.cpp.

{
 int err;
 handle = CREATE_HANDLE( entity_type, id, err );
 
 // check to see if handle exists
 const EntitySequence* dummy_seq = 0;
 ErrorCode error_code = sequence_manager()->find( handle, dummy_seq );
 return error_code;
}

References moab::CREATE_HANDLE(), and ErrorCode.

Referenced by moab::HalfFacetRep::fid_from_halfacet().

high_order_node()

ErrorCode moab::Core::high_order_node ( const EntityHandle  parent_handle, const EntityHandle *  subfacet_conn, const EntityType  subfacet_type, EntityHandle &  hon  ) const

virtual

given an entity and the connectivity and type of one of its subfacets, find the high order node on that subfacet, if any

Implements moab::Interface.

Definition at line 3134 of file Core.cpp.

{
 hon = 0;
 
 EntityType parent_type = TYPE_FROM_HANDLE( parent_handle );
 
 // get the parent's connectivity
 const EntityHandle* parent_conn = NULL;
 int num_parent_vertices = 0;
 ErrorCode result = get_connectivity( parent_handle, parent_conn, num_parent_vertices, false );MB_CHK_ERR( result );
 
 // find whether this entity has ho nodes
 int mid_nodes[4];
 CN::HasMidNodes( parent_type, num_parent_vertices, mid_nodes );
 
 // check whether this entity has mid nodes on this dimension subfacet;
 // use dimension-1 because vertices don't have mid nodes
 if( !mid_nodes[CN::Dimension( subfacet_type )] ) return MB_SUCCESS;
 
 // ok, we have mid nodes; now must compute expected index in connectivity array;
 // ho nodes stored for edges, faces then entity
 
 // offset starts with # corner vertices
 int offset = CN::VerticesPerEntity( parent_type );
 int i;
 
 for( i = 0; i < CN::Dimension( subfacet_type ) - 1; i++ )
 // for each dimension lower than that of the subfacet we're looking for,
 // if this entity has midnodes in that dimension, increment offset by #
 // of subfacets of that dimension; use dimension-1 in loop because
 // canon numbering table only has 2 positions, for edges and faces;
 if( mid_nodes[i + 1] ) offset += CN::mConnectivityMap[parent_type][i].num_sub_elements;
 
 // now add the index of this subfacet; only need to if it's not the highest dimension
 if( subfacet_type != parent_type )
 {
 
 // find indices into parent_conn for each entry in child_conn
 unsigned subfacet_size = CN::VerticesPerEntity( subfacet_type );
 int subfacet_indices[10];
 assert( subfacet_size <= sizeof( subfacet_indices ) / sizeof( subfacet_indices[0] ) );
 for( unsigned j = 0; j < subfacet_size; ++j )
 {
 subfacet_indices[j] =
 std::find( parent_conn, parent_conn + num_parent_vertices, subfacet_conn[j] ) - parent_conn;
 if( subfacet_indices[j] >= num_parent_vertices )
 {
 return MB_FAILURE;
 }
 }
 
 int dum, side_no, temp_offset;
 int temp_result =
 CN::SideNumber( parent_type, subfacet_indices, subfacet_size, subfacet_type, side_no, dum, temp_offset );
 if( temp_result != 0 ) return MB_FAILURE;
 
 offset += side_no;
 }
 
 // offset shouldn't be off the end of the connectivity vector
 if( offset >= num_parent_vertices ) return MB_INDEX_OUT_OF_RANGE;
 
 hon = parent_conn[offset];
 
 return MB_SUCCESS;
}

References moab::CN::Dimension(), moab::dum, ErrorCode, moab::CN::HasMidNodes(), MB_CHK_ERR, MB_INDEX_OUT_OF_RANGE, MB_SUCCESS, moab::CN::mConnectivityMap, moab::CN::ConnMap::num_sub_elements, moab::CN::SideNumber(), moab::TYPE_FROM_HANDLE(), and moab::CN::VerticesPerEntity().

id_from_handle()

EntityID moab::Core::id_from_handle ( const EntityHandle  handle ) const

virtual

get the id from a handle, returns id

Implements moab::Interface.

Definition at line 383 of file Core.cpp.

{
 return ID_FROM_HANDLE( handle );
}

References moab::ID_FROM_HANDLE().

Referenced by dot_down_link(), dot_nodes(), dot_write_node(), main(), and perform_laplacian_smoothing().

impl_version()

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

virtual

Returns the major.minor version number of the implementation.

Parameters

iface_name

If non-NULL, will be filled in with a string, possibly containing implementation-specific information

Implements moab::Interface.

Definition at line 366 of file Core.cpp.

{
 if( version_string ) *version_string = MOAB_VERSION_STRING;
 
 return MOAB_VERSION_MAJOR + MOAB_VERSION_MINOR / 100.0f;
}

References MOAB_VERSION_MAJOR, MOAB_VERSION_MINOR, and MOAB_VERSION_STRING.

initialize()

ErrorCode moab::Core::initialize ( )

private

database init and de-init routines

Definition at line 193 of file Core.cpp.

{
#ifdef MOAB_HAVE_MPI
 int flag;
 if( MPI_SUCCESS == MPI_Initialized( &flag ) )
 {
 if( flag )
 {
 writeMPELog = !MPE_Initialized_logging();
 if( writeMPELog ) (void)MPE_Init_log();
 }
 }
#endif
 
 initErrorHandlerInCore = false;
 if( !MBErrorHandler_Initialized() )
 {
 MBErrorHandler_Init();
 initErrorHandlerInCore = true;
 }
 
 geometricDimension = 3;
 materialTag = 0;
 neumannBCTag = 0;
 dirichletBCTag = 0;
 geomDimensionTag = 0;
 globalIdTag = 0;
 
 sequenceManager = new( std::nothrow ) SequenceManager;
 if( !sequenceManager ) return MB_MEMORY_ALLOCATION_FAILED;
 
 aEntityFactory = new( std::nothrow ) AEntityFactory( this );
 if( !aEntityFactory ) return MB_MEMORY_ALLOCATION_FAILED;
 
 mError = new( std::nothrow ) Error;
 if( !mError ) return MB_MEMORY_ALLOCATION_FAILED;
 
 mMBWriteUtil = NULL;
 mMBReadUtil = NULL;
 scdInterface = NULL;
 
 // Readers and writers try to get pointers to above utils.
 // Do this after pointers are initialized. (Pointers should
 // really be initialized in constructor to avoid this kind
 // of thing -- j.kraftcheck.)
 readerWriterSet = new( std::nothrow ) ReaderWriterSet( this );
 if( !readerWriterSet ) return MB_MEMORY_ALLOCATION_FAILED;
 
 material_tag();
 neumannBC_tag();
 dirichletBC_tag();
 geom_dimension_tag();
 globalId_tag();
 
#ifdef MOAB_HAVE_AHF
 ahfRep = new HalfFacetRep( this );
 if( !ahfRep ) return MB_MEMORY_ALLOCATION_FAILED;
 mesh_modified = false;
#endif
 
 return MB_SUCCESS;
}

References MB_MEMORY_ALLOCATION_FAILED, MB_SUCCESS, moab::MBErrorHandler_Init(), moab::MBErrorHandler_Initialized(), MPE_Init_log, and MPE_Initialized_logging.

intersect_meshset()

ErrorCode moab::Core::intersect_meshset ( EntityHandle  meshset1, const EntityHandle  meshset2  )

virtual

intersects meshset2 with meshset1 - modifies meshset1

Implements moab::Interface.

Definition at line 3325 of file Core.cpp.

{
 MeshSet* set1 = get_mesh_set( sequence_manager(), meshset1 );
 MeshSet* set2 = get_mesh_set( sequence_manager(), meshset2 );
 if( !set1 || !set2 ) return MB_ENTITY_NOT_FOUND;
 
 return set1->intersect( set2, meshset1, a_entity_factory() );
}

References moab::get_mesh_set(), moab::MeshSet::intersect(), and MB_ENTITY_NOT_FOUND.

is_valid()

bool moab::Core::is_valid

(

const EntityHandle

this_ent

)

const

return whether the input handle is valid or not

Definition at line 3863 of file Core.cpp.

{
 const EntitySequence* seq = 0;
 ErrorCode result = sequence_manager()->find( this_ent, seq );
 return seq != 0 && result == MB_SUCCESS;
}

References ErrorCode, and MB_SUCCESS.

Referenced by moab::RangeSetIterator::get_next_arr(), moab::VectorSetIterator::get_next_arr(), and moab::ScdBox::~ScdBox().

list_entities() [1/2]

ErrorCode moab::Core::list_entities ( const EntityHandle *  entities, const int  num_entities  ) const

virtual

List entities, or number of entities in database, to standard output.

Lists data pertaining to entities to standard output. If entities is NULL and num_entities is zero, lists only the number of entities of each type in the database. If entities is NULL and num_entities is non-zero, lists all information for all entities in the database.

Parameters

entities	1d vector of entities to list
num_entities	Number of entities in 1d vector

Implements moab::Interface.

Definition at line 2847 of file Core.cpp.

{
 Range temp_range;
 ErrorCode result = MB_SUCCESS;
 if( NULL == entities && num_entities == 0 )
 {
 // just list the numbers of each entity type
 int num_ents;
 std::cout << std::endl;
 std::cout << "Number of entities per type: " << std::endl;
 for( EntityType this_type = MBVERTEX; this_type < MBMAXTYPE; this_type++ )
 {
 result = get_number_entities_by_type( 0, this_type, num_ents );
 std::cout << CN::EntityTypeName( this_type ) << ": " << num_ents << std::endl;
 }
 std::cout << std::endl;
 
 return MB_SUCCESS;
 }
 else if( NULL == entities && num_entities < 0 )
 {
 
 // list all entities of all types
 std::cout << std::endl;
 for( EntityType this_type = MBVERTEX; this_type < MBMAXTYPE; this_type++ )
 {
 result = get_entities_by_type( 0, this_type, temp_range );
 }
 
 return list_entities( temp_range );
 }
 else if( NULL == entities && num_entities > 0 )
 {
 
 // list all entities of type == num_entities
 std::cout << std::endl;
 result = get_entities_by_type( 0, (EntityType)num_entities, temp_range );
 
 return list_entities( temp_range );
 }
 else
 {
 ErrorCode tmp_result;
 for( int i = 0; i < num_entities; i++ )
 {
 EntityType this_type = TYPE_FROM_HANDLE( entities[i] );
 std::cout << CN::EntityTypeName( this_type ) << " " << ID_FROM_HANDLE( entities[i] ) << ":" << endl;
 
 tmp_result = ( const_cast< Core* >( this ) )->list_entity( entities[i] );
 if( MB_SUCCESS != tmp_result ) result = tmp_result;
 }
 }
 
 return result;
}

References entities, moab::CN::EntityTypeName(), ErrorCode, moab::ID_FROM_HANDLE(), MB_SUCCESS, MBMAXTYPE, MBVERTEX, and moab::TYPE_FROM_HANDLE().

list_entities() [2/2]

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

virtual

List entities to standard output.

Lists all data pertaining to entities (i.e. vertex coordinates if vertices, connectivity if elements, set membership if set). Useful for debugging, but output can become quite long for large databases.

Implements moab::Interface.

Definition at line 2903 of file Core.cpp.

{
 ErrorCode result = MB_SUCCESS, tmp_result;
 
 for( Range::const_iterator rit = temp_range.begin(); rit != temp_range.end(); ++rit )
 {
 EntityType this_type = TYPE_FROM_HANDLE( *rit );
 std::cout << CN::EntityTypeName( this_type ) << " " << ID_FROM_HANDLE( *rit ) << ":" << endl;
 
 tmp_result = ( const_cast< Core* >( this ) )->list_entity( *rit );
 if( MB_SUCCESS != tmp_result ) result = tmp_result;
 }
 
 return result;
}

References moab::Range::begin(), moab::Range::end(), moab::CN::EntityTypeName(), ErrorCode, moab::ID_FROM_HANDLE(), MB_SUCCESS, and moab::TYPE_FROM_HANDLE().

Referenced by main().

list_entity()

ErrorCode moab::Core::list_entity ( const EntityHandle  entity ) const

virtual

List a single entity; no header printed.

Lists a single entity, including its connectivity and its adjacencies. No header is printed, because calling function might print information between header and information printed by this function.

Parameters

entity

The entity to be listed.

Implements moab::Interface.

Definition at line 2919 of file Core.cpp.

{
 ErrorCode result;
 HandleVec adj_vec;
 
 if( !is_valid( entity ) )
 {
 std::cout << "(invalid)" << std::endl;
 return MB_SUCCESS;
 }
 
 if( 0 != globalIdTag )
 {
 int dum;
 result = tag_get_data( globalIdTag, &entity, 1, &dum );
 if( MB_SUCCESS == result ) std::cout << "Global id = " << dum << std::endl;
 }
 
 // list entity
 EntityType this_type = TYPE_FROM_HANDLE( entity );
 if( this_type == MBVERTEX )
 {
 double coords[3];
 result = get_coords( &( entity ), 1, coords );MB_CHK_ERR( result );
 std::cout << "Coordinates: (" << coords[0] << ", " << coords[1] << ", " << coords[2] << ")" << std::endl;
 }
 else if( this_type == MBENTITYSET )
 this->print( entity, "" );
 
 std::cout << " Adjacencies:" << std::endl;
 bool some = false;
 int multiple = 0;
 for( int dim = 0; dim <= 3; dim++ )
 {
 if( dim == CN::Dimension( this_type ) ) continue;
 adj_vec.clear();
 // use const_cast here 'cuz we're in a const function and we're passing 'false' for
 // create_if_missing, so we know we won't change anything
 result = ( const_cast< Core* >( this ) )->get_adjacencies( &( entity ), 1, dim, false, adj_vec );
 if( MB_FAILURE == result ) continue;
 for( HandleVec::iterator adj_it = adj_vec.begin(); adj_it != adj_vec.end(); ++adj_it )
 {
 if( adj_it != adj_vec.begin() )
 std::cout << ", ";
 else
 std::cout << " ";
 std::cout << CN::EntityTypeName( TYPE_FROM_HANDLE( *adj_it ) ) << " " << ID_FROM_HANDLE( *adj_it );
 }
 if( !adj_vec.empty() )
 {
 std::cout << std::endl;
 some = true;
 }
 if( MB_MULTIPLE_ENTITIES_FOUND == result ) multiple += dim;
 }
 if( !some ) std::cout << "(none)" << std::endl;
 const EntityHandle* explicit_adjs;
 int num_exp;
 aEntityFactory->get_adjacencies( entity, explicit_adjs, num_exp );
 if( NULL != explicit_adjs && 0 != num_exp )
 {
 std::cout << " Explicit adjacencies: ";
 for( int i = 0; i < num_exp; i++ )
 {
 if( i != 0 ) std::cout << ", ";
 std::cout << CN::EntityTypeName( TYPE_FROM_HANDLE( explicit_adjs[i] ) ) << " "
 << ID_FROM_HANDLE( explicit_adjs[i] );
 }
 std::cout << std::endl;
 }
 if( multiple != 0 ) std::cout << " (MULTIPLE = " << multiple << ")" << std::endl;
 
 result = print_entity_tags( std::string(), entity, MB_TAG_DENSE );
 
 std::cout << std::endl;
 
 return result;
}

References dim, moab::CN::Dimension(), moab::dum, moab::CN::EntityTypeName(), ErrorCode, moab::ID_FROM_HANDLE(), MB_CHK_ERR, MB_MULTIPLE_ENTITIES_FOUND, MB_SUCCESS, MB_TAG_DENSE, MBENTITYSET, MBVERTEX, and moab::TYPE_FROM_HANDLE().

load_file()

ErrorCode moab::Core::load_file ( const char *  file_name, const EntityHandle *  file_set = 0, const char *  options = 0, const char *  set_tag_name = 0, const int *  set_tag_vals = 0, int  num_set_tag_vals = 0  )

virtual

Load or import a file.

Implements moab::Interface.

Examples

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

Definition at line 416 of file Core.cpp.

{
 FileOptions opts( setoptions );
 ErrorCode rval;
 ReaderIface::IDTag t = { set_tag_name, set_tag_vals, num_set_tag_vals };
 ReaderIface::SubsetList sl = { &t, 1, 0, 0 };
 
 assert( !file_set || ( *file_set && is_valid( *file_set ) ) );
 if( file_set && !*file_set )
 {
 MB_SET_GLB_ERR( MB_FAILURE, "Non-NULL file set pointer should point to non-NULL set" );
 }
 
 // if reading in parallel, call a different reader
 std::string parallel_opt;
 rval = opts.get_option( "PARALLEL", parallel_opt );
 if( MB_SUCCESS == rval )
 {
#ifdef MOAB_HAVE_MPI
 ParallelComm* pcomm = 0;
 int pcomm_id;
 rval = opts.get_int_option( "PARALLEL_COMM", pcomm_id );
 if( MB_ENTITY_NOT_FOUND == rval ) rval = opts.get_int_option( "PCOMM", pcomm_id );
 if( rval == MB_SUCCESS )
 {
 pcomm = ParallelComm::get_pcomm( this, pcomm_id );
 if( !pcomm ) return MB_ENTITY_NOT_FOUND;
 }
 else if( rval != MB_ENTITY_NOT_FOUND )
 return rval;
 if( set_tag_name && num_set_tag_vals )
 {
 rval = ReadParallel( this, pcomm ).load_file( file_name, file_set, opts, &sl );MB_CHK_ERR( rval );
 }
 else
 {
 rval = ReadParallel( this, pcomm ).load_file( file_name, file_set, opts );MB_CHK_ERR( rval );
 }
#else
 MB_SET_GLB_ERR( MB_FAILURE, "PARALLEL option not valid, this instance compiled for serial execution" );
#endif
 }
 else
 {
 if( set_tag_name && num_set_tag_vals )
 {
 rval = serial_load_file( file_name, file_set, opts, &sl );MB_CHK_ERR( rval );
 }
 else
 {
 rval = serial_load_file( file_name, file_set, opts );MB_CHK_ERR( rval );
 }
 }
 
 if( MB_SUCCESS == rval && !opts.all_seen() )
 {
 std::string bad_opt;
 if( MB_SUCCESS == opts.get_unseen_option( bad_opt ) )
 {
 MB_SET_ERR( MB_UNHANDLED_OPTION, "Unrecognized option: \"" << bad_opt << "\"" );
 }
 else
 {
 MB_SET_ERR( MB_UNHANDLED_OPTION, "Unrecognized option" );
 }
 }
 
 return MB_SUCCESS;
}

References moab::FileOptions::all_seen(), ErrorCode, moab::FileOptions::get_int_option(), moab::FileOptions::get_option(), moab::ParallelComm::get_pcomm(), moab::FileOptions::get_unseen_option(), moab::ReadParallel::load_file(), MB_CHK_ERR, MB_ENTITY_NOT_FOUND, MB_SET_ERR, MB_SET_GLB_ERR, MB_SUCCESS, MB_UNHANDLED_OPTION, and t.

Referenced by RuntimeContext::load_file(), main(), test_intx_in_parallel_elem_based(), TestErrorHandling_1(), TestErrorHandling_2(), TestErrorHandling_3(), TestErrorHandlingPar_1(), and TestErrorHandlingPar_2().

load_mesh()

ErrorCode moab::Core::load_mesh ( const char *  file_name, const int *  active_block_id_list = NULL, const int  num_blocks = 0  )

virtual

load mesh from data in file NOTE: if there is mesh already present, the new mesh will be added

Implements moab::Interface.

Definition at line 410 of file Core.cpp.

{
 const char* name = block_id_list ? MATERIAL_SET_TAG_NAME : 0;
 return load_file( file_name, 0, 0, name, block_id_list, num_blocks );
}

References MATERIAL_SET_TAG_NAME.

Referenced by main(), test_spectral_hex(), and test_spectral_quad().

material_tag()

Tag moab::Core::material_tag

(

)

return various specific tag handles

Definition at line 2597 of file Core.cpp.

{
 const int negone = -1;
 if( 0 == materialTag )
 tag_get_handle( MATERIAL_SET_TAG_NAME, 1, MB_TYPE_INTEGER, materialTag, MB_TAG_CREAT | MB_TAG_SPARSE, &negone );
 return materialTag;
}

References MATERIAL_SET_TAG_NAME, MB_TAG_CREAT, MB_TAG_SPARSE, and MB_TYPE_INTEGER.

merge_entities()

ErrorCode moab::Core::merge_entities ( EntityHandle  entity_to_keep, EntityHandle  entity_to_remove, bool  auto_merge, bool  delete_removed_entity  )

virtual

merges two entities

Implements moab::Interface.

Definition at line 2690 of file Core.cpp.

{
 if( auto_merge ) return MB_FAILURE;
 
 // The two entities to merge must not be the same entity.
 if( entity_to_keep == entity_to_remove ) return MB_FAILURE;
 
 // The two entities to merge must be of the same type
 EntityType type_to_keep = TYPE_FROM_HANDLE( entity_to_keep );
 
 if( type_to_keep != TYPE_FROM_HANDLE( entity_to_remove ) ) return MB_TYPE_OUT_OF_RANGE;
 
 // Make sure both entities exist before trying to merge.
 EntitySequence* seq = 0;
 ErrorCode result, status;
 status = sequence_manager()->find( entity_to_keep, seq );
 if( seq == 0 || status != MB_SUCCESS ) return MB_ENTITY_NOT_FOUND;
 status = sequence_manager()->find( entity_to_remove, seq );
 if( seq == 0 || status != MB_SUCCESS ) return MB_ENTITY_NOT_FOUND;
 
 // If auto_merge is not set, all sub-entities should
 // be merged if the entities are to be merged.
 int ent_dim = CN::Dimension( type_to_keep );
 if( ent_dim > 0 )
 {
 std::vector< EntityHandle > conn, conn2;
 
 result = get_connectivity( &entity_to_keep, 1, conn );MB_CHK_ERR( result );
 result = get_connectivity( &entity_to_remove, 1, conn2 );MB_CHK_ERR( result );
 
 // Check to see if we can merge before pulling adjacencies.
 int dum1, dum2;
 if( !auto_merge &&
 ( conn.size() != conn2.size() || !CN::ConnectivityMatch( &conn[0], &conn2[0], conn.size(), dum1, dum2 ) ) )
 return MB_FAILURE;
 }
 
 result = aEntityFactory->merge_adjust_adjacencies( entity_to_keep, entity_to_remove );
 
 if( MB_SUCCESS == result && delete_removed_entity ) result = delete_entities( &entity_to_remove, 1 );
 
 return result;
}

References moab::CN::ConnectivityMatch(), moab::CN::Dimension(), ErrorCode, MB_CHK_ERR, MB_ENTITY_NOT_FOUND, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, and moab::TYPE_FROM_HANDLE().

neumannBC_tag()

Tag moab::Core::neumannBC_tag

(

)

Definition at line 2605 of file Core.cpp.

{
 const int negone = -1;
 if( 0 == neumannBCTag )
 tag_get_handle( NEUMANN_SET_TAG_NAME, 1, MB_TYPE_INTEGER, neumannBCTag, MB_TAG_CREAT | MB_TAG_SPARSE, &negone );
 return neumannBCTag;
}

References MB_TAG_CREAT, MB_TAG_SPARSE, MB_TYPE_INTEGER, and NEUMANN_SET_TAG_NAME.

num_child_meshsets()

ErrorCode moab::Core::num_child_meshsets ( const EntityHandle  meshset, int *  number, const int  num_hops = 1  ) const

virtual

gets number of child meshsets

Implements moab::Interface.

Definition at line 3501 of file Core.cpp.

{
 if( 0 == meshset ) return MB_ENTITY_NOT_FOUND;
 
 const EntitySequence* seq;
 ErrorCode rval = sequence_manager()->find( meshset, seq );
 if( MB_SUCCESS != rval ) return MB_ENTITY_NOT_FOUND;
 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
 
 return mseq->num_children( sequence_manager(), meshset, *number, num_hops );
}

References ErrorCode, MB_ENTITY_NOT_FOUND, MB_SUCCESS, and moab::MeshSetSequence::num_children().

num_contained_meshsets()

ErrorCode moab::Core::num_contained_meshsets ( const EntityHandle  meshset, int *  number, const int  num_hops = 1  ) const

virtual

gets number of contained meshsets

Implements moab::Interface.

Definition at line 3513 of file Core.cpp.

{
 if( 0 == meshset )
 {
 return get_number_entities_by_type( 0, MBENTITYSET, *number );
 }
 
 const EntitySequence* seq;
 ErrorCode rval = sequence_manager()->find( meshset, seq );
 if( MB_SUCCESS != rval ) return MB_ENTITY_NOT_FOUND;
 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
 
 return mseq->num_contained_sets( sequence_manager(), meshset, *number, num_hops );
}

References ErrorCode, MB_ENTITY_NOT_FOUND, MB_SUCCESS, MBENTITYSET, and moab::MeshSetSequence::num_contained_sets().

num_parent_meshsets()

ErrorCode moab::Core::num_parent_meshsets ( const EntityHandle  meshset, int *  number, const int  num_hops = 1  ) const

virtual

gets number of parent meshsets

Implements moab::Interface.

Definition at line 3489 of file Core.cpp.

{
 if( 0 == meshset ) return MB_ENTITY_NOT_FOUND;
 
 const EntitySequence* seq;
 ErrorCode rval = sequence_manager()->find( meshset, seq );
 if( MB_SUCCESS != rval ) return MB_ENTITY_NOT_FOUND;
 const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
 
 return mseq->num_parents( sequence_manager(), meshset, *number, num_hops );
}

References ErrorCode, MB_ENTITY_NOT_FOUND, MB_SUCCESS, and moab::MeshSetSequence::num_parents().

operator=()

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

private

Do not allow copying.

print()

void moab::Core::print	(	const EntityHandle	handle,
		const char *	prefix,
		bool	first_call = true
	)		const

Definition at line 3623 of file Core.cpp.

{
 // get the entities
 Range entities;
 
 if( 0 != ms_handle )
 {
 get_entities_by_handle( ms_handle, entities );
 std::cout << prefix << "MBENTITYSET " << ID_FROM_HANDLE( ms_handle ) << std::endl;
 }
 else
 {
 get_entities_by_dimension( 0, 3, entities );
 if( entities.empty() ) get_entities_by_dimension( 0, 2, entities );
 if( entities.empty() ) get_entities_by_dimension( 0, 1, entities );
 get_entities_by_dimension( 0, 0, entities );
 get_entities_by_type( 0, MBENTITYSET, entities );
 std::cout << prefix << "--: " << std::endl;
 }
 
 std::string indent_prefix = prefix;
 indent_prefix += " ";
 entities.print( indent_prefix.c_str() );
 
 if( !first_call || !ms_handle ) return;
 
 // print parent/children
 Range temp;
 this->get_parent_meshsets( ms_handle, temp );
 std::cout << " Parent sets: ";
 if( temp.empty() )
 std::cout << "(none)" << std::endl;
 else
 {
 for( Range::iterator rit = temp.begin(); rit != temp.end(); ++rit )
 {
 if( rit != temp.begin() ) std::cout << ", ";
 std::cout << ID_FROM_HANDLE( *rit );
 }
 std::cout << std::endl;
 }
 
 temp.clear();
 this->get_child_meshsets( ms_handle, temp );
 std::cout << " Child sets: ";
 if( temp.empty() )
 std::cout << "(none)" << std::endl;
 else
 {
 for( Range::iterator rit = temp.begin(); rit != temp.end(); ++rit )
 {
 if( rit != temp.begin() ) std::cout << ", ";
 std::cout << ID_FROM_HANDLE( *rit );
 }
 std::cout << std::endl;
 }
 
 // print all sparse tags
 print_entity_tags( indent_prefix, ms_handle, MB_TAG_SPARSE );
}

References moab::Range::begin(), moab::Range::clear(), moab::Range::empty(), moab::Range::end(), entities, moab::ID_FROM_HANDLE(), MB_TAG_SPARSE, and MBENTITYSET.

print_database()

void moab::Core::print_database

(

)

const

Definition at line 4129 of file Core.cpp.

{
 ErrorCode rval;
 TypeSequenceManager::const_iterator i;
 const TypeSequenceManager& verts = sequence_manager()->entity_map( MBVERTEX );
 if( !verts.empty() )
 printf( " Vertex ID X Y Z Adjacencies \n"
 " ---------- -------- -------- -------- -----------...\n" );
 const EntityHandle* adj;
 int nadj;
 for( i = verts.begin(); i != verts.end(); ++i )
 {
 const VertexSequence* seq = static_cast< const VertexSequence* >( *i );
 printf( "(Sequence [%d,%d] in SequenceData [%d,%d])\n", (int)ID_FROM_HANDLE( seq->start_handle() ),
 (int)ID_FROM_HANDLE( seq->end_handle() ), (int)ID_FROM_HANDLE( seq->data()->start_handle() ),
 (int)ID_FROM_HANDLE( seq->data()->end_handle() ) );
 
 double c[3];
 for( EntityHandle h = seq->start_handle(); h <= seq->end_handle(); ++h )
 {
 rval = seq->get_coordinates( h, c );
 if( MB_SUCCESS == rval )
 printf( " %10d %8g %8g %8g", (int)ID_FROM_HANDLE( h ), c[0], c[1], c[2] );
 else
 printf( " %10d < ERROR %4d >", (int)ID_FROM_HANDLE( h ), (int)rval );
 
 rval = a_entity_factory()->get_adjacencies( h, adj, nadj );
 if( MB_SUCCESS != rval )
 {
 printf( " <ERROR %d>\n", (int)rval );
 continue;
 }
 EntityType pt = MBMAXTYPE;
 for( int j = 0; j < nadj; ++j )
 {
 if( TYPE_FROM_HANDLE( adj[j] ) != pt )
 {
 pt = TYPE_FROM_HANDLE( adj[j] );
 printf( " %s", pt >= MBMAXTYPE ? "INVALID TYPE" : CN::EntityTypeName( pt ) );
 }
 printf( " %d", (int)ID_FROM_HANDLE( adj[j] ) );
 }
 printf( "\n" );
 }
 }
 
 for( EntityType t = MBEDGE; t < MBENTITYSET; ++t )
 {
 const TypeSequenceManager& elems = sequence_manager()->entity_map( t );
 if( elems.empty() ) continue;
 
 int clen = 0;
 for( i = elems.begin(); i != elems.end(); ++i )
 {
 int n = static_cast< const ElementSequence* >( *i )->nodes_per_element();
 if( n > clen ) clen = n;
 }
 
 clen *= 5;
 if( clen < (int)strlen( "Connectivity" ) ) clen = strlen( "Connectivity" );
 std::vector< char > dashes( clen, '-' );
 dashes.push_back( '\0' );
 printf( " %7s ID %-*s Adjacencies\n", CN::EntityTypeName( t ), clen, "Connectivity" );
 printf( " ---------- %s -----------...\n", &dashes[0] );
 
 std::vector< EntityHandle > storage;
 const EntityHandle* conn;
 int nconn;
 for( i = elems.begin(); i != elems.end(); ++i )
 {
 const ElementSequence* seq = static_cast< const ElementSequence* >( *i );
 printf( "(Sequence [%d,%d] in SequenceData [%d,%d])\n", (int)ID_FROM_HANDLE( seq->start_handle() ),
 (int)ID_FROM_HANDLE( seq->end_handle() ), (int)ID_FROM_HANDLE( seq->data()->start_handle() ),
 (int)ID_FROM_HANDLE( seq->data()->end_handle() ) );
 
 for( EntityHandle h = seq->start_handle(); h <= seq->end_handle(); ++h )
 {
 printf( " %10d", (int)ID_FROM_HANDLE( h ) );
 rval = get_connectivity( h, conn, nconn, false, &storage );
 if( MB_SUCCESS != rval )
 printf( " <ERROR %2d>%*s", (int)rval, clen - 10, "" );
 else
 {
 for( int j = 0; j < nconn; ++j )
 printf( " %4d", (int)ID_FROM_HANDLE( conn[j] ) );
 printf( "%*s", clen - 5 * nconn, "" );
 }
 
 rval = a_entity_factory()->get_adjacencies( h, adj, nadj );
 if( MB_SUCCESS != rval )
 {
 printf( " <ERROR %d>\n", (int)rval );
 continue;
 }
 EntityType pt = MBMAXTYPE;
 for( int j = 0; j < nadj; ++j )
 {
 if( TYPE_FROM_HANDLE( adj[j] ) != pt )
 {
 pt = TYPE_FROM_HANDLE( adj[j] );
 printf( " %s", pt >= MBMAXTYPE ? "INVALID TYPE" : CN::EntityTypeName( pt ) );
 }
 printf( " %d", (int)ID_FROM_HANDLE( adj[j] ) );
 }
 printf( "\n" );
 }
 }
 }
}

References moab::TypeSequenceManager::begin(), dashes(), moab::EntitySequence::data(), moab::TypeSequenceManager::empty(), moab::TypeSequenceManager::end(), moab::EntitySequence::end_handle(), moab::SequenceData::end_handle(), moab::CN::EntityTypeName(), ErrorCode, moab::VertexSequence::get_coordinates(), moab::ID_FROM_HANDLE(), MB_SUCCESS, MBEDGE, MBENTITYSET, MBMAXTYPE, MBVERTEX, moab::ElementSequence::nodes_per_element(), moab::EntitySequence::start_handle(), moab::SequenceData::start_handle(), t, and moab::TYPE_FROM_HANDLE().

print_entity_tags()

ErrorCode moab::Core::print_entity_tags	(	std::string	indent_prefix,
		const EntityHandle	handle,
		TagType	tp
	)		const

Definition at line 3684 of file Core.cpp.

{
 std::vector< Tag > set_tags;
 ErrorCode result = this->tag_get_tags_on_entity( handle, set_tags );
 std::cout << indent_prefix << ( tp == MB_TAG_SPARSE ? "Sparse tags:" : "Dense tags:" ) << std::endl;
 indent_prefix += " ";
 
 for( std::vector< Tag >::iterator vit = set_tags.begin(); vit != set_tags.end(); ++vit )
 {
 TagType this_type;
 result = this->tag_get_type( *vit, this_type );
 if( MB_SUCCESS != result || tp != this_type ) continue;
 DataType this_data_type;
 result = this->tag_get_data_type( *vit, this_data_type );
 if( MB_SUCCESS != result ) continue;
 int this_size;
 result = this->tag_get_length( *vit, this_size );
 if( MB_SUCCESS != result ) continue;
 // use double since this is largest single-valued tag
 std::vector< double > dbl_vals( this_size );
 std::vector< int > int_vals( this_size );
 std::vector< EntityHandle > hdl_vals( this_size );
 std::string tag_name;
 result = this->tag_get_name( *vit, tag_name );
 if( MB_SUCCESS != result ) continue;
 switch( this_data_type )
 {
 case MB_TYPE_INTEGER:
 result = this->tag_get_data( *vit, &handle, 1, &int_vals[0] );
 if( MB_SUCCESS != result ) continue;
 std::cout << indent_prefix << tag_name << " = ";
 if( this_size < 10 )
 for( int i = 0; i < this_size; i++ )
 std::cout << int_vals[i] << " ";
 else
 std::cout << int_vals[0] << "... (mult values)";
 std::cout << std::endl;
 break;
 case MB_TYPE_DOUBLE:
 result = this->tag_get_data( *vit, &handle, 1, &dbl_vals[0] );
 if( MB_SUCCESS != result ) continue;
 std::cout << indent_prefix << tag_name << " = ";
 if( this_size < 10 )
 for( int i = 0; i < this_size; i++ )
 std::cout << dbl_vals[i] << " ";
 else
 std::cout << dbl_vals[0] << "... (mult values)";
 std::cout << std::endl;
 break;
 case MB_TYPE_HANDLE:
 result = this->tag_get_data( *vit, &handle, 1, &hdl_vals[0] );
 if( MB_SUCCESS != result ) continue;
 std::cout << indent_prefix << tag_name << " = ";
 if( this_size < 10 )
 for( int i = 0; i < this_size; i++ )
 std::cout << hdl_vals[i] << " ";
 else
 std::cout << hdl_vals[0] << "... (mult values)";
 std::cout << std::endl;
 break;
 case MB_TYPE_OPAQUE:
 if( NAME_TAG_SIZE == this_size )
 {
 char dum_tag[NAME_TAG_SIZE];
 result = this->tag_get_data( *vit, &handle, 1, &dum_tag );
 if( MB_SUCCESS != result ) continue;
 // insert NULL just in case there isn't one
 dum_tag[NAME_TAG_SIZE - 1] = '\0';
 std::cout << indent_prefix << tag_name << " = " << dum_tag << std::endl;
 }
 break;
 case MB_TYPE_BIT:
 break;
 }
 }
 
 return MB_SUCCESS;
}

References ErrorCode, MB_SUCCESS, MB_TAG_SPARSE, MB_TYPE_BIT, MB_TYPE_DOUBLE, MB_TYPE_HANDLE, MB_TYPE_INTEGER, MB_TYPE_OPAQUE, NAME_TAG_SIZE, and TagType.

query_interface_type()

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

virtual

Get a pointer to an internal MOAB interface.

Returns

NULL if not found, iterface pointer otherwise

Implements moab::Interface.

Definition at line 306 of file Core.cpp.

{
 if( interface_type == typeid( ReadUtilIface ) )
 {
 if( !mMBReadUtil ) mMBReadUtil = new ReadUtil( this, mError );
 ptr = static_cast< ReadUtilIface* >( mMBReadUtil );
 }
 else if( interface_type == typeid( WriteUtilIface ) )
 {
 if( !mMBWriteUtil ) mMBWriteUtil = new WriteUtil( this );
 ptr = static_cast< WriteUtilIface* >( mMBWriteUtil );
 }
 else if( interface_type == typeid( ReaderWriterSet ) )
 {
 ptr = reader_writer_set();
 }
 else if( interface_type == typeid( Error ) )
 {
 ptr = mError;
 }
 else if( interface_type == typeid( ExoIIInterface ) )
 {
 ptr = static_cast< ExoIIInterface* >( new ExoIIUtil( this ) );
 }
 else if( interface_type == typeid( ScdInterface ) )
 {
 if( !scdInterface ) scdInterface = new ScdInterface( this );
 ptr = scdInterface;
 }
 else
 {
 ptr = 0;
 return MB_FAILURE;
 }
 return MB_SUCCESS;
}

References MB_SUCCESS.

QueryInterface()

int moab::Core::QueryInterface ( const MBuuid &  uuid, UnknownInterface **  iface  )

virtual

Implements moab::UnknownInterface.

Definition at line 355 of file Core.cpp.

{
 *iface = 0;
 if( uuid == IDD_MBUnknown ) *iface = this;
 if( uuid == IDD_MBCore )
 *iface = this;
 else
 return 0;
 return 1;
}

References moab::IDD_MBCore, moab::IDD_MBUnknown, and iface.

Referenced by moab::ComponentFactory::QueryInterface().

reader_writer_set()

ReaderWriterSet* moab::Core::reader_writer_set ( )

inline

return set of registered IO tools

Definition at line 1090 of file Core.hpp.

 {
 return readerWriterSet;
 }

References readerWriterSet.

release_interface_type()

ErrorCode moab::Core::release_interface_type ( const std::type_info &  interface_type, void *  iface  )

virtual

Release reference to MB interface.

Implements moab::Interface.

Definition at line 343 of file Core.cpp.

{
 if( interface_type == typeid( ExoIIInterface ) )
 delete static_cast< ExoIIInterface* >( iface );
 else if( interface_type != typeid( ReadUtilIface ) && interface_type != typeid( WriteUtilIface ) &&
 interface_type != typeid( ReaderWriterSet ) && interface_type != typeid( Error ) &&
 interface_type != typeid( ScdInterface ) )
 return MB_FAILURE;
 
 return MB_SUCCESS;
}

References iface, and MB_SUCCESS.

remove_child_meshset()

ErrorCode moab::Core::remove_child_meshset ( EntityHandle  meshset, const EntityHandle  child_meshset  )

virtual

remove child meshset

Implements moab::Interface.

Definition at line 3604 of file Core.cpp.

{
 MeshSet* set_ptr = get_mesh_set( sequence_manager(), meshset );
 if( !set_ptr ) return MB_ENTITY_NOT_FOUND;
 set_ptr->remove_child( child_meshset );
 return MB_SUCCESS;
}

References moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, MB_SUCCESS, and moab::MeshSet::remove_child().

remove_entities() [1/2]

ErrorCode moab::Core::remove_entities ( EntityHandle  meshset, const EntityHandle *  entities, const int  num_entities  )

virtual

remove entities from meshset

remove a vector of entities from a meshset

Implements moab::Interface.

Definition at line 3372 of file Core.cpp.

{
 MeshSet* set = get_mesh_set( sequence_manager(), meshset );
 if( set )
 return set->remove_entities( entities, num_entities, meshset, a_entity_factory() );
 else
 return MB_ENTITY_NOT_FOUND;
}

References entities, moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and moab::MeshSet::remove_entities().

remove_entities() [2/2]

ErrorCode moab::Core::remove_entities ( EntityHandle  meshset, const Range &  entities  )

virtual

remove entities from meshset

remove a range of entities from a meshset

Implements moab::Interface.

Definition at line 3362 of file Core.cpp.

{
 MeshSet* set = get_mesh_set( sequence_manager(), meshset );
 if( set )
 return set->remove_entities( entities, meshset, a_entity_factory() );
 else
 return MB_ENTITY_NOT_FOUND;
}

References entities, moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and moab::MeshSet::remove_entities().

Referenced by main(), moab::AEntityFactory::remove_adjacency(), moab::ReorderTool::update_set_contents(), and moab::NestedRefine::update_special_tags().

remove_parent_child()

ErrorCode moab::Core::remove_parent_child ( EntityHandle  parent, EntityHandle  child  )

virtual

removes 'parent' to child's parent list and removes 'child' to parent's child list

Implements moab::Interface.

Definition at line 3585 of file Core.cpp.

{
 MeshSet* parent_ptr = get_mesh_set( sequence_manager(), parent );
 MeshSet* child_ptr = get_mesh_set( sequence_manager(), child );
 if( !parent_ptr || !child_ptr ) return MB_ENTITY_NOT_FOUND;
 
 parent_ptr->remove_child( child );
 child_ptr->remove_parent( parent );
 return MB_SUCCESS;
}

References child, moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, MB_SUCCESS, moab::MeshSet::remove_child(), and moab::MeshSet::remove_parent().

remove_parent_meshset()

ErrorCode moab::Core::remove_parent_meshset ( EntityHandle  meshset, const EntityHandle  parent_meshset  )

virtual

remove parent meshset

Implements moab::Interface.

Definition at line 3596 of file Core.cpp.

{
 MeshSet* set_ptr = get_mesh_set( sequence_manager(), meshset );
 if( !set_ptr ) return MB_ENTITY_NOT_FOUND;
 set_ptr->remove_parent( parent_meshset );
 return MB_SUCCESS;
}

References moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, MB_SUCCESS, and moab::MeshSet::remove_parent().

remove_set_iterator()

ErrorCode moab::Core::remove_set_iterator

(

SetIterator *

set_iter

)

Remove the set iterator from the instance's list.

Remove the set iterator from the instance's list This function is called from the SetIterator destructor, and should not be called directly from anywhere else.

Parameters

set_iter

Set iterator being removed

Definition at line 3899 of file Core.cpp.

{
 std::vector< SetIterator* >::iterator vit = std::find( setIterators.begin(), setIterators.end(), set_iter );
 if( vit == setIterators.end() )
 {
 MB_SET_ERR( MB_FAILURE, "Didn't find that iterator" );
 }
 
 setIterators.erase( vit );
 
 return MB_SUCCESS;
}

References MB_SET_ERR, and MB_SUCCESS.

Referenced by moab::SetIterator::~SetIterator().

replace_entities()

ErrorCode moab::Core::replace_entities ( EntityHandle  meshset, const EntityHandle *  old_entities, const EntityHandle *  new_entities, int  num_entities  )

virtual

replace entities

Implements moab::Interface.

Definition at line 3396 of file Core.cpp.

{
 MeshSet* set = get_mesh_set( sequence_manager(), meshset );
 if( set )
 return set->replace_entities( meshset, old_entities, new_entities, num_entities, a_entity_factory() );
 else
 return MB_ENTITY_NOT_FOUND;
}

References moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and moab::MeshSet::replace_entities().

Referenced by moab::AEntityFactory::merge_adjust_adjacencies().

sequence_manager() [1/2]

SequenceManager* moab::Core::sequence_manager ( )

inline

get/set the number of nodes

get/set the number of elements return a reference to the sequence manager

Definition at line 1039 of file Core.hpp.

 {
 return sequenceManager;
 }

References sequenceManager.

Referenced by moab::HigherOrderFactory::add_mid_edge_nodes(), moab::HigherOrderFactory::add_mid_face_nodes(), moab::HigherOrderFactory::add_mid_volume_nodes(), moab::ScdInterface::construct_box(), moab::HigherOrderFactory::convert(), moab::HigherOrderFactory::convert_sequence(), moab::ReadUtil::create_entity_sets(), moab::ScdInterface::create_scd_sequence(), moab::WriteUtil::gather_nodes_from_elements(), moab::AEntityFactory::get_adjacency_ptr(), moab::ReadUtil::get_element_connect(), moab::WriteUtil::get_element_connect(), moab::ReorderTool::get_entities(), moab::WriteUtil::get_entity_list_pointers(), moab::AEntityFactory::get_memory_use(), moab::ReadUtil::get_node_coords(), moab::WriteUtil::get_node_coords(), moab::ReorderTool::handle_order_from_int_tag(), moab::ParallelComm::initialize(), moab::ReorderTool::reorder_entities(), moab::AEntityFactory::set_adjacency_ptr(), and moab::AEntityFactory::~AEntityFactory().

sequence_manager() [2/2]

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

inline

Definition at line 1043 of file Core.hpp.

 {
 return sequenceManager;
 }

References sequenceManager.

serial_load_file()

ErrorCode moab::Core::serial_load_file	(	const char *	file_name,
		const EntityHandle *	file_set,
		const FileOptions &	opts,
		const ReaderIface::SubsetList *	subsets = 0,
		const Tag *	file_id_tag = 0
	)

Load or import a file.

Definition at line 511 of file Core.cpp.

{
 int status;
#if defined( WIN32 ) || defined( WIN64 ) || defined( MSC_VER )
 struct _stat stat_data;
 status = _stat( file_name, &stat_data );
#else
 struct stat stat_data;
 status = stat( file_name, &stat_data );
#endif
 if( status )
 {
 MB_SET_GLB_ERR( MB_FILE_DOES_NOT_EXIST, file_name << ": " << strerror( errno ) );
 }
#if defined( WIN32 ) || defined( WIN64 ) || defined( MSC_VER )
 else if( stat_data.st_mode & _S_IFDIR )
 {
#else
 else if( S_ISDIR( stat_data.st_mode ) )
 {
#endif
 MB_SET_GLB_ERR( MB_FILE_DOES_NOT_EXIST, file_name << ": Cannot read directory/folder" );
 }
 
 const ReaderWriterSet* set = reader_writer_set();
 
 Range initial_ents;
 ErrorCode rval = get_entities_by_handle( 0, initial_ents );MB_CHK_ERR( rval );
 
 std::vector< Tag > initial_tags;
 rval = tag_get_tags( initial_tags );MB_CHK_ERR( rval );
 
 // otherwise try using the file extension to select a reader
 std::string ext = set->extension_from_filename( file_name );
 
 // Try all the readers
 ReaderWriterSet::iterator iter;
 rval = MB_FAILURE;
 bool tried_one = false;
 for( iter = set->begin(); iter != set->end(); ++iter )
 {
 if( !iter->reads_extension( ext.c_str() ) ) continue;
 
 ReaderIface* reader = iter->make_reader( this );
 if( NULL != reader )
 {
 tried_one = true;
 rval = reader->load_file( file_name, file_set, opts, subsets, id_tag );
 delete reader;
 if( MB_SUCCESS == rval ) break;
 clean_up_failed_read( initial_ents, initial_tags );
 }
 }
 
 if( MB_SUCCESS != rval && !tried_one )
 {
 // didn't recognize the extension; try all of them now
 for( iter = set->begin(); iter != set->end(); ++iter )
 {
 ReaderIface* reader = iter->make_reader( this );
 if( !reader ) continue;
 rval = reader->load_file( file_name, file_set, opts, subsets, id_tag );
 delete reader;
 if( MB_SUCCESS == rval )
 break;
 else
 clean_up_failed_read( initial_ents, initial_tags );
 }
 }
 
 if( MB_SUCCESS != rval )
 {
 clean_up_failed_read( initial_ents, initial_tags );
 MB_SET_ERR( rval, "Failed to load file after trying all possible readers" );
 }
 else if( file_set )
 {
 Range new_ents;
 get_entities_by_handle( 0, new_ents );
 new_ents = subtract( new_ents, initial_ents );
 
 // Check if gather set exists
 EntityHandle gather_set;
 rval = mMBReadUtil->get_gather_set( gather_set );
 if( MB_SUCCESS == rval )
 {
 // Exclude gather set itself
 new_ents.erase( gather_set );
 
 // Exclude gather set entities
 Range gather_ents;
 rval = get_entities_by_handle( gather_set, gather_ents );
 if( MB_SUCCESS == rval ) new_ents = subtract( new_ents, gather_ents );
 }
 
 rval = add_entities( *file_set, new_ents );
 }
 
 return rval;
} // namespace moab

References moab::ReaderWriterSet::begin(), moab::ReaderWriterSet::end(), moab::Range::erase(), ErrorCode, moab::ReaderWriterSet::extension_from_filename(), moab::ReaderIface::load_file(), MB_CHK_ERR, MB_FILE_DOES_NOT_EXIST, MB_SET_ERR, MB_SET_GLB_ERR, MB_SUCCESS, and moab::subtract().

Referenced by moab::ReadParallel::load_file().

serial_read_tag()

ErrorCode moab::Core::serial_read_tag	(	const char *	file_name,
		const char *	tag_name,
		const FileOptions &	opts,
		std::vector< int > &	tag_vals,
		const ReaderIface::SubsetList *	subsets = 0
	)

Definition at line 616 of file Core.cpp.

{
 ErrorCode rval = MB_FAILURE;
 const ReaderWriterSet* set = reader_writer_set();
 
 // otherwise try using the file extension to select a reader
 ReaderIface* reader = set->get_file_extension_reader( file_name );
 if( reader )
 {
 rval = reader->read_tag_values( file_name, tag_name, opts, vals, subsets );
 delete reader;
 }
 else
 {
 // Try all the readers
 ReaderWriterSet::iterator iter;
 for( iter = set->begin(); iter != set->end(); ++iter )
 {
 reader = iter->make_reader( this );
 if( NULL != reader )
 {
 rval = reader->read_tag_values( file_name, tag_name, opts, vals, subsets );
 delete reader;
 if( MB_SUCCESS == rval ) break;
 }
 }
 }
 
 return rval;
}

References moab::ReaderWriterSet::begin(), moab::ReaderWriterSet::end(), ErrorCode, moab::ReaderWriterSet::get_file_extension_reader(), MB_SUCCESS, and moab::ReaderIface::read_tag_values().

set_connectivity()

ErrorCode moab::Core::set_connectivity ( const EntityHandle  entity_handle, EntityHandle *  connect, const int  num_connect  )

virtual

Sets the connectivity for an EntityHandle. For non-element handles, return an error.

set the connectivity for element handles. For non-element handles, return an error

Connectivity is stored exactly as it is ordered in vector connectivity.

Parameters

entity_handle	EntityHandle to set connectivity of.
connect	Vector containing new connectivity of entity_handle.
num_connect	Number of vertices in connect

Example:

std::vector<EntityHandle> conn(3);
conn[0] = node1;
conn[1] = node2;
conn[2] = node3;
set_connectivity( entity_handle, conn, 3 ); 

Implements moab::Interface.

Definition at line 1214 of file Core.cpp.

{
 ErrorCode status = MB_FAILURE;
 
 // Make sure the entity should have a connectivity.
 // WARNING: This is very dependent on the ordering of the EntityType enum
 EntityType entity_type = TYPE_FROM_HANDLE( entity_handle );
 
 EntitySequence* seq = 0;
 
 if( entity_type < MBVERTEX || entity_type > MBENTITYSET ) return MB_TYPE_OUT_OF_RANGE;
 
 status = sequence_manager()->find( entity_handle, seq );
 if( seq == 0 || status != MB_SUCCESS ) return ( status != MB_SUCCESS ? status : MB_ENTITY_NOT_FOUND );
 
 const EntityHandle* old_conn;
 int len;
 status = static_cast< ElementSequence* >( seq )->get_connectivity( entity_handle, old_conn, len );MB_CHK_ERR( status );
 
 aEntityFactory->notify_change_connectivity( entity_handle, old_conn, connect, num_connect );
 
 status = static_cast< ElementSequence* >( seq )->set_connectivity( entity_handle, connect, num_connect );
 if( status != MB_SUCCESS )
 aEntityFactory->notify_change_connectivity( entity_handle, connect, old_conn, num_connect );
 
 return status;
}

References ErrorCode, MB_CHK_ERR, MB_ENTITY_NOT_FOUND, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MBENTITYSET, and moab::TYPE_FROM_HANDLE().

Referenced by moab::AEntityFactory::merge_adjust_adjacencies(), and moab::ReorderTool::reorder_entities().

set_coords() [1/2]

ErrorCode moab::Core::set_coords ( const EntityHandle *  entity_handles, const int  num_entities, const double *  coords  )

virtual

set the coordinate information for this handle if it is of type Vertex otherwise, return an error

Implements moab::Interface.

Definition at line 1048 of file Core.cpp.

{
 
 ErrorCode status = MB_SUCCESS;
 
 int i, j = 0;
 
 for( i = 0; i < num_entities; i++ )
 {
 if( TYPE_FROM_HANDLE( entity_handles[i] ) == MBVERTEX )
 {
 EntitySequence* seq = 0;
 status = sequence_manager()->find( entity_handles[i], seq );
 
 if( seq != 0 && status == MB_SUCCESS )
 {
 status = static_cast< VertexSequence* >( seq )->set_coordinates( entity_handles[i], coords[j],
 coords[j + 1], coords[j + 2] );
 j += 3;
 }
 }
 else if( status == MB_SUCCESS )
 status = MB_TYPE_OUT_OF_RANGE;
 }
 
 return status;
}

References ErrorCode, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MBVERTEX, and moab::TYPE_FROM_HANDLE().

Referenced by compute_tracer_case1(), get_departure_grid(), main(), perform_laplacian_smoothing(), perform_lloyd_relaxation(), moab::ReorderTool::reorder_entities(), and set_departure_points_position().

set_coords() [2/2]

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

virtual

set the coordinate information for this handle if it is of type Vertex otherwise, return an error

Implements moab::Interface.

Definition at line 1078 of file Core.cpp.

{
 
 ErrorCode status = MB_SUCCESS;
 
 int j = 0;
 
 for( Range::iterator rit = entity_handles.begin(); rit != entity_handles.end(); ++rit )
 {
 if( TYPE_FROM_HANDLE( *rit ) == MBVERTEX )
 {
 EntitySequence* seq = 0;
 status = sequence_manager()->find( *rit, seq );
 
 if( seq != 0 && status == MB_SUCCESS )
 {
 status = static_cast< VertexSequence* >( seq )->set_coordinates( *rit, coords[j], coords[j + 1],
 coords[j + 2] );
 j += 3;
 }
 }
 else if( status == MB_SUCCESS )
 status = MB_TYPE_OUT_OF_RANGE;
 }
 
 return status;
}

References moab::Range::begin(), moab::Range::end(), ErrorCode, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MBVERTEX, and moab::TYPE_FROM_HANDLE().

set_dimension()

ErrorCode moab::Core::set_dimension ( const int  dim )

virtual

set overall geometric dimension

Returns error if setting to 3 dimensions, mesh has been created, and there are only 2 dimensions on that mesh

Implements moab::Interface.

Definition at line 777 of file Core.cpp.

{
 // check to see if current dimension is smaller
 if( geometricDimension < dim )
 {
 // need to check the number of entities
 int num;
 /*ErrorCode result = */ get_number_entities_by_dimension( 0, geometricDimension, num );
 
 // test written to be more readable but possibly less efficient
 // if (MB_SUCCESS != result) return MB_FAILURE;
 // else if (0 != num && dim == 2 && ycoordTag == 0) return MB_FAILURE;
 // else if (0 != num && dim == 3 && (ycoordTag == 0 || zcoordTag == 0)) return MB_FAILURE;
 // TODO -- replace this with not using xcoordTag, etc...
 }
 
 // if we got here, it's ok to set dimension
 geometricDimension = dim;
 return MB_SUCCESS;
}

References dim, and MB_SUCCESS.

set_meshset_options()

ErrorCode moab::Core::set_meshset_options ( const EntityHandle  ms_handle, const unsigned int  options  )

virtual

set the options of a mesh set

Implements moab::Interface.

Definition at line 3278 of file Core.cpp.

{
 MeshSet* set = get_mesh_set( sequence_manager(), ms_handle );
 if( !set ) return MB_ENTITY_NOT_FOUND;
 
 return set->set_flags( setoptions, ms_handle, a_entity_factory() );
}

References moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and moab::MeshSet::set_flags().

set_sequence_multiplier()

void moab::Core::set_sequence_multiplier ( double  factor )

virtual

Interface to control memory allocation for sequences Provide a factor that controls the size of the sequence that gets allocated. This is typically useful in the parallel setting when a-priori, the number of ghost entities and the memory required for them within the same sequence as the owned entities are unknown. The default factor is 1.0 but this can be appropriately updated at runtime so that we do not have broken sequences.

Parameters

meshset

User specified multiplier (should be greater than 1.0)

Implements moab::Interface.

Definition at line 1111 of file Core.cpp.

{
 assert( factor >= 1.0 );
 sequenceManager->set_sequence_multiplier( factor );
}

side_element()

ErrorCode moab::Core::side_element ( const EntityHandle  source_entity, const int  dim, const int  sd_number, EntityHandle &  target_entity  ) const

virtual

given an entity and a target dimension & side number, get that entity

Implements moab::Interface.

Definition at line 3205 of file Core.cpp.

{
 // get a handle on the connectivity
 const EntityHandle* verts;
 int num_verts;
 ErrorCode result = get_connectivity( source_entity, verts, num_verts );MB_CHK_ERR( result );
 
 // special case for vertices
 if( dim == 0 )
 {
 if( sd_number < num_verts )
 {
 target_entity = verts[sd_number];
 return MB_SUCCESS;
 }
 
 else
 return MB_INDEX_OUT_OF_RANGE;
 }
 
 // get the vertices comprising the target entity
 Range side_verts, target_ents;
 const EntityType source_type = TYPE_FROM_HANDLE( source_entity );
 // first get the indices
 std::vector< int > vertex_indices;
 
 int temp_result = CN::AdjacentSubEntities( source_type, &sd_number, 1, dim, 0, vertex_indices );
 if( 0 != temp_result ) return MB_FAILURE;
 // now get the actual vertices
 for( unsigned int i = 0; i < vertex_indices.size(); i++ )
 side_verts.insert( verts[vertex_indices[i]] );
 
 // now look for an entity of the correct type
 // use const_cast here 'cuz we're in a const function and we're passing 'false' for
 // create_if_missing, so we know we won't change anything
 result = ( const_cast< Core* >( this ) )->get_adjacencies( side_verts, dim, false, target_ents );
 if( MB_SUCCESS != result && MB_MULTIPLE_ENTITIES_FOUND != result ) return result;
 
 if( !target_ents.empty() && TYPE_FROM_HANDLE( *( target_ents.begin() ) ) != MBVERTEX &&
 TYPE_FROM_HANDLE( *( target_ents.begin() ) ) !=
 CN::mConnectivityMap[source_type][dim - 1].target_type[sd_number] )
 return MB_ENTITY_NOT_FOUND;
 
 if( !target_ents.empty() ) target_entity = *( target_ents.begin() );
 
 return result;
}

References moab::CN::AdjacentSubEntities(), moab::Range::begin(), dim, moab::Range::empty(), ErrorCode, moab::Range::insert(), MB_CHK_ERR, MB_ENTITY_NOT_FOUND, MB_INDEX_OUT_OF_RANGE, MB_MULTIPLE_ENTITIES_FOUND, MB_SUCCESS, MBVERTEX, moab::CN::mConnectivityMap, moab::CN::ConnMap::target_type, and moab::TYPE_FROM_HANDLE().

Referenced by moab::HigherOrderFactory::tag_for_deletion().

side_number()

ErrorCode moab::Core::side_number ( const EntityHandle  parent, const EntityHandle  child, int &  sd_number, int &  sense, int &  offset  ) const

virtual

function to get the side number given two elements; returns MB_FAILURE if child not related to parent; does not create adjacencies between parent and child

Implements moab::Interface.

Definition at line 3011 of file Core.cpp.

{
 // get the connectivity of parent and child
 const EntityHandle *parent_conn = NULL, *child_conn = NULL;
 int num_parent_vertices = 0, num_child_vertices = 0;
 ErrorCode result = get_connectivity( parent, parent_conn, num_parent_vertices, true );
 if( MB_NOT_IMPLEMENTED == result )
 {
 static std::vector< EntityHandle > tmp_connect( CN::MAX_NODES_PER_ELEMENT );
 result = get_connectivity( parent, parent_conn, num_parent_vertices, true, &tmp_connect );
 }
 if( MB_SUCCESS != result ) return result;
 
 if( TYPE_FROM_HANDLE( child ) == MBVERTEX )
 {
 int child_index = std::find( parent_conn, parent_conn + num_parent_vertices, child ) - parent_conn;
 if( child_index == num_parent_vertices )
 {
 sd_number = -1;
 sense = 0;
 return MB_FAILURE;
 }
 else
 {
 sd_number = child_index;
 sense = 1;
 return MB_SUCCESS;
 }
 }
 
 if( TYPE_FROM_HANDLE( parent ) == MBPOLYHEDRON )
 {
 // find the child in the parent_conn connectivity list, and call it a day ..
 // it should work only for faces within a conn list
 for( int i = 0; i < num_parent_vertices; i++ )
 if( child == parent_conn[i] )
 {
 sd_number = i;
 sense = 1; // always
 offset = 0;
 return MB_SUCCESS;
 }
 return MB_FAILURE;
 }
 result = get_connectivity( child, child_conn, num_child_vertices, true );MB_CHK_ERR( result );
 
 // call handle vector-based function
 if( TYPE_FROM_HANDLE( parent ) != MBPOLYGON && TYPE_FROM_HANDLE( parent ) != MBPOLYHEDRON )
 {
 
 // find indices into parent_conn for each entry in child_conn
 int child_conn_indices[10];
 assert( (unsigned)num_child_vertices <= sizeof( child_conn_indices ) / sizeof( child_conn_indices[0] ) );
 for( int i = 0; i < num_child_vertices; ++i )
 {
 child_conn_indices[i] =
 std::find( parent_conn, parent_conn + num_parent_vertices, child_conn[i] ) - parent_conn;
 if( child_conn_indices[i] >= num_parent_vertices )
 {
 sd_number = -1;
 return MB_FAILURE;
 }
 }
 
 int temp_result = CN::SideNumber( TYPE_FROM_HANDLE( parent ), child_conn_indices, num_child_vertices,
 CN::Dimension( TYPE_FROM_HANDLE( child ) ), sd_number, sense, offset );
 return ( 0 == temp_result ? MB_SUCCESS : MB_FAILURE );
 }
 else if( TYPE_FROM_HANDLE( parent ) == MBPOLYGON )
 {
 // find location of 1st vertex; this works even for padded vertices
 const EntityHandle* first_v = std::find( parent_conn, parent_conn + num_parent_vertices, child_conn[0] );
 if( first_v == parent_conn + num_parent_vertices ) return MB_ENTITY_NOT_FOUND;
 sd_number = first_v - parent_conn;
 offset = sd_number;
 if( TYPE_FROM_HANDLE( child ) == MBVERTEX )
 {
 sense = 0;
 return MB_SUCCESS;
 }
 else if( TYPE_FROM_HANDLE( child ) == MBPOLYGON )
 {
 bool match = CN::ConnectivityMatch( parent_conn, child_conn, num_parent_vertices, sense, offset );
 sd_number = 0;
 if( match )
 return MB_SUCCESS;
 else
 return MB_ENTITY_NOT_FOUND;
 }
 else if( TYPE_FROM_HANDLE( child ) == MBEDGE )
 {
 // determine the actual number of vertices, for the padded case
 // the padded case could be like ABCDEFFF; num_parent_vertices=8,
 // actual_num_parent_vertices=6
 int actual_num_parent_vertices = num_parent_vertices;
 while( actual_num_parent_vertices >= 3 &&
 ( parent_conn[actual_num_parent_vertices - 2] == parent_conn[actual_num_parent_vertices - 1] ) )
 actual_num_parent_vertices--;
 
 if( parent_conn[( sd_number + 1 ) % num_parent_vertices] == child_conn[1] )
 sense = 1;
 else if( parent_conn[( sd_number + num_parent_vertices - 1 ) % num_parent_vertices] ==
 child_conn[1] ) // this will also cover edge AF for padded case, side will
 // be 0, sense -1
 sense = -1;
 // if edge FA in above example, we should return sd_number = 5, sense 1
 else if( ( sd_number == actual_num_parent_vertices - 1 ) && ( child_conn[1] == parent_conn[0] ) )
 sense = 1;
 else
 return MB_ENTITY_NOT_FOUND;
 return MB_SUCCESS;
 }
 }
 
 return MB_FAILURE;
}

References child, moab::CN::ConnectivityMatch(), moab::CN::Dimension(), ErrorCode, moab::CN::MAX_NODES_PER_ELEMENT, MB_CHK_ERR, MB_ENTITY_NOT_FOUND, MB_NOT_IMPLEMENTED, MB_SUCCESS, MBEDGE, MBPOLYGON, MBPOLYHEDRON, MBVERTEX, moab::CN::SideNumber(), and moab::TYPE_FROM_HANDLE().

Referenced by create_fine_mesh(), and fill_coord_on_edges().

subtract_meshset()

ErrorCode moab::Core::subtract_meshset ( EntityHandle  meshset1, const EntityHandle  meshset2  )

virtual

subtracts meshset2 from meshset1 - modifies meshset1

Implements moab::Interface.

Definition at line 3316 of file Core.cpp.

{
 MeshSet* set1 = get_mesh_set( sequence_manager(), meshset1 );
 MeshSet* set2 = get_mesh_set( sequence_manager(), meshset2 );
 if( !set1 || !set2 ) return MB_ENTITY_NOT_FOUND;
 
 return set1->subtract( set2, meshset1, a_entity_factory() );
}

References moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and moab::MeshSet::subtract().

tag_clear_data() [1/2]

ErrorCode moab::Core::tag_clear_data ( Tag  tag_handle, const EntityHandle *  entity_handles, int  num_entities, const void *  tag_data, int  tag_size = 0  )

virtual

Set tag data given value.

set the data for given EntityHandles and Tag

For a tag, set the values for a list of passed entity handles to the same, specified value.

Parameters

tag_handle	The tag
entity_handles	The entity handles for which to set tag values.
tag_data	A pointer to the tag value.
tag_sizes	For variable-length tags, the lenght of the tag value. This argument will be ignored for fixed-length tags.

Implements moab::Interface.

Definition at line 2246 of file Core.cpp.

{
 assert( valid_tag_handle( tag_handle ) );
 CHECK_MESH_NULL
 return tag_handle->clear_data( sequenceManager, mError, entity_handles, num_entities, tag_data,
 tag_size * TagInfo::size_from_data_type( tag_handle->get_data_type() ) );
}

References CHECK_MESH_NULL, moab::TagInfo::clear_data(), moab::TagInfo::get_data_type(), and moab::TagInfo::size_from_data_type().

tag_clear_data() [2/2]

ErrorCode moab::Core::tag_clear_data ( Tag  tag_handle, const Range &  entity_handles, const void *  tag_data, int  tag_size = 0  )

virtual

Set tag data given value.

set the data for given EntityHandles and Tag

For a tag, set the values for a list of passed entity handles to the same, specified value.

Parameters

tag_handle	The tag
entity_handles	The entity handles for which to set tag values.
tag_data	A pointer to the tag value.
tag_sizes	For variable-length tags, the lenght of the tag value. This argument will be ignored for fixed-length tags.

Implements moab::Interface.

Definition at line 2259 of file Core.cpp.

{
 assert( valid_tag_handle( tag_handle ) );
 return tag_handle->clear_data( sequenceManager, mError, entity_handles, tag_data,
 tag_size * TagInfo::size_from_data_type( tag_handle->get_data_type() ) );
}

References moab::TagInfo::clear_data(), moab::TagInfo::get_data_type(), and moab::TagInfo::size_from_data_type().

tag_delete()

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

virtual

Removes the tag from the database and deletes all of its associated data.

removes the tag from MB

Implements moab::Interface.

Definition at line 2464 of file Core.cpp.

{
 std::list< TagInfo* >::iterator i = std::find( tagList.begin(), tagList.end(), tag_handle );
 if( i == tagList.end() ) return MB_TAG_NOT_FOUND;
 
 ErrorCode rval = tag_handle->release_all_data( sequenceManager, mError, true );MB_CHK_ERR( rval );
 
 tagList.erase( i );
 delete tag_handle;
 return MB_SUCCESS;
}

References ErrorCode, MB_CHK_ERR, MB_SUCCESS, MB_TAG_NOT_FOUND, and moab::TagInfo::release_all_data().

Referenced by moab::HigherOrderFactory::convert_sequence(), moab::WriteUtil::gather_nodes_from_elements(), moab::ReorderTool::handle_order_from_int_tag(), moab::ReorderTool::handle_order_from_sets_and_adj(), main(), and perform_lloyd_relaxation().

tag_delete_data() [1/2]

ErrorCode moab::Core::tag_delete_data ( Tag  tag_handle, const EntityHandle *  entity_handles, int  num_entities  )

virtual

Delete the data of a vector of entity handles and sparse tag.

removes the tag from the entity

Delete the data of a tag on a vector of entity handles. Only sparse tag data are deleted with this function; dense tags are deleted by deleting the tag itself using tag_delete.

Parameters

tag_handle	Handle of the (sparse) tag being deleted from entity
entity_handles	1d vector of entity handles from which the tag is being deleted
num_handles	Number of entity handles in 1d vector

Implements moab::Interface.

Definition at line 2449 of file Core.cpp.

{
 assert( valid_tag_handle( tag_handle ) );
 CHECK_MESH_NULL
 return tag_handle->remove_data( sequenceManager, mError, entity_handles, num_entities );
}

References CHECK_MESH_NULL, and moab::TagInfo::remove_data().

Referenced by process_partition_file(), and moab::ReorderTool::reorder_tag_data().

tag_delete_data() [2/2]

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

virtual

Delete the data of a range of entity handles and sparse tag.

removes the tag from the entity

Delete the data of a tag on a range of entity handles. Only sparse tag data are deleted with this function; dense tags are deleted by deleting the tag itself using tag_delete.

Parameters

tag_handle	Handle of the (sparse) tag being deleted from entity
entity_range	Range of entities from which the tag is being deleted

Implements moab::Interface.

Definition at line 2457 of file Core.cpp.

{
 assert( valid_tag_handle( tag_handle ) );
 return tag_handle->remove_data( sequenceManager, mError, entity_handles );
}

References moab::TagInfo::remove_data().

tag_get_by_ptr() [1/2]

ErrorCode moab::Core::tag_get_by_ptr ( const Tag  tag_handle, const EntityHandle *  entity_handles, int  num_entities, const void **  tag_data, int *  tag_sizes = 0  ) const

virtual

Get pointers to tag data.

return the tag data for a given EntityHandle and Tag

For a tag, get the values for a list of passed entity handles.

Note

This function may not be used for bit tags.

Parameters

tag_handle	The tag
entity_handles	An array of entity handles for which to retreive tag values.
num_entities	The length of the 'entity_handles' array.
tag_data	An array of 'const void*'. Array must be at least 'num_entitities' long. Array is populated (output) with pointers to the internal storage for the tag value corresponding to each entity handle.
tag_sizes	The length of each tag value. Optional for fixed-length tags. Required for variable-length tags.

Implements moab::Interface.

Definition at line 2169 of file Core.cpp.

{
 assert( valid_tag_handle( tag_handle ) );
 CHECK_MESH_NULL
 ErrorCode result =
 tag_handle->get_data( sequenceManager, mError, entity_handles, num_entities, tag_data, tag_sizes );
 int typesize = TagInfo::size_from_data_type( tag_handle->get_data_type() );
 if( tag_sizes && typesize != 1 )
 for( int i = 0; i < num_entities; ++i )
 tag_sizes[i] /= typesize;
 return result;
}

References CHECK_MESH_NULL, ErrorCode, moab::TagInfo::get_data(), moab::TagInfo::get_data_type(), and moab::TagInfo::size_from_data_type().

Referenced by moab::ReorderTool::reorder_tag_data(), and test_spectral_hex().

tag_get_by_ptr() [2/2]

ErrorCode moab::Core::tag_get_by_ptr ( const Tag  tag_handle, const Range &  entity_handles, const void **  tag_data, int *  tag_sizes = 0  ) const

virtual

Get pointers to tag data.

return the tag data for a given EntityHandle and Tag

For a tag, get the values for a list of passed entity handles.

Note

This function may not be used for bit tags.

Parameters

tag_handle	The tag
entity_handles	The entity handles for which to retreive tag values.
tag_data	An array of 'const void*'. Array is populated (output) with pointers to the internal storage for the tag value corresponding to each entity handle.
tag_sizes	The length of each tag value. Optional for fixed-length tags. Required for variable-length tags.

Implements moab::Interface.

Definition at line 2187 of file Core.cpp.

{
 assert( valid_tag_handle( tag_handle ) );
 ErrorCode result = tag_handle->get_data( sequenceManager, mError, entity_handles, tag_data, tag_sizes );
 int typesize = TagInfo::size_from_data_type( tag_handle->get_data_type() );
 if( tag_sizes && typesize != 1 )
 {
 int num_entities = entity_handles.size();
 for( int i = 0; i < num_entities; ++i )
 tag_sizes[i] /= typesize;
 }
 return result;
}

References ErrorCode, moab::TagInfo::get_data(), moab::TagInfo::get_data_type(), moab::Range::size(), and moab::TagInfo::size_from_data_type().

tag_get_bytes()

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

virtual

Get the size of the specified tag in bytes.

get size of tag in bytes

Implements moab::Interface.

Definition at line 2504 of file Core.cpp.

{
 if( !valid_tag_handle( tag_handle ) ) return MB_TAG_NOT_FOUND;
 
 if( tag_handle->variable_length() )
 {
 tag_size = MB_VARIABLE_LENGTH;
 return MB_VARIABLE_DATA_LENGTH;
 }
 else if( tag_handle->get_storage_type() == MB_TAG_BIT )
 {
 tag_size = 1;
 return MB_SUCCESS;
 }
 else
 {
 tag_size = tag_handle->get_size();
 return MB_SUCCESS;
 }
}

References moab::TagInfo::get_size(), moab::TagInfo::get_storage_type(), MB_SUCCESS, MB_TAG_BIT, MB_TAG_NOT_FOUND, MB_VARIABLE_DATA_LENGTH, MB_VARIABLE_LENGTH, and moab::TagInfo::variable_length().

Referenced by moab::check_int_tag(), main(), and moab::ReorderTool::reorder_tag_data().

tag_get_data() [1/2]

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

virtual

return the tag data for a given EntityHandle and Tag

Implements moab::Interface.

Examples

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

Definition at line 2133 of file Core.cpp.

{
 assert( valid_tag_handle( tag_handle ) );
 CHECK_MESH_NULL
 return tag_handle->get_data( sequenceManager, mError, entity_handles, num_entities, tag_data );
}

References CHECK_MESH_NULL, and moab::TagInfo::get_data().

Referenced by add_field_value(), compute_lagrange_mesh_on_sphere(), compute_tracer_case1(), moab::HigherOrderFactory::convert_sequence(), create_fine_mesh(), create_lagr_mesh(), IntxUtilsCSLAM::create_span_quads(), IntxUtilsCSLAM::deep_copy_set(), dot_nodes(), dot_write_id_nodes(), moab::WriteUtil::gather_nodes_from_elements(), moab::WriteUtil::get_adjacencies(), get_barycenters(), get_departure_grid(), moab::WriteUtil::get_element_connect(), get_intersection_weights(), get_linear_reconstruction(), moab::ReorderTool::get_new_handles(), moab::ReorderTool::get_reordered_handles(), moab::ReorderTool::handle_order_from_int_tag(), hcFilter(), moab::ReorderTool::int_order_from_sets_and_adj(), laplacianFilter(), main(), perform_laplacian_smoothing(), perform_lloyd_relaxation(), process_partition_file(), moab::ReorderTool::reorder_tag_data(), set_density(), tag_depth(), test_linear_reconstruction(), test_spectral_hex(), update_density(), and update_tracer_test().

tag_get_data() [2/2]

ErrorCode moab::Core::tag_get_data ( const Tag  tag_handle, const Range &  entity_handles, void *  tag_data  ) const

virtual

return the tag data for a given EntityHandle and Tag

Implements moab::Interface.

Definition at line 2144 of file Core.cpp.

{
 assert( valid_tag_handle( tag_handle ) );
 return tag_handle->get_data( sequenceManager, mError, entity_handles, tag_data );
}

References moab::TagInfo::get_data().

tag_get_data_type()

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

virtual

Get data type of tag.

Get the type of the tag data. The tag is data is assumed to be a vector of this type. If the tag data vetcor contains more than one value, then the tag size must be a multiple of the size of this type.

Parameters

tag	The tag
type	The type of the specified tag (output).

Implements moab::Interface.

Definition at line 2542 of file Core.cpp.

{
 if( !valid_tag_handle( handle ) ) return MB_TAG_NOT_FOUND;
 
 data_type = handle->get_data_type();
 return MB_SUCCESS;
}

References moab::TagInfo::get_data_type(), MB_SUCCESS, and MB_TAG_NOT_FOUND.

Referenced by moab::check_int_tag(), main(), and moab::ReorderTool::reorder_tag_data().

tag_get_default_value() [1/2]

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

virtual

Get the default value of the specified tag.

get default value of the tag

Implements moab::Interface.

Definition at line 2551 of file Core.cpp.

{
 if( !valid_tag_handle( tag_handle ) ) return MB_TAG_NOT_FOUND;
 
 if( tag_handle->variable_length() ) return MB_VARIABLE_DATA_LENGTH;
 
 if( !tag_handle->get_default_value() ) return MB_ENTITY_NOT_FOUND;
 
 memcpy( def_value, tag_handle->get_default_value(), tag_handle->get_default_value_size() );
 return MB_SUCCESS;
}

References moab::TagInfo::get_default_value(), moab::TagInfo::get_default_value_size(), MB_ENTITY_NOT_FOUND, MB_SUCCESS, MB_TAG_NOT_FOUND, MB_VARIABLE_DATA_LENGTH, and moab::TagInfo::variable_length().

Referenced by moab::ReorderTool::reorder_entities().

tag_get_default_value() [2/2]

ErrorCode moab::Core::tag_get_default_value ( Tag  tag, const void *&  def_val, int &  size  ) const

virtual

Get a tag handle, possibly creating the tag.

Get a handle used to associate application-defined values with MOAB entities. If the tag does not already exist then flags should contain exactly one of MB_TAG_SPARSE, MB_TAG_DENSE, MB_TAG_MESH unless type is MB_TYPE_BIT, which implies MB_TAG_BIT storage.

Parameters

name	The tag name
size	Tag size as number of values of of data type per entity (or number of bytes if MB_TAG_BYTES is passed in flags). If MB_TAG_VARLEN is specified, this value is taken to be the size of the default value if one is specified and is otherwise ignored.
type	The type of the data (used for IO)
tag_handle	Output: the resulting tag handle.
flags	Bitwise OR of values from TagType
default_value	Optional default value for tag.
created	Optional returned boolean indicating that the tag was created.

Returns

- MB_ALREADY_ALLOCATED if tag exists and MB_TAG_EXCL is specified, or default values do not match (and MB_TAG_ANY or MB_TAG_DFTOK not specified).

• MB_TAG_NOT_FOUND if tag does not exist and MB_TAG_CREAT is not specified
• MB_INVALID_SIZE if tag value size is not a multiple of the size of the data type (and MB_TAG_ANY not specified).
• MB_TYPE_OUT_OF_RANGE invalid or inconsistent parameter
• MB_VARIABLE_DATA_LENGTH if MB_TAG_VARLEN and default_value is non-null and default_value_size is not specified.

\NOTE A call to tag_get_handle that includes a default value will fail if the tag already exists with a different default value. A call without a default value will succeed if the tag already exists, regardless of whether or not the existing tag has a default value.

Examples:

Retrieve a handle for an existing tag, returning a non-success error code if the tag does not exist or does not store 1 integer value per entity:

Tag git_tag;
mb.tag_get_handle( GLOBAL_ID_TAG_NAME, 1, MB_TYPE_INTEGER, gid_tag );

Get the tag handle, or create it as a dense tag if it does not already exist:

 Tag gid_tag;
 mb.tag_get_handle( GLOBAL_ID_TAG_NAME, 1, MB_TYPE_INTEGER, gid_tag, MB_TAG_CREAT|MB_TAG_BIT
); 

Create the tag or fail if it already exists:

Tag gid_tag;
 mb.tag_get_handle( GLOBAL_ID_TAG_NAME, 1, MB_TYPE_INTEGER, gid_tag, MB_TAG_EXCL|MB_TAG_DENSE
); 

Get an existing variable length tag, failing if it does not exist or is not variable-length or does not contain double values.

 Tag vtag; mb.tag_get_handle(
*tag_name, 0, MB_TYPE_DOUBLE, vtag ); 

Get the same variable-length tag, but create it with a default value if it doesn't exist. Note that if the tag already exists this call will return a non-success error code if the existing tag has a different default value.

 Tag
*vtag; const double default_val = M_PI; const int def_val_len = 1; mb.tag_get_handle( tag_name,
*def_val_len, MB_TYPE_DOUBLE, vtag, MB_TAG_SPARSE|MB_TAG_VARLEN|MB_TAG_CREAT, &default_val );

Implements moab::Interface.

Definition at line 2563 of file Core.cpp.

{
 if( !valid_tag_handle( tag ) ) return MB_ENTITY_NOT_FOUND;
 
 if( !tag->get_default_value() ) return MB_ENTITY_NOT_FOUND;
 
 ptr = tag->get_default_value();
 size = tag->get_default_value_size() / TagInfo::size_from_data_type( tag->get_data_type() );
 return MB_SUCCESS;
}

References moab::TagInfo::get_data_type(), moab::TagInfo::get_default_value(), moab::TagInfo::get_default_value_size(), MB_ENTITY_NOT_FOUND, MB_SUCCESS, size, and moab::TagInfo::size_from_data_type().

tag_get_handle() [1/3]

ErrorCode moab::Core::tag_get_handle ( const char *  name, int  size, DataType  type, Tag &  tag_handle, unsigned  flags = 0, const void *  default_value = 0  ) const

virtual

same as non-const version, except that TAG_CREAT flag is ignored.

Implements moab::Interface.

Definition at line 2414 of file Core.cpp.

{
 // If caller specified MB_TAG_EXCL, then we must fail because
 // this const function can never create a tag. We need to test
 // this here because the non-const version of this function
 // assumes MB_TAG_CREAT if MB_TAG_EXCL is specified.
 if( flags & MB_TAG_EXCL )
 {
 // anonymous tag?
 if( !name || !*name ) return MB_TAG_NOT_FOUND;
 
 // search for an existing tag
 tag_handle = 0;
 for( std::list< Tag >::const_iterator i = tagList.begin(); i != tagList.end(); ++i )
 {
 if( ( *i )->get_name() == name )
 {
 tag_handle = *i;
 return MB_ALREADY_ALLOCATED;
 }
 }
 
 return MB_TAG_NOT_FOUND;
 }
 
 return const_cast< Core* >( this )->tag_get_handle( name, size, data_type, tag_handle,
 flags & ~(unsigned)MB_TAG_CREAT, default_value );
}

References MB_ALREADY_ALLOCATED, MB_TAG_CREAT, MB_TAG_EXCL, MB_TAG_NOT_FOUND, and size.

tag_get_handle() [2/3]

ErrorCode moab::Core::tag_get_handle ( const char *  name, int  size, DataType  type, Tag &  tag_handle, unsigned  flags = 0, const void *  default_value = 0, bool *  created = 0  )

virtual

Get a tag handle, possibly creating the tag.

Get a handle used to associate application-defined values with MOAB entities. If the tag does not already exist then flags should contain exactly one of MB_TAG_SPARSE, MB_TAG_DENSE, MB_TAG_MESH unless type is MB_TYPE_BIT, which implies MB_TAG_BIT storage.

Parameters

name	The tag name
size	Tag size as number of values of of data type per entity (or number of bytes if MB_TAG_BYTES is passed in flags). If MB_TAG_VARLEN is specified, this value is taken to be the size of the default value if one is specified and is otherwise ignored.
type	The type of the data (used for IO)
tag_handle	Output: the resulting tag handle.
flags	Bitwise OR of values from TagType
default_value	Optional default value for tag.
created	Optional returned boolean indicating that the tag was created.

Returns

- MB_ALREADY_ALLOCATED if tag exists and MB_TAG_EXCL is specified, or default values do not match (and MB_TAG_ANY or MB_TAG_DFTOK not specified).

• MB_TAG_NOT_FOUND if tag does not exist and MB_TAG_CREAT is not specified
• MB_INVALID_SIZE if tag value size is not a multiple of the size of the data type (and MB_TAG_ANY not specified).
• MB_TYPE_OUT_OF_RANGE invalid or inconsistent parameter
• MB_VARIABLE_DATA_LENGTH if MB_TAG_VARLEN and default_value is non-null and default_value_size is not specified.

Implements moab::Interface.

Examples

addPCdata.cpp, and copyPartition.cpp.

Definition at line 2275 of file Core.cpp.

{
 if( created ) *created = false;
 
 // we always work with sizes in bytes internally
 if( !( ( flags & MB_TAG_VARLEN ) && size == MB_VARIABLE_LENGTH ) )
 {
 if( flags & MB_TAG_BYTES )
 {
 if( size % TagInfo::size_from_data_type( data_type ) ) return MB_INVALID_SIZE;
 }
 else
 {
 size *= TagInfo::size_from_data_type( data_type );
 }
 }
 
 const TagType storage = static_cast< TagType >( flags & 3 );
 
 // search for an existing tag
 tag_handle = 0;
 if( name && *name )
 { // not anonymous tag
 for( std::list< Tag >::iterator i = tagList.begin(); i != tagList.end(); ++i )
 {
 if( ( *i )->get_name() == name )
 {
 tag_handle = *i;
 break;
 }
 }
 }
 
 if( tag_handle )
 {
 if( flags & MB_TAG_EXCL ) return MB_ALREADY_ALLOCATED;
 // user asked that we not check anything
 if( flags & MB_TAG_ANY ) return MB_SUCCESS;
 // user asked that we also match storage types
 if( ( flags & MB_TAG_STORE ) && tag_handle->get_storage_type() != storage ) return MB_TYPE_OUT_OF_RANGE;
 // check if data type matches
 const DataType extype = tag_handle->get_data_type();
 if( extype != data_type )
 {
 if( flags & MB_TAG_NOOPQ )
 return MB_TYPE_OUT_OF_RANGE;
 else if( extype != MB_TYPE_OPAQUE && data_type != MB_TYPE_OPAQUE )
 return MB_TYPE_OUT_OF_RANGE;
 }
 
 // Require that the size value be zero or MB_VARIABLE_LENGTH
 // for variable length tags. The caller passing such a size
 // value is sufficient to indicate that the caller is aware
 // that it is requesting a variable-length tag, so no need
 // to also require/check the MB_TAG_VARLEN bit in the flags.
 if( tag_handle->variable_length() )
 {
 if( size != 0 && size != MB_VARIABLE_LENGTH && !( flags & MB_TAG_VARLEN ) ) return MB_INVALID_SIZE;
 }
 // But /do/ fail if MB_TAG_VARLEN flag is set and tag is
 // not variable length.
 else if( flags & MB_TAG_VARLEN )
 return MB_TYPE_OUT_OF_RANGE;
 // check size for fixed-length tag
 else if( tag_handle->get_size() != size )
 return MB_INVALID_SIZE;
 
 // If user passed a default value, check that it matches.
 // If user did not pass a default value, assume they're OK
 // with the existing one.
 // If tag does not have a default value but the user passed
 // one, allow it only if the tag is dense and the passed value
 // is all zero bytes because dense tags have an implicit default
 // value of all zeros in some cases.
 if( default_value && !( flags & MB_TAG_DFTOK ) &&
 !( tag_handle->equals_default_value( default_value, size ) ||
 ( !tag_handle->get_default_value() && tag_handle->get_storage_type() == MB_TAG_DENSE &&
 is_zero_bytes( default_value, size ) ) ) )
 return MB_ALREADY_ALLOCATED;
 
 return MB_SUCCESS;
 }
 
 // MB_TAG_EXCL implies MB_TAG_CREAT
 if( !( flags & ( MB_TAG_CREAT | MB_TAG_EXCL ) ) ) return MB_TAG_NOT_FOUND;
 
 // if a non-opaque non-bit type was specified, then the size
 // must be multiple of the size of the type
 if( ( !( flags & MB_TAG_VARLEN ) || default_value ) &&
 ( size <= 0 || ( size % TagInfo::size_from_data_type( data_type ) ) != 0 ) )
 return MB_INVALID_SIZE;
 
 // if MB_TYPE_BIT may be used only with MB_TAG_BIT
 // if (storage != MB_TAG_BIT && data_type == MB_TYPE_BIT)
 // return MB_INVALID_ARG;
 if( data_type == MB_TYPE_BIT ) flags &= ~(unsigned)( MB_TAG_DENSE | MB_TAG_SPARSE );
 
 // create the tag
 switch( flags & ( MB_TAG_DENSE | MB_TAG_SPARSE | MB_TAG_MESH | MB_TAG_VARLEN ) )
 {
 case MB_TAG_DENSE | MB_TAG_VARLEN:
 tag_handle = VarLenDenseTag::create_tag( sequenceManager, mError, name, data_type, default_value, size );
 break;
 case MB_TAG_DENSE:
 tag_handle = DenseTag::create_tag( sequenceManager, mError, name, size, data_type, default_value );
 break;
 case MB_TAG_SPARSE | MB_TAG_VARLEN:
 tag_handle = new VarLenSparseTag( name, data_type, default_value, size );
 break;
 case MB_TAG_SPARSE:
 tag_handle = new SparseTag( name, size, data_type, default_value );
 break;
 case MB_TAG_MESH | MB_TAG_VARLEN:
 tag_handle = new MeshTag( name, MB_VARIABLE_LENGTH, data_type, default_value, size );
 break;
 case MB_TAG_MESH:
 tag_handle = new MeshTag( name, size, data_type, default_value, size );
 break;
 case MB_TAG_BIT:
 if( MB_TYPE_BIT != data_type && MB_TYPE_OPAQUE != data_type ) return MB_TYPE_OUT_OF_RANGE;
 tag_handle = BitTag::create_tag( name, size, default_value );
 break;
 default: // some illegal combination (multiple storage types, variable-length bit tag, etc.)
 return MB_TYPE_OUT_OF_RANGE;
 }
 
 if( !tag_handle ) return MB_INVALID_SIZE;
 
 if( created ) *created = true;
 tagList.push_back( tag_handle );
 return MB_SUCCESS;
}

References moab::BitTag::create_tag(), moab::DenseTag::create_tag(), moab::VarLenDenseTag::create_tag(), moab::TagInfo::equals_default_value(), moab::TagInfo::get_data_type(), moab::TagInfo::get_default_value(), moab::TagInfo::get_size(), moab::TagInfo::get_storage_type(), moab::is_zero_bytes(), MB_ALREADY_ALLOCATED, MB_INVALID_SIZE, MB_SUCCESS, MB_TAG_ANY, MB_TAG_BIT, MB_TAG_BYTES, MB_TAG_CREAT, MB_TAG_DENSE, MB_TAG_EXCL, MB_TAG_MESH, MB_TAG_NOOPQ, MB_TAG_NOT_FOUND, MB_TAG_SPARSE, MB_TAG_STORE, MB_TAG_VARLEN, MB_TYPE_BIT, MB_TYPE_OPAQUE, MB_TYPE_OUT_OF_RANGE, MB_VARIABLE_LENGTH, size, moab::TagInfo::size_from_data_type(), TagType, and moab::TagInfo::variable_length().

Referenced by add_field_value(), compute_lagrange_mesh_on_sphere(), compute_tracer_case1(), moab::HigherOrderFactory::convert_sequence(), create_coarse_mesh(), create_fine_mesh(), moab::ReadUtil::create_gather_set(), moab::NestedRefine::create_hm_storage_single_level(), create_lagr_mesh(), IntxUtilsCSLAM::create_span_quads(), RuntimeContext::create_sv_tags(), IntxUtilsCSLAM::deep_copy_set(), moab::WriteUtil::gather_nodes_from_elements(), moab::NestedRefine::generate_hm(), get_departure_grid(), moab::ReadUtil::get_gather_set(), get_intersection_weights(), moab::ReorderTool::handle_order_from_int_tag(), moab::ReorderTool::handle_order_from_sets_and_adj(), initialize_area_and_tracer(), moab::ReadParallel::load_file(), main(), obbvis_create(), perform_laplacian_smoothing(), perform_lloyd_relaxation(), process_partition_file(), test_spectral_hex(), TestErrorHandling_4(), update_density(), moab::NestedRefine::update_special_tags(), update_tracer(), and update_tracer_test().

tag_get_handle() [3/3]

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

virtual

Gets the tag handle corresponding to a name.

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

Parameters

tag_name	Name of the desired tag.
tag_handle	Tag handle corresponding to tag_name

Implements moab::Interface.

Definition at line 2498 of file Core.cpp.

{
 return tag_get_handle( tag_name, 0, MB_TYPE_OPAQUE, tag_handle, MB_TAG_ANY );
}

References MB_TAG_ANY, and MB_TYPE_OPAQUE.

tag_get_length()

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

virtual

Get the array length of a tag.

get size of tag in $values

Implements moab::Interface.

Definition at line 2526 of file Core.cpp.

{
 if( !valid_tag_handle( tag_handle ) ) return MB_TAG_NOT_FOUND;
 
 if( tag_handle->variable_length() )
 {
 tag_size = MB_VARIABLE_LENGTH;
 return MB_VARIABLE_DATA_LENGTH;
 }
 else
 {
 tag_size = tag_handle->get_size() / TagInfo::size_from_data_type( tag_handle->get_data_type() );
 return MB_SUCCESS;
 }
}

References moab::TagInfo::get_data_type(), moab::TagInfo::get_size(), MB_SUCCESS, MB_TAG_NOT_FOUND, MB_VARIABLE_DATA_LENGTH, MB_VARIABLE_LENGTH, moab::TagInfo::size_from_data_type(), and moab::TagInfo::variable_length().

Referenced by moab::WriteUtil::get_tag_list(), and main().

tag_get_name()

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

virtual

Gets the tag name string of the tag_handle.

gets the tag name string for the tag_handle

Parameters

tag_handle	Tag you want the name of.
tag_name	Name string of tag_handle.

Example:

Tag tag_handle = 0;
std::string tag_name = "my_special_tag";
tag_get_name( tag_handle, tag_name ); //gets the Tag from the tag's name string

Implements moab::Interface.

Definition at line 2491 of file Core.cpp.

{
 if( !valid_tag_handle( tag_handle ) ) return MB_TAG_NOT_FOUND;
 tag_name = tag_handle->get_name();
 return MB_SUCCESS;
}

References moab::TagInfo::get_name(), MB_SUCCESS, and MB_TAG_NOT_FOUND.

Referenced by gather_tag_counts(), moab::WriteUtil::get_tag_list(), and main().

tag_get_tags()

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

virtual

get handles for all tags defined

Implements moab::Interface.

Definition at line 2583 of file Core.cpp.

{
 std::copy( tagList.begin(), tagList.end(), std::back_inserter( tag_handles ) );
 return MB_SUCCESS;
}

References MB_SUCCESS.

Referenced by gather_tag_counts(), moab::WriteUtil::get_tag_list(), main(), and moab::ReorderTool::reorder_entities().

tag_get_tags_on_entity()

ErrorCode moab::Core::tag_get_tags_on_entity ( const EntityHandle  entity, std::vector< Tag > &  tag_handles  ) const

virtual

Get handles for all tags defined on this entity.

Implements moab::Interface.

Definition at line 2590 of file Core.cpp.

{
 for( std::list< TagInfo* >::const_iterator i = tagList.begin(); i != tagList.end(); ++i )
 if( ( *i )->is_tagged( sequenceManager, entity ) ) tag_handles.push_back( *i );
 return MB_SUCCESS;
}

References MB_SUCCESS.

tag_get_type()

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

virtual

get type of tag (sparse, dense, etc.; 0 = dense, 1 = sparse, 2 = bit, 3 = mesh)

get type of tag (sparse, dense, etc.; 0 = dense, 1 = sparse, 2 = bit, 3 = static)

Implements moab::Interface.

Definition at line 2575 of file Core.cpp.

{
 assert( valid_tag_handle( tag_handle ) );
 tag_type = tag_handle->get_storage_type();
 return MB_SUCCESS;
}

References moab::TagInfo::get_storage_type(), and MB_SUCCESS.

tag_iterate()

ErrorCode moab::Core::tag_iterate ( Tag  tag_handle, Range::const_iterator  iter, Range::const_iterator  end, int &  count, void *&  data_ptr, bool  allocate = true  )

virtual

Access tag data via direct pointer into contiguous blocks.

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

Parameters

tag_handle	The handle of the tag for which to access data
iter	The first entity for which to return data.
end	One past the last entity for which data is desired.
count	The number of entities for which data was returned
data_ptr	Output: pointer to tag storage.
allocate	If true, space for this tag will be allocated, if not it wont

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

\Example:

Range ents; // range to iterate over
Tag tag; // tag for which to access data
int bytes;
ErrorCode err = mb.tag_get_size( tag, bytes );
if (err) { ... }
 
...
Range::iterator iter = ents.begin();
while (iter != ents.end()) {
 int count;
 // get contiguous block of tag dat
 void* ptr;
 err = mb.tag_iterate( tag, iter, ents.end(), count, ptr );
 if (err) { ... }
 // do something with tag data
 process_Data( ptr, count );
 // advance to next block of data
 iter += count;
}

Implements moab::Interface.

Definition at line 2476 of file Core.cpp.

{
 Range::const_iterator init = iter;
 assert( valid_tag_handle( tag_handle ) );
 ErrorCode result = tag_handle->tag_iterate( sequenceManager, mError, iter, end, data_ptr, allocate );
 if( MB_SUCCESS == result ) count = iter - init;
 return result;
}

References ErrorCode, MB_SUCCESS, and moab::TagInfo::tag_iterate().

Referenced by add_field_value(), compute_lagrange_mesh_on_sphere(), compute_velocity_case1(), main(), TestErrorHandling_4(), and update_density().

tag_set_by_ptr() [1/2]

ErrorCode moab::Core::tag_set_by_ptr ( Tag  tag_handle, const EntityHandle *  entity_handles, int  num_entities, void const *const *  tag_data, const int *  tag_sizes = 0  )

virtual

Set tag data given an array of pointers to tag values.

set the data for given EntityHandles and Tag

For a tag, set the values for a list of passed entity handles.

Note

This function may not be used for bit tags.

Parameters

tag_handle	The tag
entity_handles	An array of entity handles for which to set tag values.
num_entities	The length of the 'entity_handles' array.
tag_data	An array of 'const void*'. Array must be at least 'num_entitities' long. Array is expected to contain pointers to tag values for the corresponding EntityHandle in 'entity_handles'.
tag_sizes	The length of each tag value. Optional for fixed-length tags. Required for variable-length tags.

Implements moab::Interface.

Definition at line 2205 of file Core.cpp.

{
 assert( valid_tag_handle( tag_handle ) );
 CHECK_MESH_NULL
 std::vector< int > tmp_sizes;
 int typesize = TagInfo::size_from_data_type( tag_handle->get_data_type() );
 if( typesize != 1 && tag_sizes )
 {
 tmp_sizes.resize( num_entities );
 for( int i = 0; i < num_entities; ++i )
 tmp_sizes[i] = tag_sizes[i] * typesize;
 tag_sizes = &tmp_sizes[0];
 }
 return tag_handle->set_data( sequenceManager, mError, entity_handles, num_entities, tag_data, tag_sizes );
}

References CHECK_MESH_NULL, moab::TagInfo::get_data_type(), moab::TagInfo::set_data(), and moab::TagInfo::size_from_data_type().

Referenced by moab::ReorderTool::reorder_tag_data().

tag_set_by_ptr() [2/2]

ErrorCode moab::Core::tag_set_by_ptr ( Tag  tag_handle, const Range &  entity_handles, void const *const *  tag_data, const int *  tag_sizes = 0  )

virtual

Set tag data given an array of pointers to tag values.

set the data for given EntityHandles and Tag

For a tag, set the values for a list of passed entity handles.

Note

This function may not be used for bit tags.

Parameters

tag_handle	The tag
entity_handles	The entity handles for which to set tag values.
tag_data	An array of 'const void*'. Array is expected to contain pointers to tag values for the corresponding EntityHandle in 'entity_handles'.
tag_sizes	The length of each tag value. Optional for fixed-length tags. Required for variable-length tags.

Implements moab::Interface.

Definition at line 2226 of file Core.cpp.

{
 assert( valid_tag_handle( tag_handle ) );
 std::vector< int > tmp_sizes;
 int typesize = TagInfo::size_from_data_type( tag_handle->get_data_type() );
 if( typesize != 1 && tag_sizes )
 {
 int num_entities = entity_handles.size();
 tmp_sizes.resize( num_entities );
 for( int i = 0; i < num_entities; ++i )
 tmp_sizes[i] = tag_sizes[i] * typesize;
 tag_sizes = &tmp_sizes[0];
 }
 return tag_handle->set_data( sequenceManager, mError, entity_handles, tag_data, tag_sizes );
}

References moab::TagInfo::get_data_type(), moab::TagInfo::set_data(), moab::Range::size(), and moab::TagInfo::size_from_data_type().

tag_set_data() [1/2]

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

virtual

Sets the data of a given EntityHandle and Tag.

set the data for given EntityHandles and Tag

If the tag_handle and the entity type of entity_handle are not compatible, data of entity_handle never existed and MB_FAILURE is returned.

Parameters

tag_handle	Tag indicating what data is to be set.
entity_handle	EntityHandle on which to set tag's data.
tag_data	Data to set the entity_handle's tag data to.

Example:

int tag_data = 1004;
tag_set_data( tag_handle, entity_handle, &tag_data ); 

Implements moab::Interface.

Examples

addPCdata.cpp.

Definition at line 2151 of file Core.cpp.

{
 assert( valid_tag_handle( tag_handle ) );
 CHECK_MESH_NULL
 return tag_handle->set_data( sequenceManager, mError, entity_handles, num_entities, tag_data );
}

References CHECK_MESH_NULL, and moab::TagInfo::set_data().

Referenced by moab::WriteUtil::assign_ids(), moab::ReadUtil::assign_ids(), create_coarse_mesh(), create_fine_mesh(), moab::ReadUtil::create_gather_set(), create_lagr_mesh(), IntxUtilsCSLAM::create_span_quads(), RuntimeContext::create_sv_tags(), IntxUtilsCSLAM::deep_copy_set(), moab::HalfFacetRep::determine_border_vertices(), fill_coord_on_edges(), moab::WriteUtil::gather_nodes_from_elements(), get_barycenters(), moab::WriteUtil::get_element_connect(), get_gnomonic_plane(), get_intersection_weights(), get_linear_reconstruction(), moab::WriteUtil::get_node_coords(), moab::ReorderTool::handle_order_from_int_tag(), initialize_area_and_tracer(), moab::ReorderTool::int_order_from_sets_and_adj(), main(), obbvis_create(), perform_laplacian_smoothing(), perform_lloyd_relaxation(), process_partition_file(), moab::HigherOrderFactory::remove_ho_nodes(), moab::ReorderTool::reorder_tag_data(), set_density(), tag_depth(), update_density(), and update_tracer_test().

tag_set_data() [2/2]

ErrorCode moab::Core::tag_set_data ( Tag  tag_handle, const Range &  entity_handles, const void *  tag_data  )

virtual

set the data for given EntityHandles and Tag

Implements moab::Interface.

Definition at line 2162 of file Core.cpp.

{
 assert( valid_tag_handle( tag_handle ) );
 return tag_handle->set_data( sequenceManager, mError, entity_handles, tag_data );
}

References moab::TagInfo::set_data().

type_from_handle()

EntityType moab::Core::type_from_handle ( const EntityHandle  handle ) const

virtual

get the type from a handle, returns type

Implements moab::Interface.

Definition at line 374 of file Core.cpp.

{
 if( !handle ) // root set
 return MBENTITYSET;
 else
 return TYPE_FROM_HANDLE( handle );
}

References MBENTITYSET, and moab::TYPE_FROM_HANDLE().

Referenced by moab::HalfFacetRep::add_cells_of_single_component(), moab::HalfFacetRep::another_halfedge(), moab::NestedRefine::child_to_parent(), moab::HalfFacetRep::collect_and_compare(), moab::NestedRefine::compute_coordinates(), moab::NestedRefine::construct_hm_2D(), moab::NestedRefine::construct_hm_3D(), moab::NestedRefine::create_hm_storage_single_level(), create_lagr_mesh(), IntxUtilsCSLAM::deep_copy_set(), moab::HalfFacetRep::determine_border_vertices(), moab::HalfFacetRep::determine_incident_halfedges(), moab::HalfFacetRep::determine_sibling_halfedges(), moab::HalfFacetRep::determine_sibling_halffaces(), moab::NestedRefine::estimate_hm_storage(), moab::HalfFacetRep::find_matching_halfedge(), moab::HalfFacetRep::find_matching_halfface(), moab::HalfFacetRep::find_matching_implicit_edge_in_cell(), moab::HalfFacetRep::find_total_edges_2d(), moab::WriteUtil::gather_nodes_from_elements(), moab::NestedRefine::get_connectivity(), moab::HalfFacetRep::get_down_adjacencies_2d(), moab::HalfFacetRep::get_face_edges(), moab::HalfFacetRep::get_half_facet_in_comp(), moab::HalfFacetRep::get_index_in_lmap(), moab::HalfFacetRep::get_neighbor_adjacencies_2d(), moab::HalfFacetRep::get_neighbor_adjacencies_3d(), moab::HalfFacetRep::get_up_adjacencies_2d(), moab::HalfFacetRep::get_up_adjacencies_edg_3d(), moab::HalfFacetRep::get_up_adjacencies_edg_3d_comp(), moab::HalfFacetRep::get_up_adjacencies_face_3d(), moab::HalfFacetRep::get_up_adjacencies_vert_2d(), moab::HalfFacetRep::get_up_adjacencies_vert_3d(), moab::HalfFacetRep::init_surface(), moab::NestedRefine::initialize(), moab::NestedRefine::is_entity_on_boundary(), main(), moab::HalfFacetRep::mark_halfedges(), moab::NestedRefine::parent_to_child(), perform_laplacian_smoothing(), moab::HalfFacetRep::print_tags(), moab::HalfFacetRep::resize_hf_maps(), moab::NestedRefine::update_global_ahf_2D(), moab::NestedRefine::update_global_ahf_2D_sub(), moab::NestedRefine::update_global_ahf_3D(), moab::NestedRefine::update_special_tags(), and moab::NestedRefine::update_tracking_verts().

unite_meshset()

ErrorCode moab::Core::unite_meshset ( EntityHandle  meshset1, const EntityHandle  meshset2  )

virtual

unites meshset2 with meshset1 - modifies meshset1

Implements moab::Interface.

Definition at line 3334 of file Core.cpp.

{
 MeshSet* set1 = get_mesh_set( sequence_manager(), meshset1 );
 MeshSet* set2 = get_mesh_set( sequence_manager(), meshset2 );
 if( !set1 || !set2 ) return MB_ENTITY_NOT_FOUND;
 
 return set1->unite( set2, meshset1, a_entity_factory() );
}

References moab::get_mesh_set(), MB_ENTITY_NOT_FOUND, and moab::MeshSet::unite().

valid_tag_handle()

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

inlineprivate

Definition at line 1315 of file Core.hpp.

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

References t, and tagList.

write_file() [1/2]

ErrorCode moab::Core::write_file ( const char *  file_name, const char *  file_type, const char *  options, const Range &  output_sets, const Tag *  tag_list = 0, int  num_tags = 0  )

virtual

Write or export a file

Implements moab::Interface.

Definition at line 669 of file Core.cpp.

{
 // convert range to vector
 std::vector< EntityHandle > list( output_sets.size() );
 std::copy( output_sets.begin(), output_sets.end(), list.begin() );
 
 // parse some options
 FileOptions opts( options_string );
 ErrorCode rval;
 
 rval = opts.get_null_option( "CREATE" );
 if( rval == MB_TYPE_OUT_OF_RANGE )
 {
 MB_SET_GLB_ERR( MB_FAILURE, "Unexpected value for CREATE option" );
 }
 bool overwrite = ( rval == MB_ENTITY_NOT_FOUND );
 
 // Get the file writer
 std::string ext = ReaderWriterSet::extension_from_filename( file_name );
 std::vector< std::string > qa_records;
 const EntityHandle* list_ptr = list.empty() ? (EntityHandle*)0 : &list[0];
 
 rval = MB_TYPE_OUT_OF_RANGE;
 
 // Try all possible writers
 for( ReaderWriterSet::iterator i = reader_writer_set()->begin(); i != reader_writer_set()->end(); ++i )
 {
 
 if( ( file_type && !i->name().compare( file_type ) ) || i->writes_extension( ext.c_str() ) )
 {
 
 WriterIface* writer = i->make_writer( this );
 
 // write the file
 rval =
 writer->write_file( file_name, overwrite, opts, list_ptr, list.size(), qa_records, tag_list, num_tags );
 delete writer;
 if( MB_SUCCESS == rval ) break;
 printf( "Writer with name %s for file %s using extension %s (file type \"%s\") was "
 "unsuccessful\n",
 i->name().c_str(), file_name, ext.c_str(), file_type );
 }
 }
 
 if( file_type && rval == MB_TYPE_OUT_OF_RANGE )
 {
 MB_SET_ERR( rval, "Unrecognized file type \"" << file_type << "\"" );
 }
 // Should we use default writer (e.g. HDF5)?
 else if( MB_SUCCESS != rval )
 {
 DefaultWriter writer( this );
 printf( "Using default writer %s for file %s \n", DefaultWriterName, file_name );
 rval = writer.write_file( file_name, overwrite, opts, list_ptr, list.size(), qa_records, tag_list, num_tags );
 }
 
 if( MB_SUCCESS == rval && !opts.all_seen() )
 {
 std::string bad_opt;
 if( MB_SUCCESS == opts.get_unseen_option( bad_opt ) )
 {
 MB_SET_ERR( MB_UNHANDLED_OPTION, "Unrecognized option: \"" << bad_opt << "\"" );
 }
 else
 {
 MB_SET_ERR( MB_UNHANDLED_OPTION, "Unrecognized option" );
 }
 }
 
 return MB_SUCCESS;
}

References moab::FileOptions::all_seen(), moab::Range::begin(), DefaultWriterName, moab::Range::end(), ErrorCode, moab::ReaderWriterSet::extension_from_filename(), moab::FileOptions::get_null_option(), moab::FileOptions::get_unseen_option(), MB_ENTITY_NOT_FOUND, MB_SET_ERR, MB_SET_GLB_ERR, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MB_UNHANDLED_OPTION, moab::FileOptions::size(), moab::Range::size(), moab::WriterIface::write_file(), and moab::WriteVtk::write_file().

write_file() [2/2]

ErrorCode moab::Core::write_file ( const char *  file_name, const char *  file_type = 0, const char *  options = 0, const EntityHandle *  output_sets = 0, int  num_output_sets = 0, const Tag *  tag_list = 0, int  num_tags = 0  )

virtual

Write or export a file.

Implements moab::Interface.

Examples

addPCdata.cpp.

Definition at line 656 of file Core.cpp.

{
 Range range;
 std::copy( output_sets, output_sets + num_output_sets, range_inserter( range ) );
 return write_file( file_name, file_type, options_string, range, tag_list, num_tags );
}

Referenced by compute_tracer_case1(), compute_velocity_case1(), create_coarse_mesh(), create_fine_mesh(), IntxUtilsCSLAM::create_span_quads(), main(), obbvis_create(), perform_laplacian_smoothing(), test_intx_in_parallel_elem_based(), and update_tracer().

write_mesh()

ErrorCode moab::Core::write_mesh ( const char *  file_name, const EntityHandle *  output_list = NULL, const int  num_sets = 0  )

virtual

Writes mesh to a file.

Write mesh to file 'file_name'; if output_list is non-NULL, only material sets contained in that list will be written.

Parameters

file_name	Name of file to write.
output_list	1d array of material set handles to write; if NULL, all sets are written
num_sets	Number of sets in output_list array

Example:

EntityHandle output_list[] = {meshset1, meshset2, meshset3};
write_mesh( "output_file.gen", output_list, 3 ); 

Implements moab::Interface.

Definition at line 651 of file Core.cpp.

{
 return write_file( file_name, 0, 0, output_list, num_sets );
}

Referenced by create_fine_mesh(), intersection_at_level(), and main().

Friends And Related Function Documentation

SetIterator

friend class SetIterator

friend

Definition at line 53 of file Core.hpp.

Member Data Documentation

aEntityFactory

AEntityFactory* moab::Core::aEntityFactory

private

Definition at line 1322 of file Core.hpp.

Referenced by a_entity_factory().

dirichletBCTag

Tag moab::Core::dirichletBCTag

private

Definition at line 1309 of file Core.hpp.

geomDimensionTag

Tag moab::Core::geomDimensionTag

private

Definition at line 1310 of file Core.hpp.

geometricDimension

int moab::Core::geometricDimension

private

store the total number of elements defined in this interface

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

Definition at line 1305 of file Core.hpp.

globalIdTag

Tag moab::Core::globalIdTag

private

Definition at line 1311 of file Core.hpp.

initErrorHandlerInCore

bool moab::Core::initErrorHandlerInCore

private

Definition at line 1329 of file Core.hpp.

materialTag

Tag moab::Core::materialTag

private

Definition at line 1307 of file Core.hpp.

mError

Error* moab::Core::mError

private

Definition at line 1326 of file Core.hpp.

mMBReadUtil

ReadUtil* moab::Core::mMBReadUtil

private

Definition at line 1295 of file Core.hpp.

mMBWriteUtil

WriteUtil* moab::Core::mMBWriteUtil

private

Definition at line 1294 of file Core.hpp.

mpiFinalize

bool moab::Core::mpiFinalize

private

Definition at line 1327 of file Core.hpp.

neumannBCTag

Tag moab::Core::neumannBCTag

private

Definition at line 1308 of file Core.hpp.

readerWriterSet

ReaderWriterSet* moab::Core::readerWriterSet

private

Definition at line 1324 of file Core.hpp.

Referenced by reader_writer_set().

scdInterface

ScdInterface* moab::Core::scdInterface

private

Definition at line 1296 of file Core.hpp.

sequenceManager

SequenceManager* moab::Core::sequenceManager

private

Definition at line 1320 of file Core.hpp.

Referenced by sequence_manager().

setIterators

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

private

list of iterators

Definition at line 1332 of file Core.hpp.

tagList

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

private

tag server for this interface

Definition at line 1314 of file Core.hpp.

Referenced by valid_tag_handle().

writeMPELog

int moab::Core::writeMPELog

private

Definition at line 1328 of file Core.hpp.

---

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

• Core.hpp
• Core.cpp