The MeshSet class stores one or more Mesquite::Mesh pointers and manages access to the mesh information. More...

#include <MeshSet.hpp>

Collaboration diagram for MeshSet:

Public Member Functions
	MeshSet ()

	~MeshSet ()

void	add_mesh (Mesquite::Mesh *mesh, MsqError &err)
	adds a mesh to the MeshSet. More...

void	set_domain_constraint (MeshDomain *domain, MsqError &err)
	Sets the geometrical domain for the MeshSet. More...

Mesquite::MeshDomain *	get_domain_constraint ()
	Returns the domain associated with the MeshSet from which the Patch originates. More...

void	get_meshes (msq_std::list< Mesquite::Mesh * > &mesh_list) const
	returns the list of mesh pointers previously added. More...

int	space_dim () const
	Returns the number of coordinates in the Mesh's geometric coordinate system. More...

bool	get_next_patch (PatchData &pd, PatchDataUser *pd_user, MsqError &err)
	Gets the next PatchData. More...

bool	get_next_patch (PatchData &pd, PatchDataParameters &pd_params, MsqError &err)

void	reset (MsqError &err)
	Resets the MeshSet object so that get_next_patch() will restart its iterations at the first vertex. More...

void	update_mesh (const PatchData &pd, MsqError &err)
	Updates the coordinates in the underlying mesh with the coordinates stored in PatchData. More...

void	set_flag_to_cull (MsqVertex::FlagMask f_m)
	Sets the cullFlag. More...

bool	clear_all_soft_fixed_flags (MsqError &err)

void	write_vtk (const char *out_filebase, MsqError &err)

void	write_gnuplot (const char *out_filebase, MsqError &err)

Mesh *	get_current_mesh ()

	MeshSet ()

	~MeshSet ()

void	add_mesh (Mesquite::Mesh *mesh, MsqError &err)
	adds a mesh to the MeshSet. More...

void	set_domain_constraint (MeshDomain *domain, MsqError &err)
	Sets the geometrical domain for the MeshSet. More...

Mesquite::MeshDomain *	get_domain_constraint ()
	Returns the domain associated with the MeshSet from which the Patch originates. More...

void	get_meshes (msq_std::list< Mesquite::Mesh * > &mesh_list) const
	returns the list of mesh pointers previously added. More...

int	space_dim () const
	Returns the number of coordinates in the Mesh's geometric coordinate system. More...

bool	get_next_patch (PatchData &pd, PatchDataUser *pd_user, MsqError &err)
	Gets the next PatchData. More...

bool	get_next_patch (PatchData &pd, PatchDataParameters &pd_params, MsqError &err)

void	reset (MsqError &err)
	Resets the MeshSet object so that get_next_patch() will restart its iterations at the first vertex. More...

void	update_mesh (const PatchData &pd, MsqError &err)
	Updates the coordinates in the underlying mesh with the coordinates stored in PatchData. More...

void	set_flag_to_cull (MsqVertex::FlagMask f_m)
	Sets the cullFlag. More...

bool	clear_all_soft_fixed_flags (MsqError &err)

void	write_vtk (const char *out_filebase, MsqError &err)

void	write_gnuplot (const char *out_filebase, MsqError &err)

Mesh *	get_current_mesh ()

Private Member Functions
bool	get_next_elem_on_vert_patch (PatchData &, PatchDataParameters &, MsqError &)

bool	get_next_global_patch (PatchData &, PatchDataParameters &, MsqError &)

bool	get_next_elem_on_vert_patch (PatchData &, PatchDataParameters &, MsqError &)

bool	get_next_global_patch (PatchData &, PatchDataParameters &, MsqError &)

Private Attributes
msq_std::list< Mesquite::Mesh * >	meshSet
	Meshes in this MeshSet. More...

msq_std::list< Mesquite::Mesh * > ::iterator	currentMesh
	Keeps track of which Mesh* we're currently working with in get_next_patch(). More...

Mesquite::VertexIterator *	vertexIterator
	Keeps track of where we are in the current mesh's vertex list. More...

int	spaceDim
	The number of coordinates in this mesh (2D or 3D) More...

Mesquite::EntityTopology	elementType
	The topological dimension of the elements in this MeshSet, where Mesquite::TRIANGLE indicates 2D elements (faces) and Mesquite::TETRAHEDRON indicates 3D elements (regions). More...

msq_stdc::size_t *	csrOffsets
	These are arrays that we cache so we don't have to reallocate at every patch. More...

Mesquite::EntityTopology *	elemTopologies

bool *	vertexOnBoundary

msq_stdc::size_t	csrOffsetsSize

msq_stdc::size_t	vertArraySize

msq_stdc::size_t	elemArraySize

Mesquite::MeshDomain *	mDomain

Mesquite::MsqVertex::FlagMask	cullFlag

Detailed Description

The MeshSet class stores one or more Mesquite::Mesh pointers and manages access to the mesh information.

MeshSet objects are passed to the various Mesquite algorithms in order to assess the quality, improve the mesh, etc...

Definition at line 69 of file includeLinks/MeshSet.hpp.

Constructor & Destructor Documentation

MeshSet ( )

Definition at line 65 of file Mesh/MeshSet.cpp.

References MeshSet::cullFlag, and MsqVertex::MSQ_SOFT_FIXED.

                  :
   vertexIterator(NULL),
   spaceDim(0),
   csrOffsets(0),
 //  csrData(0),
 //  vertArray(NULL),
 //  elemArray(NULL),
   elemTopologies(0),
   vertexOnBoundary(0),
   csrOffsetsSize(0),
 //  csrDataSize(0),
   vertArraySize(0),
   elemArraySize(0),
   mDomain(NULL)
 {
   cullFlag=MsqVertex::MSQ_SOFT_FIXED;
 }

~MeshSet ( )

Definition at line 83 of file Mesh/MeshSet.cpp.

References MeshSet::csrOffsets, MeshSet::elemTopologies, MeshSet::meshSet, MeshSet::vertexIterator, and MeshSet::vertexOnBoundary.

 {
     // Delete the vertex iterator
   delete vertexIterator;
     // Release all of our meshes
   list<Mesquite::Mesh*>::iterator it = meshSet.begin();
   while(!(it == meshSet.end()))
     (*it++)->release();
   
     // Delete cache arrays
   delete [] csrOffsets;
 //  delete [] csrData;
 //  delete [] vertArray;
 //  delete [] elemArray;
   delete [] elemTopologies;
   delete [] vertexOnBoundary;
 }

MeshSet ( )

~MeshSet ( )

Member Function Documentation

void add_mesh	(	Mesquite::Mesh *	mh,
		MsqError &	err
	)

adds a mesh to the MeshSet.

If several meshes are added, the mesh information will be retrieved seamlessly, as if dealing with a single mesh.

adds a Mesquite::Mesh to the MeshSet. If used several times, it concatenates the vertices from several meshes into one Mesquite::MeshSet.

Definition at line 108 of file Mesh/MeshSet.cpp.

References Mesh::get_geometric_dimension(), MsqError::INVALID_STATE, MeshSet::meshSet, MSQ_ERRRTN, MSQ_SETERR, and MeshSet::spaceDim.

Referenced by Rocmop::smooth_mesquite().

 {
     // sets MeshSet::SpaceDim
   int dim = mesh->get_geometric_dimension(err); MSQ_ERRRTN(err);
   if (spaceDim == 0) 
     spaceDim = dim;
   else if (dim != spaceDim)
   {
     MSQ_SETERR(err)( "Meshes of different dimensions added to the same MeshSet.",
                      MsqError::INVALID_STATE );
     return;
   }
   
     // adds the Mesh* to the MeshSet.
   meshSet.push_front(mesh);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void add_mesh	(	Mesquite::Mesh *	mesh,
		MsqError &	err
	)

adds a mesh to the MeshSet.

If several meshes are added, the mesh information will be retrieved seamlessly, as if dealing with a single mesh.

bool clear_all_soft_fixed_flags ( MsqError & err )

Definition at line 596 of file Mesh/MeshSet.cpp.

References MeshSet::currentMesh, EntityIterator::is_at_end(), MeshSet::meshSet, MSQ_CHKERR, MeshSet::reset(), and MeshSet::vertexIterator.

Referenced by TerminationCriterion::cleanup().

 {
     //variable to store the center vertex's fixed flag
   MsqVertex::FlagMask fixed_byte;
   bool finished_with_vertices=false;
     // initialize everything.
   if (!vertexIterator)
   {  reset(err); if(MSQ_CHKERR(err)) return false; }
     // currentVertex is pointing at next potential center vertex.
     
   while(!finished_with_vertices){
       // Move to next mesh if necessary
     if (vertexIterator->is_at_end())
     {
       delete vertexIterator;
       ++currentMesh;
       if (currentMesh == meshSet.end())
       {
         vertexIterator = NULL;
         finished_with_vertices=true;
       }
       if(!finished_with_vertices){
         vertexIterator = (*currentMesh)->vertex_iterator(err); 
         if (MSQ_CHKERR(err)) return false;
       }
     }
       //otherwise we check to see if this vertex has been culled
     else{
         //get the fixed_bit_flag 
       (*currentMesh)->vertex_get_byte(**vertexIterator,&fixed_byte, err);
       if (MSQ_CHKERR(err)) return false;
       fixed_byte &= (~MsqVertex::MSQ_SOFT_FIXED);
       (*currentMesh)->vertex_set_byte(**vertexIterator,fixed_byte, err);
       if (MSQ_CHKERR(err)) return false;
       ++(*vertexIterator);
     }
   }
   return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool clear_all_soft_fixed_flags ( MsqError & err )

Mesh* get_current_mesh ( )

inline

Definition at line 146 of file includeLinks/MeshSet.hpp.

References MeshSet::currentMesh, and MeshSet::meshSet.

Referenced by CornerTagHandles::get_current_mesh().

147 { return meshSet.empty() ? 0 : *currentMesh; }

Mesquite::MeshSet::currentMesh

msq_std::list< Mesquite::Mesh * >::iterator currentMesh

Keeps track of which Mesh* we're currently working with in get_next_patch().

Definition: includeLinks/MeshSet.hpp:158

Mesquite::MeshSet::meshSet

msq_std::list< Mesquite::Mesh * > meshSet

Meshes in this MeshSet.

Definition: includeLinks/MeshSet.hpp:155

Here is the caller graph for this function:

Mesh* get_current_mesh ( )

inline

Definition at line 146 of file src/Mesh/MeshSet.hpp.

References MeshSet::currentMesh, and MeshSet::meshSet.

147 { return meshSet.empty() ? 0 : *currentMesh; }

Mesquite::MeshSet::currentMesh

msq_std::list< Mesquite::Mesh * >::iterator currentMesh

Keeps track of which Mesh* we're currently working with in get_next_patch().

Definition: includeLinks/MeshSet.hpp:158

Mesquite::MeshSet::meshSet

msq_std::list< Mesquite::Mesh * > meshSet

Meshes in this MeshSet.

Definition: includeLinks/MeshSet.hpp:155

Mesquite::MeshDomain* get_domain_constraint ( )

inline

Returns the domain associated with the MeshSet from which the Patch originates.

NULL if no domain is defined.

Definition at line 88 of file src/Mesh/MeshSet.hpp.

References MeshSet::mDomain.

89 { return mDomain; }

Mesquite::MeshSet::mDomain

Mesquite::MeshDomain * mDomain

Definition: includeLinks/MeshSet.hpp:184

Mesquite::MeshDomain* get_domain_constraint ( )

inline

Returns the domain associated with the MeshSet from which the Patch originates.

NULL if no domain is defined.

Definition at line 88 of file includeLinks/MeshSet.hpp.

References MeshSet::mDomain.

Referenced by PatchData::get_domain_normal_at_element(), PatchData::get_domain_normal_at_vertex(), PatchData::get_domain_normals_at_corners(), PatchData::set_mesh_set(), PatchData::snap_vertex_to_domain(), and PatchData::update_cached_normals().

89 { return mDomain; }

Mesquite::MeshSet::mDomain

Mesquite::MeshDomain * mDomain

Definition: includeLinks/MeshSet.hpp:184

Here is the caller graph for this function:

void get_meshes ( msq_std::list< Mesquite::Mesh * > & mesh_list ) const

inline

returns the list of mesh pointers previously added.

Definition at line 92 of file includeLinks/MeshSet.hpp.

References MeshSet::meshSet.

93 { mesh_list = meshSet; }

Mesquite::MeshSet::meshSet

msq_std::list< Mesquite::Mesh * > meshSet

Meshes in this MeshSet.

Definition: includeLinks/MeshSet.hpp:155

void get_meshes ( msq_std::list< Mesquite::Mesh * > & mesh_list ) const

inline

returns the list of mesh pointers previously added.

Definition at line 92 of file src/Mesh/MeshSet.hpp.

References MeshSet::meshSet.

93 { mesh_list = meshSet; }

Mesquite::MeshSet::meshSet

msq_std::list< Mesquite::Mesh * > meshSet

Meshes in this MeshSet.

Definition: includeLinks/MeshSet.hpp:155

bool get_next_elem_on_vert_patch	(	PatchData &	,
		PatchDataParameters &	,
		MsqError &
	)

private

bool get_next_elem_on_vert_patch	(	PatchData &	pd,
		PatchDataParameters &	pd_params,
		MsqError &	err
	)

private

Definition at line 208 of file Mesh/MeshSet.cpp.

References MeshSet::csrOffsets, MeshSet::csrOffsetsSize, MeshSet::cullFlag, MeshSet::currentMesh, PatchData::domainHint, MeshSet::elemArraySize, PatchData::elemConnectivityArray, PatchData::elementArray, PatchData::elementHandlesArray, PatchData::ELEMENTS_ON_VERTEX_PATCH, MeshSet::elemTopologies, PatchDataParameters::get_culling_method_bits(), PatchData::get_element_array(), PatchDataParameters::get_nb_layers(), PatchData::get_vertex_array(), MeshDomain::hint(), i, PatchData::initialize_data(), EntityIterator::is_at_end(), MeshSet::mDomain, MeshSet::meshSet, MSQ_CHKERR, MSQ_ERRZERO, MsqVertex::MSQ_HARD_FIXED, MSQ_SETERR, PatchData::mType, PatchData::NO_BOUNDARY_VTX, Mesquite::NO_DOMAIN_HINT, PatchData::NO_INTERIOR_VTX, MsqError::NOT_IMPLEMENTED, MeshSet::reset(), PatchDataMem< X >::resize(), PatchData::vertexArray, MsqVertex::vertexBitFlags, PatchData::vertexHandlesArray, and MeshSet::vertexIterator.

Referenced by MeshSet::get_next_patch().

 {
   size_t i;
 
     // Get the patch parameters.
   long unsigned int culling_method_bits = pd_params.get_culling_method_bits();
 
     //variable to store the center vertex's fixed flag
   MsqVertex::FlagMask center_fixed_byte;
     // Make sure we're only getting a patch depth of 1
   int num_layers = pd_params.get_nb_layers(err); 
   if (MSQ_CHKERR(err)) return false;
 
   if ((unsigned)num_layers > (unsigned)1)
   {
     MSQ_SETERR(err)( "no implementation for patch depth > 1.",
                      MsqError::NOT_IMPLEMENTED ); 
     return false;
   }
 
     // Set the patch type
   pd.mType = PatchData::ELEMENTS_ON_VERTEX_PATCH;
   pd.domainHint = NO_DOMAIN_HINT;
   if (mDomain)
     pd.domainHint = mDomain->hint();
 
     // If this is our first time through the mesh,
     // initialize everything.
   if (!vertexIterator)
   {
     reset(err);
     if (MSQ_CHKERR(err)) return false;
   }
 
     // currentVertex is pointing at next potential center vertex.
     // Move forward in the list of vertices if necessary.
   bool next_vertex_identified = false;
   while (!next_vertex_identified)
   {
       // Move to next mesh if necessary
     while (vertexIterator->is_at_end())
     {
       delete vertexIterator;
       ++currentMesh;
       if (currentMesh == meshSet.end())
       {
         vertexIterator = NULL;
         return false;
       }
       vertexIterator = (*currentMesh)->vertex_iterator(err); MSQ_CHKERR(err);
     }
 
     bool on_bnd = false;
     bool is_mid = false;
     Mesquite::Mesh::VertexHandle vtx = **vertexIterator;
     (*currentMesh)->vertices_are_on_boundary(&vtx, &on_bnd, 1, err);
     if (MSQ_CHKERR(err)) return false;
     //(*currentMesh)->vertices_are_midnodes(&vtx, &is_mid, 1, err);
     //if (MSQ_CHKERR(err)) return false;
 
       //always skip midnodes
     if (is_mid)
     {
        vertexIterator->operator++();
     }
       //if this is a 'boundary' fixed flag, skip it now
     else if ((culling_method_bits & PatchData::NO_BOUNDARY_VTX)
              && (on_bnd==true))
     {
         ++(*vertexIterator);
     }
     else if ((culling_method_bits & PatchData::NO_INTERIOR_VTX)
              && (on_bnd==false))
     {
         ++(*vertexIterator);
     }
       //otherwise we check to see if this vertex has been culled
     else{
         //get the fixed_bit_flag for the center vertex
       (*currentMesh)->vertex_get_byte(**vertexIterator,&center_fixed_byte, err);
       if (MSQ_CHKERR(err)) return false;
 
         //remove the hard fixed flag if it has been set
       center_fixed_byte &= ~(MsqVertex::MSQ_HARD_FIXED);
         //if it is culled, skip it
       if(center_fixed_byte & cullFlag)
       {
         ++(*vertexIterator);
       }
       else
       {
           // We found the right one
         next_vertex_identified = true;
       }//end else (vertex was not fixed [boundary] or culled)
     }//end else (iterator was not at the end and vertex was not boundary)  
   }//end while (!next_vertex_identified)
   Mesh::VertexHandle vertex = **vertexIterator;
   vertexIterator->operator++();
   if(num_layers == 0 ){
     pd.vertexArray.resize( 1 );
     MsqVertex* pd_vert_array = pd.get_vertex_array(err);
     (*currentMesh)->vertices_get_coordinates(&vertex,
                                              pd_vert_array,
                                              1,
                                              err); MSQ_ERRZERO(err);
     pd_vert_array[0].vertexBitFlags=center_fixed_byte;
     
     pd.vertexHandlesArray.resize(1);
     pd.vertexHandlesArray[0]=vertex;
     
     pd.initialize_data( NULL, err ); MSQ_ERRZERO(err);
     return true;
   }
       // Get the number of elements in this vertex
   size_t num_elems =
     (*currentMesh)->vertex_get_attached_element_count(vertex, err);
   if (MSQ_CHKERR(err)) return false;
   pd.elementHandlesArray.resize( num_elems );
  
     // Get the elements attached to this vertex
   if (elemArraySize < num_elems)
   {
     delete [] elemTopologies;
     elemTopologies = new EntityTopology[num_elems];
     elemArraySize = num_elems;
   }
 
   (*currentMesh)->vertex_get_attached_elements(vertex,
                                                &pd.elementHandlesArray[0],
                                                num_elems, err);
   if (MSQ_CHKERR(err)) return false;
 
     // Get the topologies of those elements
   (*currentMesh)->elements_get_topologies(&pd.elementHandlesArray[0],
                                           elemTopologies,
                                           num_elems, err);
   if (MSQ_CHKERR(err)) return false;
 
     // Figure out how many vertices we need to allocate
   //size_t num_vert_uses = 1;
   //size_t i;
   //for (i = 0; i < num_elems; ++i)
   //  num_vert_uses += vertices_in_topology(elemTopologies[i]);
   size_t num_vert_uses = (*currentMesh)->
     get_vertex_use_count( &pd.elementHandlesArray[0], num_elems, err ); 
   MSQ_ERRZERO(err);
 
     // All elems share at least 1 vertex (the center vertex).  The
     // center vertex is used 1 time, but it was counted num_elems times.
   size_t num_verts = num_vert_uses - num_elems + 1;
   pd.vertexHandlesArray.resize( num_verts );
   pd.elementArray.resize( num_elems );
   pd.elemConnectivityArray.resize( num_vert_uses );
 
     // Get the vertices attached to those elements
   
   if (csrOffsetsSize < num_elems + 1)
   {
     delete [] csrOffsets;
     csrOffsets = new size_t[num_elems + 1];
     csrOffsetsSize = num_elems + 1;
   }
   (*currentMesh)->elements_get_attached_vertices(&pd.elementHandlesArray[0],
                                                  num_elems,
                                                  &pd.vertexHandlesArray[0],
                                                  num_verts,
                                                  &pd.elemConnectivityArray[0],
                                                  num_vert_uses,
                                                  csrOffsets,
                                                  err); 
   if (MSQ_CHKERR(err)) return false;
   
     // Update with actual vertex count
   pd.vertexHandlesArray.resize( num_verts );
 
     // Put the elements into the PatchData
   MsqMeshEntity* pd_elem_array = pd.get_element_array(err);
   for (i = 0; i < num_elems; ++i)
     pd_elem_array[i].set_element_type( elemTopologies[i] );
   pd.initialize_data( csrOffsets, err ); MSQ_ERRZERO(err);
 
     // Get the coordinates of the vertices and its flags.
   pd.vertexArray.resize( num_verts );
   MsqVertex* pd_vert_array = pd.get_vertex_array(err);
     //get the coordinates
   (*currentMesh)->vertices_get_coordinates(&pd.vertexHandlesArray[0],
                                            pd_vert_array,
                                            num_verts,
                                            err);
   if (MSQ_CHKERR(err)) return false;
   for (i = 0; i < num_verts; i++)
   {
 
       // If it's not the center vertex, mark it as hard fixed
     if (pd.vertexHandlesArray[i] != vertex)
     {
         // Get its flags
       (*currentMesh)->vertex_get_byte(pd.vertexHandlesArray[i],
                                       &(pd_vert_array[i].vertexBitFlags),
                                       err);
       if (MSQ_CHKERR(err)) return false;
       pd_vert_array[i].vertexBitFlags |= MsqVertex::MSQ_HARD_FIXED;
     }
       //else it is the center vertex.  We therefore already have
       //the fixed flag stored center_fixed_byte.  The hard fixed
       //flag has already been removed (when flag was retreived).
     else{
       pd_vert_array[i].vertexBitFlags = (center_fixed_byte);
     }
   }
 
   return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool get_next_global_patch	(	PatchData &	pd,
		PatchDataParameters &	pd_params,
		MsqError &	err
	)

private

Definition at line 425 of file Mesh/MeshSet.cpp.

References PatchData::domainHint, PatchData::elemConnectivityArray, PatchData::elementArray, PatchData::elementHandlesArray, PatchData::get_element_array(), PatchData::get_vertex_array(), PatchData::GLOBAL_PATCH, MeshDomain::hint(), i, PatchData::initialize_data(), MeshSet::mDomain, MeshSet::meshSet, MSQ_CHKERR, MSQ_ERRZERO, MsqVertex::MSQ_HARD_FIXED, MSQ_SETERR, PatchData::mType, Mesquite::NO_DOMAIN_HINT, MsqError::NOT_IMPLEMENTED, MeshSet::reset(), PatchDataMem< X >::resize(), PatchDataMem< X >::size(), MeshSet::vertArraySize, PatchData::vertexArray, MsqVertex::vertexBitFlags, PatchData::vertexHandlesArray, and MeshSet::vertexOnBoundary.

Referenced by MeshSet::get_next_patch().

 {
     // We only support global patches for a single Mesh
   if (meshSet.size() != 1)
   {
     MSQ_SETERR(err)( 
        "Global patches only supported for single-Mesh MeshSets.",
        MsqError::NOT_IMPLEMENTED );
     return false;
   }
 
   pd.mType = PatchData::GLOBAL_PATCH;
   pd.domainHint = NO_DOMAIN_HINT;
   if (mDomain)
     pd.domainHint = mDomain->hint();
 
     // for a global patch, we always reset to start of the mesh.
   reset(err);
   if (MSQ_CHKERR(err)) return false;
 
   size_t i;
 
     // Get sizes for mesh data
   size_t num_verts, num_elems, num_uses;
   (*currentMesh)->get_all_sizes( num_verts, num_elems, num_uses, err ); MSQ_ERRZERO(err);
 
     // Get handles and connectivity
   pd.vertexHandlesArray.resize( num_verts );
   pd.elementHandlesArray.resize( num_elems );
   pd.elemConnectivityArray.resize( num_uses );
   msq_std::vector<size_t> offsets(num_elems+1);
   (*currentMesh)->get_all_mesh( &pd.vertexHandlesArray[0], num_verts,
                                 &pd.elementHandlesArray[0], num_elems,
                                 &offsets[0], offsets.size(),
                                 &pd.elemConnectivityArray[0], 
                                 pd.elemConnectivityArray.size(),
                                 err ); MSQ_ERRZERO(err);
   
     // Get element topologies
   pd.elementArray.resize( num_elems );
   msq_std::vector<EntityTopology> elem_topologies(num_elems);
   (*currentMesh)->elements_get_topologies( &pd.elementHandlesArray[0], 
                                            &elem_topologies[0], 
                                            num_elems, err );MSQ_ERRZERO(err);
 
     // Put them into the patch
   MsqMeshEntity* pd_elem_array = pd.get_element_array(err);MSQ_ERRZERO(err);
   for (i = 0; i < num_elems; ++i)
     pd_elem_array[i].set_element_type( elem_topologies[i] );
     
     // Complete connectivity data in patch
   pd.initialize_data( &offsets[0], err ); MSQ_ERRZERO(err);
 
 
     // Get vertex coordinates
   pd.vertexArray.resize( num_verts );
   MsqVertex* pd_vert_array = pd.get_vertex_array(err);MSQ_ERRZERO(err);
   (*currentMesh)->vertices_get_coordinates(&pd.vertexHandlesArray[0],
                                            pd_vert_array,
                                            num_verts,
                                            err); MSQ_ERRZERO(err);
 
     // Get vertex boundary flag
   if (vertArraySize < num_verts)
   {
     delete [] vertexOnBoundary;
     vertArraySize = num_verts;
     vertexOnBoundary = new bool[vertArraySize];
   }
   (*currentMesh)->vertices_are_on_boundary( &pd.vertexHandlesArray[0],
                                             vertexOnBoundary,
                                             num_verts,
                                             err );MSQ_ERRZERO(err);
 
   for (i = 0; i < num_verts; i++)
   {
       // Get its flags
     /*(*currentMesh)->vertex_get_byte(vertArray[i],
                                     &(pd_vert_array[i].vertexBitFlags),
                                     err); MSQ_CHKERR(err);*/
       // Set its hard-fixed flag
     if (/*(*currentMesh)->vertex_is_fixed(vertArray[i], err) ||*/
        vertexOnBoundary[i])
     {
       pd_vert_array[i].vertexBitFlags |= MsqVertex::MSQ_HARD_FIXED;
     }
     else
     {
       pd_vert_array[i].vertexBitFlags &= ~(MsqVertex::MSQ_HARD_FIXED);
     }
   }
 
   return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool get_next_global_patch	(	PatchData &	,
		PatchDataParameters &	,
		MsqError &
	)

private

bool get_next_patch	(	PatchData &	pd,
		PatchDataUser *	pd_user,
		MsqError &	err
	)

inline

Gets the next PatchData.

The type of the patch is usually set on the algorithm with set_patch_type() and propagated to the MeshSet. This version of the get_next_patch() function is the most often used. It actually delegates to the original get_next_patch function, which has a slightly different signature.

Definition at line 107 of file src/Mesh/MeshSet.hpp.

References PatchDataUser::get_all_parameters(), and MeshSet::get_next_patch().

       {
         return get_next_patch(pd, pd_user->get_all_parameters(), err);
       }

Here is the call graph for this function:

bool get_next_patch	(	PatchData &	pd,
		PatchDataUser *	pd_user,
		MsqError &	err
	)

inline

Gets the next PatchData.

The type of the patch is usually set on the algorithm with set_patch_type() and propagated to the MeshSet. This version of the get_next_patch() function is the most often used. It actually delegates to the original get_next_patch function, which has a slightly different signature.

Definition at line 107 of file includeLinks/MeshSet.hpp.

References PatchDataUser::get_all_parameters().

Referenced by TerminationCriterion::accumulate_outer(), TargetCalculator::compute_reference_corner_matrices(), WTargetCalculator::compute_target_matrices(), LVQDTargetCalculator::compute_target_matrices(), MeshSet::get_next_patch(), VertexMover::loop_over_mesh(), MeshTransform::loop_over_mesh(), QualityAssessor::loop_over_mesh(), TerminationCriterion::reset_outer(), InstructionQueue::run_instructions(), MeshSet::write_gnuplot(), and MeshSet::write_vtk().

       {
         return get_next_patch(pd, pd_user->get_all_parameters(), err);
       }

Here is the call graph for this function:

Here is the caller graph for this function:

bool get_next_patch	(	PatchData &	pd,
		PatchDataParameters &	pd_params,
		MsqError &	err
	)

This version of get_next_patch() is rarely used, but this is where the implementation actually is. See the most frequently used signature: get_next_patch(PatchData &pd, PatchDataUser* pd_user, MsqError &err).

bool get_next_patch	(	PatchData &	pd,
		PatchDataParameters &	pd_params,
		MsqError &	err
	)

This version of get_next_patch() is rarely used, but this is where the implementation actually is. See the most frequently used signature: get_next_patch(PatchData &pd, PatchDataUser* pd_user, MsqError &err).

Definition at line 175 of file Mesh/MeshSet.cpp.

References PatchData::clear(), PatchData::domainSet, PatchData::ELEMENTS_ON_VERTEX_PATCH, MeshSet::get_next_elem_on_vert_patch(), MeshSet::get_next_global_patch(), PatchDataParameters::get_patch_type(), PatchData::GLOBAL_PATCH, MeshSet::mDomain, PatchData::meshSet, MSQ_CHKERR, MSQ_FUNCTION_TIMER, MSQ_SETERR, and MsqError::NOT_IMPLEMENTED.

 {
   MSQ_FUNCTION_TIMER( "MeshSet::get_next_patch" );
 
     // get rid of previous Patch information (but keep memory allocated).
   pd.clear();
 
     // Mark this MeshSet as the originator
   pd.meshSet = this;
   pd.domainSet = (mDomain != NULL);
 
   bool result = false;
   switch (pd_params.get_patch_type())
   {
     case PatchData::ELEMENTS_ON_VERTEX_PATCH:
       result = get_next_elem_on_vert_patch( pd, pd_params, err );
       break;
     case PatchData::GLOBAL_PATCH:
       result = get_next_global_patch( pd, pd_params, err );
       break;
     default:
       MSQ_SETERR(err)( "no implementation for specified patch type.",
                        MsqError::NOT_IMPLEMENTED );
       result = false;
       break;
   }
 
   return !MSQ_CHKERR(err) && result;
 }

Here is the call graph for this function:

void reset ( MsqError & err )

Resets the MeshSet object so that get_next_patch() will restart its iterations at the first vertex.

Resets the MeshSet object. The current vertex is set back to the first vertex in the first mesh handle.

Definition at line 131 of file Mesh/MeshSet.cpp.

References MeshSet::currentMesh, MeshSet::meshSet, MSQ_ERRRTN, EntityIterator::restart(), and MeshSet::vertexIterator.

Referenced by MeshSet::clear_all_soft_fixed_flags(), MeshSet::get_next_elem_on_vert_patch(), MeshSet::get_next_global_patch(), VertexMover::loop_over_mesh(), and TargetCalculator::reset_reference_meshset().

 {
     // If we have at least one mesh...
   if (meshSet.size())
   {
       // If we aren't already on the first mesh...
     if (!vertexIterator || !(currentMesh == meshSet.begin()))
     {
       currentMesh = meshSet.begin();
       delete vertexIterator;
       vertexIterator = (*currentMesh)->vertex_iterator(err); MSQ_ERRRTN(err);
     }
     else // We ARE on the first mesh...
     {
         // ...so we can re-use the iterator.
       vertexIterator->restart();
     }
   }
   else
   {
       // This is probably redundant...
     vertexIterator = NULL;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void reset ( MsqError & err )

Resets the MeshSet object so that get_next_patch() will restart its iterations at the first vertex.

void set_domain_constraint	(	MeshDomain *	domain,
		MsqError &	err
	)

Sets the geometrical domain for the MeshSet.

This can only be used with surface meshes.

Definition at line 157 of file Mesh/MeshSet.cpp.

References MeshSet::mDomain.

 {
     mDomain = domain;
 }

void set_domain_constraint	(	MeshDomain *	domain,
		MsqError &	err
	)

Sets the geometrical domain for the MeshSet.

This can only be used with surface meshes.

void set_flag_to_cull ( MsqVertex::FlagMask f_m )

inline

Sets the cullFlag.

This flag is used to dermine which vertices should be culled. For local schemes, get_next_patch() will not build a patch around a a culled vertex.

Definition at line 135 of file src/Mesh/MeshSet.hpp.

References MeshSet::cullFlag.

       {
         cullFlag=f_m;
       }

void set_flag_to_cull ( MsqVertex::FlagMask f_m )

inline

Sets the cullFlag.

This flag is used to dermine which vertices should be culled. For local schemes, get_next_patch() will not build a patch around a a culled vertex.

Definition at line 135 of file includeLinks/MeshSet.hpp.

References MeshSet::cullFlag.

       {
         cullFlag=f_m;
       }

int space_dim ( ) const

inline

Returns the number of coordinates in the Mesh's geometric coordinate system.

Definition at line 98 of file src/Mesh/MeshSet.hpp.

References MeshSet::spaceDim.

99 { return spaceDim; }

Mesquite::MeshSet::spaceDim

int spaceDim

The number of coordinates in this mesh (2D or 3D)

Definition: includeLinks/MeshSet.hpp:162

int space_dim ( ) const

inline

Returns the number of coordinates in the Mesh's geometric coordinate system.

Definition at line 98 of file includeLinks/MeshSet.hpp.

References MeshSet::spaceDim.

Referenced by NonSmoothSteepestDescent::optimize_vertex_positions().

99 { return spaceDim; }

Mesquite::MeshSet::spaceDim

int spaceDim

The number of coordinates in this mesh (2D or 3D)

Definition: includeLinks/MeshSet.hpp:162

Here is the caller graph for this function:

void update_mesh	(	const PatchData &	pd,
		MsqError &	err
	)

Updates the coordinates in the underlying mesh with the coordinates stored in PatchData.

void update_mesh	(	const PatchData &	pd,
		MsqError &	err
	)

Updates the coordinates in the underlying mesh with the coordinates stored in PatchData.

Definition at line 524 of file Mesh/MeshSet.cpp.

References PatchData::ELEMENTS_ON_VERTEX_PATCH, PatchData::GLOBAL_PATCH, i, EntityIterator::is_at_end(), MSQ_ERRRTN, MSQ_FUNCTION_TIMER, MsqVertex::MSQ_HARD_FIXED, MSQ_SETERR, MsqError::NOT_IMPLEMENTED, PatchData::num_nodes(), PatchData::type(), PatchData::vertexArray, and PatchData::vertexHandlesArray.

Referenced by PatchData::update_mesh().

 {
   MSQ_FUNCTION_TIMER( "MeshSet::update_mesh" );
   if (pd.num_nodes() == 0)
     return;
   
   size_t i;
   
   switch (pd.type())
   {
     // If the patch type is marked as local,
     // all handles belong to the currentMesh.
   case PatchData::ELEMENTS_ON_VERTEX_PATCH:
       // For each vertex, update the coordinates
         // and the "mesquite byte".
       for (i = 0; i < pd.num_nodes(); i++)
       {
         if(!pd.vertexArray[i].is_flag_set( MsqVertex::MSQ_HARD_FIXED))
         {
           (*currentMesh)->vertex_set_coordinates(pd.vertexHandlesArray[i],
                                                  pd.vertexArray[i],
                                                  err); MSQ_ERRRTN(err);
         }
         
         (*currentMesh)->vertex_set_byte(pd.vertexHandlesArray[i],
                                         pd.vertexArray[i].vertexBitFlags,
                                         err); MSQ_ERRRTN(err);
       }
       break;
       
     // If the patch type is marked as global,
     // the handles may belong to more than
     // one Mesh.
   case PatchData::GLOBAL_PATCH:
     {
       list<Mesquite::Mesh*>::iterator mesh_itr = meshSet.begin();
       assert( mesh_itr != meshSet.end() );
       Mesquite::Mesh* cur_mesh = *mesh_itr;
       Mesquite::VertexIterator *vert_itr = cur_mesh->vertex_iterator(err);
       MSQ_ERRRTN(err);
       for (i = 0; i < pd.num_nodes(); i++)
       {
         if (vert_itr->is_at_end())
         {
           mesh_itr++;
           if ( mesh_itr==meshSet.end() )
             return;
           cur_mesh = *mesh_itr;
           delete vert_itr;
           vert_itr = cur_mesh->vertex_iterator(err); MSQ_ERRRTN(err);
         }
         if(!pd.vertexArray[i].is_flag_set( MsqVertex::MSQ_HARD_FIXED))
         {
           cur_mesh->vertex_set_coordinates(pd.vertexHandlesArray[i],
                                            pd.vertexArray[i],
                                            err); MSQ_ERRRTN(err);
         }
         cur_mesh->vertex_set_byte(pd.vertexHandlesArray[i],
                                   pd.vertexArray[i].vertexBitFlags,
                                   err); MSQ_ERRRTN(err);
       }
       delete vert_itr;
     }
     break;
   default:
     {
       MSQ_SETERR(err)("PatchData Type not accepted yet.", MsqError::NOT_IMPLEMENTED);
       break;
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void write_gnuplot	(	const char *	out_filebase,
		MsqError &	err
	)

void write_gnuplot	(	const char *	out_filebase,
		Mesquite::MsqError &	err
	)

Writes a gnuplot file directly from the MeshSet. This means that any mesh imported successfully into Mesquite can be outputed in gnuplot format.

Within gnuplot, use plot 'file1.gpt' w l, 'file2.gpt' w l

This is not geared for performance, since it has to load a global Patch from the mesh to write a mesh file.

Definition at line 755 of file Mesh/MeshSet.cpp.

References PatchData::elementArray, MsqError::FILE_ACCESS, MeshSet::get_next_patch(), PatchData::GLOBAL_PATCH, i, j, MSQ_ERRRTN, MSQ_SETERR, PatchDataParameters::no_culling_method(), PatchData::num_elements(), PatchDataParameters::set_patch_type(), and PatchData::vertexArray.

 {
     // Open the file
   string out_filename = out_filebase;
   out_filename += ".gpt";
   ofstream file(out_filename.c_str());
   if (!file)
   {
     MSQ_SETERR(err)(MsqError::FILE_ACCESS);
     return;
   }
 
     // loads a global patch
   PatchData pd;
   PatchDataParameters pd_params;
   pd_params.set_patch_type(PatchData::GLOBAL_PATCH, err); MSQ_ERRRTN(err);
   pd_params.no_culling_method();
   get_next_patch(pd, pd_params, err); MSQ_ERRRTN(err);
     
     // Write a header
   file << "\n";
   
   for (size_t i=0; i<pd.num_elements(); ++i)
   {
     std::vector<size_t> vtx_indices;
     pd.elementArray[i].get_node_indices(vtx_indices);
     for (size_t j = 0; j < vtx_indices.size(); ++j)
     {
       file << pd.vertexArray[vtx_indices[j]][0] << ' '
            << pd.vertexArray[vtx_indices[j]][1] << ' '
            << pd.vertexArray[vtx_indices[j]][2] << '\n';
     }
       file << pd.vertexArray[vtx_indices[0]][0] << ' '
            << pd.vertexArray[vtx_indices[0]][1] << ' '
            << pd.vertexArray[vtx_indices[0]][2] << '\n';
     file << '\n';
   }
   
     // Close the file
   file.close();
 }

Here is the call graph for this function:

void write_vtk	(	const char *	out_filebase,
		MsqError &	err
	)

void write_vtk	(	const char *	out_filename,
		Mesquite::MsqError &	err
	)

Writes a VTK file directly from the MeshSet. This means that any mesh imported successfully into Mesquite can be outputed in VTK format. This is not geared for performance, since it has to load a global Patch from the mesh to write a mesh file.

Definition at line 651 of file Mesh/MeshSet.cpp.

References PatchData::elementArray, MsqError::FILE_ACCESS, MeshSet::get_next_patch(), PatchData::GLOBAL_PATCH, Mesquite::HEXAHEDRON, i, j, MSQ_ERRRTN, MSQ_SETERR, PatchDataParameters::no_culling_method(), MsqError::NOT_IMPLEMENTED, PatchData::num_elements(), PatchData::num_nodes(), Mesquite::QUADRILATERAL, PatchDataParameters::set_patch_type(), Mesquite::TETRAHEDRON, Mesquite::TRIANGLE, and PatchData::vertexArray.

 {
     // Open the file
   msq_stdio::ofstream file(out_filename);
   if (!file)
   {
     MSQ_SETERR(err)(MsqError::FILE_ACCESS);
     return;
   }
 
     // loads a global patch
   PatchData pd;
   PatchDataParameters pd_params;
   pd_params.set_patch_type(PatchData::GLOBAL_PATCH, err); MSQ_ERRRTN(err);
   pd_params.no_culling_method();
   get_next_patch(pd, pd_params, err); MSQ_ERRRTN(err);
     
     // Write a header
   file << "# vtk DataFile Version 2.0\n";
   file << "Mesquite Mesh " << out_filename << " .\n";
   file << "ASCII\n";
   file << "DATASET UNSTRUCTURED_GRID\n";
   
     // Write vertex coordinates
   file << "POINTS " << pd.num_nodes() << " float\n";
   size_t i;
   for (i = 0; i < pd.num_nodes(); i++)
   {
     file << pd.vertexArray[i][0] << ' '
          << pd.vertexArray[i][1] << ' '
          << pd.vertexArray[i][2] << '\n';
   }
   
     // Write out the connectivity table
   size_t connectivity_size = 0;
   for (i = 0; i < pd.num_elements(); ++i)
     connectivity_size += pd.elementArray[i].node_count()+1;
     
   file << "CELLS " << pd.num_elements() << ' ' << connectivity_size << '\n';
   for (i = 0; i < pd.num_elements(); i++)
   {
     std::vector<size_t> vtx_indices;
     pd.elementArray[i].get_node_indices(vtx_indices);
     file << vtx_indices.size();
     for (msq_stdc::size_t j = 0; j < vtx_indices.size(); ++j)
     {
       file << ' ' << vtx_indices[j];
     }
     file << '\n';
   }
   
     // Write out the element types
   file << "CELL_TYPES " << pd.num_elements() << '\n';
   for (i = 0; i < pd.num_elements(); i++)
   {
     unsigned char type_id = 0;
     switch (pd.elementArray[i].get_element_type())
     {
       case Mesquite::TRIANGLE:
         type_id = 5;
         break;
       case Mesquite::QUADRILATERAL:
         type_id = 9;
         break;
       case Mesquite::TETRAHEDRON:
         type_id = 10;
         break;
       case Mesquite::HEXAHEDRON:
         type_id = 12;
         break;
     default:
       MSQ_SETERR(err)("element type not implemented",MsqError::NOT_IMPLEMENTED);
       break;
     }
     file << (int)type_id << '\n';
   }
   
     // Write out which points are fixed.
   file << "POINT_DATA " << pd.num_nodes()
        << "\nSCALARS fixed float\nLOOKUP_TABLE default\n";
   for (i = 0; i < pd.num_nodes(); ++i)
   {
     if (pd.vertexArray[i].is_free_vertex())
       file << "0\n";
     else
       file << "1\n";
   }
   
     // Close the file
   file.close();
 }

Here is the call graph for this function:

Member Data Documentation

msq_stdc::size_t * csrOffsets

private

These are arrays that we cache so we don't have to reallocate at every patch.

Definition at line 172 of file includeLinks/MeshSet.hpp.

Referenced by MeshSet::get_next_elem_on_vert_patch(), and MeshSet::~MeshSet().

msq_stdc::size_t csrOffsetsSize

private

Definition at line 178 of file includeLinks/MeshSet.hpp.

Referenced by MeshSet::get_next_elem_on_vert_patch().

Mesquite::MsqVertex::FlagMask cullFlag

private

Definition at line 188 of file includeLinks/MeshSet.hpp.

Referenced by MeshSet::get_next_elem_on_vert_patch(), MeshSet::MeshSet(), and MeshSet::set_flag_to_cull().

msq_std::list< Mesquite::Mesh * >::iterator currentMesh

private

Keeps track of which Mesh* we're currently working with in get_next_patch().

Definition at line 158 of file includeLinks/MeshSet.hpp.

Referenced by MeshSet::clear_all_soft_fixed_flags(), MeshSet::get_current_mesh(), MeshSet::get_next_elem_on_vert_patch(), and MeshSet::reset().

msq_stdc::size_t elemArraySize

private

Definition at line 181 of file includeLinks/MeshSet.hpp.

Referenced by MeshSet::get_next_elem_on_vert_patch().

Mesquite::EntityTopology elementType

private

The topological dimension of the elements in this MeshSet, where Mesquite::TRIANGLE indicates 2D elements (faces) and Mesquite::TETRAHEDRON indicates 3D elements (regions).

Must be the same for all meshes added with add_mesh().

Definition at line 168 of file includeLinks/MeshSet.hpp.

Mesquite::EntityTopology * elemTopologies

private

Definition at line 176 of file includeLinks/MeshSet.hpp.

Referenced by MeshSet::get_next_elem_on_vert_patch(), and MeshSet::~MeshSet().

Mesquite::MeshDomain * mDomain

private

Definition at line 184 of file includeLinks/MeshSet.hpp.

Referenced by MeshSet::get_domain_constraint(), MeshSet::get_next_elem_on_vert_patch(), MeshSet::get_next_global_patch(), MeshSet::get_next_patch(), and MeshSet::set_domain_constraint().