A class enabling Mesquite calls on Rocmop panes. More...

#include <MesqPane.h>

Inheritance diagram for MesqPane:

Collaboration diagram for MesqPane:

Classes
struct	tag
	A tag structure required by Mesquite. More...

struct	tagStruct

Public Types
typedef void *	EntityHandle
	Opaque EntityHandle type and tag type. More...

typedef void *	TagHandle

typedef EntityHandle	VertexHandle

typedef EntityHandle	ElementHandle

typedef void *	EntityHandle
	Opaque EntityHandle type and tag type. More...

typedef void *	TagHandle

typedef EntityHandle	VertexHandle

typedef EntityHandle	ElementHandle

Public Types inherited from Mesh
enum	TagType { BYTE, BOOL, INT, DOUBLE, HANDLE }
	The type of a tag. More...

typedef void *	EntityHandle
	Opaque EntityHandle type and tag type. More...

typedef EntityHandle	VertexHandle

typedef EntityHandle	ElementHandle

Public Member Functions
void	invert (int conn_type)
	Invert Elements. More...

	MesqPane (COM::Pane *p, bool with_ghost=true)
	Construct from a pane. More...

void	set_verb (int verb)
	Set the MesqPane verbose level (int, >= 0) More...

virtual	~MesqPane ()
	Destructor. More...

void	init ()
	Initialize the MesqPane. More...

virtual int	get_geometric_dimension (MsqError &err)
	Returns whether this mesh lies in a 2D or 3D coordinate system. More...

virtual void	get_all_elements (msq_std::vector< ElementHandle > &elements, MsqError &err)
	Get all elements in mesh. More...

virtual void	get_all_vertices (msq_std::vector< VertexHandle > &vertices, MsqError &err)
	Get all vertices in mesh. More...

virtual void	get_all_sizes (size_t &vertex_count, size_t &element_count, size_t &vertex_use_count, MsqError &err)
	get sizes for calling get_all_mesh More...

virtual void	get_all_mesh (VertexHandle vert_array, size_t vert_len, ElementHandle elem_array, size_t elem_len, size_t elem_conn_offsets, size_t offset_len, size_t elem_conn_indices, size_t index_len, MsqError &err)
	Get entities and connectivity. More...

virtual VertexIterator *	vertex_iterator (MsqError &err)
	Returns a pointer to an iterator that iterates over the set of all vertices in this mesh. More...

virtual ElementIterator *	element_iterator (MsqError &err)
	Returns a pointer to an iterator that iterates over the set of all top-level elements in this mesh. More...

virtual void	vertices_get_fixed_flag (const VertexHandle vert_array[], bool fixed_flag_array[], size_t num_vtx, MsqError &err)
	Returns true or false, indicating whether the vertex is allowed to be repositioned. More...

virtual bool	vertex_is_fixed (VertexHandle vertex, MsqError &err)
	Returns true or false, indicating whether the vertex is allowed to be repositioned. More...

virtual void	vertices_are_on_boundary (VertexHandle vert_array[], bool on_bnd[], size_t num_vtx, MsqError &err)
	Returns true or false, indicating whether the vertex is on the boundary. More...

virtual void	vertices_get_coordinates (const VertexHandle vert_array[], MsqVertex *coordinates, size_t num_vtx, MsqError &err)
	Get/set location of a vertex. More...

virtual void	vertex_set_coordinates (VertexHandle vertex, const Vector3D &coordinates, MsqError &err)

virtual void	vertex_set_byte (VertexHandle vertex, unsigned char byte, MsqError &err)
	Each vertex has a byte-sized flag that can be used to store flags. More...

virtual void	vertices_set_byte (VertexHandle vert_array, unsigned char byte_array, size_t array_size, MsqError &err)

virtual void	vertices_set_byte (const VertexHandle vert_array, const unsigned char byte_array, size_t array_size, MsqError &err)

virtual void	vertex_get_byte (VertexHandle vertex, unsigned char *byte, MsqError &err)
	Retrieve the byte value for the specified vertex or vertices. More...

virtual void	vertices_get_byte (VertexHandle vertex, unsigned char byte_array, size_t array_size, MsqError &err)

virtual void	vertices_get_byte (const VertexHandle vertex, unsigned char byte_array, size_t array_size, MsqError &err)

virtual size_t	vertex_get_attached_element_count (VertexHandle vertex, MsqError &err)
	Gets the number of elements attached to this vertex. More...

virtual void	vertex_get_attached_elements (VertexHandle vertex, ElementHandle *elem_array, size_t sizeof_elem_array, MsqError &err)
	Gets the elements attached to this vertex. More...

virtual void	vertices_get_attached_elements (const VertexHandle *vertex_array, size_t num_vertex, msq_std::vector< ElementHandle > &elements, msq_std::vector< size_t > &offsets, MsqError &err)
	get elements adjacent to vertices More...

virtual size_t	element_get_attached_vertex_count (ElementHandle elem, MsqError &err)
	Gets the number of vertices in this element. More...

virtual size_t	get_vertex_use_count (ElementHandle *handle_array, size_t num_handles, MsqError &err)

virtual void	elements_get_attached_vertices (const ElementHandle *elem_handles, size_t num_elems, msq_std::vector< VertexHandle > &vert_handles, msq_std::vector< size_t > &offsets, MsqError &err)
	Get element connectivity. More...

virtual void	elements_get_attached_vertices (ElementHandle elem_handles, size_t num_elems, VertexHandle vert_handles, size_t &sizeof_vert_handles, size_t csr_data, size_t &sizeof_csr_data, size_t csr_offsets, MsqError &err)
	Returns the vertices that are part of the topological definition of each element in the "elem_handles" array. More...

virtual EntityTopology	element_get_topology (ElementHandle entity_handle, MsqError &err)
	Returns the topology of the given entity. More...

virtual void	elements_get_topologies (ElementHandle element_handle_array, EntityTopology element_topologies, size_t num_elements, MsqError &err)
	Returns the topologies of the given entities. More...

virtual void	elements_get_topologies (const ElementHandle element_handle_array, EntityTopology element_topologies, size_t num_elements, MsqError &err)
	Returns the topologies of the given entities. More...

virtual TagHandle	tag_create (const msq_std::string &tag_name, TagType type, unsigned length, const void *default_value, MsqError &err)
	Create a tag. More...

virtual void	tag_delete (TagHandle handle, MsqError &err)
	Remove a tag and all corresponding data. More...

virtual TagHandle	tag_get (const msq_std::string &name, MsqError &err)
	Get handle for existing tag, by name. More...

virtual void	tag_properties (TagHandle handle, msq_std::string &name_out, TagType &type_out, unsigned &length_out, MsqError &err)
	Get properites of tag. More...

virtual void	tag_set_element_data (TagHandle handle, size_t num_elems, const ElementHandle elem_array, const void tag_data, MsqError &err)
	Set tag values on elements. More...

virtual void	tag_set_vertex_data (TagHandle handle, size_t num_elems, const VertexHandle node_array, const void tag_data, MsqError &err)
	Set tag values on vertices. More...

virtual void	tag_get_element_data (TagHandle handle, size_t num_elems, const ElementHandle elem_array, void tag_data, MsqError &err)
	Get tag values on elements. More...

virtual void	tag_get_vertex_data (TagHandle handle, size_t num_elems, const VertexHandle node_array, void tag_data, MsqError &err)
	Get tag values on vertices. More...

virtual void	release_entity_handles (const EntityHandle *handle_array, size_t num_handles, MsqError &err)
	Tells the mesh that the client is finished with a given entity handle. More...

virtual void	release_entity_handles (EntityHandle *handle_array, size_t num_handles, MsqError &err)
	Tells the mesh that the client is finished with a given entity handle. More...

virtual void	release ()
	Instead of deleting a Mesh when you think you are done, call release(). More...

void	invert ()
	Invert Tetrahedrons. More...

	MesqPane (COM::Pane *p, bool with_ghost=true)
	Construct from a pane. More...

void	set_verb (int verb)
	Set the MesqPane verbose level (int, >= 0) More...

virtual	~MesqPane ()
	Destructor. More...

void	init ()
	Initialize the MesqPane. More...

virtual int	get_geometric_dimension (MsqError &err)
	Returns whether this mesh lies in a 2D or 3D coordinate system. More...

virtual void	get_all_sizes (size_t &vertex_count, size_t &element_count, size_t &vertex_use_count, MsqError &err)
	get sizes for calling get_all_mesh More...

virtual void	get_all_mesh (VertexHandle vert_array, size_t vert_len, ElementHandle elem_array, size_t elem_len, size_t elem_conn_offsets, size_t offset_len, size_t elem_conn_indices, size_t index_len, MsqError &err)
	Get entities and connectivity. More...

virtual VertexIterator *	vertex_iterator (MsqError &err)
	Returns a pointer to an iterator that iterates over the set of all vertices in this mesh. More...

virtual ElementIterator *	element_iterator (MsqError &err)
	Returns a pointer to an iterator that iterates over the set of all top-level elements in this mesh. More...

virtual bool	vertex_is_fixed (VertexHandle vertex, MsqError &err)
	Returns true or false, indicating whether the vertex is allowed to be repositioned. More...

virtual void	vertices_are_on_boundary (VertexHandle vert_array[], bool on_bnd[], size_t num_vtx, MsqError &err)
	Returns true or false, indicating whether the vertex is on the boundary. More...

virtual void	vertices_get_coordinates (const VertexHandle vert_array[], MsqVertex *coordinates, size_t num_vtx, MsqError &err)
	Get/set location of a vertex. More...

virtual void	vertex_set_coordinates (VertexHandle vertex, const Vector3D &coordinates, MsqError &err)

virtual void	vertex_set_byte (VertexHandle vertex, unsigned char byte, MsqError &err)
	Each vertex has a byte-sized flag that can be used to store flags. More...

virtual void	vertices_set_byte (VertexHandle vert_array, unsigned char byte_array, size_t array_size, MsqError &err)

virtual void	vertex_get_byte (VertexHandle vertex, unsigned char *byte, MsqError &err)
	Retrieve the byte value for the specified vertex or vertices. More...

virtual void	vertices_get_byte (VertexHandle vertex, unsigned char byte_array, size_t array_size, MsqError &err)

virtual size_t	vertex_get_attached_element_count (VertexHandle vertex, MsqError &err)
	Gets the number of elements attached to this vertex. More...

virtual void	vertex_get_attached_elements (VertexHandle vertex, ElementHandle *elem_array, size_t sizeof_elem_array, MsqError &err)
	Gets the elements attached to this vertex. More...

virtual size_t	element_get_attached_vertex_count (ElementHandle elem, MsqError &err)
	Gets the number of vertices in this element. More...

virtual size_t	get_vertex_use_count (ElementHandle *handle_array, size_t num_handles, MsqError &err)

virtual void	elements_get_attached_vertices (ElementHandle elem_handles, size_t num_elems, VertexHandle vert_handles, size_t &sizeof_vert_handles, size_t csr_data, size_t &sizeof_csr_data, size_t csr_offsets, MsqError &err)
	Returns the vertices that are part of the topological definition of each element in the "elem_handles" array. More...

virtual EntityTopology	element_get_topology (ElementHandle entity_handle, MsqError &err)
	Returns the topology of the given entity. More...

virtual void	elements_get_topologies (ElementHandle element_handle_array, EntityTopology element_topologies, size_t num_elements, MsqError &err)
	Returns the topologies of the given entities. More...

virtual TagHandle	tag_create (const msq_std::string &tag_name, TagType type, unsigned length, const void *default_value, MsqError &err)
	Create a tag. More...

virtual void	tag_delete (TagHandle handle, MsqError &err)
	Remove a tag and all corresponding data. More...

virtual TagHandle	tag_get (const msq_std::string &name, MsqError &err)
	Get handle for existing tag, by name. More...

virtual void	tag_properties (TagHandle handle, msq_std::string &name_out, TagType &type_out, unsigned &length_out, MsqError &err)
	Get properites of tag. More...

virtual void	tag_set_element_data (TagHandle handle, size_t num_elems, const ElementHandle elem_array, const void tag_data, MsqError &err)
	Set tag values on elements. More...

virtual void	tag_set_vertex_data (TagHandle handle, size_t num_elems, const VertexHandle node_array, const void tag_data, MsqError &err)
	Set tag values on vertices. More...

virtual void	tag_get_element_data (TagHandle handle, size_t num_elems, const ElementHandle elem_array, void tag_data, MsqError &err)
	Get tag values on elements. More...

virtual void	tag_get_vertex_data (TagHandle handle, size_t num_elems, const VertexHandle node_array, void tag_data, MsqError &err)
	Get tag values on vertices. More...

virtual void	release_entity_handles (EntityHandle *handle_array, size_t num_handles, MsqError &err)
	Tells the mesh that the client is finished with a given entity handle. More...

virtual void	release ()
	Instead of deleting a Mesh when you think you are done, call release(). More...

Constructors and Destructors
	MesqPane (COM::Pane *p, bool with_ghost=true)
	Construct from a pane. More...

virtual	~MesqPane ()
	Destructor. More...

Miscellaneous functions
void	invert ()
	Invert Tetrahedrons. More...

void	init ()
	Initialize the MesqPane. More...

void	set_verb (int verb)
	Set the MesqPane verbose level (int, >= 0) More...

Inherited Operations on Entire Mesh
virtual int	get_geometric_dimension (MsqError &err) const
	Returns whether this mesh lies in a 2D or 3D coordinate system. More...

virtual size_t	get_total_vertex_count (MsqError &err) const
	Returns the number of nodes. More...

virtual size_t	get_total_element_count (MsqError &err) const
	Returns the number of elements. More...

virtual void	get_all_vertices (VertexHandle *vert_array, size_t array_size, MsqError &err)
	Fills array with handles to all vertices. More...

virtual void	get_all_elements (ElementHandle *elem_array, size_t array_size, MsqError &err)
	Fills array with handles to all elements in the mesh. More...

virtual VertexIterator *	vertex_iterator (MsqError &err)
	Returns a pointer to a vertex iterator over this Pane. More...

virtual ElementIterator *	element_iterator (MsqError &err)
	Returns a pointer to an element iterator over this Pane. More...

Inherited vertex Properties
virtual bool	vertex_is_fixed (VertexHandle vertex, MsqError &err)
	Tells wheter the vertex is allowed to be repositioned. More...

virtual void	vertices_are_on_boundary (VertexHandle vert_array[], bool on_bnd[], size_t num_vtx, MsqError &err)
	Tells whether the vertex is on the boundary. More...

virtual void	vertices_get_coordinates (VertexHandle vert_array[], Mesquite::MsqVertex *const &coordinates, const size_t &num_vtx, MsqError &err)
	Get the location of a vertex. More...

virtual void	vertex_set_coordinates (VertexHandle vertex, const Vector3D &coordinates, MsqError &err)
	Set the Location of a vertex. More...

virtual void	vertex_set_byte (VertexHandle vertex, unsigned char byte, MsqError &err)
	Set a vertex flag. More...

virtual void	vertices_set_byte (VertexHandle vert_array, unsigned char byte_array, size_t array_size, MsqError &err)
	Set mutliple vertex flags. More...

virtual void	vertex_get_byte (VertexHandle vertex, unsigned char *byte, MsqError &err)
	Retrieve the byte value for the specified vertex. More...

virtual void	vertices_get_byte (VertexHandle vertex, unsigned char byte_array, size_t array_size, MsqError &err)
	Retrieve the byte value for the specified vertices. More...

Inherited Vertex Topology
virtual size_t	vertex_get_attached_element_count (VertexHandle vertex, MsqError &err) const
	Gets the number of elements attached to this vertex. More...

virtual void	vertex_get_attached_elements (VertexHandle vertex, ElementHandle *elem_array, size_t sizeof_elem_array, MsqError &err)
	Gets the elements attached to this vertex. More...

Inherited Element Topology
virtual size_t	element_get_attached_vertex_count (ElementHandle elem, MsqError &err) const
	Gets the number of vertices in this element. More...

virtual void	elements_get_attached_vertices (ElementHandle elem_handles, size_t num_elems, VertexHandle vert_handles, size_t &sizeof_vert_handles, size_t csr_data, size_t &sizeof_csr_data, size_t csr_offsets, MsqError &err)
	Returns vertices which are part of each element in the "elem_handles" array. More...

virtual void	elements_get_attached_vertex_indices (ElementHandle element[], size_t num_elems, size_t index_array[], size_t array_size, size_t *offsets, MsqError &err)
	Return each vertex's global index. More...

virtual EntityTopology	element_get_topology (ElementHandle entity_handle, MsqError &err) const
	Returns the topology of the given entity. More...

virtual void	elements_get_topologies (ElementHandle element_handle_array, EntityTopology element_topologies, size_t num_elements, MsqError &err)
	Returns the topologies of the given entities. More...

Inherited Tags
virtual void	element_tag_create (const string tag_name, int tag_size, TagHandle &tag_handle, MsqError &err)
	Add a new tag with given name and size to the dense tag map. More...

virtual void *	tag_get_handle (const string tag_name, MsqError &err)
	Returns the tag handle corresponding to the string. More...

virtual void	elements_set_tag_data (const size_t num_elements, const TagHandle tag_handle, TagDataPt const tag_data_array, const int &tag_size, MsqError &err)
	Sets the Tag data pointers for an array of entities. More...

virtual void	elements_get_tag_data (const size_t num_elements, const TagHandle tag_handle, TagDataPt &tag_data_array, int &tag_size, MsqError &err)
	Gets the Tag data for an array of entities. More...

Inherited Memory Management
virtual void	release_entity_handles (EntityHandle *handle_array, size_t num_handles, MsqError &err)
	Tells the mesh that the client is finished with a given entity handle. More...

virtual void	release ()
	Release a MesqPane from use. More...

Public Member Functions inherited from Mesh
virtual int	get_geometric_dimension (MsqError &err)=0
	Returns whether this mesh lies in a 2D or 3D coordinate system. More...

virtual void	get_all_sizes (size_t &vertex_count, size_t &element_count, size_t &vertex_use_count, MsqError &err)=0
	get sizes for calling get_all_mesh More...

virtual void	get_all_mesh (VertexHandle vert_array, size_t vert_len, ElementHandle elem_array, size_t elem_len, size_t elem_conn_offsets, size_t offset_len, size_t elem_conn_indices, size_t index_len, MsqError &err)=0
	Get entities and connectivity. More...

virtual void	vertices_get_coordinates (const VertexHandle vert_array[], MsqVertex *coordinates, size_t num_vtx, MsqError &err)=0
	Get/set location of a vertex. More...

virtual size_t	vertex_get_attached_element_count (VertexHandle vertex, MsqError &err)=0
	Gets the number of elements attached to this vertex. More...

virtual size_t	element_get_attached_vertex_count (ElementHandle elem, MsqError &err)=0
	Gets the number of vertices in this element. More...

virtual size_t	get_vertex_use_count (ElementHandle *handle_array, size_t num_handles, MsqError &err)=0

virtual EntityTopology	element_get_topology (ElementHandle entity_handle, MsqError &err)=0
	Returns the topology of the given entity. More...

virtual TagHandle	tag_create (const msq_std::string &tag_name, TagType type, unsigned length, const void *default_value, MsqError &err)=0
	Create a tag. More...

virtual void	tag_delete (TagHandle handle, MsqError &err)=0
	Remove a tag and all corresponding data. More...

virtual TagHandle	tag_get (const msq_std::string &name, MsqError &err)=0
	Get handle for existing tag, by name. More...

virtual void	tag_properties (TagHandle handle, msq_std::string &name_out, TagType &type_out, unsigned &length_out, MsqError &err)=0
	Get properites of tag. More...

virtual void	tag_set_element_data (TagHandle handle, size_t num_elems, const ElementHandle elem_array, const void tag_data, MsqError &err)=0
	Set tag values on elements. More...

virtual void	tag_set_vertex_data (TagHandle handle, size_t num_elems, const VertexHandle node_array, const void tag_data, MsqError &err)=0
	Set tag values on vertices. More...

virtual void	tag_get_element_data (TagHandle handle, size_t num_elems, const ElementHandle elem_array, void tag_data, MsqError &err)=0
	Get tag values on elements. More...

virtual void	tag_get_vertex_data (TagHandle handle, size_t num_elems, const VertexHandle node_array, void tag_data, MsqError &err)=0
	Get tag values on vertices. More...

Protected Attributes
COM::Pane *	_pane

MAP::Pane_dual_connectivity *	_dc

std::vector< bool >	_is_border

std::vector< unsigned char >	_vertexBytes

int	_verb

bool	_with_ghost

std::map< std::string, MesqPane::tag >	denseTags

std::map< msq_std::string, tagStruct >	s_to_t

Private Member Functions
size_t	vertices_in_topology (EntityTopology)

size_t	vertices_in_topology (EntityTopology)

size_t	vertices_in_topology (EntityTopology)

Additional Inherited Members
Protected Member Functions inherited from Mesh
virtual	~Mesh ()
	Don't allow a Mesh to be deleted directly. More...

Detailed Description

A class enabling Mesquite calls on Rocmop panes.

Type used to refer to a tag defintion.

Mesquite's Mesh base class defines an interface which allows Mesquite to interact with non-native mesh types. MesqPane is an implementation of this class which enables Mesquite to use a Roccom Pane as an input mesh.

Definition at line 95 of file MesqPane.h.

Member Typedef Documentation

typedef EntityHandle ElementHandle

Definition at line 108 of file MesqPane_1_1.h.

typedef EntityHandle ElementHandle

Definition at line 109 of file MesqPane_95.h.

typedef void* EntityHandle

Opaque EntityHandle type and tag type.

Definition at line 100 of file MesqPane_1_1.h.

typedef void* EntityHandle

Opaque EntityHandle type and tag type.

Definition at line 101 of file MesqPane_95.h.

typedef void* TagHandle

Definition at line 101 of file MesqPane_1_1.h.

typedef void* TagHandle

Definition at line 102 of file MesqPane_95.h.

typedef EntityHandle VertexHandle

Definition at line 107 of file MesqPane_1_1.h.

typedef EntityHandle VertexHandle

Definition at line 108 of file MesqPane_95.h.

Constructor & Destructor Documentation

MesqPane	(	COM::Pane *	p,
		bool	with_ghost = `true`
	)

inline

Construct from a pane.

Build a MesqPane for the given Pane either on all nodes and elements, or just on real nodes and elements.

Parameters

p	the Pane whose mesh we would like to smooth.
with_ghost	use ghost nodes and cells?

Definition at line 113 of file MesqPane.h.

     : _pane(p), _verb(0), _with_ghost(with_ghost){
     init();
   }

~MesqPane ( )

virtual

Destructor.

Definition at line 38 of file MesqPane.C.

                      {
      _pane = NULL;
      if(_dc)
        delete _dc;
      _dc = NULL;
   }

MesqPane	(	COM::Pane *	p,
		bool	with_ghost = `true`
	)

inline

Construct from a pane.

Build a MesqPane for the given Pane either on all nodes and elements, or just on real nodes and elements.

Parameters

p	the Pane whose mesh we would like to smooth.
with_ghost	use ghost nodes and cells?

Definition at line 127 of file MesqPane_1_1.h.

     : _pane(p), _verb(0), _with_ghost(with_ghost){
     init();
   }

virtual ~MesqPane ( )

virtual

Destructor.

MesqPane	(	COM::Pane *	p,
		bool	with_ghost = `true`
	)

inline

Construct from a pane.

Build a MesqPane for the given Pane either on all nodes and elements, or just on real nodes and elements.

Parameters

p	the Pane whose mesh we would like to smooth.
with_ghost	use ghost nodes and cells?

Definition at line 127 of file MesqPane_95.h.

     : _pane(p), _verb(0), _with_ghost(with_ghost){
     init();
   }

virtual ~MesqPane ( )

virtual

Destructor.

Member Function Documentation

virtual size_t element_get_attached_vertex_count	(	ElementHandle	elem,
		MsqError &	err
	)

virtual

Gets the number of vertices in this element.

This data can also be found by querying the element's topology and getting the number of vertices per element for that topology type.

size_t element_get_attached_vertex_count	(	ElementHandle	elem,
		MsqError &	err
	)		const

virtual

Gets the number of vertices in this element.

Definition at line 349 of file MesqPane.C.

                                                                        {
     if(_verb)
       cout << "MesqPane::element_get_attached_vertex_count" << endl;
     int element_id = ((char*)elem - (char*)NULL);                       
     const COM::Connectivity *con = _pane->connectivity(element_id);
     return con->size_of_nodes_pe();
   }

size_t element_get_attached_vertex_count	(	ElementHandle	elem,
		MsqError &	err
	)

virtual

Gets the number of vertices in this element.

This data can also be found by querying the element's topology and getting the number of vertices per element for that topology type.

Definition at line 487 of file MesqPane_1_1.C.

                                                                    {
     if(_verb)
       cout << "MOP> MesqPane::element_get_attached_vertex_count" << endl;
     int element_id = ((char*)elem - (char*)NULL);                       
     const COM::Connectivity *con = _pane->connectivity(element_id);
     return con->size_of_nodes_pe();
   }

virtual EntityTopology element_get_topology	(	ElementHandle	entity_handle,
		MsqError &	err
	)

virtual

Returns the topology of the given entity.

EntityTopology element_get_topology	(	ElementHandle	entity_handle,
		MsqError &	err
	)		const

virtual

Returns the topology of the given entity.

Definition at line 454 of file MesqPane.C.

References COM_assertion_msg, Mesquite::HEXAHEDRON, Mesquite::QUADRILATERAL, Mesquite::TETRAHEDRON, and Mesquite::TRIANGLE.

                                                                     {
     if(_verb)
       cout << "MesqPane::element_get_topology" << endl;
     int elem_id = ((char*)entity_handle-(char*)NULL);
 
     const COM::Connectivity *con = _pane->connectivity(elem_id);
     COM_assertion_msg(con!=NULL, "con is NULL");
     switch(con->element_type()){
     case COM::Connectivity::TRI3 :
       return TRIANGLE;
       break;
     case COM::Connectivity::QUAD4 :
       return QUADRILATERAL;
       break;
     case COM::Connectivity::TET4 :
       return TETRAHEDRON;
       break;
     case COM::Connectivity::HEX8 :
       return HEXAHEDRON;
       break;
     default:
       COM_assertion_msg( 0,
                          "Element type not supported by Mesquite.");
       break;
     }
     // Control should never reach here...
     // this 'return' gets rid of compiler warnings
     return TRIANGLE;
   }

EntityTopology element_get_topology	(	ElementHandle	entity_handle,
		MsqError &	err
	)

virtual

Returns the topology of the given entity.

Definition at line 606 of file MesqPane_1_1.C.

References COM_assertion_msg, Mesquite::HEXAHEDRON, Mesquite::PRISM, Mesquite::PYRAMID, Mesquite::QUADRILATERAL, Mesquite::TETRAHEDRON, and Mesquite::TRIANGLE.

                                                               {
     if(_verb)
       cout << "MOP> MesqPane::element_get_topology" << endl;
     int elem_id = ((char*)entity_handle-(char*)NULL);
 
     const COM::Connectivity *con = _pane->connectivity(elem_id);
     COM_assertion_msg(con!=NULL, "con is NULL");
     switch(con->element_type()){
     case COM::Connectivity::TRI3 :
       return TRIANGLE;
       break;
     case COM::Connectivity::QUAD4 :
       return QUADRILATERAL;
       break;
     case COM::Connectivity::TET4 :
       return TETRAHEDRON;
       break;
     case COM::Connectivity::HEX8 :
       return HEXAHEDRON;
       break;
     case COM::Connectivity::PYRIMID5 :
       return PYRAMID;
       break;
     case COM::Connectivity::PRISM6 :
       return PRISM;
       break;
     default:
       COM_assertion_msg( 0,
                          "Element type not supported by Mesquite.");
       break;
     }
     // Control should never reach here...
     // this 'return' gets rid of compiler warnings
     return TRIANGLE;
   }

ElementIterator * element_iterator ( MsqError & err )

virtual

Returns a pointer to an element iterator over this Pane.

The calling code should delete the returned iterator when it is finished with it. If elements are added or removed from the Mesh after obtaining an iterator, the behavior of that iterator is undefined.

Implements Mesh.

Definition at line 149 of file MesqPane.C.

                                                           {
     if(_verb>1)
       cout << "MesqPane::element_iterator" << endl;
     return new MyEntityIterator(_with_ghost ? _pane->size_of_elements() :
                                 _pane->size_of_real_elements());
   }

virtual ElementIterator* element_iterator ( MsqError & err )

virtual

Returns a pointer to an iterator that iterates over the set of all top-level elements in this mesh.

The calling code should delete the returned iterator when it is finished with it. If elements are added or removed from the Mesh after obtaining an iterator, the behavior of that iterator is undefined.

ElementIterator * element_iterator ( MsqError & err )

virtual

Returns a pointer to an iterator that iterates over the set of all top-level elements in this mesh.

The calling code should delete the returned iterator when it is finished with it. If elements are added or removed from the Mesh after obtaining an iterator, the behavior of that iterator is undefined.

Definition at line 235 of file MesqPane_1_1.C.

                                                           {
     if(_verb>1)
       cout << "MOP> MesqPane::element_iterator" << endl;
     return new MyEntityIterator(_with_ghost ? _pane->size_of_elements() :
                                 _pane->size_of_real_elements());
   }

void element_tag_create	(	const string	tag_name,
		int	tag_size,
		TagHandle &	tag_handle,
		MsqError &	err
	)

virtual

Add a new tag with given name and size to the dense tag map.

Definition at line 497 of file MesqPane.C.

References MSQ_CHKERR, MesqPane::tag::pt, and MesqPane::tag::size.

   {
     if(_verb)
       cout << "MesqPane::element_tag_create" << endl;
     MesqPane::tag new_tag;
     new_tag.pt = 0;
     new_tag.size = tag_size;
     denseTags[tag_name] = new_tag;
     tag_handle = tag_get_handle(tag_name, err);
     MSQ_CHKERR(err);
     if(_verb)
       cout << "MesqPane::element_tag_create finished" << endl;  }

void elements_get_attached_vertex_indices	(	ElementHandle	element[],
		size_t	num_elems,
		size_t	index_array[],
		size_t	array_size,
		size_t *	offsets,
		MsqError &	err
	)

virtual

Return each vertex's global index.

Identifies the vertices attached to the elements by returning each vertex's global index. The vertex's global index indicates where that vertex can be found in the array returned by get_all_vertices()

Parameters

elems	Array of element handles.
num_elems	number of elements in the array elems
index_array	Array containing the indexes of the elements vertices. Indexes can be repeated.
index_array_size	indicates the size of index_array
offsets	Has length num_elems+1. An array of offsets into the index_array that indicates where the indexes corresponding to an element start. First entry is 0. For example element, to get the vertex indices of elems[3], we look at the entries index_array[offsets[3]] to index_array[offsets[4]] .

Definition at line 410 of file MesqPane.C.

References i, and j.

                                                                     {
     if(_verb)
       cout << "MesqPane::elements_get_attached_vertex_indices" << endl;
 
     int elem_id;
     offsets[0] = 0;
 
     Element_node_enumerator *ene;
     for(uint i = 0; i < num_elems; ++i){
 
       elem_id = ((char*)element[i] - (char*)NULL);
       if(_verb>1){
         cout << "    element " << elem_id << " contains nodes ";
       }
         
       ene = new Element_node_enumerator(_pane,elem_id);
       int nodes_in_elem = ene->size_of_nodes();
       offsets[i+1] = offsets[i] + nodes_in_elem;
       // loop through vertices in element
       std::vector<int> nodes;
       ene->get_nodes(nodes);
       
       for(int j = 0; j < nodes_in_elem; ++j){
         //index_array[offsets[i] + j] = con_array[first_offset+nodes_in_elem*(elem_id-1)+j] -1;
         index_array[offsets[i]+j] = nodes[j]-1;
         if(_verb>1){
           cout << nodes[j]
              << " ";
         }
         delete ene;
         ene = NULL;
       }
       if(_verb>1)
         cout << endl;
     }
     if(_verb>1)
       cout << "  MesqPane::e_g_a_v_i loop finished  " << endl;
   }

virtual void elements_get_attached_vertices	(	ElementHandle *	elem_handles,
		size_t	num_elems,
		VertexHandle *	vert_handles,
		size_t &	sizeof_vert_handles,
		size_t *	csr_data,
		size_t &	sizeof_csr_data,
		size_t *	csr_offsets,
		MsqError &	err
	)

virtual

Returns the vertices that are part of the topological definition of each element in the "elem_handles" array.

When this function is called, the following must be true:

"elem_handles" points at an array of "num_elems" element handles.
"vert_handles" points at an array of size "sizeof_vert_handles"
"csr_data" points at an array of size "sizeof_csr_data"
"csr_offsets" points at an array of size "num_elems+1"

When this function returns, adjacency information will be stored in csr format:

"vert_handles" stores handles to all vertices found in one or more of the elements. Each vertex appears only once in "vert_handles", even if it is in multiple elements.
"sizeof_vert_handles" is set to the number of vertex handles placed into "vert_handles".
"sizeof_csr_data" is set to the total number of vertex uses (for example, sizeof_csr_data = 6 in the case of 2 TRIANGLES, even if the two triangles share some vertices).
"csr_offsets" is filled such that csr_offset[i] indicates the location of entity i's first adjacency in "csr_data". The number of vertices in element i is equal to csr_offsets[i+1] - csr_offsets[i]. For this reason, csr_offsets[num_elems] is set to the new value of "sizeof_csr_data".
"csr_data" stores integer offsets which give the location of each adjacency in the "vert_handles" array.

As an example of how to use this data, you can get the handle of the first vertex in element #3 like this:

VertexHandle vh = vert_handles[ csr_data[ csr_offsets[3] ] ]

and the second vertex of element #3 like this:

VertexHandle vh = vert_handles[ csr_data[ csr_offsets[3]+1 ] ]

void elements_get_attached_vertices	(	ElementHandle *	elem_handles,
		size_t	num_elems,
		VertexHandle *	vert_handles,
		size_t &	sizeof_vert_handles,
		size_t *	csr_data,
		size_t &	sizeof_csr_data,
		size_t *	csr_offsets,
		MsqError &	err
	)

virtual

Returns vertices which are part of each element in the "elem_handles" array.

When this function is called, the following must be true:

"elem_handles" points at an array of "num_elems" element handles.
"vert_handles" points at an array of size "sizeof_vert_handles"
1. "csr_data" points at an array of size "sizeof_csr_data"
"csr_offsets" points at an array of size "num_elems+1"

When this function returns, adjacency information will be stored in csr format:

"vert_handles" stores handles to all vertices found in one or more of the elements. Each vertex appears only once in "vert_handles", even if it is in multiple elements.
"sizeof_vert_handles" is set to the number of vertex handles placed into "vert_handles".
"sizeof_csr_data" is set to the total number of vertex uses (for example, sizeof_csr_data = 6 in the case of 2 TRIANGLES, even if the two triangles share some vertices).
"csr_offsets" is filled such that csr_offset[i] indicates the location of entity i's first adjacency in "csr_data". The number of vertices in element i is equal to csr_offsets[i+1] - csr_offsets[i]. For this reason, csr_offsets[num_elems] is set to the new value of "sizeof_csr_data".
"csr_data" stores integer offsets which give the location of each adjacency in the "vert_handles" array.

As an example of how to use this data, you can get the handle of the first vertex in element #3 like this:

VertexHandle vh = vert_handles[ csr_data[ csr_offsets[3] ] ]

and the second vertex of element #3 like this:

VertexHandle vh = vert_handles[ csr_data[ csr_offsets[3]+1 ] ]

Implements Mesh.

Definition at line 358 of file MesqPane.C.

References COM_assertion_msg, i, and j.

                                                             {
     if(_verb)
       cout << "MesqPane::elements_get_attached_vertices" << endl;
     int vert_count = 0;
     // maps vertex id's to position in vert_handles
     std::map<int,int> itop_map;
     std::map<int,int>::iterator pos;
     if (num_elems == 0)
       return;
     csr_offsets[0] = 0;
     // loop through elements
     for (size_t i = 0; i < num_elems; ++i){
       int elem_id = ((char*)elem_handles[i] - (char*)NULL);
       std::cout << "\n  element " << elem_id << " has nodes : ";
       std::vector<int> elist;
       _dc->incident_elements(elem_id,elist);
       size_t nodes_in_elem = elist.size();
       csr_offsets[i+1] = csr_offsets[i] + nodes_in_elem;
       // Check for space in csr_data
       COM_assertion_msg( (sizeof_csr_data >= csr_offsets[i+1]),
                          "Not enough space in arg. csr_data");  
 
       // Loop through vertices of current element
       for( uint j = 0 ; j < nodes_in_elem; ++j){
         int node_id = ((char*)elist[j] - (char*)NULL);                          
         std::cout << node_id << " ";
         pos = itop_map.find(node_id);
         // current vertex isn't in vert_handles, add it
         if(pos == itop_map.end()){
           itop_map.insert(std::map<int,int>::value_type(node_id,num_elems));
           vert_handles[vert_count] = ((char*)(NULL)+node_id);
           csr_data[csr_offsets[i]+j] = vert_count;
           ++vert_count;  
         }
         // add current vertex to csr_data
         csr_data[csr_offsets[i] + j] = pos->second;
       }
       elist.clear();
     }
     sizeof_csr_data = csr_offsets[num_elems];
     sizeof_vert_handles = vert_count;
     if(_verb)
       cout << "MesqPane::elements_get_attached_vertices" << endl;
   }

void elements_get_attached_vertices	(	const ElementHandle *	elem_handles,
		size_t	num_elems,
		msq_std::vector< VertexHandle > &	vert_handles,
		msq_std::vector< size_t > &	offsets,
		MsqError &	err
	)

virtual

Get element connectivity.

Get the connectivity (ordered list of vertex handles) for each element in the input array.

Parameters

elem_handles	The array of element handles for which to retrieve the connectivity list.
num_elems	The length of elem_handles
vert_handles	Array in which to place the vertex handles in each elements connectivity.
offsets	For each element in elem_handles, the value in the same position in this array is the index into vert_handles at which the connectivity list for that element begins.

Definition at line 511 of file MesqPane_1_1.C.

References i, j, nj, and swap().

                                                               {
 
     //    std::cout << "elements_get_attached_vertices\n";
 
     offsets.clear();
     vert_handles.clear();
     offsets.resize(num_elems+1);
     offsets[0] = 0;
     std::vector<int> nodes;
     nodes.clear();
 
     // guess 4 vertices per element
     vert_handles.reserve(4*num_elems);
 
     //    std::cout << "vert_handles = \n";
 
     for( size_t i=0; i< num_elems; ++i){
       offsets[i] += nodes.size();
       offsets[i+1] = offsets[i];
       nodes.clear();
 
       int elem_id = ((char*)elem_handles[i] - (char*)NULL);
       Element_node_enumerator ene(_pane,elem_id);
       ene.get_nodes(nodes);
 
       for(uint j=0, nj= nodes.size(); j<nj; ++j){
         vert_handles.push_back((char*)NULL + nodes[j]);
         //      std::cout << nodes[j] << " ";
       }
       //      std::cout << "\n";
     }
     offsets[num_elems] += nodes.size();
     msq_std::vector<VertexHandle>(vert_handles).swap(vert_handles);
     //    std::cout << "offsets = \n";
     for(uint i=0; i < offsets.size(); ++i){
       //      std::cout << offsets[i] << " ";
     }
     //    std::cout << "\n";
     
   }

Here is the call graph for this function:

void elements_get_attached_vertices	(	ElementHandle *	elem_handles,
		size_t	num_elems,
		VertexHandle *	vert_handles,
		size_t &	sizeof_vert_handles,
		size_t *	csr_data,
		size_t &	sizeof_csr_data,
		size_t *	csr_offsets,
		MsqError &	err
	)

virtual

Returns the vertices that are part of the topological definition of each element in the "elem_handles" array.

When this function is called, the following must be true:

"elem_handles" points at an array of "num_elems" element handles.
"vert_handles" points at an array of size "sizeof_vert_handles"
"csr_data" points at an array of size "sizeof_csr_data"
"csr_offsets" points at an array of size "num_elems+1"

When this function returns, adjacency information will be stored in csr format:

"vert_handles" stores handles to all vertices found in one or more of the elements. Each vertex appears only once in "vert_handles", even if it is in multiple elements.
"sizeof_vert_handles" is set to the number of vertex handles placed into "vert_handles".
"sizeof_csr_data" is set to the total number of vertex uses (for example, sizeof_csr_data = 6 in the case of 2 TRIANGLES, even if the two triangles share some vertices).
"csr_offsets" is filled such that csr_offset[i] indicates the location of entity i's first adjacency in "csr_data". The number of vertices in element i is equal to csr_offsets[i+1] - csr_offsets[i]. For this reason, csr_offsets[num_elems] is set to the new value of "sizeof_csr_data".
"csr_data" stores integer offsets which give the location of each adjacency in the "vert_handles" array.

As an example of how to use this data, you can get the handle of the first vertex in element #3 like this:

VertexHandle vh = vert_handles[ csr_data[ csr_offsets[3] ] ]

and the second vertex of element #3 like this:

VertexHandle vh = vert_handles[ csr_data[ csr_offsets[3]+1 ] ]

Definition at line 556 of file MesqPane_1_1.C.

References COM_assertion_msg, i, and j.

                                                               {
     if(_verb)
       cout << "MOP> MesqPane::elements_get_attached_vertices" << endl;
     int vert_count = 0;
     // maps vertex id's to position in vert_handles
     std::map<int,int> itop_map;
     std::map<int,int>::iterator pos;
     if (num_elems == 0)
       return;
     csr_offsets[0] = 0;
     // loop through elements
     for (size_t i = 0; i < num_elems; ++i){
       int elem_id = ((char*)elem_handles[i] - (char*)NULL);
       std::vector<int> elist;
       _dc->incident_elements(elem_id,elist);
       size_t nodes_in_elem = elist.size();
       csr_offsets[i+1] = csr_offsets[i] + nodes_in_elem;
       // Check for space in csr_data
       COM_assertion_msg( (sizeof_csr_data >= csr_offsets[i+1]),
                          "Not enough space in arg. csr_data");  
 
       // Loop through vertices of current element
       for( uint j = 0 ; j < nodes_in_elem; ++j){
         int node_id = ((char*)elist[j] - (char*)NULL);                          
         pos = itop_map.find(node_id);
         // current vertex isn't in vert_handles, add it
         if(pos == itop_map.end()){
           itop_map.insert(std::map<int,int>::value_type(node_id,num_elems));
           vert_handles[vert_count] = ((char*)(NULL)+node_id);
           csr_data[csr_offsets[i]+j] = vert_count;
           ++vert_count;  
         }
         // add current vertex to csr_data
         csr_data[csr_offsets[i] + j] = pos->second;
       }
       elist.clear();
     }
     sizeof_csr_data = csr_offsets[num_elems];
     sizeof_vert_handles = vert_count;
     if(_verb)
       cout << "MOP> MesqPane::elements_get_attached_vertices" << endl;
   }

void elements_get_tag_data	(	const size_t	num_elements,
		const TagHandle	tag_handle,
		TagDataPt &	tag_data_array,
		int &	tag_size,
		MsqError &	err
	)

virtual

Gets the Tag data for an array of entities.

The implementation handles the pointers to the tag data, not the memory pointed to. This means that the implementation is not responsible for making sure the memory pointed to is valid.

The implementation handles the pointers to the tag data, not the memory pointed to. This means that the implementation is not responsible for making sure the memory pointed to is valid

Definition at line 560 of file MesqPane.C.

                                                      {
     if(_verb)
       cout << "MesqPane::elements_get_tag_data" << endl;
     if (_with_ghost && (num_elements != _pane->size_of_elements())) {
       err.set_msg("Incorrect num_elements. Must be equal to the total number of elements "
                   "since only dense tags are supported.");
       return;    }
     else if (num_elements != _pane->size_of_real_elements()) {
       err.set_msg("Incorrect num_elements. Must be equal to the number of real elements "
                   "since only dense tags are supported.");
       return;
     }
     else if (((tag*)tag_handle)->size != tag_size) {
       err.set_msg("tag_size does not correspong to actual tag size.");
       return;
     }
     else
       tag_data_array = ((tag*)tag_handle)->pt;
     if(_verb)
       cout << "MesqPane::elements_get_tag_data finished" << endl;
   }  

virtual void elements_get_topologies	(	ElementHandle *	element_handle_array,
		EntityTopology *	element_topologies,
		size_t	num_elements,
		MsqError &	err
	)

virtual

Returns the topologies of the given entities.

The "entity_topologies" array must be at least "num_elements" in size.

void elements_get_topologies	(	ElementHandle *	element_handle_array,
		EntityTopology *	element_topologies,
		size_t	num_elements,
		MsqError &	err
	)

virtual

Returns the topologies of the given entities.

The "entity_topologies" array must be at least "num_elements" in size.

Implements Mesh.

Definition at line 485 of file MesqPane.C.

References i.

                                                                             {
     if(_verb >0)
       cout << "MesqPane::element_get_topologies" << endl;
     for (size_t i = 0; i < num_elements; i++){
       element_topologies[i] = element_get_topology(element_handle_array[i],err);
     }
     if(_verb >0)
       cout << "MesqPane::element_get_topologies done" << endl;
  }

void elements_get_topologies	(	ElementHandle *	element_handle_array,
		EntityTopology *	element_topologies,
		size_t	num_elements,
		MsqError &	err
	)

virtual

Returns the topologies of the given entities.

The "entity_topologies" array must be at least "num_elements" in size.

Definition at line 643 of file MesqPane_1_1.C.

References i.

                                                                             {
     if(_verb >0)
       cout << "MOP> MesqPane::element_get_topologies" << endl;
     for (size_t i = 0; i < num_elements; i++){
       element_topologies[i] = element_get_topology(element_handle_array[i],err);
     }
     if(_verb >0)
       cout << "MOP> MesqPane::element_get_topologies done" << endl;
   }

void elements_get_topologies	(	const ElementHandle *	element_handle_array,
		EntityTopology *	element_topologies,
		size_t	num_elements,
		MsqError &	err
	)

virtual

Returns the topologies of the given entities.

The "entity_topologies" array must be at least "num_elements" in size.

Definition at line 655 of file MesqPane_1_1.C.

References i.

                                                                             {
     if(_verb >0)
       cout << "MOP> MesqPane::element_get_topologies" << endl;
     for (size_t i = 0; i < num_elements; i++){
       element_topologies[i] = element_get_topology(element_handle_array[i],err);
     }
     if(_verb >0)
       cout << "MOP> MesqPane::element_get_topologies done" << endl;
   }

void elements_set_tag_data	(	const size_t	num_elements,
		const TagHandle	tag_handle,
		TagDataPt const	tag_data_array,
		const int &	tag_size,
		MsqError &	err
	)

virtual

Sets the Tag data pointers for an array of entities.

The memory pointed to is the reponsibility of the function caller, i.e. either the memory was obtained from entities_get_tag_data or the function caller allocated the memory and will keep it allocated as long as the tag pointer is set to that memory.

Definition at line 528 of file MesqPane.C.

   {
     if(_verb)
       cout << "MesqPane::element_set_tag_data" << endl;
     if (_with_ghost && (num_elements != _pane->size_of_elements())) {
       err.set_msg("Incorrect num_elements. Must be equal to the total number of elements "
                   "since only dense tags are supported.");
       return;
     }
     else if(num_elements != _pane->size_of_real_elements()){
       err.set_msg("Incorrect num_elements. Must be equal to the number of real elements "
                   "since only dense tags are supported.");
       return;
     }
     else if (((tag*)tag_handle)->size != tag_size) {
       err.set_msg("tag_size does not correspong to actual tag size.");
       return;
     }
     else
       ((tag*)tag_handle)->pt = tag_data_array;
     if(_verb)
       cout << "MesqPane::element_set_tag_data" << endl;
   }

void get_all_elements	(	msq_std::vector< ElementHandle > &	elements,
		MsqError &	err
	)

virtual

Get all elements in mesh.

Get the handles of every element in the active mesh.

Definition at line 166 of file MesqPane_1_1.C.

References i.

                                                   {
     elements.clear();
     int e_size = _with_ghost ? _pane->size_of_elements() :
       _pane->size_of_real_elements();
     elements.resize(e_size);
     for(int i=1; i<= e_size; ++i){
       elements[i-1] = ((char*)NULL)+i;
     }
   }

void get_all_elements	(	ElementHandle *	elem_array,
		size_t	array_size,
		MsqError &	err
	)

virtual

Fills array with handles to all elements in the mesh.

Parameters

elem_array	a pointer to the element handle array.
array_size	Must be at least the number of elements. If less than the mesh number of elements, causes a run time error.

Definition at line 127 of file MesqPane.C.

References COM_assertion_msg, and i.

                                                                     {
     if(_verb)
       cout << "MesqPane::get_all_elements" << endl;
     int pane_size = _with_ghost ? _pane->size_of_elements() :
       _pane->size_of_real_elements();
     COM_assertion_msg( (array_size >= (size_t)pane_size),
                        "Array_Size Must Be At Least Number of Nodes");
     for(int i = 1; i <= pane_size; ++i){
       elem_array[i-1] = ((char*)NULL)+i;
     }
     if(_verb)
       cout << "MesqPane::get_all_elements done" << endl;
   }

virtual void get_all_mesh	(	VertexHandle *	vert_array,
		size_t	vert_len,
		ElementHandle *	elem_array,
		size_t	elem_len,
		size_t *	elem_conn_offsets,
		size_t	offset_len,
		size_t *	elem_conn_indices,
		size_t	index_len,
		MsqError &	err
	)

virtual

Get entities and connectivity.

Get vertex handles, element handles, and connectivty for active mesh. Use get_all_sizes to determine required array sizes.

Parameters

vert_array	Array to store vertex handles in
vert_len	Length of vert_array
elem_array	Array to store element handles in
elem_len	Length of elem_array
elem_conn_offsets	Offsets into elem_conn_indices at which the connectivity data for each element begins.
offset_len	Length of elem_conn_offsets. Should be elem_len + 1.
elem_conn_indices	Indices into vert_array
index_len	Length of elem_conn_indices.

void get_all_mesh	(	VertexHandle *	vert_array,
		size_t	vert_len,
		ElementHandle *	elem_array,
		size_t	elem_len,
		size_t *	elem_conn_offsets,
		size_t	offset_len,
		size_t *	elem_conn_indices,
		size_t	index_len,
		MsqError &	err
	)

virtual

Get entities and connectivity.

Get vertex handles, element handles, and connectivty for active mesh. Use get_all_sizes to determine required array sizes.

Parameters

vert_array	Array to store vertex handles in
vert_len	Length of vert_array
elem_array	Array to store element handles in
elem_len	Length of elem_array
elem_conn_offsets	Offsets into elem_conn_indices at which the connectivity data for each element begins.
offset_len	Length of elem_conn_offsets. Should be elem_len + 1.
elem_conn_indices	Indices into vert_array
index_len	Length of elem_conn_indices.

Definition at line 190 of file MesqPane_1_1.C.

References COM_assertion_msg, i, j, and nj.

                                               {
     if(_verb)
       cout << "MOP> MesqPane::get_all_mesh" << endl;
     int pane_size = _with_ghost ? _pane->size_of_nodes() : 
       _pane->size_of_real_nodes();
 
     COM_assertion_msg( (vert_len >= (size_t)pane_size),
                        "Vert_Len Must Be At Least Number of Nodes");
 
     for(int i = 1; i <= pane_size; ++i)
       vert_array[i-1] = ((char*)NULL)+i;
     
     pane_size = _with_ghost ? _pane->size_of_elements() :
       _pane->size_of_real_elements();
 
     COM_assertion_msg( (elem_len >= (size_t)pane_size),
                        "Array_Size Must Be At Least Number of Nodes");
 
     elem_conn_offsets[0] = 0;
     Element_node_enumerator ene(_pane,1);
     std::vector<int> nodes;
 
     for(int i = 1; i <= pane_size; ++i, ene.next()){
       
       elem_array[i-1] = ((char*)NULL)+i;
 
       elem_conn_offsets[i] = elem_conn_offsets[i-1]+ ene.size_of_nodes();
 
       ene.get_nodes(nodes);
       for(int j=0, nj=ene.size_of_nodes(); j<nj; ++j)
         elem_conn_indices[elem_conn_offsets[i-1]+j] = nodes[j]-1;
     }
   }

virtual void get_all_sizes	(	size_t &	vertex_count,
		size_t &	element_count,
		size_t &	vertex_use_count,
		MsqError &	err
	)

inlinevirtual

get sizes for calling get_all_mesh

Get counts of entities in mesh.

Parameters

vertex_count	- Number of vertices connected to active mesh
element_count	- Number of elements in active mesh
vertex_use_count	- Number of vertex uses (sum of the length of the connectivity list for all elements in active.)

Definition at line 165 of file MesqPane_95.h.

References i, and ni.

                                              {
     vertex_count = _with_ghost ? _pane->size_of_nodes() : 
       _pane->size_of_real_nodes();
     element_count = _with_ghost ? _pane->size_of_elements() : 
       _pane->size_of_real_elements();
     std::vector<const COM::Connectivity*> conns;
     _pane->connectivities(conns);
     vertex_use_count = 0;
     for(int i=0, ni = conns.size(); i<ni; ++i){
       vertex_use_count += conns[i]->size_of_nodes_pe() *
         (_with_ghost ? conns[i]->size_of_elements() :
          conns[i]->size_of_real_elements());
     }
   }

virtual void get_all_sizes	(	size_t &	vertex_count,
		size_t &	element_count,
		size_t &	vertex_use_count,
		MsqError &	err
	)

inlinevirtual

get sizes for calling get_all_mesh

Get counts of entities in mesh.

Parameters

vertex_count	- Number of vertices connected to active mesh
element_count	- Number of elements in active mesh
vertex_use_count	- Number of vertex uses (sum of the length of the connectivity list for all elements in active.)

Definition at line 181 of file MesqPane_1_1.h.

References i, and ni.

                                              {
     vertex_count = _with_ghost ? _pane->size_of_nodes() : 
       _pane->size_of_real_nodes();
     element_count = _with_ghost ? _pane->size_of_elements() : 
       _pane->size_of_real_elements();
     std::vector<const COM::Connectivity*> conns;
     _pane->connectivities(conns);
     vertex_use_count = 0;
     for(int i=0, ni = conns.size(); i<ni; ++i){
       vertex_use_count += conns[i]->size_of_nodes_pe() *
         (_with_ghost ? conns[i]->size_of_elements() :
          conns[i]->size_of_real_elements());
     }
   }

void get_all_vertices	(	msq_std::vector< VertexHandle > &	vertices,
		MsqError &	err
	)

virtual

Get all vertices in mesh.

Get the handles of every vertex in the active mesh

Definition at line 178 of file MesqPane_1_1.C.

References i.

                                                   {
     vertices.clear();
     int v_size = _with_ghost ? _pane->size_of_nodes() :
       _pane->size_of_real_nodes();
     vertices.resize(v_size);
     for(int i=1; i<= v_size; ++i){
       vertices[i-1] = ((char*)NULL)+i;
     }
   }

void get_all_vertices	(	VertexHandle *	vert_array,
		size_t	array_size,
		MsqError &	err
	)

virtual

Fills array with handles to all vertices.

Parameters

vert_array	a pointer to the vertex array to be filled.
array_size	Must be at least the number of vertices. If less than the mesh number of vertices, causes a run time error.

Definition at line 112 of file MesqPane.C.

References COM_assertion_msg, and i.

                                                                     {
     if(_verb)
       cout << "MesqPane::get_all_vertices" << endl;
     int pane_size = _with_ghost ? _pane->size_of_nodes() : 
       _pane->size_of_real_nodes();
     COM_assertion_msg( (array_size >= (size_t)pane_size),
                        "Array_Size Must Be At Least Number of Nodes");
     for(int i = 1; i <= pane_size; ++i){
       vert_array[i-1] = ((char*)NULL)+i;
     }
     if(_verb)
       cout << "MesqPane::get_all_vertices done" << endl;
   }

virtual int get_geometric_dimension ( MsqError & err )

inlinevirtual

Returns whether this mesh lies in a 2D or 3D coordinate system.

Definition at line 149 of file MesqPane_1_1.h.

                                                      {
     if(_verb >1) 
       std::cout << "MesqPane::get_geometric_dimension\n";
     return 3;  
   }

virtual int get_geometric_dimension ( MsqError & err )

inlinevirtual

Returns whether this mesh lies in a 2D or 3D coordinate system.

Definition at line 149 of file MesqPane_95.h.

                                                      {
     if(_verb >1) 
       std::cout << "MesqPane::get_geometric_dimension\n";
     return 3;  
   }

virtual int get_geometric_dimension ( MsqError & err ) const

inlinevirtual

Returns whether this mesh lies in a 2D or 3D coordinate system.

Definition at line 156 of file MesqPane.h.

                                                            {
     if(_verb >1) std::cout << "MesqPane::get_geometric_dimension" << std::endl;
     return 3;  
   }

virtual size_t get_total_element_count ( MsqError & err ) const

inlinevirtual

Returns the number of elements.

Definition at line 168 of file MesqPane.h.

                                                               {
     if(_verb >1) std::cout << "MesqPane::get_total_element_count" << std::endl;
     return _with_ghost ? _pane->size_of_elements() : _pane->size_of_real_elements();  }

virtual size_t get_total_vertex_count ( MsqError & err ) const

inlinevirtual

Returns the number of nodes.

Definition at line 162 of file MesqPane.h.

                                                              {
     if(_verb >1) std::cout << "MesqPane::get_total_vertex_count" << std::endl;
     return _with_ghost ? _pane->size_of_nodes() : _pane->size_of_real_nodes();  
   }

virtual size_t get_vertex_use_count	(	ElementHandle *	handle_array,
		size_t	num_handles,
		MsqError &	err
	)

virtual

size_t get_vertex_use_count	(	ElementHandle *	handle_array,
		size_t	num_handles,
		MsqError &	err
	)

virtual

Definition at line 497 of file MesqPane_1_1.C.

References i.

                                                         {
     if(_verb)
       cout << "MOP> MesqPane::get_vertex_use_count" << endl;
     size_t count = 0;
     for(uint i=0; i< num_handles; ++i){
       int e_id = ((char*)handle_array[i] - (char*)NULL);                        
       Element_node_enumerator ene(_pane,e_id);
       count += (size_t)ene.size_of_nodes();
     }
     return count;
   }

void init ( )

Initialize the MesqPane.

Builds the dual connectivity, determines border nodes, and resizes data structures.

Definition at line 68 of file MesqPane.C.

References i.

                      {
     if(_verb)
       cout << "MesqPane::init" << endl;
     _dc = new MAP::Pane_dual_connectivity(_pane, _with_ghost);
     if(_verb>1)
       cout << "Building pb" << endl;
     MAP::Pane_boundary pb(_pane);
     if(_verb>1)
       cout << "Finished building pb" << endl;
     std::vector<bool> _is_isolated;
     _is_isolated.clear();
     if(_verb>1)
       cout << "Determining border nodes" << endl;
     if(_with_ghost)
       pb.determine_border_nodes(_is_border, _is_isolated, NULL, 1);
     else
       pb.determine_border_nodes(_is_border, _is_isolated, NULL, 0);
     if(_verb>1)
       cout << "Finished determining border nodes" << endl;
     int siz = _is_border.size();
     for(int i =0; i < siz; ++i){
       if(_is_border[i] && _verb >1)
         cout << " node " << i+1 << " is on the border" << endl;
       if(_is_isolated[i] && _verb >1)
         cout << " node " << i+1 << " is isolated" << endl;
       if(!(_is_border[i] || _is_isolated[i]) && _verb >1)
         cout << " node " << i+1 << " is free" << endl;
       _is_border[i] = (_is_border[i] || _is_isolated[i]);
       
     }
     _vertexBytes.resize(_with_ghost ? _pane->size_of_nodes() :
                         _pane->size_of_real_nodes());
     if(_verb>1){
       cout << "  size_of_elements       = " << _pane->size_of_elements() << endl;
       cout << "  size_of_ghost_elements = " << _pane->size_of_ghost_elements() << endl;
       cout << "  size_of_real_elements  = " << _pane->size_of_real_elements() << endl;
       cout << "  size_of_nodes          = " << _pane->size_of_nodes() << endl;
       cout << "  size_of_ghost_nodes    = " << _pane->size_of_ghost_nodes() << endl;
       cout << "  size_of_real_nodes     = " << _pane->size_of_real_nodes() << endl;
     }
     if(_verb>0)
       cout << "MesqPane::init done" << endl;
   }

void init ( )

Initialize the MesqPane.

Builds the dual connectivity, determines border nodes, and resizes data structures.

void init ( )

Initialize the MesqPane.

Builds the dual connectivity, determines border nodes, and resizes data structures.

void invert ( int conn_type )

Invert Elements.

Either inverts tetrahedrons by swapping the 2nd and 4th nodes in each element. Or inverts hexahedrons by swapping the 2nd and 4th nodes as well as the 6th and 8th.

Definition at line 85 of file MesqPane_1_1.C.

References i, j, nj, and offset().

                                     {
     std::vector<COM::Connectivity*> conn;
     _pane->connectivities(conn);
 
     int temp = 0;
     int *cptr = NULL;
     uint offset = 0;
     for(uint i=0; i<conn.size(); ++i){
       if(conn[i]->element_type() == conn_type &&
          conn_type == COM::Connectivity::TET4){
         cptr = conn[i]->pointer();
         uint nj = _with_ghost ? (uint)conn[i]->size_of_elements() : 
           (uint)conn[i]->size_of_real_elements();
         for(uint j = 0; j< nj; ++j){
           temp = cptr[offset+4*j];
           cptr[offset+4*j] = cptr[offset+4*j+2];
           cptr[offset+4*j+2] = temp;
         }
       }
       else if(conn[i]->element_type() == conn_type &&
               conn_type == COM::Connectivity::HEX8){
         cptr = conn[i]->pointer();
         uint nj = _with_ghost ? (uint)conn[i]->size_of_elements() : 
           (uint)conn[i]->size_of_real_elements();
         for(uint j = 0; j< nj; ++j){
           temp = cptr[offset+8*j+5];
           cptr[offset+8*j+5] = cptr[offset+8*j+7];
           cptr[offset+8*j+7] = temp;
           temp = cptr[offset+8*j+1];
           cptr[offset+8*j+1] = cptr[offset+8*j+3];
           cptr[offset+8*j+3] = temp;
         }       
       }
     }
   }

Here is the call graph for this function:

void invert ( )

Invert Tetrahedrons.

Assumes that the connectivities of the Pane are all unstructured tetrahedral, and inverts the tetrahedrons by swapping the 2nd and 4th nodes in each element.

void invert ( )

Invert Tetrahedrons.

Assumes that the connectivities of the Pane are all unstructured tetrahedral, and inverts the tetrahedrons by swapping the 2nd and 4th nodes in each element.

Definition at line 45 of file MesqPane.C.

References i, j, nj, and offset().

Referenced by Rocmop::invert_elements(), and Rocmop::invert_tets().

                        {
     std::vector<COM::Connectivity*> conn;
     _pane->connectivities(conn);
 
     int temp = 0;
     int *cptr = NULL;
     uint offset = 0;
     for(uint i=0; i<conn.size(); ++i){
       if(_verb>1){
         cout << "Connectivity " << i <<" has name " << conn[i]->name() << endl;
         cout << "offset = " << offset << endl;
       }
       cptr = conn[i]->pointer();
       uint nj = _with_ghost ? (uint)conn[i]->size_of_elements() : 
         (uint)conn[i]->size_of_real_elements();
       for(uint j = 0; j< nj; ++j){
         temp = cptr[offset+4*j];
         cptr[offset+4*j] = cptr[offset+4*j+2];
         cptr[offset+4*j+2] = temp;
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void release ( )

virtual

Release a MesqPane from use.

Instead of deleting a Mesh when you think you are done, call release(). In simple cases, the implementation could just call the destructor. More sophisticated implementations may want to keep the Mesh object to live longer than Mesquite is using it.

Implements Mesh.

Definition at line 593 of file MesqPane.C.

   {
     if(_verb)
       cout << "MesqPane::release()" << endl;
   }

virtual void release ( )

virtual

Instead of deleting a Mesh when you think you are done, call release().

In simple cases, the implementation could just call the destructor. More sophisticated implementations may want to keep the Mesh object to live longer than Mesquite is using it.

Implements Mesh.

virtual void release ( )

virtual

Instead of deleting a Mesh when you think you are done, call release().

In simple cases, the implementation could just call the destructor. More sophisticated implementations may want to keep the Mesh object to live longer than Mesquite is using it.

Implements Mesh.

void release_entity_handles	(	EntityHandle *	handle_array,
		size_t	num_handles,
		MsqError &	err
	)

virtual

Tells the mesh that the client is finished with a given entity handle.

Implements Mesh.

Definition at line 586 of file MesqPane.C.

                                                                           {
 
     if(_verb)
       cout << "MesqPane::release_entity_handles" << endl;
   }

virtual void release_entity_handles	(	EntityHandle *	handle_array,
		size_t	num_handles,
		MsqError &	err
	)

virtual

Tells the mesh that the client is finished with a given entity handle.

void release_entity_handles	(	const EntityHandle *	handle_array,
		size_t	num_handles,
		MsqError &	err
	)

virtual

Tells the mesh that the client is finished with a given entity handle.

Definition at line 1321 of file MesqPane_1_1.C.

                                                                           {
     
     if(_verb)
       cout << "MOP> MesqPane::release_entity_handles" << endl;
   }

void release_entity_handles	(	EntityHandle *	handle_array,
		size_t	num_handles,
		MsqError &	err
	)

virtual

Tells the mesh that the client is finished with a given entity handle.

Definition at line 1314 of file MesqPane_1_1.C.

                                                                           {
 
     if(_verb)
       cout << "MOP> MesqPane::release_entity_handles" << endl;
   }

void set_verb ( int verb )

inline

Set the MesqPane verbose level (int, >= 0)

Definition at line 133 of file MesqPane_1_1.h.

                          {
     _verb = verb;
   }

void set_verb ( int verb )

inline

Set the MesqPane verbose level (int, >= 0)

Definition at line 133 of file MesqPane_95.h.

                          {
     _verb = verb;
   }

void set_verb ( int verb )

inline

Set the MesqPane verbose level (int, >= 0)

Definition at line 144 of file MesqPane.h.

Referenced by Rocmop::smooth_mesquite().

                          {
     _verb = verb;
   }

Here is the caller graph for this function:

virtual TagHandle tag_create	(	const msq_std::string &	tag_name,
		TagType	type,
		unsigned	length,
		const void *	default_value,
		MsqError &	err
	)

virtual

Create a tag.

Create a user-defined data type that can be attached to any element or vertex in the mesh. For an opaque or undefined type, use type=BYTE and length=sizeof(..).

Parameters

tag_name	A unique name for the data object
type	The type of the data
length	Number of values per entity (1->scalar, >1 ->vector)
default_value	Default value to assign to all entities - may be NULL

Returns: - Handle for tag definition

void * tag_create	(	const msq_std::string &	tag_n,
		TagType	type,
		unsigned	length,
		const void *	default_value,
		MsqError &	err
	)

virtual

Create a tag.

Create a user-defined data type that can be attached to any element or vertex in the mesh. For an opaque or undefined type, use type=BYTE and length=sizeof(..).

Parameters

tag_name	A unique name for the data object
type	The type of the data
length	Number of values per entity (1->scalar, >1 ->vector)
default_value	Default value to assign to all entities - may be NULL

Returns: - Handle for tag definition

Definition at line 679 of file MesqPane_1_1.C.

References COM_assertion_msg, MesqPane::tagStruct::edata, i, Mesquite::length(), and MesqPane::tagStruct::ndata.

                                             {
 
     std::string tag_name(*(const_cast<std::string *>(&tag_n)));
     if(_verb)
       cout << "MOP> MesqPane::tag_create" << endl;
 
     tagStruct new_tag = {length, type, NULL, 
                              NULL, tag_name};
     int esize = 1+(_with_ghost ? _pane->size_of_elements() : 
                  _pane->size_of_real_elements());
     int nsize = 1+(_with_ghost ? _pane->size_of_nodes() :
                  _pane->size_of_real_nodes());
     switch (type){
     case BYTE :{
 
       std::vector<char>* temp = new std::vector<char>;
       temp->reserve(length*esize);
       temp->resize(length*esize);
       new_tag.edata = (void *)temp;
 
       temp = new std::vector<char>;
       temp->reserve(nsize*length);
       temp->resize(nsize*length);
       new_tag.ndata = (void *)temp;
 
       for(uint i=0; i<length*esize; ++i)
         (*static_cast<std::vector<char>*>(new_tag.edata))[i] 
           = ((char *)default_value)[i];
       for(uint i=0; i<length*nsize; ++i)      
         (*((std::vector<char>*)new_tag.ndata))[i] 
           = ((char *)default_value)[i];
       break;
     }
     case BOOL :{
 
       std::vector<bool>* temp = new std::vector<bool>;
       temp->reserve(esize*length);
       temp->resize(esize*length);
       new_tag.edata = (void *) temp;
 
       temp = new std::vector<bool>;
       temp->reserve(nsize*length);
       temp->resize(nsize*length);
       new_tag.ndata = (void *) temp;
 
       for(uint i=0; i<esize*length; ++i)
         (*((std::vector<bool>*)new_tag.edata))[i] 
           = ((bool *)default_value)[i];
       for(uint i=0; i<nsize*length; ++i)
         (*((std::vector<bool>*)new_tag.ndata))[i] 
           = ((bool *)default_value)[i];
       break;
     }
     case INT :{
 
       std::vector<int>* temp = new std::vector<int>;
       temp->reserve(esize*length);
       temp->resize(esize*length);
       new_tag.edata = (void *) temp;
 
       temp = new std::vector<int>;
       temp->reserve(nsize*length);
       temp->resize(nsize*length);     
       new_tag.ndata = (void *) temp;
 
       for(uint i=0; i<esize*length; ++i)
         (*((std::vector<int>*)new_tag.edata))[i] 
           = ((int *)default_value)[i];
       for(uint i=0; i<nsize*length; ++i)
         (*((std::vector<int>*)new_tag.ndata))[i] 
           = ((int *)default_value)[i];
       break;
     }
     case DOUBLE :{
 
       std::vector<double>* temp = new std::vector<double>;
       temp->reserve(esize*length);
       temp->resize(esize*length);
       new_tag.edata = (void *) temp;
 
       temp = new std::vector<double>;
       temp->reserve(nsize*length);
       temp->resize(nsize*length);
       new_tag.ndata = (void *) temp;
 
       for(uint i=0; i<esize*length; ++i)
         (*((std::vector<double>*)new_tag.edata))[i] 
           = ((double *)default_value)[i];
       for(uint i=0; i<nsize*length; ++i)
         (*((std::vector<double>*)new_tag.ndata))[i] 
           = ((double *)default_value)[i];
       break;
     }
     case HANDLE : {
 
       std::vector<void*>* temp = new std::vector<void*>;
       temp->reserve(esize*length);
       temp->resize(esize*length);
       new_tag.edata = (void *) temp;
 
       temp = new std::vector<void*>;
       temp->reserve(nsize*length);
       temp->resize(nsize*length);      
       new_tag.ndata = (void *) temp;
 
       for(uint i=0; i<esize*length; ++i)
         (*((std::vector<void*>*)new_tag.edata))[i] 
           = ((void* *)default_value)[i];
       for(uint i=0; i<nsize*length; ++i)
         (*((std::vector<void*>*)new_tag.ndata))[i] 
           = ((void* *)default_value)[i];
       break;
     }
     default :
       COM_assertion_msg (0,
                          "Unrecognized TagType.");
       break;
     }
     s_to_t.insert(std::make_pair<msq_std::string,tagStruct>(tag_name,new_tag));
     std::map<msq_std::string,tagStruct>::iterator pos;
     pos = s_to_t.find(tag_name);
     COM_assertion_msg(pos != s_to_t.end(),
                       "Unable to create tag for Mesquite.");
     return &(pos->second);
   }

Here is the call graph for this function:

virtual void tag_delete	(	TagHandle	handle,
		MsqError &	err
	)

virtual

Remove a tag and all corresponding data.

Delete a tag.

void tag_delete	(	TagHandle	handle,
		MsqError &	err
	)

virtual

Remove a tag and all corresponding data.

Delete a tag.

Definition at line 812 of file MesqPane_1_1.C.

References COM_assertion_msg, if(), n, and v.

                                                             {
     if(_verb)
       cout << "MOP> MesqPane::tag_delete" << endl;
     tagStruct* tag = (tagStruct*)handle;
     switch ( (*tag).type){
     case BYTE : {
       std::vector<char>* v = (std::vector<char>*)(*tag).edata;
       if (v!= NULL)
         delete v;
       v = (std::vector<char>*)(*tag).ndata;
       if (v!= NULL)
         delete v;
       break;
     }
     case BOOL :{
       std::vector<bool>* v = (std::vector<bool>*) (*tag).edata;
       if (v!= NULL)
         delete v;
       v = (std::vector<bool>*) (*tag).ndata;
       if (v!= NULL)
         delete v;
       break;
     }
     case INT :{
       std::vector<int>* v = (std::vector<int>*) (*tag).edata;
       if (v!= NULL)
         delete v;
       v = (std::vector<int>*) (*tag).ndata;
       if (v!= NULL)
         delete v;
       break;
     }
     case DOUBLE :{
       std::vector<double>* v = (std::vector<double>*) (*tag).edata;
       if (v!= NULL)
         delete v;
       v = (std::vector<double>*) (*tag).ndata;
       if (v!= NULL)
         delete v;
       break;
     }
     case HANDLE :{
       std::vector<void*>* v = (std::vector<void*>*) (*tag).edata;
       if (v!= NULL)
         delete v;
       v = (std::vector<void*>*) (*tag).ndata;
       if (v!= NULL)
         delete v;
       break;
     }
     default:
       COM_assertion_msg (0,
                          "Unrecognized TagType.");
       break;
     }
     const msq_std::string n= (*tag).name;
     std::map<msq_std::string,tagStruct>::iterator pos;
     pos = s_to_t.find(n);
     assert(pos != s_to_t.end());
     s_to_t.erase(n);
   }

Here is the call graph for this function:

virtual TagHandle tag_get	(	const msq_std::string &	name,
		MsqError &	err
	)

virtual

Get handle for existing tag, by name.

Check for the existance of a tag given it's name and if it exists return a handle for it. If the specified tag does not exist, zero should be returned WITHOUT flagging an error.

TagHandle tag_get	(	const msq_std::string &	name,
		MsqError &	err
	)

virtual

Get handle for existing tag, by name.

Check for the existance of a tag given it's name and if it exists return a handle for it. If the specified tag does not exist, zero should be returned WITHOUT flagging an error.

Definition at line 883 of file MesqPane_1_1.C.

                                               {
     if(_verb)
       cout << "MOP> MesqPane::tag_get" << endl;
     std::map<msq_std::string,tagStruct>::iterator pos;
     pos = s_to_t.find(name);
     if(pos == s_to_t.end())
       return NULL;
     else
       return (TagHandle)(&(*pos));
   }

virtual void tag_get_element_data	(	TagHandle	handle,
		size_t	num_elems,
		const ElementHandle *	elem_array,
		void *	tag_data,
		MsqError &	err
	)

virtual

Get tag values on elements.

Get the value of a tag for a list of mesh elements.

Parameters

handle	The tag
num_elems	Length of elem_array
elem_array	Array of elements for which to get the tag value.
tag_data	Return buffer in which to copy tag data, contiguous in memory. This data is expected to be num_elemstag_lengthsizeof(tag_type) bytes.

void tag_get_element_data	(	TagHandle	handle,
		size_t	num_elems,
		const ElementHandle *	elem_array,
		void *	tag_data,
		MsqError &	err
	)

virtual

Get tag values on elements.

Get the value of a tag for a list of mesh elements.

Parameters

handle	The tag
num_elems	Length of elem_array
elem_array	Array of elements for which to get the tag value.
tag_data	Return buffer in which to copy tag data, contiguous in memory. This data is expected to be num_elemstag_lengthsizeof(tag_type) bytes.

Definition at line 1189 of file MesqPane_1_1.C.

References i, and j.

                                                       {
     if(_verb)
       cout << "MOP> MesqPane::tag_get_element_data" << endl;
     tagStruct* tag = (tagStruct*)handle;
     switch ((*tag).type){
     case BYTE : {
       for(uint i=0; i<num_elems; ++i){
         int eid = ((char*)elem_array[i]-(char*)NULL);   
         for(uint j=0; j<(*tag).size; ++j)
           ((char*)tag_data)[i * (*tag).size +j] 
             = ((char*)((*tag).edata))[eid*(*tag).size+j];
       }
       break;
     }
     case BOOL :{
       for(uint i=0; i<num_elems; ++i){
         int eid = ((bool*)elem_array[i]-(bool*)NULL);   
         for(uint j=0; j<(*tag).size; ++j)
           ((bool*)tag_data)[i * (*tag).size +j] 
             = ((bool*)((*tag).edata))[eid*(*tag).size+j];
       }
       break;
     }
     case INT :{
       for(uint i=0; i<num_elems; ++i){
         int eid = ((int*)elem_array[i]-(int*)NULL);     
         for(uint j=0; j<(*tag).size; ++j)
           ((int*)tag_data)[i * (*tag).size +j] 
             = ((int*)((*tag).edata))[eid*(*tag).size+j];
       }
       break;
     }
     case DOUBLE :{
       for(uint i=0; i<num_elems; ++i){
         int eid = ((double*)elem_array[i]-(double*)NULL);       
         for(uint j=0; j<(*tag).size; ++j)
           ((double*)tag_data)[i * (*tag).size +j] 
             = ((double*)((*tag).edata))[eid*(*tag).size+j];
       }
       break;
     }
     case HANDLE : {
       for(uint i=0; i<num_elems; ++i){
         int eid = ((void**)elem_array[i]-(void**)NULL);         
         for(uint j=0; j<(*tag).size; ++j)
           ((void**)tag_data)[i * (*tag).size +j] 
             = ((void**)((*tag).edata))[eid*(*tag).size+j];
       }
       break;
     }
     }
   }

void * tag_get_handle	(	const string	tag_name,
		MsqError &	err
	)

virtual

Returns the tag handle corresponding to the string.

Sets an error if the string is not recognised

Definition at line 515 of file MesqPane.C.

                                                                     {
     if(_verb)
       cout << "MesqPane::tag_get_handle" << endl;
     return (void*) &(denseTags[tag_name]);
     if(_verb)
       cout << "MesqPane::tag_get_handle finished" << endl;
   }

virtual void tag_get_vertex_data	(	TagHandle	handle,
		size_t	num_elems,
		const VertexHandle *	node_array,
		void *	tag_data,
		MsqError &	err
	)

virtual

Get tag values on vertices.

Get the value of a tag for a list of mesh vertices.

Parameters

handle	The tag
num_elems	Length of elem_array
elem_array	Array of vertices for which to get the tag value.
tag_data	Return buffer in which to copy tag data, contiguous in memory. This data is expected to be num_elemstag_lengthsizeof(tag_type) bytes.

void tag_get_vertex_data	(	TagHandle	handle,
		size_t	num_elems,
		const VertexHandle *	node_array,
		void *	tag_data,
		MsqError &	err
	)

virtual

Get tag values on vertices.

Get the value of a tag for a list of mesh vertices.

Parameters

handle	The tag
num_elems	Length of elem_array
elem_array	Array of vertices for which to get the tag value.
tag_data	Return buffer in which to copy tag data, contiguous in memory. This data is expected to be num_elemstag_lengthsizeof(tag_type) bytes.

Definition at line 1256 of file MesqPane_1_1.C.

References i, and j.

                                                       {
     if(_verb)
       cout << "MOP> MesqPane::tag_get_vertex_data" << endl;
     tagStruct* tag = (tagStruct*)handle;
     switch ((*tag).type){
     case BYTE : {
       for(uint i=0; i<num_elems; ++i){
         int vid = ((char*)node_array[i]-(char*)NULL);   
         for(uint j=0; j<(*tag).size; ++j)
           ((char*)tag_data)[i * (*tag).size +j] 
             = ((char*)((*tag).ndata))[vid*(*tag).size+j];
       }
       break;
     }
     case BOOL :{
       for(uint i=0; i<num_elems; ++i){
         int vid = ((bool*)node_array[i]-(bool*)NULL);   
         for(uint j=0; j<(*tag).size; ++j)
           ((bool*)tag_data)[i * (*tag).size +j] 
             = ((bool*)((*tag).ndata))[vid*(*tag).size+j];
       }
       break;
     }
     case INT :{
       for(uint i=0; i<num_elems; ++i){
         int vid = ((int*)node_array[i]-(int*)NULL);     
         for(uint j=0; j<(*tag).size; ++j)
           ((int*)tag_data)[i * (*tag).size +j] 
             = ((int*)((*tag).ndata))[vid*(*tag).size+j];
       }
       break;
     }
     case DOUBLE :{
       for(uint i=0; i<num_elems; ++i){
         int vid = ((double*)node_array[i]-(double*)NULL);       
         for(uint j=0; j<(*tag).size; ++j)
           ((double*)tag_data)[i * (*tag).size +j] 
             = ((double*)((*tag).ndata))[vid*(*tag).size+j];
       }
       break;
     }
     case HANDLE : {
       for(uint i=0; i<num_elems; ++i){
         int vid = ((void**)node_array[i]-(void**)NULL);         
         for(uint j=0; j<(*tag).size; ++j)
           ((void**)tag_data)[i * (*tag).size +j] 
             = ((void**)((*tag).ndata))[vid*(*tag).size+j];
       }
       break;
     }
     }
   }

virtual void tag_properties	(	TagHandle	handle,
		msq_std::string &	name_out,
		TagType &	type_out,
		unsigned &	length_out,
		MsqError &	err
	)

virtual

Get properites of tag.

Get data type and number of values per entity for tag.

Parameters

handle	Tag to get properties of.
name_out	Passed back tag name.
type_out	Passed back tag type.
length_out	Passed back number of values per entity.

void tag_properties	(	TagHandle	handle,
		msq_std::string &	name_out,
		TagType &	type_out,
		unsigned &	length_out,
		MsqError &	err
	)

virtual

Get properites of tag.

Get data type and number of values per entity for tag.

Parameters

handle	Tag to get properties of.
name_out	Passed back tag name.
type_out	Passed back tag type.
length_out	Passed back number of values per entity.

Definition at line 903 of file MesqPane_1_1.C.

References MesqPane::tag::size.

                                                 {
     if(_verb)
       cout << "MOP> MesqPane::tag_properties" << endl;
     tagStruct* tag = (tagStruct*)handle;
     name_out = (*tag).name;
     type_out = (*tag).type;
     length_out = (*tag).size;
   }

virtual void tag_set_element_data	(	TagHandle	handle,
		size_t	num_elems,
		const ElementHandle *	elem_array,
		const void *	tag_data,
		MsqError &	err
	)

virtual

Set tag values on elements.

Set the value of a tag for a list of mesh elements.

Parameters

handle	The tag
num_elems	Length of elem_array
elem_array	Array of elements for which to set the tag value.
tag_data	Tag data for each element, contiguous in memory. This data is expected to be num_elemstag_lengthsizeof(tag_type) bytes.

void tag_set_element_data	(	TagHandle	handle,
		size_t	num_elems,
		const ElementHandle *	elem_array,
		const void *	tag_data,
		MsqError &	err
	)

virtual

Set tag values on elements.

Set the value of a tag for a list of mesh elements.

Parameters

handle	The tag
num_elems	Length of elem_array
elem_array	Array of elements for which to set the tag value.
tag_data	Tag data for each element, contiguous in memory. This data is expected to be num_elemstag_lengthsizeof(tag_type) bytes.

Definition at line 926 of file MesqPane_1_1.C.

References COM_assertion_msg, i, if(), j, and v.

                                                       {
     if(_verb)
       cout << "MOP> MesqPane::tag_set_element_data" << endl;
     tagStruct* tag = (tagStruct*)handle;
     int ne = 1 + (_with_ghost ? _pane->size_of_elements() :
                   _pane->size_of_real_elements());
     switch ((*tag).type){
     case BYTE : {
       std::vector<char>* v = (std::vector<char>*)(*tag).edata;
       uint tsize = ne*(*tag).size;
       if (v->size() != tsize){
         // This tag isn't used yet... should only have default value
         COM_assertion_msg(v->size() == (*tag).size,
                           "Invalid TagHandle received from Mesquite");
         v->reserve(tsize);
         v->resize(tsize);
         for(int i=0; i < ne; ++i){
           for(uint j=0; j< (*tag).size; ++j)
             (*v)[i*(*tag).size+j]=(*v)[j];
         }
       }
       for(uint i=0; i<num_elems; ++i){
         int eid = ((char*)elem_array[i]-(char*)NULL); 
         for(uint j=0; j< (*tag).size; ++j)
           (*v)[eid * (*tag).size +j]=((char*)tag_data)[i*(*tag).size+j];
       }
       break;
     }
     case BOOL :{
       std::vector<bool>* v = (std::vector<bool>*)(*tag).edata;
       uint tsize = ne*(*tag).size;
       if (v->size() != tsize){
         // This tag isn't used yet... should only have default value
         COM_assertion_msg(v->size() == (*tag).size,
                           "Invalid TagHandle received from Mesquite");
         v->reserve(tsize);
         v->resize(tsize);
         for(int i=0; i < ne; ++i){
           for(uint j=0; j< (*tag).size; ++j)
             (*v)[i*(*tag).size+j]=(*v)[j];
         }
       }
       for(uint i=0; i<num_elems; ++i){
         int eid = ((bool*)elem_array[i]-(bool*)NULL); 
         for(uint j=0; j< (*tag).size; ++j)
           (*v)[eid * (*tag).size +j]=((bool*)tag_data)[i*(*tag).size+j];
       }
       break;
     }
     case INT :{
       std::vector<int>* v = (std::vector<int>*)(*tag).edata;
       uint tsize = ne*(*tag).size;
       if (v->size() != tsize){
         // This tag isn't used yet... should only have default value
         COM_assertion_msg(v->size() == (*tag).size,
                           "Invalid TagHandle received from Mesquite");
         v->reserve(tsize);
         v->resize(tsize);
         for(int i=0; i < ne; ++i){
           for(uint j=0; j< (*tag).size; ++j)
             (*v)[i*(*tag).size+j]=(*v)[j];
         }
       }
       for(uint i=0; i<num_elems; ++i){
         int eid = ((int*)elem_array[i]-(int*)NULL); 
         for(uint j=0; j< (*tag).size; ++j)
           (*v)[eid * (*tag).size +j]=((int*)tag_data)[i*(*tag).size+j];
       }
       break;
     }
     case DOUBLE :{
       std::vector<double>* v = (std::vector<double>*)(*tag).edata;
       uint tsize = ne*(*tag).size;
       if (v->size() != tsize){
         // This tag isn't used yet... should only have default value
         COM_assertion_msg(v->size() == (*tag).size,
                           "Invalid TagHandle received from Mesquite");
         v->reserve(tsize);
         v->resize(tsize);
         for(int i=0; i < ne; ++i){
           for(uint j=0; j< (*tag).size; ++j)
             (*v)[i*(*tag).size+j]=(*v)[j];
         }
       }
       for(uint i=0; i<num_elems; ++i){
         int eid = ((double*)elem_array[i]-(double*)NULL); 
         for(uint j=0; j< (*tag).size; ++j)
           (*v)[eid * (*tag).size +j]=((double*)tag_data)[i*(*tag).size+j];
       }
       break;
     }
     case HANDLE : {
       std::vector<void*>* v = (std::vector<void*>*)(*tag).edata;
       uint tsize = ne*(*tag).size;
       if (v->size() != tsize){
         // This tag isn't used yet... should only have default value
         COM_assertion_msg(v->size() == (*tag).size,
                           "Invalid TagHandle received from Mesquite");
         v->reserve(tsize);
         v->resize(tsize);
         for(int i=0; i < ne; ++i){
           for(uint j=0; j< (*tag).size; ++j)
             (*v)[i*(*tag).size+j]=(*v)[j];
         }
       }
       for(uint i=0; i<num_elems; ++i){
         int eid = ((void**)elem_array[i]-(void**)NULL); 
         for(uint j=0; j< (*tag).size; ++j)
           (*v)[eid * (*tag).size +j]=((void**)tag_data)[i*(*tag).size+j];
       }
       break;
     }
     default :
       COM_assertion_msg(0,
                         "TagHandle with unrecgonized TagType received.");
     }
   }

Here is the call graph for this function:

virtual void tag_set_vertex_data	(	TagHandle	handle,
		size_t	num_elems,
		const VertexHandle *	node_array,
		const void *	tag_data,
		MsqError &	err
	)

virtual

Set tag values on vertices.

Set the value of a tag for a list of mesh vertices.

Parameters

handle	The tag
num_elems	Length of node_array
node_array	Array of vertices for which to set the tag value.
tag_data	Tag data for each element, contiguous in memory. This data is expected to be num_elemstag_lengthsizeof(tag_type) bytes.

void tag_set_vertex_data	(	TagHandle	handle,
		size_t	num_elems,
		const VertexHandle *	node_array,
		const void *	tag_data,
		MsqError &	err
	)

virtual

Set tag values on vertices.

Set the value of a tag for a list of mesh vertices.

Parameters

handle	The tag
num_elems	Length of node_array
node_array	Array of vertices for which to set the tag value.
tag_data	Tag data for each element, contiguous in memory. This data is expected to be num_elemstag_lengthsizeof(tag_type) bytes.

Definition at line 1059 of file MesqPane_1_1.C.

References COM_assertion_msg, i, j, and v.

                                                       {
     if(_verb)
       cout << "MOP> MesqPane::tag_set_vertex_data" << endl;
     tagStruct* tag = (tagStruct*)handle;
     uint nn = 1 + (_with_ghost ? _pane->size_of_nodes() :
                    _pane->size_of_real_nodes());
     switch ((*tag).type){
     case BYTE : {
       std::vector<char>* v = (std::vector<char>*)(*tag).ndata;
       uint tsize = (nn)* (*tag).size;
       if (v->size() != tsize){
         // This tag isn't used yet... should only have default value
         COM_assertion_msg(v->size() == (*tag).size,
                           "Invalid TagHandle received from Mesquite");
         v->reserve(tsize);
         v->resize(tsize);
         for(uint i=0; i < nn; ++i){
           for(uint j=0; j< (*tag).size; ++j)
             (*v)[i * (*tag).size +j]=(*v)[j];
         }
       }
       for(uint i=0; i<num_elems; ++i){
         int eid = ((char*)node_array[i]-(char*)NULL); 
         for(uint j=0; j<(*tag).size; ++j)
           (*v)[eid * (*tag).size +j]=((char*)tag_data)[i*(*tag).size+j];
       }
       break;
     }
     case BOOL :{
       std::vector<bool>* v = (std::vector<bool>*)(*tag).ndata;
       uint tsize = (nn)* (*tag).size;
       if (v->size() != tsize){
         // This tag isn't used yet... should only have default value
         COM_assertion_msg(v->size() == (*tag).size,
                           "Invalid TagHandle received from Mesquite");
         v->reserve(tsize);
         v->resize(tsize);
         for(uint i=0; i < nn; ++i){
           for(uint j=0; j< (*tag).size; ++j)
             (*v)[i * (*tag).size +j]=(*v)[j];
         }
       }
       for(uint i=0; i<num_elems; ++i){
         int eid = ((bool*)node_array[i]-(bool*)NULL); 
         for(uint j=0; j<(*tag).size; ++j)
           (*v)[eid * (*tag).size +j]=((bool*)tag_data)[i*(*tag).size+j];
       }
       break;
     }
     case INT :{
       std::vector<int>* v = (std::vector<int>*)(*tag).ndata;
       uint tsize = (nn)* (*tag).size;
       if (v->size() != tsize){
         // This tag isn't used yet... should only have default value
         COM_assertion_msg(v->size() == (*tag).size,
                           "Invalid TagHandle received from Mesquite");
         v->reserve(tsize);
         v->resize(tsize);
         for(uint i=0; i < nn; ++i){
           for(uint j=0; j< (*tag).size; ++j)
             (*v)[i * (*tag).size +j]=(*v)[j];
         }
       }
       for(uint i=0; i<num_elems; ++i){
         int eid = ((int*)node_array[i]-(int*)NULL); 
         for(uint j=0; j<(*tag).size; ++j)
           (*v)[eid * (*tag).size +j]=((int*)tag_data)[i*(*tag).size+j];
       }
       break;
     }
     case DOUBLE :{
       std::vector<double>* v = (std::vector<double>*)(*tag).ndata;
       uint tsize = (nn)* (*tag).size;
       if (v->size() != tsize){
         // This tag isn't used yet... should only have default value
         COM_assertion_msg(v->size() == (*tag).size,
                           "Invalid TagHandle received from Mesquite");
         v->reserve(tsize);
         v->resize(tsize);
         for(uint i=0; i < nn; ++i){
           for(uint j=0; j< (*tag).size; ++j)
             (*v)[i * (*tag).size +j]=(*v)[j];
         }
       }
       for(uint i=0; i<num_elems; ++i){
         int eid = ((double*)node_array[i]-(double*)NULL); 
         for(uint j=0; j<(*tag).size; ++j)
           (*v)[eid * (*tag).size +j]=((double*)tag_data)[i*(*tag).size+j];
       }
       break;
     }
     case HANDLE : {
       std::vector<void*>* v = (std::vector<void*>*)(*tag).ndata;
       uint tsize = (nn)* (*tag).size;
       if (v->size() != tsize){
         // This tag isn't used yet... should only have default value
         COM_assertion_msg(v->size() == (*tag).size,
                           "Invalid TagHandle received from Mesquite");
         v->reserve(tsize);
         v->resize(tsize);
         for(uint i=0; i < nn; ++i){
           for(uint j=0; j< (*tag).size; ++j)
             (*v)[i * (*tag).size +j]=(*v)[j];
         }
       }
       for(uint i=0; i<num_elems; ++i){
         int eid = ((void**)node_array[i]-(void**)NULL); 
         for(uint j=0; j<(*tag).size; ++j)
           (*v)[eid * (*tag).size +j]=((void**)tag_data)[i*(*tag).size+j];
       }
       break;
     }
     }
   }

virtual size_t vertex_get_attached_element_count	(	VertexHandle	vertex,
		MsqError &	err
	)

virtual

Gets the number of elements attached to this vertex.

Useful to determine how large the "elem_array" parameter of the vertex_get_attached_elements() function must be.

size_t vertex_get_attached_element_count	(	VertexHandle	vertex,
		MsqError &	err
	)		const

virtual

Gets the number of elements attached to this vertex.

Useful to determine how large the "elem_array" parameter of the vertex_get_attached_elements() function must be.

Definition at line 319 of file MesqPane.C.

                                                                          {
     if(_verb)
       cout << "MesqPane::vertex_get_attached_element_count" << endl;
     int node_id = ((char*)vertex - (char*)NULL);                    
     std::vector<int> elist;
     _dc->incident_elements(node_id,elist);
     return elist.size();
     if(_verb)
       cout << "MesqPane::vertex_get_attached_element_count finished" << endl;
   }

size_t vertex_get_attached_element_count	(	VertexHandle	vertex,
		MsqError &	err
	)

virtual

Gets the number of elements attached to this vertex.

Useful to determine how large the "elem_array" parameter of the vertex_get_attached_elements() function must be.

Definition at line 427 of file MesqPane_1_1.C.

                                                                    {
     if(_verb)
       cout << "MOP> MesqPane::vertex_get_attached_element_count" << endl;
     int node_id = ((char*)vertex - (char*)NULL);                    
     std::vector<int> elist;
     _dc->incident_elements(node_id,elist);
     return elist.size();
     if(_verb)
       cout << "MOP> MesqPane::vertex_get_attached_element_count finished" << endl;
   }

virtual void vertex_get_attached_elements	(	VertexHandle	vertex,
		ElementHandle *	elem_array,
		size_t	sizeof_elem_array,
		MsqError &	err
	)

virtual

Gets the elements attached to this vertex.

void vertex_get_attached_elements	(	VertexHandle	vertex,
		ElementHandle *	elem_array,
		size_t	sizeof_elem_array,
		MsqError &	err
	)

virtual

Gets the elements attached to this vertex.

Implements Mesh.

Definition at line 331 of file MesqPane.C.

References i.

                                                             {
     if(_verb)
       cout << "MesqPane::vertex_get_attached_elements" << endl;
     int node_id = ((char*)vertex - (char*)NULL);                    
     std::vector<int> elist;
     _dc->incident_elements(node_id,elist);    
     if(sizeof_elem_array > elist.size())
       sizeof_elem_array = elist.size();
     for(uint i = 0; i < sizeof_elem_array; i++){
       elem_array[i] = ((char*)NULL+elist[i]);
     }
     if(_verb)
       cout << "MesqPane::vertex_get_attached_elements finished" << endl;
   }

void vertex_get_attached_elements	(	VertexHandle	vertex,
		ElementHandle *	elem_array,
		size_t	sizeof_elem_array,
		MsqError &	err
	)

virtual

Gets the elements attached to this vertex.

Definition at line 439 of file MesqPane_1_1.C.

References i.

                                                             {
     if(_verb)
       cout << "MOP> MesqPane::vertex_get_attached_elements" << endl;
     int node_id = ((char*)vertex - (char*)NULL);                    
     std::vector<int> elist;
     _dc->incident_elements(node_id,elist);    
     if(sizeof_elem_array > elist.size())
       elist.resize(sizeof_elem_array);
     for(uint i = 0; i < sizeof_elem_array; i++){
       elem_array[i] = ((char*)NULL+elist[i]);
     }
     if(_verb)
       cout << "MOP> MesqPane::vertex_get_attached_elements finished" << endl;
   }

virtual void vertex_get_byte	(	VertexHandle	vertex,
		unsigned char *	byte,
		MsqError &	err
	)

virtual

Retrieve the byte value for the specified vertex or vertices.

The byte value is 0 if it has not yet been set via one of the *_set_byte() functions.

void vertex_get_byte	(	VertexHandle	vertex,
		unsigned char *	byte,
		MsqError &	err
	)

virtual

Retrieve the byte value for the specified vertex.

The byte value is 0 if it has not yet been set via one of the _set_byte() functions.

Implements Mesh.

Definition at line 297 of file MesqPane.C.

References offset().

                                                                   {
     if(_verb)
       cout << "MesqPane::vertex_get_byte" << endl;
     int offset = ((char*)vertex - (char*)NULL) - 1;
     *byte = _vertexBytes[offset];
   }

Here is the call graph for this function:

void vertex_get_byte	(	VertexHandle	vertex,
		unsigned char *	byte,
		MsqError &	err
	)

virtual

Retrieve the byte value for the specified vertex or vertices.

The byte value is 0 if it has not yet been set via one of the *_set_byte() functions.

Definition at line 405 of file MesqPane_1_1.C.

References offset().

                                                                     {
     if(_verb)
       cout << "MOP> MesqPane::vertex_get_byte" << endl;
     int offset = ((char*)vertex - (char*)NULL) - 1;
     *byte = _vertexBytes[offset];
   }

Here is the call graph for this function:

bool vertex_is_fixed	(	VertexHandle	vertex,
		MsqError &	err
	)

virtual

Tells wheter the vertex is allowed to be repositioned.

True indicates that the vertex is fixed and cannot be moved. This flag is not modifiable by users of the Mesquite::Mesh interface.

Implements Mesh.

Definition at line 156 of file MesqPane.C.

References COM_assertion_msg.

                                                                    {
     if(_verb>1)
       cout << "MesqPane::vertex_is_fixed" << endl;
     uint node_id = (char*)vertex - (char*)NULL;
     COM_assertion_msg(node_id <= _is_border.size(),
                       "Invalid vertex for MesqPane::vertex_is_fixed()");
     return _is_border[node_id-1];
     if(_verb>1)
       cout << "MesqPane::vertex_is_fixed finished" << endl;
   }

virtual bool vertex_is_fixed	(	VertexHandle	vertex,
		MsqError &	err
	)

virtual

Returns true or false, indicating whether the vertex is allowed to be repositioned.

True indicates that the vertex is fixed and cannot be moved. Note that this is a read-only property; this flag can't be modified by users of the Mesquite::Mesh interface.

bool vertex_is_fixed	(	VertexHandle	vertex,
		MsqError &	err
	)

virtual

Returns true or false, indicating whether the vertex is allowed to be repositioned.

True indicates that the vertex is fixed and cannot be moved. Note that this is a read-only property; this flag can't be modified by users of the Mesquite::Mesh interface.

Definition at line 252 of file MesqPane_1_1.C.

References COM_assertion_msg.

                                                                    {
     if(_verb>1)
       cout << "MOP> MesqPane::vertex_is_fixed" << endl;
     uint node_id = (char*)vertex - (char*)NULL;
     COM_assertion_msg(node_id <= _is_border.size(),
                       "Invalid vertex for MesqPane::vertex_is_fixed()");
     return _is_border[node_id-1];
     if(_verb>1)
       cout << "MOP> MesqPane::vertex_is_fixed finished" << endl;
   }

VertexIterator * vertex_iterator ( MsqError & err )

virtual

Returns a pointer to a vertex iterator over this Pane.

The calling code should delete the returned iterator when it is finished with it. If vertices are added or removed from the Mesh after obtaining an iterator, the behavior of that iterator is undefined.

Implements Mesh.

Definition at line 142 of file MesqPane.C.

                                                         {
     if(_verb>1)
       cout << "MesqPane::vertex_iterator" << endl;
     return new MyEntityIterator(_with_ghost ? _pane->size_of_nodes() :
                                 _pane->size_of_real_nodes());
   }

virtual VertexIterator* vertex_iterator ( MsqError & err )

virtual

Returns a pointer to an iterator that iterates over the set of all vertices in this mesh.

The calling code should delete the returned iterator when it is finished with it. If vertices are added or removed from the Mesh after obtaining an iterator, the behavior of that iterator is undefined.

VertexIterator * vertex_iterator ( MsqError & err )

virtual

Returns a pointer to an iterator that iterates over the set of all vertices in this mesh.

The calling code should delete the returned iterator when it is finished with it. If vertices are added or removed from the Mesh after obtaining an iterator, the behavior of that iterator is undefined.

Definition at line 228 of file MesqPane_1_1.C.

                                                         {
     if(_verb>1)
       cout << "MOP> MesqPane::vertex_iterator" << endl;
     return new MyEntityIterator(_with_ghost ? _pane->size_of_nodes() :
                                 _pane->size_of_real_nodes());
   }

virtual void vertex_set_byte	(	VertexHandle	vertex,
		unsigned char	byte,
		MsqError &	err
	)

virtual

Each vertex has a byte-sized flag that can be used to store flags.

This byte's value is neither set nor used by the mesh implementation. It is intended to be used by Mesquite algorithms. Until a vertex's byte has been explicitly set, its value is 0.

void vertex_set_byte	(	VertexHandle	vertex,
		unsigned char	byte,
		MsqError &	err
	)

virtual

Set a vertex flag.

Each vertex has a byte-sized flag that can be used to store flags. This byte's value is neither set nor used by the Pane. It is intended to be used by Mesquite algorithms. Until a vertex's byte has been explicitly set, its value is 0.

Parameters

vertex	a handle to the vertex in question.
byte	the new flag value.

Implements Mesh.

Definition at line 273 of file MesqPane.C.

References offset().

                                                                   {
     if(_verb)
       cout << "MesqPane::vertex_set_byte" << endl;
     int offset = ((char*)vertex - (char*)NULL) - 1;
     _vertexBytes[offset] = byte;    
     if(_verb)
       cout << "MesqPane::vertex_set_byte finished" << endl;  
 }

Here is the call graph for this function:

void vertex_set_byte	(	VertexHandle	vertex,
		unsigned char	byte,
		MsqError &	err
	)

virtual

Each vertex has a byte-sized flag that can be used to store flags.

This byte's value is neither set nor used by the mesh implementation. It is intended to be used by Mesquite algorithms. Until a vertex's byte has been explicitly set, its value is 0.

Definition at line 369 of file MesqPane_1_1.C.

References offset().

                                                                     {
     if(_verb)
       cout << "MOP> MesqPane::vertex_set_byte" << endl;
     int offset = ((char*)vertex - (char*)NULL) - 1;
     _vertexBytes[offset] = byte;    
     if(_verb)
       cout << "MOP> MesqPane::vertex_set_byte finished" << endl;  
   }

Here is the call graph for this function:

virtual void vertex_set_coordinates	(	VertexHandle	vertex,
		const Vector3D &	coordinates,
		MsqError &	err
	)

virtual

void vertex_set_coordinates	(	VertexHandle	vertex,
		const Vector3D &	coordinates,
		MsqError &	err
	)

virtual

Set the Location of a vertex.

Parameters

vertex	the vertex in question.
coordinates	Mesquite's coordinates for this vertex.

Implements Mesh.

Definition at line 244 of file MesqPane.C.

References Vector3D::get_coordinates(), and offset().

                                                       {
     int node_id = ((char*)vertex-(char*)NULL);
     if(_verb > 1)
       cout << "MesqPane::vertex_set_coordinates, node = " << node_id << endl;
     int offset = node_id - 1;
     double * xptr = _pane->coordinates();
     if(xptr){
       xptr += offset *3;
       if(_verb>1){
         cout << "Coordinate: [" << *xptr << " , "
              << *(xptr+1) << " , " << *(xptr+2) << "], ";      
       }
       coordinates.get_coordinates(xptr);
       if(_verb>1){
         cout << "-> [" << *xptr << " , "
              << *(xptr+1) << " , " << *(xptr+2) << "]" << endl;
       }
     }
     else{
       coordinates.get_coordinates(*(_pane->x_coordinates()+offset),
                                   *(_pane->y_coordinates()+offset),
                                   *(_pane->z_coordinates()+offset));
     }
     if(_verb)
       cout << "MesqPane::vertex_set_coordinates finished" << endl;
   }

Here is the call graph for this function:

void vertex_set_coordinates	(	VertexHandle	vertex,
		const Vector3D &	coordinates,
		MsqError &	err
	)

virtual

Definition at line 340 of file MesqPane_1_1.C.

References offset().

                                                       {
     int node_id = ((char*)vertex-(char*)NULL);
     if(_verb)
       cout << "MOP> MesqPane::vertex_set_coordinates, node = " << node_id << endl;
     int offset = node_id - 1;
     double * xptr = _pane->coordinates();
     if(xptr){
       xptr += offset *3;
       if(_verb>2){
         cout << "MOP> Coordinate: [" << *xptr << " , "
              << *(xptr+1) << " , " << *(xptr+2) << "], ";      
       }
       coordinates.get_coordinates(xptr);
       if(_verb>2){
         cout << "-> [" << *xptr << " , "
              << *(xptr+1) << " , " << *(xptr+2) << "]" << endl;
       }
     }
     else{
       coordinates.get_coordinates(*(_pane->x_coordinates()+offset),
                                   *(_pane->y_coordinates()+offset),
                                   *(_pane->z_coordinates()+offset));
     }
     if(_verb)
       cout << "MOP> MesqPane::vertex_set_coordinates finished" << endl;
   }

Here is the call graph for this function:

void vertices_are_on_boundary	(	VertexHandle	vert_array[],
		bool	on_bnd[],
		size_t	num_vtx,
		MsqError &	err
	)

virtual

Tells whether the vertex is on the boundary.

Boundary nodes may be treated as a special case by some algorithms or culling methods. This flag is not modifiable by users of the Mesquite::Mesh interface.

Implements Mesh.

Definition at line 167 of file MesqPane.C.

References i.

                                                                         {
     if(_verb)
       cout << "MesqPane::vertices_are_on_boundary" << endl;
     for (size_t i = 0; i < num_vtx; ++i){
       uint node_id = (((char*)vert_array[i]) - (char*)NULL);
       if (_is_border[node_id-1]){
         on_bnd[i] = true;
         if(_verb>1)
           std::cout << "Node " << node_id << " is on the boundary." << endl;
       }
       else{
         on_bnd[i] = false;
       }
     }
     if(_verb)
       cout << "MesqPane::vertices_are_on_boundary finished" << endl;
   }

virtual void vertices_are_on_boundary	(	VertexHandle	vert_array[],
		bool	on_bnd[],
		size_t	num_vtx,
		MsqError &	err
	)

virtual

Returns true or false, indicating whether the vertex is on the boundary.

Boundary nodes may be treated as a special case by some algorithms or culling methods. Note that this is a read-only property; this flag can't be modified by users of the Mesquite::Mesh interface.

void vertices_are_on_boundary	(	VertexHandle	vert_array[],
		bool	on_bnd[],
		size_t	num_vtx,
		MsqError &	err
	)

virtual

Returns true or false, indicating whether the vertex is on the boundary.

Boundary nodes may be treated as a special case by some algorithms or culling methods. Note that this is a read-only property; this flag can't be modified by users of the Mesquite::Mesh interface.

Definition at line 263 of file MesqPane_1_1.C.

References i.

                                                                         {
     if(_verb)
       cout << "MOP> MesqPane::vertices_are_on_boundary" << endl;
     for (size_t i = 0; i < num_vtx; ++i){
       uint node_id = (((char*)vert_array[i]) - (char*)NULL);
       if (_is_border[node_id-1]){
         on_bnd[i] = true;
         if(_verb>1)
           std::cout << "MOP> Node " << node_id << " is on the boundary." << endl;
       }
       else{
         on_bnd[i] = false;
       }
     }
     if(_verb)
       cout << "MOP> MesqPane::vertices_are_on_boundary finished" << endl;
   }

void vertices_get_attached_elements	(	const VertexHandle *	vertex_array,
		size_t	num_vertex,
		msq_std::vector< ElementHandle > &	elements,
		msq_std::vector< size_t > &	offsets,
		MsqError &	err
	)

virtual

get elements adjacent to vertices

Get adjacency data for vertices

Parameters

vertex_array	Array of vertex handles specifying the list of vertices to retrieve adjacency data for.
num_vertex	Number of vertex handles in vertex_array
elements	The array in which to place the handles of elements adjacent to the input vertices.
offsets	For each vertex in vertex_array, the value in the corresponding position in this array is the index into elem_array at which the adjacency list begins for that vertex.

Definition at line 458 of file MesqPane_1_1.C.

References i, ni, and swap().

                                                 {
 
     // Guess 6 elements to each node for initial memory allocation
     // to avoid frequent memory allocation and swapping.
     elements.reserve(6*num_vertex);
     offsets.resize(num_vertex+1);
     if(num_vertex > 0)
       offsets[0] = 0;
     std::vector<int> elist;
     elist.clear();
     
     for(size_t i=0; i<num_vertex; ++i){
       offsets[i] += elist.size();
       offsets[i+1] = offsets[i];
       int node_id = ((char*)vertex_array[i] - (char*)NULL);      
       _dc->incident_elements(node_id,elist);
       for(uint i=0, ni=elist.size(); i<ni; ++i)
         elements.push_back((char*)NULL + elist[i]);
     }
     offsets[num_vertex] = offsets[num_vertex-1] + elist.size();
 
     // trim excess capacity
     vector<ElementHandle>(elements).swap(elements);
   }

Here is the call graph for this function:

virtual void vertices_get_byte	(	VertexHandle *	vertex,
		unsigned char *	byte_array,
		size_t	array_size,
		MsqError &	err
	)

virtual

void vertices_get_byte	(	VertexHandle *	vertex,
		unsigned char *	byte_array,
		size_t	array_size,
		MsqError &	err
	)

virtual

Retrieve the byte value for the specified vertices.

The byte value is 0 if it has not yet been set via one of the _set_byte() functions.

Implements Mesh.

Definition at line 305 of file MesqPane.C.

References i, and offset().

                                                                   {
     if(_verb)
       cout << "MesqPane::vertices_get_byte" << endl;
     int offset =0;
     for(size_t i = 0; i < array_size; ++i){ 
       offset = ((char*)vertex[i] - (char*)NULL) - 1;
       byte_array[i] = _vertexBytes[offset];
     }
     if(_verb)
       cout << "MesqPane::vertices_get_byte finished" << endl;
   }

Here is the call graph for this function:

void vertices_get_byte	(	VertexHandle *	vertex,
		unsigned char *	byte_array,
		size_t	array_size,
		MsqError &	err
	)

virtual

Definition at line 413 of file MesqPane_1_1.C.

References i, and offset().

                                                                     {
     if(_verb)
       cout << "MOP> MesqPane::vertices_get_byte" << endl;
     int offset =0;
     for(size_t i = 0; i < array_size; ++i){ 
       offset = ((char*)vertex[i] - (char*)NULL) - 1;
       byte_array[i] = _vertexBytes[offset];
     }
     if(_verb)
       cout << "MOP> MesqPane::vertices_get_byte finished" << endl;
   }

Here is the call graph for this function:

virtual void vertices_get_byte	(	const VertexHandle *	vertex,
		unsigned char *	byte_array,
		size_t	array_size,
		MsqError &	err
	)

inlinevirtual

Definition at line 303 of file MesqPane_1_1.h.

306 {;}

virtual void vertices_get_coordinates	(	const VertexHandle	vert_array[],
		MsqVertex *	coordinates,
		size_t	num_vtx,
		MsqError &	err
	)

virtual

Get/set location of a vertex.

void vertices_get_coordinates	(	VertexHandle	vert_array[],
		Mesquite::MsqVertex *const &	coordinates,
		const size_t &	num_vtx,
		MsqError &	err
	)

virtual

Get the location of a vertex.

Parameters

vert_array	the array of vertex handles for this Pane.
coordinates	Mesquite's array of vertex coordinates.
num_vtx	number of vertices to process.

Definition at line 186 of file MesqPane.C.

References COM_assertion_msg, COM_NC, COM_NC1, COM_NC2, COM_NC3, i, offset(), and Vector3D::set().

                                                         {
     if(_verb)
       cout << "MesqPane::vertices_get_coordinates" << endl;
     const double *xptr = _pane->coordinates(), *yptr=NULL, *zptr=NULL;
     const COM::Attribute *nc = _pane->attribute(COM::COM_NC);
     int stride = nc->stride();
     if(!stride){
       const COM::Attribute *xc = _pane->attribute(COM::COM_NC1);
       const COM::Attribute *yc = _pane->attribute(COM::COM_NC2);
       const COM::Attribute *zc = _pane->attribute(COM::COM_NC3);
       int stride1 = xc->stride();
       int stride2 = yc->stride(); 
       int stride3 = zc->stride();
       xptr = _pane->x_coordinates();
       yptr = _pane->y_coordinates();
       zptr = _pane->z_coordinates();
       for (size_t i = 0; i < num_vtx; ++i){
         int offset = (char*)vert_array[i]-(char*)NULL -1;
         coordinates[i].set(*(xptr+offset*stride1),
                            *(yptr+offset*stride2),
                            *(zptr+offset*stride3));
       }
     }
     else if (stride==1){
       int nn = _with_ghost ? _pane->size_of_nodes() : 
         _pane->size_of_real_nodes();
       xptr = _pane->x_coordinates();
       for (size_t i = 0; i < num_vtx; ++i){
         int offset = (char*)vert_array[i]-(char*)NULL -1;
         coordinates[i].set(*(xptr+offset),
                            *(xptr+offset+nn),
                            *(xptr+offset+2*nn));
       }      
     }
     else if (stride>=3){
       xptr = _pane->x_coordinates();
       for (size_t i = 0; i < num_vtx; ++i){
         int offset = (char*)vert_array[i]-(char*)NULL -1;
         coordinates[i].set(xptr + offset * stride);
         if(_verb>1){
           cout << "Coords of node " << offset+1 << " = ["
                << coordinates[i][0] << ","
                << coordinates[i][1] << ","
                << coordinates[i][2] << "]" << endl;
         }
       }      
     }
     else{
       COM_assertion_msg( 0,
                          "Invalid stride length for nodal coordinates.");
     }
     if(_verb)
       cout << "MesqPane::vertices_get_coordinates finished" << endl;
   }

Here is the call graph for this function:

void vertices_get_coordinates	(	const VertexHandle	vert_array[],
		MsqVertex *	coordinates,
		size_t	num_vtx,
		MsqError &	err
	)

virtual

Get/set location of a vertex.

Definition at line 282 of file MesqPane_1_1.C.

References COM_assertion_msg, COM_NC, COM_NC1, COM_NC2, COM_NC3, i, and offset().

                                                         {
     if(_verb)
       cout << "MOP> MesqPane::vertices_get_coordinates" << endl;
     const double *xptr = _pane->coordinates(), *yptr=NULL, *zptr=NULL;
     const COM::Attribute *nc = _pane->attribute(COM::COM_NC);
     int stride = nc->stride();
     if(!stride){
       const COM::Attribute *xc = _pane->attribute(COM::COM_NC1);
       const COM::Attribute *yc = _pane->attribute(COM::COM_NC2);
       const COM::Attribute *zc = _pane->attribute(COM::COM_NC3);
       int stride1 = xc->stride();
       int stride2 = yc->stride(); 
       int stride3 = zc->stride();
       xptr = _pane->x_coordinates();
       yptr = _pane->y_coordinates();
       zptr = _pane->z_coordinates();
       for (size_t i = 0; i < num_vtx; ++i){
         int offset = (char*)vert_array[i]-(char*)NULL -1;
         coordinates[i].set(*(xptr+offset*stride1),
                            *(yptr+offset*stride2),
                            *(zptr+offset*stride3));
       }
     }
     else if (stride==1){
       int nn = _with_ghost ? _pane->size_of_nodes() : 
         _pane->size_of_real_nodes();
       xptr = _pane->x_coordinates();
       for (size_t i = 0; i < num_vtx; ++i){
         int offset = (char*)vert_array[i]-(char*)NULL -1;
         coordinates[i].set(*(xptr+offset),
                            *(xptr+offset+nn),
                            *(xptr+offset+2*nn));
       }      
     }
     else if (stride>=3){
       xptr = _pane->x_coordinates();
       for (size_t i = 0; i < num_vtx; ++i){
         int offset = (char*)vert_array[i]-(char*)NULL -1;
         coordinates[i].set(xptr + offset * stride);
         if(_verb>1){
           cout << "MOP> Coords of node " << offset+1 << " = ["
                << coordinates[i][0] << ","
                << coordinates[i][1] << ","
                << coordinates[i][2] << "]" << endl;
         }
       }      
     }
     else{
       COM_assertion_msg( 0,
                          "Invalid stride length for nodal coordinates.");
     }
     if(_verb)
       cout << "MOP> MesqPane::vertices_get_coordinates finished" << endl;
   }

Here is the call graph for this function:

void vertices_get_fixed_flag	(	const VertexHandle	vert_array[],
		bool	fixed_flag_array[],
		size_t	num_vtx,
		MsqError &	err
	)

virtual

Returns true or false, indicating whether the vertex is allowed to be repositioned.

True indicates that the vertex is fixed and cannot be moved. Note that this is a read-only property; this flag can't be modified by users of the Mesquite::Mesh interface.

Definition at line 242 of file MesqPane_1_1.C.

References i.

                                                          {
     for(size_t i =0; i< num_vtx; ++i){
       uint node_id = (char*)vert_array[i] - (char*)NULL;
       fixed_flag_array[i] = _is_border[node_id-1];
     }
   }

size_t vertices_in_topology ( EntityTopology )

inlineprivate

size_t vertices_in_topology ( EntityTopology )

inlineprivate

size_t vertices_in_topology ( EntityTopology )

inlineprivate

virtual void vertices_set_byte	(	VertexHandle *	vert_array,
		unsigned char *	byte_array,
		size_t	array_size,
		MsqError &	err
	)

virtual

void vertices_set_byte	(	VertexHandle *	vert_array,
		unsigned char *	byte_array,
		size_t	array_size,
		MsqError &	err
	)

virtual

Set mutliple vertex flags.

Each vertex has a byte-sized flag that can be used to store flags. This byte's value is neither set nor used by the Pane. It is intended to be used by Mesquite algorithms. Until a vertex's byte has been explicitly set, its value is 0.

Parameters

vert_array	handles to the vertices in question.
byte	the new flag value.

Implements Mesh.

Definition at line 283 of file MesqPane.C.

References i, and offset().

                                                                    {
     if(_verb)
       cout << "MesqPane::vertices_set_byte" << endl;
     int offset =0;
     for(size_t i = 0; i < array_size; ++i){ 
       offset = ((char*)vert_array[i] - (char*)NULL) - 1;
       _vertexBytes[offset] = byte_array[i];
     }
     if(_verb)
       cout << "MesqPane::vertices_set_byte" << endl;
   }

Here is the call graph for this function:

void vertices_set_byte	(	VertexHandle *	vert_array,
		unsigned char *	byte_array,
		size_t	array_size,
		MsqError &	err
	)

virtual

Definition at line 379 of file MesqPane_1_1.C.

References i, and offset().

                                                                      {
     if(_verb)
       cout << "MOP> MesqPane::vertices_set_byte" << endl;
     int offset =0;
     for(size_t i = 0; i < array_size; ++i){ 
       offset = ((char*)vert_array[i] - (char*)NULL) - 1;
       _vertexBytes[offset] = byte_array[i];
     }
     if(_verb)
       cout << "MOP> MesqPane::vertices_set_byte" << endl;
   }

Here is the call graph for this function:

void vertices_set_byte	(	const VertexHandle *	vert_array,
		const unsigned char *	byte_array,
		size_t	array_size,
		MsqError &	err
	)

virtual

Definition at line 394 of file MesqPane_1_1.C.

References i, and offset().

                                                    {
     int offset =0;
     for(size_t i = 0; i < array_size; ++i){ 
       offset = ((char*)vert_array[i] - (char*)NULL) - 1;
       _vertexBytes[offset] = byte_array[i];
     }
   }

Here is the call graph for this function:

Member Data Documentation

MAP::Pane_dual_connectivity * _dc

protected

Definition at line 475 of file MesqPane.h.

std::vector< bool > _is_border

protected

Definition at line 476 of file MesqPane.h.

COM::Pane * _pane

protected

Definition at line 474 of file MesqPane.h.

int _verb

protected

Definition at line 479 of file MesqPane.h.

std::vector< unsigned char > _vertexBytes

protected

Definition at line 477 of file MesqPane.h.

bool _with_ghost

protected

Definition at line 483 of file MesqPane.h.

std::map<std::string, MesqPane::tag> denseTags

protected

Definition at line 491 of file MesqPane.h.

std::map< msq_std::string, tagStruct > s_to_t

protected

Definition at line 613 of file MesqPane_1_1.h.

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

Classes

Public Types

Public Member Functions

Protected Attributes

Private Member Functions

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation