MeshTSTTImpl Class Reference

Implementation of MeshTSTT. More...

Inheritance diagram for MeshTSTTImpl:

Collaboration diagram for MeshTSTTImpl:

Public Member Functions
	MeshTSTTImpl (TSTTM::Mesh &tstt_mesh, MsqError &err)
virtual	~MeshTSTTImpl ()
virtual void	set_active_set (void *element_set, MsqError &)
	set mesh to be smoothed. More...
virtual int	get_geometric_dimension (Mesquite::MsqError &)
	Get dimension of vertex coordinates (2D vs. 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)
	Create iterator for vertices in active set. More...
virtual ElementIterator *	element_iterator (MsqError &err)
	Create iterator for elements in active set. More...
virtual bool	vertex_is_fixed (VertexHandle vertex, MsqError &err)
	Query "fixed" flag for a vertex. More...
virtual void	vertices_are_on_boundary (VertexHandle vert_array[], bool on_bnd[], size_t num_vtx, MsqError &err)
	Query "boundary" flag for an array of vertices. More...
virtual void	vertices_get_coordinates (const VertexHandle vert_array[], MsqVertex *coordinates, size_t num_vtx, MsqError &err)
	Get vertex coordinates. More...
virtual void	vertex_set_coordinates (VertexHandle vertex, const Vector3D &coordinates, MsqError &err)
	Set vertex coordinates. More...
virtual void	vertex_set_byte (VertexHandle vertex, unsigned char byte, MsqError &err)
	Set vertex mark. More...
virtual void	vertices_set_byte (VertexHandle *vert_array, unsigned char *byte_array, size_t array_size, MsqError &err)
	Set vertex mark. More...
virtual void	vertex_get_byte (VertexHandle vertex, unsigned char *byte, MsqError &err)
	Get vertex mark. More...
virtual void	vertices_get_byte (VertexHandle *vert_array, unsigned char *byte_array, size_t array_size, MsqError &err)
	Get vertex mark. More...
virtual size_t	vertex_get_attached_element_count (VertexHandle vertex, MsqError &err)
	Get vertex adjacencies. More...
virtual void	vertex_get_attached_elements (VertexHandle vertex, ElementHandle *elem_array, size_t sizeof_elem_array, MsqError &err)
	Get vertex adjacencies. More...
virtual size_t	element_get_attached_vertex_count (ElementHandle elem, MsqError &err)
	Get length of connectivity list More...
virtual size_t	get_vertex_use_count (ElementHandle *array, size_t length, 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)
	Get element connectivity in overly-complex CSR rep. More...
virtual EntityTopology	element_get_topology (ElementHandle entity_handle, MsqError &err)
	Return topology type enum for specified element. More...
virtual void	elements_get_topologies (ElementHandle *element_handle_array, EntityTopology *element_topologies, size_t num_elements, MsqError &err)
	Return topology type enum for an array of elements. More...
virtual void	release_entity_handles (EntityHandle *handle_array, size_t num_handles, MsqError &err)
	no-op More...
virtual void	release ()
	Instead of deleting a Mesh when you think you are done, call release(). 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...
Public Member Functions inherited from MeshTSTT
virtual	~MeshTSTT ()
virtual	~MeshTSTT ()

Protected Member Functions
void	set_int_tag (void *tag, void *meshset, int value, MsqError &err)
void	popupate_input_elements () throw ( TSTTB::Error )
	Populate inputElements from elemetnSet. More...
Protected Member Functions inherited from Mesh
virtual	~Mesh ()
	Don't allow a Mesh to be deleted directly. More...

Private Member Functions
void	tag_set_data (TagHandle handle, size_t num_elems, const EntityHandle *handle_array, const void *tag_data, MsqError &err)
	Set tag values. More...
void	tag_get_data (TagHandle handle, size_t num_elems, const EntityHandle *handle_array, void *tag_data, MsqError &err)
	Get tag values. More...
void	cache_adjacent_elements (void *vertex_handle, MsqError &err)
	Get elements adjacent to vertex and store in vertexAdjElements. More...

Private Attributes
TSTTM::Mesh	meshIFace
	TSTT basic mesh interface instance. More...
TSTTM::Entity	entIFace
	TSTT interface for per-entity queries. More...
TSTTB::EntTag	tagIFace
TSTTM::Arr	arrIFace
	TSTT interface for multi-entity (array) queries. More...
TSTTB::ArrTag	arrTagIFace
TSTTM::Modify	modIFace
	TSTT interface for modifying mesh. More...
TSTTB::EntSet	setIFace
	TSTT interface for entity set operations. More...
bool	haveMesh
	Have mesh. More...
void *	elementSet
	TSTTM entity set handle for elements to improve. More...
void *	nodeSet
	TSTTM entity set handle for nodes to move. More...
msq_std::set< void * >	inputElements
	std::set containing elements in elementSet, used to constrain vertex->element adjaceny queries to only those elements that are in the input element set. More...
TSTTM::EntityType	inputSetType
	The type of elements contained in the input element set. More...
TagHandle	byteTag
	Handle for tag used to hold vertex byte. More...
bool	createdByteTag
	Tag was created in constructor. More...
TagHandle	fixedTag
	Handle for tag used to hold vertex-fixed flag. More...
bool	createdFixedTag
	Fixed tag was created in constructor. More...
EntityTopology	topologyMap [TSTTM::EntityTopology_ALL_TOPOLOGIES+1]
	Handle for the tag used internally to remove duplicates from lists. More...
sidl::array< void * >	vertexAdjElements
	Cached result for vertex->element query. More...
int	vertexAdjElementSize
	Number of valid entries vertexAdjElements. More...
void *	cachedAdjVertex
	Vertex for which vertexAdjElements is cached. More...

Additional Inherited Members
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
Static Public Member Functions inherited from MeshTSTT
static MeshTSTT *	create (TSTTM::Mesh &mesh, void *meshset, MsqError &err)
	factory method More...
static MeshTSTT *	create (TSTTM::Mesh &mesh, MsqError &err)
	factory method More...
static MeshTSTT *	create (TSTTM::Mesh &mesh, void *meshset, MsqError &err)
	factory method More...
static MeshTSTT *	create (TSTTM::Mesh &mesh, MsqError &err)
	factory method More...

Detailed Description

Implementation of MeshTSTT.

Definition at line 307 of file MeshTSTT.cpp.

Constructor & Destructor Documentation

MeshTSTTImpl	(	TSTTM::Mesh &	tstt_mesh,
		Mesquite::MsqError &	err
	)

Definition at line 714 of file MeshTSTT.cpp.

References MeshTSTTImpl::arrIFace, MeshTSTTImpl::arrTagIFace, MeshTSTTImpl::byteTag, MeshTSTTImpl::createdByteTag, MeshTSTTImpl::createdFixedTag, MeshTSTTImpl::entIFace, MeshTSTTImpl::fixedTag, Mesquite::HEXAHEDRON, i, MsqError::INTERNAL_ERROR, MsqError::INVALID_STATE, Mesquite::MIXED, MeshTSTTImpl::modIFace, MSQ_SETERR, MeshTSTTImpl::nodeSet, Mesquite::PRISM, Mesquite::process_tstt_error(), Mesquite::PYRAMID, Mesquite::QUADRILATERAL, MeshTSTTImpl::set_int_tag(), MeshTSTTImpl::setIFace, MeshTSTTImpl::tagIFace, Mesquite::TETRAHEDRON, MeshTSTTImpl::topologyMap, Mesquite::TRIANGLE, Mesquite::VERTEX_BYTE_TAG_NAME, and Mesquite::VERTEX_FIXED_TAG_NAME.

  : meshIFace(tstt_mesh), 
    elementSet(0), nodeSet(0), 
    inputSetType( TSTTM::EntityType_ALL_TYPES ),
    byteTag(0), createdByteTag(false),
    fixedTag(0), createdFixedTag(false),
    vertexAdjElementSize(0), cachedAdjVertex(0)
//    ,vertexIndexTag(0), createdVertexIndexTag(false)
{
    // Initialize topology map 
  
  const size_t mapsize = sizeof(topologyMap) / sizeof(Mesquite::EntityTopology);
  if (mapsize < TSTTM::EntityTopology_ALL_TOPOLOGIES)
  {
    MSQ_SETERR(err)("MeshTSTT needs to be updated for new TSTT element topologies.",
                    MsqError::INTERNAL_ERROR);
    return;
  }
  
  for (size_t i = 0; i <= TSTTM::EntityTopology_ALL_TOPOLOGIES; ++i)
    topologyMap[i] = Mesquite::MIXED;
  
  topologyMap[TSTTM::EntityTopology_TRIANGLE     ] = Mesquite::TRIANGLE;
  topologyMap[TSTTM::EntityTopology_QUADRILATERAL] = Mesquite::QUADRILATERAL;
  topologyMap[TSTTM::EntityTopology_TETRAHEDRON  ] = Mesquite::TETRAHEDRON;
  topologyMap[TSTTM::EntityTopology_HEXAHEDRON   ] = Mesquite::HEXAHEDRON;
  topologyMap[TSTTM::EntityTopology_PRISM        ] = Mesquite::PRISM;
  topologyMap[TSTTM::EntityTopology_PYRAMID      ] = Mesquite::PYRAMID;
  
  try {
      // Attempt to cast to single-entity query interface
    entIFace  = tstt_mesh;
    if (!entIFace)
    {
      MSQ_SETERR(err)( "TSTTM::Mesh does not implement TSTTM::EntTag",
                       MsqError::INVALID_STATE );
      return;
    } 
      // Attempt cast to multi-entity query interface
    arrIFace  = tstt_mesh;
    if (!arrIFace)
    {
      MSQ_SETERR(err)( "TSTTM::Mesh does not implement TSTTM::ArrTag",
                       MsqError::INVALID_STATE );
      return;
    }
      // Attempt cast to modify interface
    modIFace  = tstt_mesh;
    if (!arrIFace)
    {
      MSQ_SETERR(err)( "TSTTM::Mesh does not implement TSTTM::Modify",
                       MsqError::INVALID_STATE );
      return;
    }
      // Attempt cast to entity set interface
    setIFace  = tstt_mesh;
    if (!arrIFace)
    {
      MSQ_SETERR(err)( "TSTTM::Mesh does not implement TSTTM::EntSet",
                       MsqError::INVALID_STATE );
      return;
    }
      // Get tag interface
    tagIFace = tstt_mesh;
    if (!tagIFace)
    {
      MSQ_SETERR(err)( "TSTTM::Mesh does not implement TSTTB::EntTag",
                       MsqError::INVALID_STATE );
      return;
    }
      // Get tag interface
    arrTagIFace = tstt_mesh;
    if (!arrTagIFace)
    {
      MSQ_SETERR(err)( "TSTTM::Mesh does not implement TSTTB::ArrTag",
                       MsqError::INVALID_STATE );
      return;
    }
    
      // Get tag for fixed flag
    try {
      fixedTag = tagIFace.getTagHandle( VERTEX_FIXED_TAG_NAME );

        // Double-check types incase tag already existed
      if (tagIFace.getTagSize(fixedTag) != sizeof(int) || 
          tagIFace.getTagType(fixedTag) != TSTTB::TagValueType_INTEGER)
      {
        MSQ_SETERR(err)( MsqError::INVALID_STATE, 
                         "Tag \"%s\" exists with invalid type/size", 
                         VERTEX_FIXED_TAG_NAME );
        return;
      }
    } catch (...) { 
      fixedTag = 0;
    }
    
      // Get/create tag for vertex byte
    try {
      byteTag = tagIFace.getTagHandle( VERTEX_BYTE_TAG_NAME );
    } catch (...) {}

    if (!byteTag) {
      tagIFace.createTag( VERTEX_BYTE_TAG_NAME, sizeof(int), TSTTB::TagValueType_INTEGER, byteTag );
      createdByteTag = true;
    } 
      // Double-check types incase tag already existed
    if (tagIFace.getTagSize(byteTag) != sizeof(int) || 
        tagIFace.getTagType(byteTag) != TSTTB::TagValueType_INTEGER)
    {
      MSQ_SETERR(err)( MsqError::INVALID_STATE, 
                       "Tag \"%s\" exists with invalid type/size", 
                       VERTEX_BYTE_TAG_NAME );
      return;
    }
    
      // Clear vertex byte tag
    set_int_tag( byteTag, nodeSet, 0, err );
    if (err)
      return;
    
      // Get/create tag for vertex index
/*
    //try {
    //  vertexIndexTag = tagIFace.getTagHandle( VERTEX_INDEX_TAG_NAME );
    //} catch (...) {}

    if (!vertexIndexTag) {
      tagIFace.createTag( VERTEX_INDEX_TAG_NAME, sizeof(int), TSTTB::TagValueType_INTEGER, byteTag );
      createdVertexIndexTag = true;
    } 
      // Double-check types incase tag already existed
    if (tagIFace.getTagSize(vertexIndexTag) != sizeof(int) || 
        tagIFace.getTagType(vertexIndexTag) != TSTTB::TagValueType_INTEGER)
    {
      MSQ_SETERR(err)( MsqError::INVALID_STATE, 
                       "Tag \"%s\" exists with invalid type/size", 
                       VERTEX_INDEX_TAG_NAME );
      return;
    }
*/
  }
  catch (TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
    try {
      if (createdFixedTag)
        tagIFace.destroyTag( fixedTag, false );
      if (createdByteTag)
        tagIFace.destroyTag( byteTag, false );
//      if (createdVertexIndexTag)
//        tagIFace.destroyTag( vertexIndexTag, false );
    } 
    catch (...) {}
  }
  catch(...) {
    MSQ_SETERR(err)("Uknown exception",MsqError::INTERNAL_ERROR);
  }
}

Here is the call graph for this function:

~MeshTSTTImpl ( )

virtual

Definition at line 872 of file MeshTSTT.cpp.

References Mesquite::process_tstt_error().

{
  try {
    if (elementSet) 
      setIFace.destroyEntSet( elementSet );
    if (nodeSet)
      setIFace.destroyEntSet( nodeSet );
      
    if (createdFixedTag)
      tagIFace.destroyTag( fixedTag, false );
    if (createdByteTag)
      tagIFace.destroyTag( byteTag, false );
//    if (createdVertexIndexTag)
//      tagIFace.destroyTag( vertexIndexTag, false );
  } 
  catch (TSTTB::Error& tstt_err ) {
    process_tstt_error(tstt_err);
    throw;
  }
}

Here is the call graph for this function:

Member Function Documentation

void cache_adjacent_elements ( void *  vertex_handle, MsqError &  err  )

private

Get elements adjacent to vertex and store in vertexAdjElements.

Definition at line 1362 of file MeshTSTT.cpp.

References MeshTSTTImpl::cachedAdjVertex, Mesquite::convert_from_sidl_vector(), MeshTSTTImpl::entIFace, MeshTSTTImpl::inputElements, MeshTSTTImpl::inputSetType, MsqError::INTERNAL_ERROR, MSQ_SETERR, MeshTSTTImpl::popupate_input_elements(), Mesquite::process_tstt_error(), MeshTSTTImpl::vertexAdjElements, and MeshTSTTImpl::vertexAdjElementSize.

Referenced by MeshTSTTImpl::vertex_get_attached_element_count(), and MeshTSTTImpl::vertex_get_attached_elements().

{
    // If already have data cached for this vertex, just return
  if (vtx == cachedAdjVertex)
    return;
  
    // make sure to clear this so that if we fail in the middle,
    // we don't end up with invlaid cache data for the prev vertex.
  cachedAdjVertex = 0;
  vertexAdjElementSize = 0;
  
  try {
      // First try using current array size
    bool success;
    try {
      entIFace.getEntAdj( vtx, inputSetType, vertexAdjElements, vertexAdjElementSize );
      success = true;
    } 
    catch( ... ) {
      success = false;
    }
  
    // If failed, try again and let implementation allocate storage
    if (!success) {
      vertexAdjElements = sidl::array<void*>();
      entIFace.getEntAdj( vtx, inputSetType, vertexAdjElements, vertexAdjElementSize );
    }
    
      // Store which vertex we have cached adj data for
    cachedAdjVertex = vtx;

      // We need to use inputElements.  Fill it if it hasn't
      // been filled yet.
    if (inputElements.empty())
      popupate_input_elements();
  }
  catch(::TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
    return;
  }
  
    // Remove from list any elements not in the input set
  void** write_ptr = convert_from_sidl_vector( vertexAdjElements );
  void** const end_ptr = write_ptr + vertexAdjElementSize;
  for (void** read_ptr = write_ptr; read_ptr != end_ptr; ++read_ptr)
  {
    if (inputElements.find( *read_ptr ) != inputElements.end())
    {
      *write_ptr = *read_ptr;
      ++write_ptr;
    }
  }
  
  vertexAdjElementSize = write_ptr - convert_from_sidl_vector( vertexAdjElements );
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t element_get_attached_vertex_count ( ElementHandle  elem, MsqError &  err  )

virtual

Get length of connectivity list

Implements Mesh.

Definition at line 1453 of file MeshTSTT.cpp.

References MeshTSTTImpl::entIFace, MsqError::INTERNAL_ERROR, MSQ_SETERR, and Mesquite::process_tstt_error().

{
  try {
    sidl::array<void*> junk;
    int result = 0;
    entIFace.getEntAdj( elem, TSTTM::EntityType_VERTEX, junk, result );
    return result;
  }
  catch(::TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
    return 0;
  }
}

Here is the call graph for this function:

EntityTopology element_get_topology ( ElementHandle  entity_handle, MsqError &  err  )

virtual

Return topology type enum for specified element.

Implements Mesh.

Definition at line 1668 of file MeshTSTT.cpp.

References MeshTSTTImpl::entIFace, MsqError::INTERNAL_ERROR, Mesquite::MIXED, MSQ_SETERR, Mesquite::process_tstt_error(), and MeshTSTTImpl::topologyMap.

{
  try {
    TSTTM::EntityTopology topo = entIFace.getEntTopo( element );
    return topologyMap[topo];
  }
  catch(::TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
    return MIXED;
  }
}

Here is the call graph for this function:

ElementIterator * element_iterator ( MsqError &  err )

virtual

Create iterator for elements in active set.

Implements Mesh.

Definition at line 1108 of file MeshTSTT.cpp.

References MeshTSTTImpl::arrIFace, MeshTSTTImpl::elementSet, MsqError::INTERNAL_ERROR, MSQ_SETERR, and Mesquite::process_tstt_error().

{
  try {
    return new TSTTArrIter( arrIFace, 
                            elementSet, 
                            TSTTM::EntityType_ALL_TYPES, 
                            TSTTM::EntityTopology_ALL_TOPOLOGIES );
  }
  catch (TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
    return 0;
  }
}

Here is the call graph for this function:

void elements_get_attached_vertices ( ElementHandle *  elements, size_t  num_elems, VertexHandle *  vertices, size_t &  vert_len, size_t *  indices, size_t &  indices_len, size_t *  offsets, Mesquite::MsqError &  err  )

virtual

Get element connectivity in overly-complex CSR rep.

Get connectivity.

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: a) "elem_handles" points at an array of "num_elems" element handles. b) "vert_handles" points at an array of size "sizeof_vert_handles" c) "csr_data" points at an array of size "sizeof_csr_data" d) "csr_offsets" points at an array of size "num_elems+1"

When this function returns, adjacency information will be stored in csr format: a) "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. b) "sizeof_vert_handles" is set to the number of vertex handles placed into "vert_handles". c) "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). c) "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". d) "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 ] ]

Parameters

elements	- Array of length num_elems containing elements handles of elements for which connectivity is to be queried.
vertices	- Array of vertex handles in connectivity list.
offsets	- Indices into indices array, one per element.
indices	- Indices into vertex_handles

Implements Mesh.

Definition at line 1495 of file MeshTSTT.cpp.

References MeshTSTTImpl::arrIFace, Mesquite::convert_to_sidl_vector(), Mesquite::copy_from_sidl(), MsqError::INTERNAL_ERROR, MSQ_SETERR, and Mesquite::process_tstt_error().

Referenced by MeshTSTTImpl::get_all_mesh().

{
  if (num_elems == 0)
    return;

  try {
      // Constuct arguments to TSTT
    int vert_count, off_count;
    sidl::array<void*> elem_arr( convert_to_sidl_vector( elements, num_elems ) );
    sidl::array<void*> vert_arr( convert_to_sidl_vector( (void**)indices, indices_len ) );
    sidl::array<int> off_arr;
    if (sizeof(size_t) == sizeof(int))
      off_arr = convert_to_sidl_vector( (int*)offsets, num_elems + 1 );
    else
      off_arr = alloc_sidl_vector<int>( num_elems + 1 );
    
      // Query TSTT for element connectivity
    arrIFace.getEntArrAdj( elem_arr, num_elems,
                           TSTTM::EntityType_VERTEX,
                           vert_arr, vert_count,
                           off_arr,  off_count );
  
    indices_len = vert_count;
      // If couldn't do array borrow, copy offsets into output array
    if (sizeof(size_t) != sizeof(int))
      copy_from_sidl( off_arr, offsets );
      
      // Mesquite expects index array length as last value in offset array.
      // If TSTT mesh doesn't return it, then add it.
    if ((unsigned)off_count == num_elems)
      offsets[num_elems] = vert_count;
    else
      assert( (unsigned)off_count == num_elems+1 );
  }
  catch(::TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
    return;
  }
    
    // Construct unique list of vertex handles
  vert_len = 0;
  msq_std::map<VertexHandle,size_t> index_map;
  const size_t* end = indices + indices_len;
  /*
  for (size_t* iter = indices; iter != end; ++iter)
  {
    VertexHandle vertex = *(VertexHandle*)iter;
    msq_std::map<VertexHandle,size_t>::iterator pos = index_map.find( vertex );
    size_t index;
    if (pos == index_map.end())
      index_map[vertex] = index = vert_len++;
    else
      index = pos->second;
    
    vertices[index] = vertex;
    *iter = index;
  }
  */
    // Rather than the above simple code, do the following more complicated 
    // code so the resulting list of vertices are sorted (easier to debug)
  for (size_t* iter = indices; iter != end; ++iter)
  {
    VertexHandle vertex = *(VertexHandle*)iter;
    msq_std::map<VertexHandle,size_t>::iterator pos = index_map.find( vertex );
    if (pos == index_map.end())
      index_map[vertex] = 0;
  }
  for (msq_std::map<VertexHandle,size_t>::iterator m_iter = index_map.begin();
       m_iter != index_map.end(); ++m_iter)
  {
    vertices[vert_len] = m_iter->first;
    m_iter->second = vert_len++;
  }
  for (size_t* iter = indices; iter != end; ++iter)
  {
    VertexHandle vertex = *(VertexHandle*)iter;
    msq_std::map<VertexHandle,size_t>::iterator pos = index_map.find( vertex );
    *iter = pos->second;
  }      
  
  
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

virtual

Return topology type enum for an array of elements.

Implements Mesh.

Definition at line 1683 of file MeshTSTT.cpp.

References MeshTSTTImpl::arrIFace, Mesquite::convert_to_sidl_vector(), i, MsqError::INTERNAL_ERROR, MSQ_SETERR, Mesquite::process_tstt_error(), and MeshTSTTImpl::topologyMap.

{
  try {
    
    sidl::array<TSTTM::EntityTopology> topologies( alloc_sidl_vector<TSTTM::EntityTopology>( num_elements ) );
    sidl::array<void*> handles( convert_to_sidl_vector( element_handle_array, num_elements ) );
    int topo_len_out;
    arrIFace.getEntArrTopo( handles, num_elements, topologies, topo_len_out );
    if ((size_t)topo_len_out != num_elements) {
      MSQ_SETERR(err)(MsqError::INTERNAL_ERROR);
      return;
    }
    
    for (unsigned i = 0; i < num_elements; ++i)
      element_topologies[i] = topologyMap[topologies.get(i)];
  }
  catch(::TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
  }
}

Here is the call graph for this function:

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.

Implements Mesh.

Definition at line 1629 of file MeshTSTT.cpp.

References Mesquite::convert_to_sidl_vector(), MeshTSTTImpl::elements_get_attached_vertices(), MeshTSTTImpl::elementSet, MsqError::INTERNAL_ERROR, MeshTSTTImpl::meshIFace, MSQ_SETERR, MsqError::OUT_OF_MEMORY, and Mesquite::process_tstt_error().

{
  int num_elem;
  try {
    sidl::array<void*> elements( convert_to_sidl_vector( elem_array, elem_len ) );
    meshIFace.getEntities( elementSet, 
                           TSTTM::EntityType_ALL_TYPES,
                           TSTTM::EntityTopology_ALL_TOPOLOGIES,
                           elements,
                           num_elem );
    if ((unsigned)num_elem > elem_len)
    {
      MSQ_SETERR(err)("Insufficient space in array", MsqError::OUT_OF_MEMORY);
      return;
    }
  }
  catch(::TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
    return;
  }
  
  if (offset_len <= (unsigned)num_elem)
  {
    MSQ_SETERR(err)("Insufficient space in array", MsqError::OUT_OF_MEMORY);
    return;
  }
  
  elements_get_attached_vertices( elem_array, num_elem,
                                  vert_array, vert_len,
                                  conn_array, conn_len,
                                  offset_array, err );
}

Here is the call graph for this function:

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

virtual

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.)

Implements Mesh.

Definition at line 1586 of file MeshTSTT.cpp.

References MeshTSTTImpl::elementSet, MsqError::INTERNAL_ERROR, MeshTSTTImpl::meshIFace, MSQ_SETERR, MeshTSTTImpl::nodeSet, and Mesquite::process_tstt_error().

{
  try {
    
      // Get number of vertices
    vertex_count   = meshIFace.getNumOfType( nodeSet,    TSTTM::EntityType_VERTEX );
    
      // Get number of elements
    element_count  = meshIFace.getNumOfType( elementSet, TSTTM::EntityType_FACE );
    element_count += meshIFace.getNumOfType( elementSet, TSTTM::EntityType_REGION );
    
      // Get number of vertex uses
    sidl::array<void*> handles1, handles2;
    sidl::array<int> offsets1, offsets2;
    sidl::array<int> flags1, flags2;
    int num_handles, num_offsets, num_flags;
      // Face elements
    meshIFace.getAdjEntities( elementSet, 
                              TSTTM::EntityType_FACE,
                              TSTTM::EntityTopology_ALL_TOPOLOGIES,
                              TSTTM::EntityType_VERTEX,
                              handles1, num_handles,
                              offsets1, num_offsets,
                              flags1  , num_flags );
    vertex_use_count = num_handles;
      // Region elements
    meshIFace.getAdjEntities( elementSet, 
                              TSTTM::EntityType_REGION,
                              TSTTM::EntityTopology_ALL_TOPOLOGIES,
                              TSTTM::EntityType_VERTEX,
                              handles2, num_handles,
                              offsets2, num_offsets,
                              flags2  , num_flags );
    vertex_use_count += num_handles;
  }
  catch(::TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
  }
}

Here is the call graph for this function:

int get_geometric_dimension ( Mesquite::MsqError &  err )

virtual

Get dimension of vertex coordinates (2D vs.

3D).

Implements Mesh.

Definition at line 1072 of file MeshTSTT.cpp.

References MsqError::INTERNAL_ERROR, MeshTSTTImpl::meshIFace, MSQ_SETERR, and Mesquite::process_tstt_error().

{
  try {
    return meshIFace.getGeometricDim();
  }
  catch (TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
    return 0;
  }
}

Here is the call graph for this function:

size_t get_vertex_use_count ( ElementHandle *  array, size_t  length, MsqError &  err  )

virtual

Implements Mesh.

Definition at line 1469 of file MeshTSTT.cpp.

References MeshTSTTImpl::arrIFace, Mesquite::convert_to_sidl_vector(), MsqError::INTERNAL_ERROR, MSQ_SETERR, and Mesquite::process_tstt_error().

{
  try {
    sidl::array<void*> handles( convert_to_sidl_vector( array, length ) ); 
    sidl::array<void*> adj;
    sidl::array<int> offsets;
    int32_t adj_size, off_size;
    arrIFace.getEntArrAdj( handles, length, TSTTM::EntityType_VERTEX, adj, adj_size, offsets, off_size );
    return adj_size;
  }
  catch(::TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
    return 0;
  }
}

Here is the call graph for this function:

void popupate_input_elements ( ) throw ( TSTTB::Error )

protected

Populate inputElements from elemetnSet.

Definition at line 1037 of file MeshTSTT.cpp.

References MeshTSTTImpl::arrIFace, Mesquite::convert_to_sidl_vector(), MeshTSTTImpl::elementSet, MeshTSTTImpl::inputElements, and MeshTSTTImpl::setIFace.

Referenced by MeshTSTTImpl::cache_adjacent_elements().

{
  const int ELEM_BUFFER_SIZE = 1024;
  void* handle_array[ELEM_BUFFER_SIZE];
  sidl::array<void*> handles = convert_to_sidl_vector( handle_array, ELEM_BUFFER_SIZE );
  void* iter;
 
  inputElements.clear();
 
  arrIFace.initEntArrIter( elementSet, 
                           TSTTM::EntityType_ALL_TYPES, 
                           TSTTM::EntityTopology_ALL_TOPOLOGIES,
                           ELEM_BUFFER_SIZE, 
                           iter );
      
  int count = 0;
  bool more = false;
  do {
      // Add elements to element set
    more = arrIFace.getEntArrNextIter( iter, handles, count );
    if (!count) break;
    setIFace.addEntArrToSet( handles, count, elementSet );

    void** const end_ptr = handle_array + count;
    for (void** ptr = handle_array; ptr != end_ptr; ++ptr)
      inputElements.insert( *ptr );

  } while (more);

  arrIFace.endEntArrIter( iter );
} 

Here is the call graph for this function:

Here is the caller graph for this function:

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.

Definition at line 1722 of file MeshTSTT.cpp.

{
}

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

virtual

no-op

Implements Mesh.

Definition at line 1710 of file MeshTSTT.cpp.

{
    // Do nothing
}

void set_active_set ( void *  element_set, MsqError &  err  )

virtual

set mesh to be smoothed.

Set the mesh which Mesquite is to smooth. Optionally specify fixed vertices. NOTE: If an active set is not specified, the default is to use the global set (the ENTIRE mesh.)

Parameters

element_set

TSTT entity set handle for set containing mesh elements and vertices for which quality is to be improved.

Implements MeshTSTT.

Definition at line 931 of file MeshTSTT.cpp.

References MeshTSTTImpl::arrIFace, MeshTSTTImpl::cachedAdjVertex, MeshTSTTImpl::elementSet, i, MeshTSTTImpl::inputElements, MeshTSTTImpl::inputSetType, MsqError::INTERNAL_ERROR, MSQ_SETERR, MeshTSTTImpl::nodeSet, num_nodes, Mesquite::process_tstt_error(), MeshTSTTImpl::setIFace, and MeshTSTTImpl::vertexAdjElementSize.

{
  const int ELEM_BUFFER_SIZE = 1024;
  const int NODE_BUFFER_SIZE = 27 * ELEM_BUFFER_SIZE; 
  sidl::array<void*> elements( alloc_sidl_vector<void*>( ELEM_BUFFER_SIZE ) );
  sidl::array<void*>    nodes( alloc_sidl_vector<void*>( NODE_BUFFER_SIZE ) );
  sidl::array<int>    offsets( alloc_sidl_vector<int  >( ELEM_BUFFER_SIZE ) );
  void* iter = 0;
 
  try {
    
      // Create new sets for nodes and elements
    if (elementSet)
    {
      setIFace.destroyEntSet( elementSet );
      elementSet = 0;
    }
    if (nodeSet)
    {
      setIFace.destroyEntSet( nodeSet );
      nodeSet = 0;
    }
    setIFace.createEntSet( false, elementSet );
    setIFace.createEntSet( false, nodeSet );
    
      // Iterate over set twice, once for FACEs and once for REGIONs
    bool have_faces = false, have_regions = false;
    for (int i = 0; i < 2; ++i)
    {
      TSTTM::EntityType type = i ? TSTTM::EntityType_REGION : 
                                   TSTTM::EntityType_FACE;
      bool& have_some = i ? have_regions : have_faces;
                                   
      arrIFace.initEntArrIter( elem_set, 
                               type, 
                               TSTTM::EntityTopology_ALL_TOPOLOGIES,
                               ELEM_BUFFER_SIZE, 
                               iter );
      
      int count = 0;
      bool more = false;
      do {
          // Add elements to element set
        more = arrIFace.getEntArrNextIter( iter, elements, count );
        if (!count) break;
        setIFace.addEntArrToSet( elements, count, elementSet );
        
          // Add nodes to node set
        int num_nodes, num_offsets;
        arrIFace.getEntArrAdj( elements, count, TSTTM::EntityType_VERTEX,
                               nodes, num_nodes, offsets, num_offsets );
        setIFace.addEntArrToSet( nodes, num_nodes, nodeSet );
        
        have_some = true;
      } while (more);
        
      arrIFace.endEntArrIter( iter );
      iter = 0;
      
    } // for (type)
    
    if (!have_faces)
      inputSetType = TSTTM::EntityType_REGION;
    else if (!have_regions)
      inputSetType = TSTTM::EntityType_FACE;
    else
      inputSetType = TSTTM::EntityType_ALL_TYPES;
    
    //set_fixed_tag( nodeSet, false, err ); MSQ_ERRRTN(err);
  }
  catch (TSTTB::Error &tstt_err) {
      // If an error occured, try to clean up anything created above

    try {
      if (iter) {
        arrIFace.endEntArrIter( iter );
        iter = 0;
      }
    }
    catch( ... ) {}
    
    try {
      if (elementSet) {
        setIFace.destroyEntSet( elementSet );
        elementSet = 0;
      }
    }
    catch( ... ) {}
    
    try {
      if (nodeSet) {
        setIFace.destroyEntSet( nodeSet );
        nodeSet = 0;
      }
    }
    catch( ... ) {}
    
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
  }
  
    // clear cached data
  inputElements.clear();
  vertexAdjElementSize = 0;
  cachedAdjVertex = 0;
}

Here is the call graph for this function:

void set_int_tag ( void *  tag, void *  meshset, int  value, MsqError &  err  )

protected

Definition at line 894 of file MeshTSTT.cpp.

References MeshTSTTImpl::arrIFace, MeshTSTTImpl::arrTagIFace, MsqError::INTERNAL_ERROR, MSQ_SETERR, and Mesquite::process_tstt_error().

Referenced by MeshTSTTImpl::MeshTSTTImpl().

{
  const unsigned BUFFER_COUNT = 1024;
  
  sidl::array<int> value_array( alloc_sidl_vector<int>( BUFFER_COUNT, value ) );
  
  sidl::array<void*> handle_array( alloc_sidl_vector<void*>( BUFFER_COUNT ) );
  int count = BUFFER_COUNT;
  void* iter = 0;
  bool more;
  
  try {
    
    arrIFace.initEntArrIter( elem_set, 
                             TSTTM::EntityType_VERTEX, 
                             TSTTM::EntityTopology_POINT, 
                             BUFFER_COUNT, iter );
                             
    do {
      more = arrIFace.getEntArrNextIter( iter, handle_array, count );
      if (count > 0)
        arrTagIFace.setIntArrData( handle_array, count, tag, value_array, count );
    } while (more);
    
    arrIFace.endEntArrIter( iter );
  }
  
  catch (TSTTB::Error &tstt_err) {
    if( iter ) try {  arrIFace.endEntArrIter( iter ); } catch (...) {}
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Implements Mesh.

Definition at line 1727 of file MeshTSTT.cpp.

References Mesh::BYTE, Mesh::DOUBLE, Mesh::HANDLE, Mesh::INT, MsqError::INTERNAL_ERROR, MsqError::INVALID_ARG, Mesquite::length(), MSQ_SETERR, Mesquite::process_tstt_error(), and MeshTSTTImpl::tagIFace.

{
  TSTTB::TagValueType tstt_type;
  size_t size = 0;
  switch (type) {
    case Mesquite::Mesh::BYTE:   size = sizeof(char  ); tstt_type = TSTTB::TagValueType_OPAQUE;        break;
    case Mesquite::Mesh::INT:    size = sizeof(int   ); tstt_type = TSTTB::TagValueType_INTEGER;       break;
    case Mesquite::Mesh::DOUBLE: size = sizeof(double); tstt_type = TSTTB::TagValueType_DOUBLE;        break;
    case Mesquite::Mesh::HANDLE: size = sizeof(void* ); tstt_type = TSTTB::TagValueType_ENTITY_HANDLE; break;
    default:
      MSQ_SETERR(err)("Invalid tag type", MsqError::INVALID_ARG );
      return 0;
  }
  size *= length;
  
  try {
    void* handle = 0;
    tagIFace.createTag( name, size, tstt_type, handle );
    return handle;
  } 
  catch(::TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
    return 0;
  }
}

Here is the call graph for this function:

void tag_delete ( TagHandle  handle, MsqError &  err  )

virtual

Remove a tag and all corresponding data.

Delete a tag.

Implements Mesh.

Definition at line 1756 of file MeshTSTT.cpp.

References MsqError::INTERNAL_ERROR, MSQ_SETERR, Mesquite::process_tstt_error(), and MeshTSTTImpl::tagIFace.

{
  try {
    tagIFace.destroyTag( handle, true );
  } 
  catch(::TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
  }
}

Here is the call graph for this function:

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

virtual

Get handle for existing tag, by name.

Implements Mesh.

Definition at line 1766 of file MeshTSTT.cpp.

References MsqError::INTERNAL_ERROR, MSQ_SETERR, Mesquite::process_tstt_error(), and MeshTSTTImpl::tagIFace.

{
  try {
    return tagIFace.getTagHandle( name );
  } 
  catch(::TSTTB::Error &tstt_err) {
    if (tstt_err.getErrorType() != TSTTB::ErrorType_TAG_NOT_FOUND) {
      MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
    }
    return 0;
  }
}

Here is the call graph for this function:

void tag_get_data ( TagHandle  handle, size_t  num_elems, const EntityHandle *  handle_array, void *  tag_data, MsqError &  err  )

private

Get tag values.

Definition at line 1922 of file MeshTSTT.cpp.

References Mesquite::alloc_sidl_vector(), MeshTSTTImpl::arrTagIFace, Mesquite::convert_to_sidl_vector(), i, MsqError::INTERNAL_ERROR, MSQ_SETERR, Mesquite::process_tstt_error(), and MeshTSTTImpl::tagIFace.

Referenced by MeshTSTTImpl::tag_get_element_data(), and MeshTSTTImpl::tag_get_vertex_data().

{
  try {
    size_t len, size = tagIFace.getTagSize( tag );
    int32_t lower = 0, upper = num_elems - 1, stride = 1, count = num_elems;
    sidl::array<void*> handles;
    handles.borrow( const_cast<void**>(array), 1, &lower, &upper, &stride );
    switch (tagIFace.getTagType( tag ))
    {
      case TSTTB::TagValueType_ENTITY_HANDLE:
      {
        len = size / sizeof(void*);
        sidl::array<void*> sdata( convert_to_sidl_vector( (void**)data, len*num_elems ));
        arrTagIFace.getEHArrData( handles, num_elems, tag, sdata, count );
      }
      break;
      
      case TSTTB::TagValueType_DOUBLE:
      {
        len = size / sizeof(double);
        sidl::array<double> sdata( convert_to_sidl_vector( (double*)data, len*num_elems ));
        arrTagIFace.getDblArrData( handles, num_elems, tag, sdata, count );
      }
      break;
      
      case TSTTB::TagValueType_INTEGER:
      {
        len = size / sizeof(int);
        sidl::array<int> sdata( convert_to_sidl_vector( (int*)data, len*num_elems ));
        arrTagIFace.getIntArrData( handles, num_elems, tag, sdata, count );
      }
      break;

      default:
      {
#if TSTT_OPAQUE_TAG_TYPE == OPAQUE_TYPE_OPAQUE_PACKED
        len = num_elems / sizeof(void*);
        if (num_elems % sizeof(void*))
          ++len;
        sidl::array<void*> sdata( convert_to_sidl_vector( (void**)data, len ) );
#elif TSTT_OPAQUE_TAG_TYPE == OPAQUE_TYPE_OPAQUE_PADDED
        assert( size <= sizeof(void*) );
        sidl::array<void*> sdata( alloc_sidl_vector<void*>(num_elems) );
#elif TSTT_OPAQUE_TAG_TYPE == OPAQUE_TYPE_CHAR
        len = size * num_elems;
        sidl::array<char> sdata( convert_to_sidl_vector( (char*)data, len ) );
#elif TSTT_OPAQUE_TAG_TYPE == OPAQUE_TYPE_UCHAR \
   || TSTT_OPAQUE_TAG_TYPE == OPAQUE_TYPE_BYTE
        len = size * num_elems;
        sidl::array<unsigned char> sdata( alloc_sidl_vector( (unsigned char*)data, len ) );
#else
#error
#endif
        int32_t junk;
        arrTagIFace.getArrData( handles, num_elems, tag, sdata, count, junk );
        
#if TSTT_OPAQUE_TAG_TYPE == OPAQUE_TYPE_OPAQUE_PADDED
        const char* ptr = reinterpret_cast<const char*>(data);
        for (size_t i = 0; i < num_elems; ++i)
          sdata.set( i, reinterpret_cast<void*>(*(ptr + i*size)) );
#endif
      }
    }
  }
  catch(::TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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_elems*tag_length*sizeof(tag_type) bytes.

Implements Mesh.

Definition at line 1904 of file MeshTSTT.cpp.

References MeshTSTTImpl::tag_get_data().

{
  tag_get_data( tag, num_elems, array, data, err );
}

Here is the call graph for this function:

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_elems*tag_length*sizeof(tag_type) bytes.

Implements Mesh.

Definition at line 1913 of file MeshTSTT.cpp.

References MeshTSTTImpl::tag_get_data().

{
  tag_get_data( tag, num_elems, array, data, err );
}

Here is the call graph for this function:

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.

Implements Mesh.

Definition at line 1779 of file MeshTSTT.cpp.

References Mesh::BYTE, Mesh::DOUBLE, Mesh::HANDLE, Mesh::INT, MsqError::INTERNAL_ERROR, MSQ_SETERR, MsqError::NOT_IMPLEMENTED, Mesquite::process_tstt_error(), and MeshTSTTImpl::tagIFace.

{
  size_t size;
  TSTTB::TagValueType type;
  try {
    name = tagIFace.getTagName( handle );
    size = tagIFace.getTagSize( handle );
    type = tagIFace.getTagType( handle );
  }
  catch(::TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
    return;
  }
  
  size_t tsize;
  switch (type) {
    case TSTTB::TagValueType_OPAQUE       : tsize = sizeof(char  ); type_out = Mesquite::Mesh::BYTE  ; break;
    case TSTTB::TagValueType_INTEGER      : tsize = sizeof(int   ); type_out = Mesquite::Mesh::INT   ; break;
    case TSTTB::TagValueType_DOUBLE       : tsize = sizeof(double); type_out = Mesquite::Mesh::DOUBLE; break;
    case TSTTB::TagValueType_ENTITY_HANDLE: tsize = sizeof(void* ); type_out = Mesquite::Mesh::HANDLE; break;
    default:
      MSQ_SETERR(err)("Unsupported TSTT tag type", MsqError::NOT_IMPLEMENTED );
      return;
  }
  
  if (size % tsize != 0)
  {
    MSQ_SETERR(err)("Invalid TSTT tag size", MsqError::INTERNAL_ERROR );
    return;
  }
  
  length_out = size / tsize;
}

Here is the call graph for this function:

void tag_set_data ( TagHandle  handle, size_t  num_elems, const EntityHandle *  handle_array, const void *  tag_data, MsqError &  err  )

private

Set tag values.

Definition at line 1835 of file MeshTSTT.cpp.

References Mesquite::alloc_sidl_vector(), MeshTSTTImpl::arrTagIFace, Mesquite::convert_to_sidl_vector(), i, MsqError::INTERNAL_ERROR, MSQ_SETERR, Mesquite::process_tstt_error(), and MeshTSTTImpl::tagIFace.

Referenced by MeshTSTTImpl::tag_set_element_data(), and MeshTSTTImpl::tag_set_vertex_data().

{
  try {
    size_t len, size = tagIFace.getTagSize( tag );
    int count;
    sidl::array<void*> handles( convert_to_sidl_vector( (void**)array, num_elems ) );
    switch (tagIFace.getTagType( tag ))
    {
      case TSTTB::TagValueType_ENTITY_HANDLE:
      {
        len = size / sizeof(void*);
        sidl::array<void*> sdata( convert_to_sidl_vector( (void**)data, len*num_elems ));
        arrTagIFace.setEHArrData( handles, num_elems, tag, sdata, count );
      }
      break;
      
      case TSTTB::TagValueType_DOUBLE:
      {
        len = size / sizeof(double);
        sidl::array<double> sdata( convert_to_sidl_vector( (double*)data, len*num_elems ));
        arrTagIFace.setDblArrData( handles, num_elems, tag, sdata, count );
      }
      break;
      
      case TSTTB::TagValueType_INTEGER:
      {
        len = size / sizeof(int);
        sidl::array<int> sdata( convert_to_sidl_vector( (int*)data, len*num_elems ));
        arrTagIFace.setIntArrData( handles, num_elems, tag, sdata, count );
      }
      break;

      default:
      {
#if TSTT_OPAQUE_TAG_TYPE == OPAQUE_TYPE_OPAQUE_PACKED
        len = num_elems / sizeof(void*);
        if (num_elems % sizeof(void*))
          ++len;
        sidl::array<void*> sdata( convert_to_sidl_vector( (void**)data, len ) );
#elif TSTT_OPAQUE_TAG_TYPE == OPAQUE_TYPE_OPAQUE_PADDED
        assert( size <= sizeof(void*) );
        sidl::array<void*> sdata( alloc_sidl_vector<void*>(num_elems) );
        const char* ptr = reinterpret_cast<const char*>(data);
        for (size_t i = 0; i < num_elems; ++i)
          sdata.set( i, reinterpret_cast<void*>(*(ptr + i*size)) );
#elif TSTT_OPAQUE_TAG_TYPE == OPAQUE_TYPE_CHAR
        len = size * num_elems;
        sidl::array<char> sdata( convert_to_sidl_vector( (char*)data, len ) );
#elif TSTT_OPAQUE_TAG_TYPE == OPAQUE_TYPE_UCHAR \
   || TSTT_OPAQUE_TAG_TYPE == OPAQUE_TYPE_BYTE
        len = size * num_elems;
        sidl::array<unsigned char> sdata( alloc_sidl_vector( (unsigned char*)data, len ) );
#else
#error
#endif
        arrTagIFace.setArrData( handles, num_elems, tag, sdata, count, size );
      }
    }
  }
  catch(::TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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_elems*tag_length*sizeof(tag_type) bytes.

Implements Mesh.

Definition at line 1817 of file MeshTSTT.cpp.

References MeshTSTTImpl::tag_set_data().

{
  tag_set_data( tag, num_elems, array, data, err );
}

Here is the call graph for this function:

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_elems*tag_length*sizeof(tag_type) bytes.

Implements Mesh.

Definition at line 1826 of file MeshTSTT.cpp.

References MeshTSTTImpl::tag_set_data().

{
  tag_set_data( tag, num_elems, array, data, err );
}

Here is the call graph for this function:

size_t vertex_get_attached_element_count ( VertexHandle  vertex, MsqError &  err  )

virtual

Get vertex adjacencies.

Implements Mesh.

Definition at line 1424 of file MeshTSTT.cpp.

References MeshTSTTImpl::cache_adjacent_elements(), MSQ_ERRZERO, and MeshTSTTImpl::vertexAdjElementSize.

{
  cache_adjacent_elements( vertex, err ); MSQ_ERRZERO(err);
  return vertexAdjElementSize;
}

Here is the call graph for this function:

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

virtual

Get vertex adjacencies.

Implements Mesh.

Definition at line 1432 of file MeshTSTT.cpp.

References MeshTSTTImpl::cache_adjacent_elements(), Mesquite::convert_from_sidl_vector(), MsqError::INVALID_ARG, MSQ_ERRRTN, MSQ_SETERR, MeshTSTTImpl::vertexAdjElements, and MeshTSTTImpl::vertexAdjElementSize.

{
  cache_adjacent_elements( vertex, err ); MSQ_ERRRTN(err);
  if (sizeof_elem_array < (unsigned)vertexAdjElementSize) {
    MSQ_SETERR(err)("Insufficient space in array.", MsqError::INVALID_ARG);
    return;
  }
  
  assert( sizeof(ElementHandle) == sizeof(void*) );
  void** array = convert_from_sidl_vector( vertexAdjElements );
  memcpy( elem_array, array, vertexAdjElementSize * sizeof(void*) );
}

Here is the call graph for this function:

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

virtual

Get vertex mark.

Implements Mesh.

Definition at line 1323 of file MeshTSTT.cpp.

References MeshTSTTImpl::byteTag, MsqError::INTERNAL_ERROR, MSQ_SETERR, Mesquite::process_tstt_error(), and MeshTSTTImpl::tagIFace.

{
  try {
    *byte = (unsigned char)tagIFace.getIntData( vertex, byteTag );
  }
  catch(::TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
  }
}

Here is the call graph for this function:

bool vertex_is_fixed ( VertexHandle  vertex, MsqError &  err  )

virtual

Query "fixed" flag for a vertex.

Implements Mesh.

Definition at line 1128 of file MeshTSTT.cpp.

References MeshTSTTImpl::fixedTag, MsqError::INTERNAL_ERROR, MSQ_SETERR, Mesquite::process_tstt_error(), and MeshTSTTImpl::tagIFace.

{
    // If mesh does not contain a fixed tag, assume no vertices are fixed
  if (!fixedTag) 
    return false;
    
  try {
    return (bool)tagIFace.getIntData( vertex, fixedTag );
  }
  catch( TSTTB::Error& tstt_err ) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
    return true;
  }
}

Here is the call graph for this function:

VertexIterator * vertex_iterator ( MsqError &  err )

virtual

Create iterator for vertices in active set.

Implements Mesh.

Definition at line 1089 of file MeshTSTT.cpp.

References MeshTSTTImpl::arrIFace, MsqError::INTERNAL_ERROR, MSQ_SETERR, MeshTSTTImpl::nodeSet, and Mesquite::process_tstt_error().

{
  try {
    return new TSTTArrIter( arrIFace, 
                            nodeSet, 
                            TSTTM::EntityType_ALL_TYPES,
                            TSTTM::EntityTopology_ALL_TOPOLOGIES );
  }
  catch (TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
    return 0;
  }
}

Here is the call graph for this function:

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

virtual

Set vertex mark.

Implements Mesh.

Definition at line 1285 of file MeshTSTT.cpp.

References MeshTSTTImpl::byteTag, MsqError::INTERNAL_ERROR, MSQ_SETERR, Mesquite::process_tstt_error(), and MeshTSTTImpl::tagIFace.

{
  try {
    int value = byte;
    tagIFace.setIntData( vertex, byteTag, value );
  }
  catch(::TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
  }
}

Here is the call graph for this function:

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

virtual

Set vertex coordinates.

Implements Mesh.

Definition at line 1267 of file MeshTSTT.cpp.

References Mesquite::convert_to_sidl_vector(), MsqError::INTERNAL_ERROR, MeshTSTTImpl::modIFace, MSQ_SETERR, Mesquite::process_tstt_error(), and Vector3D::to_array().

{
  try {
    sidl::array<double> coords( 
      convert_to_sidl_vector( const_cast<double*>(coordinates.to_array()), 3 ) );
    modIFace.setVtxCoords( vertex, coords, 1 );
  }
  catch(::TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
  }
}

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

Query "boundary" flag for an array of vertices.

Implements Mesh.

Definition at line 1149 of file MeshTSTT.cpp.

References MeshTSTTImpl::arrTagIFace, Mesquite::convert_to_sidl_vector(), MeshTSTTImpl::fixedTag, i, MsqError::INTERNAL_ERROR, MSQ_SETERR, and Mesquite::process_tstt_error().

{
    // If mesh does not contain a fixed tag, assume no vertices are fixed
  if (!fixedTag) {
    memset( bool_array, 0, num_vtx * sizeof(bool) );
    return;
  }
  
    // Get per-vertex flags from fixedTag
  try {
    sidl::array<void*> vert_wrapper( convert_to_sidl_vector( vert_array, num_vtx ) );
    sidl::array<int> bools = alloc_sidl_vector<int>(num_vtx);
    
    int num_bools = num_vtx;
    arrTagIFace.getIntArrData( vert_wrapper, num_vtx, fixedTag, bools, num_bools );
    if (num_vtx != (unsigned)num_bools)
      MSQ_SETERR(err)(MsqError::INTERNAL_ERROR);

    for (size_t i = 0; i < num_vtx; ++i)
      bool_array[i] = bools.get(i);
  }
  catch(::TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
  }
}

Here is the call graph for this function:

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

virtual

Get vertex mark.

Implements Mesh.

Definition at line 1335 of file MeshTSTT.cpp.

References MeshTSTTImpl::arrTagIFace, MeshTSTTImpl::byteTag, Mesquite::convert_to_sidl_vector(), i, MsqError::INTERNAL_ERROR, MSQ_SETERR, and Mesquite::process_tstt_error().

{
    // TSTT implementations seem to be inconsistant with
    // regard to setting opaque tags.  Set one at a time
    // to be safe.  This would be much easier if Mesquite
    // used a TSTT-defined type for the data, rather than
    // a single byte.
  try {
    sidl::array<void*> handles( convert_to_sidl_vector( vert_array, array_size ));
    sidl::array<int> data( alloc_sidl_vector<int>(array_size) );
    int32_t junk;
    arrTagIFace.getIntArrData( handles, array_size, byteTag, data, junk );

    for (size_t i = 0; i< array_size; ++i )
      byte_array[i] = (unsigned char)data.get(i);
  }
  catch(::TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
  }
}

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 vertex coordinates.

Implements Mesh.

Definition at line 1179 of file MeshTSTT.cpp.

References Mesquite::convert_to_sidl_vector(), i, MsqError::INTERNAL_ERROR, MsqError::INVALID_STATE, MeshTSTTImpl::meshIFace, MSQ_SETERR, Mesquite::process_tstt_error(), Vector3D::set(), Vector3D::x(), Vector3D::y(), and Vector3D::z().

{
  double* dbl_array = 0;
  
  try {
    int dim = meshIFace.getGeometricDim();
    int dbl_len = dim * num_vtx;

    sidl::array<void*> vertex_wrapper( 
      convert_to_sidl_vector( const_cast<void**>(vert_array), num_vtx ) );
    dbl_array = new double[dbl_len];
    sidl::array<double> dbl_wrapper( convert_to_sidl_vector( dbl_array, dbl_len ));
    
    TSTTM::StorageOrder order = TSTTM::StorageOrder_UNDETERMINED;
    meshIFace.getVtxArrCoords( vertex_wrapper, num_vtx, order, dbl_wrapper, dbl_len );
    if ((unsigned)dbl_len != dim*num_vtx) {
      MSQ_SETERR(err)(MsqError::INTERNAL_ERROR);
      delete [] dbl_array;
      return;
    }
    
    if (dim == 2)
    {
      if (order == TSTTM::StorageOrder_INTERLEAVED)
      {
        double* iter = dbl_array;
        for (size_t i = 0; i < num_vtx; ++i)
        {
          coordinates[i].x(*iter); ++iter;
          coordinates[i].y(*iter); ++iter;
          coordinates[i].z(0);
        }
      }
      else
      {
        double *xiter = dbl_array;
        double *yiter = dbl_array + num_vtx;
        for (size_t i = 0; i < num_vtx; ++i)
        {
          coordinates[i].x(*xiter); ++xiter;
          coordinates[i].y(*yiter); ++yiter;
          coordinates[i].z(0);
        }
      }
    }
    else if(dim == 3)
    {
      if (order == TSTTM::StorageOrder_INTERLEAVED)
      {
        double* iter = dbl_array;
        for (size_t i = 0; i < num_vtx; ++i)
        {
          coordinates[i].set(iter);
          iter += 3;
        }
      }
      else
      {
        double *xiter = dbl_array;
        double *yiter = dbl_array + num_vtx;
        double *ziter = dbl_array + 2*num_vtx;
        for (size_t i = 0; i < num_vtx; ++i)
        {
          coordinates[i].x(*xiter); ++xiter;
          coordinates[i].y(*yiter); ++yiter;
          coordinates[i].z(*ziter); ++ziter;
        }
      }
    }
    else
    {
      MSQ_SETERR(err)(MsqError::INVALID_STATE, "TSTTB database dimension = %d", dim);
      delete [] dbl_array;
      return;
    }
      
  }
  catch(::TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
  }
  
  delete [] dbl_array;
}

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

Set vertex mark.

Implements Mesh.

Definition at line 1298 of file MeshTSTT.cpp.

References MeshTSTTImpl::arrTagIFace, MeshTSTTImpl::byteTag, Mesquite::convert_to_sidl_vector(), i, MsqError::INTERNAL_ERROR, MSQ_SETERR, and Mesquite::process_tstt_error().

{
    // TSTT implementations seem to be inconsistant with
    // regard to setting opaque tags.  Set one at a time
    // to be safe.  This would be much easier if Mesquite
    // used a TSTT-defined type for the data, rather than
    // a single byte.
  try {
    sidl::array<void*> handles( convert_to_sidl_vector( vert_array, array_size ));
    sidl::array<int> data(alloc_sidl_vector<int>(array_size));
    for (size_t i = 0; i < array_size; ++i)
      data.set( i, byte_array[i] );
    arrTagIFace.setIntArrData( handles, array_size, byteTag, data, array_size );
  }
  catch(::TSTTB::Error &tstt_err) {
    MSQ_SETERR(err)( process_tstt_error(tstt_err), MsqError::INTERNAL_ERROR );
  }
}

Here is the call graph for this function:

Member Data Documentation

TSTTM::Arr arrIFace

private

TSTT interface for multi-entity (array) queries.

Definition at line 626 of file MeshTSTT.cpp.

Referenced by MeshTSTTImpl::element_iterator(), MeshTSTTImpl::elements_get_attached_vertices(), MeshTSTTImpl::elements_get_topologies(), MeshTSTTImpl::get_vertex_use_count(), MeshTSTTImpl::MeshTSTTImpl(), MeshTSTTImpl::popupate_input_elements(), MeshTSTTImpl::set_active_set(), MeshTSTTImpl::set_int_tag(), and MeshTSTTImpl::vertex_iterator().

TSTTB::ArrTag arrTagIFace

private

Definition at line 627 of file MeshTSTT.cpp.

Referenced by MeshTSTTImpl::MeshTSTTImpl(), MeshTSTTImpl::set_int_tag(), MeshTSTTImpl::tag_get_data(), MeshTSTTImpl::tag_set_data(), MeshTSTTImpl::vertices_are_on_boundary(), MeshTSTTImpl::vertices_get_byte(), and MeshTSTTImpl::vertices_set_byte().

TagHandle byteTag

private

Handle for tag used to hold vertex byte.

Definition at line 654 of file MeshTSTT.cpp.

Referenced by MeshTSTTImpl::MeshTSTTImpl(), MeshTSTTImpl::vertex_get_byte(), MeshTSTTImpl::vertex_set_byte(), MeshTSTTImpl::vertices_get_byte(), and MeshTSTTImpl::vertices_set_byte().

void* cachedAdjVertex

private

Vertex for which vertexAdjElements is cached.

Definition at line 674 of file MeshTSTT.cpp.

Referenced by MeshTSTTImpl::cache_adjacent_elements(), and MeshTSTTImpl::set_active_set().

bool createdByteTag

private

Tag was created in constructor.

Definition at line 656 of file MeshTSTT.cpp.

Referenced by MeshTSTTImpl::MeshTSTTImpl().

bool createdFixedTag

private

Fixed tag was created in constructor.

Definition at line 660 of file MeshTSTT.cpp.

Referenced by MeshTSTTImpl::MeshTSTTImpl().

void* elementSet

private

TSTTM entity set handle for elements to improve.

Definition at line 636 of file MeshTSTT.cpp.

Referenced by MeshTSTTImpl::element_iterator(), MeshTSTTImpl::get_all_mesh(), MeshTSTTImpl::get_all_sizes(), MeshTSTTImpl::popupate_input_elements(), and MeshTSTTImpl::set_active_set().

TSTTM::Entity entIFace

private

TSTT interface for per-entity queries.

Definition at line 623 of file MeshTSTT.cpp.

Referenced by MeshTSTTImpl::cache_adjacent_elements(), MeshTSTTImpl::element_get_attached_vertex_count(), MeshTSTTImpl::element_get_topology(), and MeshTSTTImpl::MeshTSTTImpl().

TagHandle fixedTag

private

Handle for tag used to hold vertex-fixed flag.

Definition at line 658 of file MeshTSTT.cpp.

Referenced by MeshTSTTImpl::MeshTSTTImpl(), MeshTSTTImpl::vertex_is_fixed(), and MeshTSTTImpl::vertices_are_on_boundary().

bool haveMesh

private

Have mesh.

Definition at line 634 of file MeshTSTT.cpp.

msq_std::set<void*> inputElements

private

std::set containing elements in elementSet, used to constrain vertex->element adjaceny queries to only those elements that are in the input element set.

Definition at line 643 of file MeshTSTT.cpp.

Referenced by MeshTSTTImpl::cache_adjacent_elements(), MeshTSTTImpl::popupate_input_elements(), and MeshTSTTImpl::set_active_set().

TSTTM::EntityType inputSetType

private

The type of elements contained in the input element set.

Should be one of:

• TSTTM::EntityType_REGION - volume elements
• TSTTM::EntityType_FACE - face/2d elements
• TSTTM::EntityType_ALL_TYPES - mixed volume and face elements

Definition at line 651 of file MeshTSTT.cpp.

Referenced by MeshTSTTImpl::cache_adjacent_elements(), and MeshTSTTImpl::set_active_set().

TSTTM::Mesh meshIFace

private

TSTT basic mesh interface instance.

Definition at line 621 of file MeshTSTT.cpp.

Referenced by MeshTSTTImpl::get_all_mesh(), MeshTSTTImpl::get_all_sizes(), MeshTSTTImpl::get_geometric_dimension(), and MeshTSTTImpl::vertices_get_coordinates().

TSTTM::Modify modIFace

private

TSTT interface for modifying mesh.

Definition at line 629 of file MeshTSTT.cpp.

Referenced by MeshTSTTImpl::MeshTSTTImpl(), and MeshTSTTImpl::vertex_set_coordinates().

void* nodeSet

private

TSTTM entity set handle for nodes to move.

Definition at line 638 of file MeshTSTT.cpp.

Referenced by MeshTSTTImpl::get_all_sizes(), MeshTSTTImpl::MeshTSTTImpl(), MeshTSTTImpl::set_active_set(), and MeshTSTTImpl::vertex_iterator().

TSTTB::EntSet setIFace

private

TSTT interface for entity set operations.

Definition at line 631 of file MeshTSTT.cpp.

Referenced by MeshTSTTImpl::MeshTSTTImpl(), MeshTSTTImpl::popupate_input_elements(), and MeshTSTTImpl::set_active_set().

TSTTB::EntTag tagIFace

private

Definition at line 624 of file MeshTSTT.cpp.

Referenced by MeshTSTTImpl::MeshTSTTImpl(), MeshTSTTImpl::tag_create(), MeshTSTTImpl::tag_delete(), MeshTSTTImpl::tag_get(), MeshTSTTImpl::tag_get_data(), MeshTSTTImpl::tag_properties(), MeshTSTTImpl::tag_set_data(), MeshTSTTImpl::vertex_get_byte(), MeshTSTTImpl::vertex_is_fixed(), and MeshTSTTImpl::vertex_set_byte().

EntityTopology topologyMap[TSTTM::EntityTopology_ALL_TOPOLOGIES+1]

private

Handle for the tag used internally to remove duplicates from lists.

vertexIndexTag was created in constructor Map TSTTM::EntityTopology to Mesquite::EntityTopology

Definition at line 667 of file MeshTSTT.cpp.

Referenced by MeshTSTTImpl::element_get_topology(), MeshTSTTImpl::elements_get_topologies(), and MeshTSTTImpl::MeshTSTTImpl().

sidl::array<void*> vertexAdjElements

private

Cached result for vertex->element query.

Definition at line 670 of file MeshTSTT.cpp.

Referenced by MeshTSTTImpl::cache_adjacent_elements(), and MeshTSTTImpl::vertex_get_attached_elements().

int vertexAdjElementSize

private

Number of valid entries vertexAdjElements.

Definition at line 672 of file MeshTSTT.cpp.

Referenced by MeshTSTTImpl::cache_adjacent_elements(), MeshTSTTImpl::set_active_set(), MeshTSTTImpl::vertex_get_attached_element_count(), and MeshTSTTImpl::vertex_get_attached_elements().

---

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

• MeshTSTT.cpp