#include <ArrayMesh.hpp>

Inheritance diagram for MBMesquite::ArrayMesh:

Collaboration diagram for MBMesquite::ArrayMesh:

Classes
struct	Tag
Public Member Functions
	ArrayMesh (int coords_per_vertex, unsigned long num_vertices, double interleaved_vertex_coords, const int vertex_fixed_flags, unsigned long num_elements, EntityTopology element_type, const unsigned long element_connectivity_array, bool one_based_conn_indices=false, unsigned nodes_per_element=0, const int vertex_slaved_flags=0)
	ArrayMesh (int coords_per_vertex, unsigned long num_vertices, double interleaved_vertex_coords, const int vertex_fixed_flags, unsigned long num_elements, const EntityTopology element_types, const unsigned long element_connectivity_array, const unsigned long element_connectivity_offsets=NULL, bool one_based_conn_indices=false, const int vertex_slaved_flags=0)
	ArrayMesh ()
	~ArrayMesh ()
void	clear_mesh ()
void	set_mesh (int coords_per_vertex, unsigned long num_vertices, double interleaved_vertex_coords, const int vertex_fixed_flags, unsigned long num_elements, EntityTopology element_type, const unsigned long element_connectivity_array, bool one_based_conn_indices=false, unsigned nodes_per_element=0, const int vertex_slaved_flags=0)
TagHandle	add_read_only_tag_data (const char tag_name, TagType data_type, int vals_per_entity, const void vertex_data, const void element_data, const void default_value, MsqError &err)
	Give mesquite access to per-entity application data via a tag.
TagHandle	add_writable_tag_data (const char tag_name, TagType tag_data_type, int vals_per_entity, void vertex_data, void element_data, const void default_value, MsqError &err)
	Give mesquite access to per-entity application data via a tag.
virtual int	get_geometric_dimension (MsqError &err)
	Returns whether this mesh lies in a 2D or 3D coordinate system.
virtual void	get_all_elements (std::vector< ElementHandle > &elements, MsqError &err)
	Get all elements in mesh.
virtual void	get_all_vertices (std::vector< VertexHandle > &vertices, MsqError &err)
	Get all vertices in mesh.
virtual VertexIterator *	vertex_iterator (MsqError &err)
virtual ElementIterator *	element_iterator (MsqError &err)
virtual void	vertices_get_fixed_flag (const VertexHandle vert_array[], std::vector< bool > &fixed_flag_array, size_t num_vtx, MsqError &err)
virtual void	vertices_get_slaved_flag (const VertexHandle vert_array[], std::vector< bool > &slaved_flag_array, size_t num_vtx, MsqError &err)
virtual void	vertices_get_coordinates (const VertexHandle vert_array[], MsqVertex *coordinates, size_t num_vtx, MsqError &err)
	Get/set location of a vertex.
virtual void	vertex_set_coordinates (VertexHandle vertex, const Vector3D &coordinates, MsqError &err)
virtual void	vertex_set_byte (VertexHandle vertex, unsigned char byte, 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 (const VertexHandle vertex, unsigned char *byte, MsqError &err)
virtual void	vertices_get_byte (const VertexHandle vertex, unsigned char byte_array, size_t array_size, MsqError &err)
virtual void	vertices_get_attached_elements (const VertexHandle *vertex_array, size_t num_vertex, std::vector< ElementHandle > &elements, std::vector< size_t > &offsets, MsqError &err)
	get elements adjacent to vertices
virtual void	elements_get_attached_vertices (const ElementHandle *elem_handles, size_t num_elems, std::vector< VertexHandle > &vert_handles, std::vector< size_t > &offsets, MsqError &err)
	Get element connectivity.
virtual void	elements_get_topologies (const ElementHandle element_handle_array, EntityTopology element_topologies, size_t num_elements, MsqError &err)
virtual TagHandle	tag_create (const std::string &tag_name, TagType type, unsigned length, const void *default_value, MsqError &err)
	Create a tag.
virtual void	tag_delete (TagHandle handle, MsqError &err)
	Remove a tag and all corresponding data.
virtual TagHandle	tag_get (const std::string &name, MsqError &err)
	Get handle for existing tag, by name.
virtual void	tag_properties (TagHandle handle, std::string &name_out, TagType &type_out, unsigned &length_out, MsqError &err)
	Get properites of tag.
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.
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.
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.
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.
virtual void	release_entity_handles (const EntityHandle *handle_array, size_t num_handles, MsqError &err)
virtual void	release ()
Private Member Functions
const unsigned long *	elem_verts (size_t elem_index, int &num_vertex) const
void	build_vertex_adjacency_list ()
Tag *	allocate_tag (const char name, bool owned, TagType type, unsigned size, const void vertex_ro_data, void vertex_rw_data, const void element_ro_data, void element_rw_data, const void default_value, MsqError &err)
bool	valid () const
Static Private Member Functions
static unsigned	bytes (TagType type)
static void	fill (unsigned char buffer, const unsigned char value, size_t size, size_t count)
Private Attributes
int	mDimension
	Coordinates per vertex.
unsigned long	vertexCount
	Number of vertices.
double *	coordArray
	Interleaved vertex coordinates.
const int *	fixedFlags
	Vertex fixed flags.
const int *	slavedFlags
	Vertex slaved flags.
unsigned char *	vertexByteArray
	Vertex bytes.
unsigned long	elementCount
	Number of elements.
const unsigned long *	connArray
	Element connectivity.
const unsigned long *	connOffsets
unsigned long *	allocConnOffsets
EntityTopology	elementType
	Type for all elements if connOffsets is NULL.
const EntityTopology *	elementTypes
	Type for each element type if connOffsets is not NULL.
unsigned	nodesPerElement
	Nodes per element if connOffsets is NULL.
bool	oneBasedArrays
	FORTRAN-style array indexing.
unsigned long *	vertexAdjacencyList
unsigned long *	vertexAdjacencyOffsets
Tag *	tagList

Detailed Description

Definition at line 41 of file ArrayMesh.hpp.

Constructor & Destructor Documentation

MBMesquite::ArrayMesh::ArrayMesh	(	int	coords_per_vertex,
		unsigned long	num_vertices,
		double *	interleaved_vertex_coords,
		const int *	vertex_fixed_flags,
		unsigned long	num_elements,
		EntityTopology	element_type,
		const unsigned long *	element_connectivity_array,
		bool	one_based_conn_indices = `false`,
		unsigned	nodes_per_element = `0`,
		const int *	vertex_slaved_flags = `0`
	)

Create a MBMesquite::Mesh instance that wraps application-provided arrays.

Note: An instance of this class will reference the passed in arrays. It will not copy them.

Parameters:

coords_per_vertex	Dimension of the mesh (2 or 3)
num_vertices	Number of vertices in the mesh
interleaved_vertex_coords	Vertex coordinates. Ordered as [x1, y1, z1, x2, y2, z2, ...]
vertex_fixed_flags	One value per vertex. Zero if vertex is free, one if the position is fixed.
num_elements	Number of elements in the mesh
element_type	The type of the elements
element_connectivity_array	Element connectivity, specified as vertex indices such that the location of the vertex coordinates in vertex_coords is at 3 times the value in this array.
one_based_conn_indices	Use one-based (Fortran) array indexing.
nodes_per_element	Number of nodes in each element. If not specified, number of nodes in a linear element with the type 'element_type' is assumed.
vertex_slaved_flags	One value per vertex. Zero if vertex is free, one if the vertex is slaved to the logical position of the element mapping/shape function..

Definition at line 77 of file ArrayMesh.cpp.

References coordArray, corners, fixedFlags, mDimension, nodesPerElement, oneBasedArrays, valid(), and vertexByteArray.

    : mDimension( coords_per_vertex ), vertexCount( num_vertices ), coordArray( interleaved_vertex_coords ),
      fixedFlags( vertex_fixed_flags ), slavedFlags( vertex_slaved_flags ),
      vertexByteArray( new unsigned char[num_vertices + one_based_conn_indices] ), elementCount( num_elements ),
      connArray( element_connectivity_array ), connOffsets( 0 ), allocConnOffsets( 0 ), elementType( element_type ),
      elementTypes( 0 ), nodesPerElement( nodes_per_element ), oneBasedArrays( one_based_conn_indices ),
      vertexAdjacencyList( 0 ), vertexAdjacencyOffsets( 0 ), tagList( 0 )
{
    if( oneBasedArrays )
    {
        coordArray -= mDimension;
        --fixedFlags;
    }

    if( nodesPerElement < 2 ) nodesPerElement = TopologyInfo::corners( element_type );

    assert( valid() );
    memset( vertexByteArray, 0, num_vertices + one_based_conn_indices );
}

MBMesquite::ArrayMesh::ArrayMesh	(	int	coords_per_vertex,
		unsigned long	num_vertices,
		double *	interleaved_vertex_coords,
		const int *	vertex_fixed_flags,
		unsigned long	num_elements,
		const EntityTopology *	element_types,
		const unsigned long *	element_connectivity_array,
		const unsigned long *	element_connectivity_offsets = `NULL`,
		bool	one_based_conn_indices = `false`,
		const int *	vertex_slaved_flags = `0`
	)

Create a MBMesquite::Mesh instance that wraps application-provided arrays.

Note: An instance of this class will reference the passed in arrays. It will not copy them.

Parameters:

coords_per_vertex	Dimension of the mesh (2 or 3)
num_vertices	Number of vertices in the mesh
interleaved_vertex_coords	Vertex coordinates. Ordered as [x1, y1, z1, x2, y2, z2, ...]
vertex_fixed_flags	One value per vertex. Zero if vertex is free, one if the poistion is fixed.
num_elements	Number of elements in the mesh
element_types	The topological type for each element.
element_connectivity_array	Element connectivity, specified as vertex indices such that the location of the vertex coordinates in vertex_coords is at 3 times the value in this array.
element_connectivity_offsets	An optional array of length one greater than num_elements. Each entry other than the last should contain the value of the index into element_connectivity_array at which the connectivity data for the corresponding element begins. The last entry in the array must be the next-to-last entry plus the length of the connectivity data for the last element, such that the length of the connectivity data for any element 'e' can be calculated with: n = element_connectivity_offsets[e+1] - element_connectivity_offsets[e]

If this array is not specified, then it will be assumed that the length of the connectivity data for each element is the number of corners necessary to represent its topological type (that it has no higher-order nodes.)

Parameters:

one_based_conn_indices	Use one-based (Fortran) array indexing.
vertex_slaved_flags	One value per vertex. Zero if vertex is free, one if the vertex is slaved to the logical position of the element mapping/shape function..

Definition at line 106 of file ArrayMesh.cpp.

References allocConnOffsets, connArray, connOffsets, coordArray, corners, elementTypes, fixedFlags, mDimension, oneBasedArrays, valid(), and vertexByteArray.

    : mDimension( coords_per_vertex ), vertexCount( num_vertices ), coordArray( interleaved_vertex_coords ),
      fixedFlags( vertex_fixed_flags ), slavedFlags( vertex_slaved_flags ),
      vertexByteArray( new unsigned char[num_vertices + one_based_conn_indices] ), elementCount( num_elements ),
      connArray( element_connectivity_array ), connOffsets( element_connectivity_offsets ), allocConnOffsets( 0 ),
      elementType( MIXED ), elementTypes( element_types ), nodesPerElement( 0 ),
      oneBasedArrays( one_based_conn_indices ), vertexAdjacencyList( 0 ), vertexAdjacencyOffsets( 0 ), tagList( 0 )
{
    if( oneBasedArrays )
    {
        coordArray -= mDimension;
        --fixedFlags;
        if( element_connectivity_offsets ) --connArray;
    }

    if( !element_connectivity_offsets )
    {
        connOffsets = allocConnOffsets = new unsigned long[num_elements + 1];
        allocConnOffsets[0]            = 0;
        for( unsigned long i = 1; i <= num_elements; ++i )
            allocConnOffsets[i] = allocConnOffsets[i - 1] + TopologyInfo::corners( elementTypes[i - 1] );
    }

    assert( valid() );
    memset( vertexByteArray, 0, num_vertices + one_based_conn_indices );
}

MBMesquite::ArrayMesh::ArrayMesh ( )

Definition at line 69 of file ArrayMesh.cpp.

    : mDimension( 0 ), vertexCount( 0 ), coordArray( 0 ), fixedFlags( 0 ), slavedFlags( 0 ), vertexByteArray( 0 ),
      elementCount( 0 ), connArray( 0 ), connOffsets( 0 ), allocConnOffsets( 0 ), elementType( MIXED ),
      elementTypes( 0 ), nodesPerElement( 0 ), oneBasedArrays( false ), vertexAdjacencyList( 0 ),
      vertexAdjacencyOffsets( 0 ), tagList( 0 )
{
}

MBMesquite::ArrayMesh::~ArrayMesh ( )

Definition at line 241 of file ArrayMesh.cpp.

References clear_mesh().

{
    clear_mesh();
}

Member Function Documentation

TagHandle MBMesquite::ArrayMesh::add_read_only_tag_data	(	const char *	tag_name,
		TagType	data_type,
		int	vals_per_entity,
		const void *	vertex_data,
		const void *	element_data,
		const void *	default_value,
		MsqError &	err
	)

Give mesquite access to per-entity application data via a tag.

Allow mesquite to access application-owned per-element and/or per-vertex data by assigning a tag name to said data. Mesquite will be allowed to read application-owned data. Any attempt by Mesquite to modify the data will result in an internal error condition.

Parameters:

tag_name	Tag name through which Mesquite can access the data
data_type	The type of the data
vals_per_entity	Number of values of type `data_type` that each entity has Data is assumed to be interleaved such that all values associated with a a single entity are adjacent in memory
vertex_data	A pointer to the region of memory in which per-vertex values are stored. May be NULL if per-vertex data is not available. Values are assumed to be in the same order as the vertex coordinates passed to the constructor or `set_mesh`.
vertex_data	A pointer to the region of memory in which per-element values are stored. May be NULL if per-element data is not available. Values are assumed to be in the same order as the element connetivity passed to the constructor or `set_mesh`.
default_value	Value to return for all vertices and/or all elements if the cooresponding data array is null. May be NULL if no default value.

Definition at line 597 of file ArrayMesh.cpp.

References allocate_tag(), and MSQ_ERRZERO.

Referenced by ArrayMeshTest::test_delete_tag(), and ArrayMeshTest::test_tag_data().

{
    Tag* tag = allocate_tag( tag_name, false, data_type, vals_per_entity, vertex_data, 0, element_data, 0,
                             default_value, err );
    MSQ_ERRZERO( err );
    return reinterpret_cast< TagHandle >( tag );
}

TagHandle MBMesquite::ArrayMesh::add_writable_tag_data	(	const char *	tag_name,
		TagType	tag_data_type,
		int	vals_per_entity,
		void *	vertex_data,
		void *	element_data,
		const void *	default_value,
		MsqError &	err
	)

Give mesquite access to per-entity application data via a tag.

Allow mesquite to access and/or set application-owned per-element and/or per-vertex data by assigning a tag name to said data.

Parameters:

tag_name	Tag name through which Mesquite can access the data
data_type	The type of the data
vals_per_entity	Number of values of type `data_type` that each entity has Data is assumed to be interleaved such that all values associated with a a single entity are adjacent in memory
vertex_data	A pointer to the region of memory in which per-vertex values are stored. May be NULL if per-vertex data is not available. Values are assumed to be in the same order as the vertex coordinates passed to the constructor or `set_mesh`.
vertex_data	A pointer to the region of memory in which per-element values are stored. May be NULL if per-element data is not available. Values are assumed to be in the same order as the element connetivity passed to the constructor or `set_mesh`.
default_value	Value to return for all vertices and/or all elements if the cooresponding data array is null. May be NULL if no default value.

Definition at line 611 of file ArrayMesh.cpp.

References allocate_tag(), and MSQ_ERRZERO.

Referenced by ArrayMeshTest::test_delete_tag(), and ArrayMeshTest::test_tag_data().

{
    Tag* tag = allocate_tag( tag_name, false, data_type, vals_per_entity, 0, vertex_data, 0, element_data,
                             default_value, err );
    MSQ_ERRZERO( err );
    return reinterpret_cast< TagHandle >( tag );
}

ArrayMesh::Tag * MBMesquite::ArrayMesh::allocate_tag	(	const char *	name,
		bool	owned,
		TagType	type,
		unsigned	size,
		const void *	vertex_ro_data,
		void *	vertex_rw_data,
		const void *	element_ro_data,
		void *	element_rw_data,
		const void *	default_value,
		MsqError &	err
	)		`[private]`

Definition at line 537 of file ArrayMesh.cpp.

References bytes(), MBMesquite::ArrayMesh::Tag::defaultValue, MBMesquite::ArrayMesh::Tag::eleReadPtr, MBMesquite::ArrayMesh::Tag::eleWritePtr, MSQ_SETERR, MBMesquite::ArrayMesh::Tag::name, MBMesquite::ArrayMesh::Tag::next, MBMesquite::ArrayMesh::Tag::owned, MBMesquite::ArrayMesh::Tag::size, MBMesquite::MsqError::TAG_ALREADY_EXISTS, tagList, MBMesquite::ArrayMesh::Tag::type, MBMesquite::ArrayMesh::Tag::vtxReadPtr, and MBMesquite::ArrayMesh::Tag::vtxWritePtr.

Referenced by add_read_only_tag_data(), add_writable_tag_data(), and tag_create().

{
    // check if name is already in use
    for( Tag* iter = tagList; iter; iter = iter->next )
    {
        if( !strcmp( iter->name, name ) )
        {
            MSQ_SETERR( err )( MsqError::TAG_ALREADY_EXISTS );
            return 0;
        }
    }

    // allocate object
    Tag* result = new Tag;

    // initialize members
    result->type  = type;
    result->size  = size * bytes( type );
    result->owned = owned;
    result->name  = new char[strlen( name ) + 1];
    strcpy( result->name, name );

    result->vtxWritePtr = reinterpret_cast< unsigned char* >( vertex_rw_data );
    if( vertex_rw_data )
        result->vtxReadPtr = reinterpret_cast< unsigned char* >( vertex_rw_data );
    else
        result->vtxReadPtr = reinterpret_cast< const unsigned char* >( vertex_ro_data );

    result->eleWritePtr = reinterpret_cast< unsigned char* >( element_rw_data );
    if( element_rw_data )
        result->eleReadPtr = reinterpret_cast< unsigned char* >( element_rw_data );
    else
        result->eleReadPtr = reinterpret_cast< const unsigned char* >( element_ro_data );

    if( default_value )
    {
        result->defaultValue = new unsigned char[result->size];
        memcpy( result->defaultValue, default_value, result->size );
    }
    else
    {
        result->defaultValue = 0;
    }

    // prepend to tag list
    result->next = tagList;
    tagList      = result;

    return result;
}

void MBMesquite::ArrayMesh::build_vertex_adjacency_list ( ) [private]

Definition at line 470 of file ArrayMesh.cpp.

References conn, elem_verts(), elementCount, n, oneBasedArrays, vertexAdjacencyList, vertexAdjacencyOffsets, and vertexCount.

Referenced by vertices_get_attached_elements().

{
    delete[] vertexAdjacencyList;
    delete[] vertexAdjacencyOffsets;
    vertexAdjacencyOffsets = new unsigned long[vertexCount + oneBasedArrays + 1];

    // for each vertex, store the number of elements the previous
    // vertex occurs in.
    memset( vertexAdjacencyOffsets, 0, sizeof( unsigned long ) * ( vertexCount + oneBasedArrays + 1 ) );
    for( size_t i = 0; i < elementCount; ++i )
    {
        int n;
        const unsigned long* conn = elem_verts( i, n );
        for( int j = 0; j < n; ++j )
            ++vertexAdjacencyOffsets[conn[j] + 1];
    }

    // convert vertexAdjacencyOffsets from a shifted list of counts
    // to a list of offsts
    for( size_t i = 1; i <= vertexCount + oneBasedArrays; ++i )
        vertexAdjacencyOffsets[i] += vertexAdjacencyOffsets[i - 1];

    // allocate space and populate with reverse connectivity
    vertexAdjacencyList = new unsigned long[vertexAdjacencyOffsets[vertexCount + oneBasedArrays]];
    for( size_t i = 0; i < elementCount; ++i )
    {
        int n;
        const unsigned long* conn = elem_verts( i, n );
        for( int j = 0; j < n; ++j )
            vertexAdjacencyList[vertexAdjacencyOffsets[conn[j]]++] = i;
    }

    for( size_t i = vertexCount + oneBasedArrays; i > 0; --i )
        vertexAdjacencyOffsets[i] = vertexAdjacencyOffsets[i - 1];
    vertexAdjacencyOffsets[0] = 0;
}

unsigned MBMesquite::ArrayMesh::bytes ( TagType type ) [static, private]

Definition at line 507 of file ArrayMesh.cpp.

References MBMesquite::Mesh::BOOL, MBMesquite::Mesh::BYTE, MBMesquite::Mesh::DOUBLE, MBMesquite::Mesh::HANDLE, and MBMesquite::Mesh::INT.

Referenced by allocate_tag(), and tag_properties().

{
    switch( type )
    {
        case BYTE:
        case BOOL:
            return 1;
        case INT:
            return sizeof( int );
        case DOUBLE:
            return sizeof( double );
        case HANDLE:
            return sizeof( EntityHandle );
    }
    return 0;
}

void MBMesquite::ArrayMesh::clear_mesh ( )

Definition at line 168 of file ArrayMesh.cpp.

References allocConnOffsets, connOffsets, coordArray, MBMesquite::ArrayMesh::Tag::defaultValue, elementCount, elementType, elementTypes, MBMesquite::ArrayMesh::Tag::eleWritePtr, fixedFlags, mDimension, MBMesquite::MIXED, MBMesquite::ArrayMesh::Tag::name, MBMesquite::ArrayMesh::Tag::next, nodesPerElement, oneBasedArrays, MBMesquite::ArrayMesh::Tag::owned, tagList, vertexAdjacencyList, vertexAdjacencyOffsets, vertexByteArray, vertexCount, and MBMesquite::ArrayMesh::Tag::vtxWritePtr.

Referenced by set_mesh(), and ~ArrayMesh().

{
    delete[] vertexByteArray;
    delete[] vertexAdjacencyList;
    delete[] vertexAdjacencyOffsets;
    delete[] allocConnOffsets;
    while( tagList )
    {
        Tag* dead = tagList;
        tagList   = tagList->next;
        delete[] dead->name;
        delete[] dead->defaultValue;
        if( dead->owned )
        {
            delete[] dead->vtxWritePtr;
            delete[] dead->eleWritePtr;
        }
        delete dead;
    }
    mDimension             = 0;
    vertexCount            = 0;
    coordArray             = 0;
    connOffsets            = 0;
    allocConnOffsets       = 0;
    fixedFlags             = 0;
    vertexByteArray        = 0;
    elementCount           = 0;
    elementType            = MIXED;
    elementTypes           = 0;
    nodesPerElement        = 0;
    oneBasedArrays         = false;
    vertexAdjacencyList    = 0;
    vertexAdjacencyOffsets = 0;
}

const unsigned long * MBMesquite::ArrayMesh::elem_verts	(	size_t	elem_index,
		int &	num_vertex
	)		const `[inline, private]`

Definition at line 246 of file ArrayMesh.cpp.

References connArray, connOffsets, elementCount, and nodesPerElement.

Referenced by build_vertex_adjacency_list(), and elements_get_attached_vertices().

{
    assert( e < elementCount );
    if( connOffsets )
    {
        n = connOffsets[e + 1] - connOffsets[e];
        return connArray + connOffsets[e];
    }
    else
    {
        n = nodesPerElement;
        return connArray + nodesPerElement * e;
    }
}

ElementIterator * MBMesquite::ArrayMesh::element_iterator ( MsqError & err ) [virtual]

Definition at line 285 of file ArrayMesh.cpp.

References elementCount.

{
    return new IndexIterator( 0, elementCount );
}

void MBMesquite::ArrayMesh::elements_get_attached_vertices	(	const ElementHandle *	elem_handles,
		size_t	num_elems,
		std::vector< VertexHandle > &	vert_handles,
		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.

void MBMesquite::ArrayMesh::elements_get_topologies	(	const ElementHandle *	element_handle_array,
		EntityTopology *	element_topologies,
		size_t	num_elements,
		MsqError &	err
	)		`[virtual]`

void MBMesquite::ArrayMesh::fill	(	unsigned char *	buffer,
		const unsigned char *	value,
		size_t	size,
		size_t	count
	)		`[static, private]`

void MBMesquite::ArrayMesh::get_all_elements	(	std::vector< ElementHandle > &	elements,
		MsqError &	err
	)		`[virtual]`

void MBMesquite::ArrayMesh::get_all_vertices	(	std::vector< VertexHandle > &	vertices,
		MsqError &	err
	)		`[virtual]`

void MBMesquite::ArrayMesh::release_entity_handles	(	const EntityHandle *	handle_array,
		size_t	num_handles,
		MsqError &	err
	)		`[virtual]`

void MBMesquite::ArrayMesh::set_mesh	(	int	coords_per_vertex,
		unsigned long	num_vertices,
		double *	interleaved_vertex_coords,
		const int *	vertex_fixed_flags,
		unsigned long	num_elements,
		EntityTopology	element_type,
		const unsigned long *	element_connectivity_array,
		bool	one_based_conn_indices = `false`,
		unsigned	nodes_per_element = `0`,
		const int *	vertex_slaved_flags = `0`
	)

TagHandle MBMesquite::ArrayMesh::tag_create	(	const std::string &	tag_name,
		TagType	type,
		unsigned	length,
		const void *	default_value,
		MsqError &	err
	)		`[virtual]`

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

void MBMesquite::ArrayMesh::tag_delete	(	TagHandle	handle,
		MsqError &	err
	)		`[virtual]`

TagHandle MBMesquite::ArrayMesh::tag_get	(	const std::string &	name,
		MsqError &	err
	)		`[virtual]`

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 MBMesquite::ArrayMesh::tag_get_element_data	(	TagHandle	handle,
		size_t	num_elems,
		const ElementHandle *	elem_array,
		void *	tag_data,
		MsqError &	err
	)		`[virtual]`

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 MBMesquite::ArrayMesh::tag_get_vertex_data	(	TagHandle	handle,
		size_t	num_elems,
		const VertexHandle *	node_array,
		void *	tag_data,
		MsqError &	err
	)		`[virtual]`

void MBMesquite::ArrayMesh::tag_properties	(	TagHandle	handle,
		std::string &	name_out,
		TagType &	type_out,
		unsigned &	length_out,
		MsqError &	err
	)		`[virtual]`

void MBMesquite::ArrayMesh::tag_set_element_data	(	TagHandle	handle,
		size_t	num_elems,
		const ElementHandle *	elem_array,
		const void *	tag_data,
		MsqError &	err
	)		`[virtual]`

void MBMesquite::ArrayMesh::tag_set_vertex_data	(	TagHandle	handle,
		size_t	num_elems,
		const VertexHandle *	node_array,
		const void *	tag_data,
		MsqError &	err
	)		`[virtual]`

void MBMesquite::ArrayMesh::vertex_get_byte	(	const VertexHandle	vertex,
		unsigned char *	byte,
		MsqError &	err
	)		`[virtual]`

void MBMesquite::ArrayMesh::vertex_set_byte	(	VertexHandle	vertex,
		unsigned char	byte,
		MsqError &	err
	)		`[virtual]`

void MBMesquite::ArrayMesh::vertex_set_coordinates	(	VertexHandle	vertex,
		const Vector3D &	coordinates,
		MsqError &	err
	)		`[virtual]`

void MBMesquite::ArrayMesh::vertices_get_attached_elements	(	const VertexHandle *	vertex_array,
		size_t	num_vertex,
		std::vector< ElementHandle > &	elements,
		std::vector< size_t > &	offsets,
		MsqError &	err
	)		`[virtual]`

Classes

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

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.

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

void MBMesquite::ArrayMesh::vertices_set_byte	(	const VertexHandle *	vert_array,
		const unsigned char *	byte_array,
		size_t	array_size,
		MsqError &	err
	)		`[virtual]`