Rocstar: PatchData Class Reference

unsigned haveComputedInfos

Definition: includeLinks/PatchData.hpp:460

void clear_computed_info ( )

inline

This function clears the patch information such as maximum volume, etc ...

Definition at line 116 of file src/Mesh/PatchData.hpp.

References PatchData::haveComputedInfos.

116 { haveComputedInfos = 0; }

Mesquite::PatchData::domainSet

unsigned haveComputedInfos

Definition: includeLinks/PatchData.hpp:460

void clear_tag_data ( )

Definition at line 1485 of file Mesh/PatchData.cpp.

References PatchData::targetMatrices.

Referenced by PatchData::allocate_storage(), PatchData::initialize_data(), and PatchData::reorder().

 {
   targetMatrices.clear();
 }

Here is the caller graph for this function:

void clear_tag_data ( )

PatchDataVerticesMemento * create_vertices_memento	(	MsqError &	err,
		bool	include_higher_order = `false`
	)

inline

Creates a memento that holds the current state of the PatchData coordinates.

Definition at line 615 of file includeLinks/PatchData.hpp.

References PatchDataVerticesMemento::arraySize, PatchData::num_nodes(), PatchData::num_vertices(), PatchDataVerticesMemento::numVertices, PatchDataVerticesMemento::originator, PatchData::vertexArray, and PatchDataVerticesMemento::vertices.

Referenced by ConjugateGradient::initialize(), FeasibleNewton::initialize(), SteepestDescent::optimize_vertex_positions(), TerminationCriterion::reset_inner(), and TerminationCriterion::reset_patch().

   {
     size_t num_verts = include_higher_order ? num_nodes() : num_vertices();
     PatchDataVerticesMemento* memento = new PatchDataVerticesMemento;
     memento->originator = this;
     if (num_verts)
       memento->vertices = new MsqVertex[num_verts];
     memento->numVertices = num_verts;
     memento->arraySize = num_verts;
      
       // Copy the coordinates
     msq_stdc::memcpy(memento->vertices, &vertexArray[0], num_verts*sizeof(MsqVertex) );
     
     return memento;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

PatchDataVerticesMemento* create_vertices_memento	(	MsqError &	err,
		bool	include_higher_order = `false`
	)

Creates a memento that holds the current state of the PatchData coordinates.

bool domain_set ( )

inline

Returns whether a domain is associated with the MeshSet from which the Patch originates. If false, you cannot ask for a surface normal.

Definition at line 280 of file includeLinks/PatchData.hpp.

References PatchData::domainSet.

Referenced by GeneralizedConditionNumberQualityMetric::compute_condition_number(), MsqMeshEntity::compute_corner_normals(), and ShapeQualityMetric::condition_number_2d().

281 { return domainSet; }

bool domainSet

Definition: includeLinks/PatchData.hpp:444

Here is the caller graph for this function:

bool domain_set ( )

inline

Returns whether a domain is associated with the MeshSet from which the Patch originates. If false, you cannot ask for a surface normal.

Definition at line 280 of file src/Mesh/PatchData.hpp.

References PatchData::domainSet.

281 { return domainSet; }

Mesquite::PatchData::domainSet

bool domainSet

Definition: includeLinks/PatchData.hpp:444

MsqMeshEntity& element_by_index ( size_t index )

MsqMeshEntity & element_by_index ( size_t index )

inline

Definition at line 589 of file includeLinks/PatchData.hpp.

References PatchData::elementArray.

Referenced by NonSmoothSteepestDescent::compute_function(), MeanMidNodeMover::loop_over_mesh(), QualityAssessor::loop_over_mesh(), and CornerTagHandles::num_corners().

   {
     return elementArray[index];
   }

Here is the caller graph for this function:

void generate_vertex_to_element_data ( )

Create the arrays that store which elements are attached to each node. If you know how many total vertex uses there are, pass it in. Otherwise the PatchData will calculate that number.

Definition at line 944 of file Mesh/PatchData.cpp.

References PatchDataMem< X >::begin(), PatchData::elemConnectivityArray, PatchData::elementArray, PatchDataMem< X >::empty(), PatchDataMem< X >::end(), i, MSQ_FUNCTION_TIMER, PatchData::num_nodes(), PatchDataMem< X >::resize(), PatchDataMem< X >::size(), PatchData::vertAdjacencyArray, and PatchData::vertAdjacencyOffsets.

Referenced by PatchData::get_vertex_element_adjacencies(), and PatchData::reorder().

 {
   MSQ_FUNCTION_TIMER( "PatchData::generate_vertex_to_element_data" );
   
     // Skip if data already exists
   if (!vertAdjacencyArray.empty())
     return;
   
     // Allocate offset array
   vertAdjacencyOffsets.resize( num_nodes() + 1 );
   memset( &vertAdjacencyOffsets[0], 0, sizeof(size_t)*vertAdjacencyOffsets.size() );
   
     // Temporarily use offsets array to hold per-vertex element count
   PatchDataMem<MsqMeshEntity>::iterator elem_iter;
   const PatchDataMem<MsqMeshEntity>::iterator elem_end = elementArray.end();
   for (elem_iter = elementArray.begin(); elem_iter != elem_end; ++elem_iter)
   {
     size_t* conn_iter = elem_iter->get_vertex_index_array();
     const size_t* conn_end = conn_iter + elem_iter->node_count();
     for ( ; conn_iter != conn_end; ++conn_iter )
       ++vertAdjacencyOffsets[*conn_iter];
   }
   
     // Convert counts to end indices.
     // When done, vertAdjacencyOffsets will contain, for each vertex,
     // one more than the *last* index for that vertex's data in the
     // adjacency array.  This is *not* the final state for this data.
     // See comments for next loop.
   PatchDataMem<size_t>::iterator off_iter = vertAdjacencyOffsets.begin();
   const PatchDataMem<size_t>::iterator off_end = vertAdjacencyOffsets.end();
   size_t prev = *off_iter;
   ++off_iter;
   for ( ; off_iter != off_end; ++off_iter)
   {
     prev += *off_iter;
     *off_iter = prev;
   }
   
     // Allocate space for element numbers
   const size_t num_vert_uses = vertAdjacencyOffsets[num_nodes()-1];
   assert( num_vert_uses == elemConnectivityArray.size() );
   vertAdjacencyArray.resize( num_vert_uses );
   
     // Fill vertAdjacencyArray, using the indices in vertAdjacencyOffsets
     // as the location to insert the next element number in
     // vertAdjacencyArray.  When done, vertAdjacenyOffsets will contain
     // the start index for each vertex, rather than one past the last
     // index.
   for (size_t i = 0; i < elementArray.size(); ++i)
   {
     size_t* conn_iter = elementArray[i].get_vertex_index_array();
     const size_t* conn_end = conn_iter + elementArray[i].node_count();
     for ( ; conn_iter != conn_end; ++conn_iter )
     {
       const size_t array_index = --vertAdjacencyOffsets[*conn_iter];
       vertAdjacencyArray[array_index] = i;
     }
   }
   
     // Last entry should be number of vertex uses (one past the
     // last index of the last vertex.)
   vertAdjacencyOffsets[num_nodes()] = num_vert_uses;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void generate_vertex_to_element_data ( )

Create the arrays that store which elements are attached to each node. If you know how many total vertex uses there are, pass it in. Otherwise the PatchData will calculate that number.

void get_adjacent_entities_via_n_dim	(	int	n,
		size_t	ent_ind,
		msq_std::vector< size_t > &	adj_ents,
		MsqError &	err
	)

Get the indices of entities attached to entity (given by ent_ind). adj_ents is filled with the indices into the entity array of elements adjacent to the given element via an n-dimensional entity.

Referenced by ASMQualityMetric::evaluate_element().

Here is the caller graph for this function:

void get_adjacent_entities_via_n_dim	(	int	n,
		size_t	ent_ind,
		msq_std::vector< size_t > &	adj_ents,
		MsqError &	err
	)

Get the indices of entities attached to entity (given by ent_ind). adj_ents is filled with the indices into the entity array of elements adjacent to the given element via an n-dimensional entity.

void get_adjacent_vertex_indices	(	size_t	vertex_index,
		msq_std::vector< size_t > &	vert_indices,
		MsqError &	err
	)

Get the indices of vertices that are attached to vertex (given by vertex_index) by an element edge.

void get_adjacent_vertex_indices	(	size_t	vertex_index,
		msq_std::vector< size_t > &	vert_indices,
		MsqError &	err
	)

Get the indices of vertices that are attached to vertex (given by vertex_index) by an element edge.

Referenced by LPtoPTemplate::compute_analytical_gradient(), EdgeLengthQualityMetric::evaluate_vertex(), EdgeLengthRangeQualityMetric::evaluate_vertex(), SmartLaplacianSmoother::optimize_vertex_positions(), and LaplacianSmoother::optimize_vertex_positions().

Here is the caller graph for this function:

double get_average_Lambda_3d ( MsqError & err )

Returns average corner determinant over all corners in the patch This information is stored in the patch and should not decrease performance when used properly.

Definition at line 158 of file Mesh/PatchData.cpp.

References A, PatchData::AVERAGE_DET3D, TargetCalculator::compute_Lambda(), PatchData::computedInfos, PatchData::elementArray, PatchData::have_computed_info(), i, MSQ_ERRZERO, Mesquite::MSQ_MAX_NUM_VERT_PER_ENT, and PatchData::note_have_info().

Referenced by LVQDTargetCalculator::compute_target_matrices().

 {
   double avg;
   if (have_computed_info(AVERAGE_DET3D))
   {
     avg = computedInfos[AVERAGE_DET3D];
   }
   else 
   {
     avg =0.;
     int total_num_corners =0;
     Matrix3D A[MSQ_MAX_NUM_VERT_PER_ENT];
     for (size_t i=0; i<elementArray.size(); ++i) {
       int nve = elementArray[i].vertex_count();
       elementArray[i].compute_corner_matrices(*this, A, nve, err); 
       MSQ_ERRZERO(err);
       total_num_corners += nve;
       for (int c=0; c<nve; ++c) {
         avg += TargetCalculator::compute_Lambda(A[c], err); 
         MSQ_ERRZERO(err);
       }
     }
 
     avg = avg / total_num_corners;
     computedInfos[AVERAGE_DET3D] = avg;
     note_have_info(AVERAGE_DET3D);
   }
   return avg;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double get_average_Lambda_3d ( MsqError & err )

Returns average corner determinant over all corners in the patch This information is stored in the patch and should not decrease performance when used properly.

double get_barrier_delta ( MsqError & err )

Returns delta based on the minimum and maximum corner determinant over all elements in the patch This information is stored in the patch and should not decrease performance when used properly.

Definition at line 117 of file Mesh/PatchData.cpp.

References A, PatchData::computedInfos, Mesquite::det(), PatchData::elementArray, PatchData::have_computed_info(), i, MsqError::INVALID_MESH, j, max(), min(), PatchData::MINMAX_SIGNED_DET3D, Mesquite::MSQ_DBL_MAX, MSQ_ERRZERO, Mesquite::MSQ_MAX_NUM_VERT_PER_ENT, Mesquite::MSQ_MIN, MSQ_SETERR, PatchData::note_have_info(), and PatchData::num_elements().

Referenced by RI_DFT::compute_element_analytical_gradient(), I_DFT::compute_element_analytical_gradient(), RI_DFT::compute_element_analytical_hessian(), I_DFT::compute_element_analytical_hessian(), ShapeQualityMetric::condition_number_2d(), ShapeQualityMetric::condition_number_3d(), RI_DFT::evaluate_element(), I_DFT::evaluate_element(), and DistanceFromTarget::get_barrier_function().

 {
   double result;
   if (have_computed_info(MINMAX_SIGNED_DET3D))
   {
     result = computedInfos[MINMAX_SIGNED_DET3D];
   }
   else
   {
     double min= MSQ_DBL_MAX;
     double max=-MSQ_DBL_MAX;
     size_t count = num_elements();
     for (size_t i=0; i<count; ++i) {
       Matrix3D A[MSQ_MAX_NUM_VERT_PER_ENT];
       size_t nve = elementArray[i].vertex_count();
       elementArray[i].compute_corner_matrices(*this, A, nve, err);
       MSQ_ERRZERO(err);
       for (size_t j=0; j<nve; ++j) {
         min = det(A[j]) < min ? det(A[j]) : min;
         max = det(A[j]) > max ? det(A[j]) : max;
       }
     }
 
     if (max <= 0) {
       MSQ_SETERR(err)("Sigma_max is not positive.", MsqError::INVALID_MESH);
       return 0;
     }
       //We set delta to zero if everything in the initial mesh is valid.
       //  This causes metrics with a barrier between valid and inverted
       //  meshes to retain that barrier.  If there is a negative jacobian
       //  corner in the mesh, we set delta to a small fraction of the
       //  maximum jacobian in the mesh.
     result = (min<=MSQ_MIN) ? 0.001 * max : 0;
     computedInfos[MINMAX_SIGNED_DET3D] = result;
     note_have_info(MINMAX_SIGNED_DET3D);
   }
   
   return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double get_barrier_delta ( MsqError & err )

Returns delta based on the minimum and maximum corner determinant over all elements in the patch This information is stored in the patch and should not decrease performance when used properly.

size_t* get_connectivity_array ( )

inline

Definition at line 201 of file src/Mesh/PatchData.hpp.

References PatchData::elemConnectivityArray.

202 { return &elemConnectivityArray[0]; }

Mesquite::PatchData::elemConnectivityArray

PatchDataMem< size_t > elemConnectivityArray

Definition: includeLinks/PatchData.hpp:452

size_t* get_connectivity_array ( )

inline

Definition at line 201 of file includeLinks/PatchData.hpp.

References PatchData::elemConnectivityArray.

202 { return &elemConnectivityArray[0]; }

Mesquite::PatchData::elemConnectivityArray

PatchDataMem< size_t > elemConnectivityArray

Definition: includeLinks/PatchData.hpp:452

void get_domain_normal_at_element	(	size_t	elem_index,
		Vector3D &	surf_norm,
		MsqError &	err
	)		const

Get the normal to the domain at the centroid (projected to the domain) of a given element. Normal is returned in Vector3D &surf_norm. If the normal cannot be determined, or if the underlying domain is not a surface, the normal will be set to (0,0,0). Check PatchData::domain_set() is not false first.

Definition at line 1184 of file Mesh/PatchData.cpp.

References PatchData::elementArray, PatchData::elementHandlesArray, MeshSet::get_domain_constraint(), MsqError::INVALID_STATE, PatchData::meshSet, MSQ_ERRRTN, MSQ_SETERR, and MeshDomain::normal_at().

Referenced by IdealWeightInverseMeanRatio::compute_element_analytical_gradient(), IdealWeightMeanRatio::compute_element_analytical_gradient(), IdealWeightInverseMeanRatio::compute_element_analytical_hessian(), IdealWeightMeanRatio::compute_element_analytical_hessian(), MsqMeshEntity::compute_signed_area(), IdealWeightInverseMeanRatio::evaluate_element(), IdealWeightMeanRatio::evaluate_element(), PatchData::get_domain_normal_at_element(), and UntangleBetaQualityMetric::untangle_function_2d().

 {
   if (meshSet && meshSet->get_domain_constraint())
   {
     elementArray[elem_index].get_centroid(surf_norm, *this, err); 
     MSQ_ERRRTN(err);
     meshSet->get_domain_constraint()->normal_at(
       elementHandlesArray[elem_index],
       surf_norm);
   }
   else
     MSQ_SETERR(err)( "No domain constraint set.", MsqError::INVALID_STATE );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void get_domain_normal_at_element	(	size_t	elem_index,
		Vector3D &	surf_norm,
		MsqError &	err
	)		const

Get the normal to the domain at the centroid (projected to the domain) of a given element. Normal is returned in Vector3D &surf_norm. If the normal cannot be determined, or if the underlying domain is not a surface, the normal will be set to (0,0,0). Check PatchData::domain_set() is not false first.

void get_domain_normal_at_element	(	MsqMeshEntity *	elem_ptr,
		Vector3D &	surf_norm,
		MsqError &	err
	)		const

inline

Alternative signature. Same functionality.

Definition at line 321 of file includeLinks/PatchData.hpp.

References PatchData::elementArray, and PatchData::get_domain_normal_at_element().

323 { get_domain_normal_at_element(size_t(elem_ptr-&(elementArray[0])), surf_norm, err); }

Mesquite::PatchData::get_domain_normal_at_element

void get_domain_normal_at_element(size_t elem_index, Vector3D &surf_norm, MsqError &err) const

Definition: Mesh/PatchData.cpp:1184

Mesquite::PatchData::get_domain_normal_at_element

PatchDataMem< MsqMeshEntity > elementArray

Definition: includeLinks/PatchData.hpp:450

Here is the call graph for this function:

void get_domain_normal_at_element	(	MsqMeshEntity *	elem_ptr,
		Vector3D &	surf_norm,
		MsqError &	err
	)		const

inline

Alternative signature. Same functionality.

Definition at line 321 of file src/Mesh/PatchData.hpp.

References PatchData::elementArray, and PatchData::get_domain_normal_at_element().

323 { get_domain_normal_at_element(size_t(elem_ptr-&(elementArray[0])), surf_norm, err); }

void get_domain_normal_at_element(size_t elem_index, Vector3D &surf_norm, MsqError &err) const

Definition: Mesh/PatchData.cpp:1184

Referenced by MsqHessian::accumulate_entries(), VertexMover::check_feasible(), LPtoPTemplate::compute_analytical_gradient(), LPtoPTemplate::compute_analytical_hessian(), TargetCalculator::compute_default_target_matrices(), TargetCalculator::compute_guide_matrices(), TargetCalculator::compute_reference_corner_matrices(), WTargetCalculator::compute_target_matrices(), LVQDTargetCalculator::compute_target_matrices(), TargetCalculator::compute_target_matrices_and_check_det(), LInfTemplate::concrete_evaluate(), MaxTemplate::concrete_evaluate(), LPtoPTemplate::concrete_evaluate(), ASMQualityMetric::evaluate_element(), VertexConditionNumberQualityMetric::evaluate_vertex(), LocalSizeQualityMetric::evaluate_vertex(), MeshSet::get_next_elem_on_vert_patch(), MeshSet::get_next_global_patch(), MsqHessian::initialize(), NonSmoothSteepestDescent::optimize_vertex_positions(), and CornerTagHandles::save_load_tags().

PatchDataMem< MsqMeshEntity > elementArray

Definition: includeLinks/PatchData.hpp:450

Here is the call graph for this function:

void get_domain_normal_at_vertex	(	size_t	vertex_index,
		bool	normalize,
		Vector3D &	surf_norm,
		MsqError &	err
	)

Get the normal of the surface for a given vertex. Normal is returned in Vector3D &surf_norm. If the normal cannot be determined, or if the underlying domain is not a surface, the normal will be set to (0,0,0). Check PatchData::domain_set() is not false first.

Definition at line 1117 of file Mesh/PatchData.cpp.

References PatchData::domainHint, MeshSet::get_domain_constraint(), MsqError::INVALID_STATE, PatchData::meshSet, MSQ_ERRRTN, MSQ_SETERR, Mesquite::NO_DOMAIN_HINT, MeshDomain::normal_at(), Vector3D::normalize(), Mesquite::PLANAR_DOMAIN, PatchData::update_cached_normals(), PatchData::vertexArray, PatchData::vertexHandlesArray, and PatchData::vertexNormals.

Referenced by GeneralizedConditionNumberQualityMetric::compute_condition_number(), RI_DFT::compute_element_analytical_gradient(), RI_DFT::compute_element_analytical_hessian(), ShapeQualityMetric::condition_number_2d(), and RI_DFT::evaluate_element().

 {
   if (domainHint != NO_DOMAIN_HINT)
   {
     if (vertexNormals.empty())
     {
       update_cached_normals( err ); MSQ_ERRRTN(err);
     }
     
     if (domainHint == PLANAR_DOMAIN)
       vertex_index = 0;
     surf_norm = vertexNormals[vertex_index];
   }
   else
   {
     MeshDomain* domain = meshSet ? meshSet->get_domain_constraint() : 0;
     if (!domain)
     {
       MSQ_SETERR(err)( "No domain constraint set.", MsqError::INVALID_STATE );
       return;
     }
   
     surf_norm = vertexArray[vertex_index];
     domain->normal_at( vertexHandlesArray[vertex_index], surf_norm );
   }
 
   if (normalize)
     surf_norm.normalize();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void get_domain_normal_at_vertex	(	size_t	vertex_index,
		bool	normalize,
		Vector3D &	surf_norm,
		MsqError &	err
	)

Get the normal of the surface for a given vertex. Normal is returned in Vector3D &surf_norm. If the normal cannot be determined, or if the underlying domain is not a surface, the normal will be set to (0,0,0). Check PatchData::domain_set() is not false first.

void get_domain_normals_at_corners	(	size_t	element_index,
		Vector3D	normals_out[],
		MsqError &	err
	)

Get surface normal at a point where the surface is the domain of an element and the point is the location of one of the element corners.

Get surface normals at element corners. normals_out must be of sufficient size to hold the normals of all the corners.

Definition at line 1221 of file Mesh/PatchData.cpp.

References PatchData::domainHint, PatchData::elementArray, PatchData::elementHandlesArray, MeshSet::get_domain_constraint(), MsqMeshEntity::get_vertex_index_array(), i, MsqError::INVALID_STATE, PatchData::meshSet, MSQ_CHKERR, MSQ_ERRRTN, MSQ_SETERR, Mesquite::NO_DOMAIN_HINT, MeshDomain::normal_at(), Mesquite::PLANAR_DOMAIN, PatchData::update_cached_normals(), MsqMeshEntity::vertex_count(), PatchData::vertexArray, and PatchData::vertexNormals.

Referenced by MsqMeshEntity::compute_corner_normals().

 {
   const MsqMeshEntity& elem = elementArray[elem_index];
   const unsigned count = elem.vertex_count();
   const size_t* const vertex_indices = elem.get_vertex_index_array();
 
   if (domainHint != NO_DOMAIN_HINT)
   {
     if (vertexNormals.empty())
     {
       update_cached_normals( err ); MSQ_ERRRTN(err);
     }
     
     if (domainHint == PLANAR_DOMAIN)
     {
       for (unsigned i = 0; i < count; ++i)
         normals_out[i] = vertexNormals[0];
     }
     else
     {
       for (unsigned i = 0; i < count; ++i)
         normals_out[i] = vertexNormals[vertex_indices[i]];
     }
   }
   else
   {
     MeshDomain* domain = meshSet ? meshSet->get_domain_constraint() : 0;
     if (!domain)
     {
       MSQ_SETERR(err)( "No domain constraint set.", MsqError::INVALID_STATE );
       return;
     }
     
     for (unsigned i = 0; i < count; ++i)
       normals_out[i] = vertexArray[ vertex_indices[i] ];
     
     domain->normal_at( elementHandlesArray[elem_index], 
                        normals_out, count,
                        err ); MSQ_CHKERR(err);
   }
 }  

Here is the call graph for this function:

Here is the caller graph for this function:

void get_domain_normals_at_corners	(	size_t	element_index,
		Vector3D	normals_out[],
		MsqError &	err
	)

Get surface normal at a point where the surface is the domain of an element and the point is the location of one of the element corners.

Get surface normals at element corners. normals_out must be of sufficient size to hold the normals of all the corners.

const MsqMeshEntity * get_element_array ( MsqError & err ) const

inline

Returns a pointer to the start of the element array.

Returns the PatchData element array.

Definition at line 530 of file includeLinks/PatchData.hpp.

References PatchData::elementArray, MsqError::INVALID_STATE, and MSQ_SETERR.

   {
     if (elementArray.empty()) 
       MSQ_SETERR(err)( "No element array defined", MsqError::INVALID_STATE );
     return &elementArray[0];
   }

Here is the caller graph for this function:

const MsqMeshEntity* get_element_array ( MsqError & err ) const

Returns a pointer to the start of the element array.

MsqMeshEntity* get_element_array ( MsqError & err )

MsqMeshEntity * get_element_array ( MsqError & err )

inline

Definition at line 536 of file includeLinks/PatchData.hpp.

References PatchData::elementArray, MsqError::INVALID_STATE, and MSQ_SETERR.

   {
     if (elementArray.empty()) 
       MSQ_SETERR(err)( "No element array defined", MsqError::INVALID_STATE );
     return &elementArray[0];
   }

const Mesh::ElementHandle* get_element_handles_array ( ) const

inline

Definition at line 204 of file src/Mesh/PatchData.hpp.

References PatchData::elementHandlesArray.

205 { return &elementHandlesArray[0]; }

Mesquite::PatchData::elementHandlesArray

PatchDataMem< Mesh::ElementHandle > elementHandlesArray

Definition: includeLinks/PatchData.hpp:451

const Mesh::ElementHandle* get_element_handles_array ( ) const

inline

Definition at line 204 of file includeLinks/PatchData.hpp.

References PatchData::elementHandlesArray.

Referenced by CornerTagHandles::save_load_tags().

205 { return &elementHandlesArray[0]; }

Mesquite::PatchData::elementHandlesArray

PatchDataMem< Mesh::ElementHandle > elementHandlesArray

Definition: includeLinks/PatchData.hpp:451

Here is the caller graph for this function:

size_t get_element_index ( MsqMeshEntity * element )

inline

Definition at line 601 of file includeLinks/PatchData.hpp.

References PatchData::elementArray.

Referenced by MsqMeshEntity::compute_corner_normals(), RI_DFT::compute_element_analytical_gradient(), I_DFT::compute_element_analytical_gradient(), RI_DFT::compute_element_analytical_hessian(), I_DFT::compute_element_analytical_hessian(), MsqMeshEntity::compute_signed_area(), DistanceFromTarget::compute_T_matrices(), RI_DFT::evaluate_element(), ASMQualityMetric::evaluate_element(), UntangleBetaQualityMetric::evaluate_element(), AspectRatioGammaQualityMetric::evaluate_element(), and I_DFT::evaluate_element().

   {
     return element - &elementArray[0];
   }

Here is the caller graph for this function:

void get_element_vertex_coordinates	(	size_t	elem_index,
		msq_std::vector< Vector3D > &	coords,
		MsqError &	err
	)

Get the coordinates of vertices attached to the specified element.

void get_element_vertex_coordinates	(	size_t	elem_index,
		msq_std::vector< Vector3D > &	coords,
		MsqError &	err
	)

Get the coordinates of vertices attached to the specified element.

Referenced by AspectRatioGammaQualityMetric::evaluate_element().

Here is the caller graph for this function:

void get_element_vertex_indices	(	size_t	elem_index,
		msq_std::vector< size_t > &	vertex_indices,
		MsqError &	err
	)

Get the indices of vertices of specified element. !inefficient!

void get_element_vertex_indices	(	size_t	elem_index,
		msq_std::vector< size_t > &	vertex_indices,
		MsqError &	err
	)

Get the indices of vertices of specified element. !inefficient!

double get_max_vertex_movement_squared	(	PatchDataVerticesMemento *	memento,
		MsqError &	err
	)

Calculates the distance each vertex has moved from its original position as defined by the PatchDataVerticesMememnto.

Finds the maximum movement (in the distance norm) of the vertices in a patch. The previous vertex positions are givena as a PatchDataVerticesMemento (memento). The distance squared which each vertex has moved is then calculated, and the largest of those distances is returned. This function only considers the movement of vertices that are currently 'free'.

Parameters

memento a memento of this patch's vertex position at some (prior) time in the optimization.

Definition at line 679 of file Mesh/PatchData.cpp.

References Vector3D::length_squared(), MSQ_ERRZERO, MsqFreeVertexIndexIterator::next(), MsqFreeVertexIndexIterator::reset(), MsqFreeVertexIndexIterator::value(), PatchData::vertexArray, and PatchDataVerticesMemento::vertices.

Referenced by TerminationCriterion::accumulate_inner(), TerminationCriterion::accumulate_patch(), and TerminationCriterion::cull_vertices().

 {
   int m=0;
   Vector3D temp_vec;
   double temp_dist=0.0;
   double max_dist=0.0;
   MsqFreeVertexIndexIterator free_iter(this, err); MSQ_ERRZERO(err);
   free_iter.reset();
   while (free_iter.next())
   {
     m=free_iter.value();
     temp_vec=vertexArray[m] - memento->vertices[m];
     temp_dist=temp_vec.length_squared();
     if(temp_dist>max_dist)
     {
       max_dist=temp_dist;
     }
   }
   return max_dist;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double get_max_vertex_movement_squared	(	PatchDataVerticesMemento *	memento,
		MsqError &	err
	)

Calculates the distance each vertex has moved from its original position as defined by the PatchDataVerticesMememnto.

MeshSet* get_mesh_set ( )

inline

Returns the originating meshSet.

Definition at line 423 of file includeLinks/PatchData.hpp.

References PatchData::meshSet.

Referenced by CornerTagHandles::get_current_mesh().

424 { return meshSet; }

Mesquite::PatchData::meshSet

MeshSet * meshSet

Definition: includeLinks/PatchData.hpp:443

Here is the caller graph for this function:

MeshSet* get_mesh_set ( )

inline

Returns the originating meshSet.

Definition at line 423 of file src/Mesh/PatchData.hpp.

References PatchData::meshSet.

424 { return meshSet; }

Mesquite::PatchData::meshSet

MeshSet * meshSet

Definition: includeLinks/PatchData.hpp:443

void get_minmax_element_unsigned_area	(	double &	min,
		double &	max,
		MsqError &	err
	)

Returns the maximum volume or area out of all the elements in the patch This information is stored in the patch and should not decrease performance when used properly.

Definition at line 86 of file Mesh/PatchData.cpp.

References PatchData::computedInfos, PatchData::elementArray, PatchData::have_computed_info(), i, MsqError::INTERNAL_ERROR, max(), PatchData::MAX_UNSIGNED_AREA, min(), PatchData::MIN_UNSIGNED_AREA, Mesquite::MSQ_DBL_MAX, MSQ_ERRRTN, MSQ_SETERR, PatchData::note_have_info(), and PatchData::num_elements().

 {
   if (!have_computed_info(MAX_UNSIGNED_AREA) ||
       !have_computed_info(MIN_UNSIGNED_AREA))
   {
     max=0;
     min=MSQ_DBL_MAX;
     size_t count = num_elements();
     for (size_t i=0; i<count; ++i) {
       double vol;
       vol = elementArray[i].compute_unsigned_area(*this, err); MSQ_ERRRTN(err);
       if (vol > max)
         max = vol;
       if (vol < min)
         min = vol;
     }
     note_have_info(MAX_UNSIGNED_AREA);
     note_have_info(MIN_UNSIGNED_AREA);
     computedInfos[MAX_UNSIGNED_AREA] = max;
     computedInfos[MIN_UNSIGNED_AREA] = min;
   }
   else
   {
     max = computedInfos[MAX_UNSIGNED_AREA];
     min = computedInfos[MIN_UNSIGNED_AREA];
   }
     
   if (max <= 0 || min < 0 || min == MSQ_DBL_MAX)
     MSQ_SETERR(err)(MsqError::INTERNAL_ERROR);
 }

Here is the call graph for this function:

void get_minmax_element_unsigned_area	(	double &	min,
		double &	max,
		MsqError &	err
	)

Returns the maximum volume or area out of all the elements in the patch This information is stored in the patch and should not decrease performance when used properly.

void get_subpatch	(	size_t	center_vertex_index,
		PatchData &	pd_to_fill,
		MsqError &	err
	)

Fills a PatchData with the elements attached to a center vertex.

Note that all entities in the sub-patch are copies of the entities in 'this' patch. As such, moving a vertex in the sub-patch won't move the corresponding vertex in the source patch. Also, calling 'update_mesh()' on the sub-patch WILL modify the TSTT mesh, but the source patch won't see the changes.

Definition at line 1008 of file Mesh/PatchData.cpp.

References PatchData::elemConnectivityArray, PatchData::elementArray, PatchData::elementHandlesArray, MsqMeshEntity::get_element_type(), PatchData::get_vertex_element_adjacencies(), MsqMeshEntity::get_vertex_index(), PatchData::initialize_data(), MsqError::INVALID_ARG, MSQ_ERRRTN, MSQ_SETERR, MsqMeshEntity::node_count(), PatchData::num_vertices(), PatchDataMem< X >::resize(), PatchData::vertexArray, and PatchData::vertexHandlesArray.

Referenced by ObjectiveFunction::compute_numerical_gradient().

 {
     // Make sure we're in range
   if (center_vertex_index >= num_vertices())
   {
     MSQ_SETERR(err)("Invalid index for center vertex",MsqError::INVALID_ARG);
     return;
   }
 
     // Map vertex indices from this patch data to indices in new patch data
   msq_std::map<size_t, size_t> vertex_index_map;
   
   size_t num_elems;
   const size_t* vertex_adjacencies;
   vertex_adjacencies = get_vertex_element_adjacencies( center_vertex_index,
                                                        num_elems, err );
   MSQ_ERRRTN(err);
   
     // Loop through each element, populating vertex_index_map.
   size_t which_elem, which_vert, vertex_count = 0;
   size_t vertex_uses = 0;
   for (which_elem = 0; which_elem < num_elems; ++which_elem )
   {
     size_t elem_index = vertex_adjacencies[which_elem];
     MsqMeshEntity& elem = elementArray[elem_index];
     for (which_vert = elem.node_count(); which_vert--; )
     {
       size_t vert_index = elem.get_vertex_index(which_vert);
       if (vertex_index_map.find(vert_index) != vertex_index_map.end())
         vertex_index_map[vert_index] = vertex_count++;
     }
     vertex_uses += elem.node_count();
   }
   
     // Allocate storage in subpatch
   subpatch.vertexHandlesArray.resize( vertex_count );
   subpatch.elementArray.resize( num_elems );
   subpatch.elementHandlesArray.resize( num_elems );
   subpatch.elemConnectivityArray.resize( vertex_uses );
   
     // For now, put reverse of index map into handles array (such that
     // the handles array in the subpatch contains the index in this
     // patch for each vertex.)  When PatchData::initalize_data re-orders 
     // the vertices, we can then use this array to determine which vertices
     // where placed where.
   msq_std::map<size_t,size_t>::iterator iter;
   for (iter = vertex_index_map.begin(); iter != vertex_index_map.end(); ++iter)
     subpatch.vertexHandlesArray[iter->second] = (Mesh::VertexHandle)(iter->first);
   
     // Store elements with updated connectivity list in subpatch
   msq_std::vector<size_t> elem_conn_offsets(vertex_uses);
   size_t* elem_connectivity = &(subpatch.elemConnectivityArray[0]);
   size_t elem_conn_index = 0;
   for (which_elem = 0; which_elem < num_elems; ++which_elem)
   {
     size_t elem_index = vertex_adjacencies[which_elem];
     MsqMeshEntity& elem = elementArray[elem_index];
     elem_conn_offsets[which_elem] = elem_conn_index;
     for (which_vert = 0; which_vert < elem.node_count(); which_vert++ )
     {
       size_t vert_index = elem.get_vertex_index(which_vert);
       
         // Add this vertex to the new element's array
       elem_connectivity[elem_conn_index++] = vertex_index_map[vert_index];
     }
     subpatch.elementArray[which_elem].set_element_type( elem.get_element_type() );
   }
   
     // Re-order vertices and initialize other data in subpatch
   subpatch.initialize_data( &elem_conn_offsets[0], err ); MSQ_ERRRTN(err);
   
     // Copy vertex data into subpatch.  subpatch.vertexHandlesArray contains
     // the indices into this PatchData for each vertex
   subpatch.vertexArray.resize( vertex_count );
   for (which_vert = 0; which_vert < vertex_count; ++which_vert)
   {
     size_t vert_index = (size_t)(subpatch.vertexHandlesArray[which_vert]);
     subpatch.vertexHandlesArray[which_vert] = vertexHandlesArray[vert_index];
     subpatch.vertexArray[which_vert] = vertexArray[vert_index];
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void get_subpatch	(	size_t	center_vertex_index,
		PatchData &	pd_to_fill,
		MsqError &	err
	)

Fills a PatchData with the elements attached to a center vertex.

Note that all entities in the sub-patch are copies of the entities in 'this' patch. As such, moving a vertex in the sub-patch won't move the corresponding vertex in the source patch. Also, calling 'update_mesh()' on the sub-patch WILL modify the TSTT mesh, but the source patch won't see the changes.

const MsqVertex * get_vertex_array ( MsqError & err ) const

inline

Returns a pointer to the start of the vertex array.

Returns an array of all vertices in the PatchData.

Definition at line 513 of file includeLinks/PatchData.hpp.

References MsqError::INVALID_STATE, MSQ_SETERR, and PatchData::vertexArray.

   {
     if (vertexArray.empty()) 
       MSQ_SETERR(err)( "No vertex array defined", MsqError::INVALID_STATE );
     return &vertexArray[0];
   }

Here is the caller graph for this function:

const MsqVertex* get_vertex_array ( MsqError & err ) const

Returns a pointer to the start of the vertex array.

MsqVertex* get_vertex_array ( MsqError & err )

MsqVertex * get_vertex_array ( MsqError & err )

inline

Definition at line 519 of file includeLinks/PatchData.hpp.

References MsqError::INVALID_STATE, MSQ_SETERR, and PatchData::vertexArray.

   {
     if (vertexArray.empty()) 
       MSQ_SETERR(err)( "No vertex array defined", MsqError::INVALID_STATE );
     return &vertexArray[0];
   }

size_t* get_vertex_element_adjacencies	(	size_t	vertex_index,
		size_t &	array_len_out,
		MsqError &	err
	)

Get indices of elements attached to specified vertex

size_t * get_vertex_element_adjacencies	(	size_t	vertex_index,
		size_t &	array_len_out,
		MsqError &	err
	)

Get indices of elements attached to specified vertex

Definition at line 778 of file Mesh/PatchData.cpp.

References PatchDataMem< X >::empty(), PatchData::generate_vertex_to_element_data(), PatchData::vertAdjacencyArray, and PatchData::vertAdjacencyOffsets.

Referenced by VertexConditionNumberQualityMetric::evaluate_vertex(), LocalSizeQualityMetric::evaluate_vertex(), PatchData::get_subpatch(), and MeanMidNodeMover::loop_over_mesh().

 {
     // Make sure we've got the data
   if (vertAdjacencyArray.empty())
   {
     generate_vertex_to_element_data();
   }
   
   const size_t begin = vertAdjacencyOffsets[vertex_index];
   const size_t end = vertAdjacencyOffsets[vertex_index+1];
   array_len_out = end - begin;
   return &vertAdjacencyArray[begin];
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void get_vertex_element_indices	(	size_t	vertex_index,
		msq_std::vector< size_t > &	elem_indices,
		MsqError &	err
	)

Get the indices of the elements attached to the specified vertex.

void get_vertex_element_indices	(	size_t	vertex_index,
		msq_std::vector< size_t > &	elem_indices,
		MsqError &	err
	)

Get the indices of the elements attached to the specified vertex.

size_t get_vertex_index ( MsqVertex * vertex )

inline

gets the index of a vertex in the PatchData vertex array, given a pointer to the vertex.

Definition at line 596 of file includeLinks/PatchData.hpp.

References PatchData::vertexArray.

Referenced by LPtoPTemplate::compute_analytical_gradient(), QualityMetric::compute_element_gradient_expanded(), QualityMetric::compute_element_hessian(), QualityMetric::compute_element_numerical_hessian(), VertexConditionNumberQualityMetric::evaluate_vertex(), EdgeLengthQualityMetric::evaluate_vertex(), LocalSizeQualityMetric::evaluate_vertex(), EdgeLengthRangeQualityMetric::evaluate_vertex(), and Randomize::randomize_vertex().

   {
     return vertex - &vertexArray[0];
   }

Here is the caller graph for this function:

bool have_computed_info ( ComputedInfo info ) const

inline

Definition at line 118 of file includeLinks/PatchData.hpp.

References PatchData::haveComputedInfos, and cimg_library::cimg::info().

Referenced by PatchData::get_average_Lambda_3d(), PatchData::get_barrier_delta(), PatchData::get_minmax_element_unsigned_area(), and Mesquite::operator<<().

119 { return 0 != (haveComputedInfos&(1<<info)); }

unsigned haveComputedInfos

Definition: includeLinks/PatchData.hpp:460

void info()

Print informations about CImg environement variables.

Definition: CImg.h:5702

Here is the call graph for this function:

Here is the caller graph for this function:

bool have_computed_info ( ComputedInfo info ) const

inline

Definition at line 118 of file src/Mesh/PatchData.hpp.

References PatchData::haveComputedInfos, and cimg_library::cimg::info().

119 { return 0 != (haveComputedInfos&(1<<info)); }

unsigned haveComputedInfos

Definition: includeLinks/PatchData.hpp:460

void info()

Print informations about CImg environement variables.

Definition: CImg.h:5702

Here is the call graph for this function:

void initialize_data	(	size_t *	elem_offset_array,
		MsqError &	err
	)

Call after filling vertex handle and connectivity arrays to finish initializing the PatchData.

Reorders vertex handles array such that all higher-order nodes are at end of array, updates element connectivity array appropriately, initalizes numCornerVertices, and per-element vertex and node counts.

NOTE: If the patch contains higher-order elements, this function will re-order the nodes in the vertex array. Do NOT assume vertex indices are the same after calling this function!

NOTE: This function expects the following data to be initalized: vertexHandlesArray elemConnectivityArray the topology type for all elements in elementArray The function assumes the following data has not been initialized and therefore does not need to be updated: vertexArray

Parameters

elem_offset_array Offset into connectivity array for each element

void initialize_data	(	size_t *	elem_offset_array,
		MsqError &	err
	)

Call after filling vertex handle and connectivity arrays to finish initializing the PatchData.

Reorders vertex handles array such that all higher-order nodes are at end of array, updates element connectivity array appropriately, initalizes numCornerVertices, and per-element vertex and node counts.

NOTE: If the patch contains higher-order elements, this function will re-order the nodes in the vertex array. Do NOT assume vertex indices are the same after calling this function!

NOTE: This function expects the following data to be initalized: vertexHandlesArray elemConnectivityArray the topology type for all elements in elementArray The function assumes the following data has not been initialized and therefore does not need to be updated: vertexArray

Parameters

elem_offset_array Offset into connectivity array for each element

Definition at line 1354 of file Mesh/PatchData.cpp.

References PatchDataMem< X >::clear(), PatchData::clear_tag_data(), PatchData::domainHint, PatchData::elemConnectivityArray, PatchData::elementArray, MsqMeshEntity::get_vertex_index_array(), i, MsqError::INVALID_STATE, j, MSQ_SETERR, MsqMeshEntity::node_count(), PatchData::num_nodes(), PatchData::num_vertices(), PatchData::numCornerVertices, Mesquite::PLANAR_DOMAIN, PatchDataMem< X >::resize(), PatchDataMem< X >::size(), swap(), PatchData::vertAdjacencyArray, PatchData::vertAdjacencyOffsets, MsqMeshEntity::vertex_count(), PatchData::vertexHandlesArray, and PatchData::vertexNormals.

Referenced by MeshSet::get_next_elem_on_vert_patch(), MeshSet::get_next_global_patch(), and PatchData::get_subpatch().

 {
   if (numCornerVertices)
   {
     MSQ_SETERR(err)(MsqError::INVALID_STATE);
     return;
   }
   
     // Clear out data specific to patch
   clear_tag_data();
   if (domainHint != PLANAR_DOMAIN)
     vertexNormals.clear();
   
     // Clear any vertex->element adjacency data.  It
     // is probably invalid, and certainly will be by the time
     // this function completes if the mesh contains higher-order
     // elements.
   vertAdjacencyArray.clear();
   vertAdjacencyOffsets.clear();
   
     // Initialize connectivity data in each element
   size_t i, j;
   bool higher_order = false;
   for (i = 0; i < elementArray.size(); ++i)
   {
     size_t start = elem_offset_array[i];
     size_t conn_len = elem_offset_array[i+1] - start;
     assert(conn_len > 0);
     elementArray[i].set_connectivity( &elemConnectivityArray[start], conn_len );
     if (conn_len != elementArray[i].vertex_count())
       higher_order = true;
   }
   
     // If no higher-order elements, then we're done
   if (!higher_order)
   {
       // All nodes are corner vertices
     numCornerVertices = vertexHandlesArray.size();
     return;
   }
   
     // Need to move higher-order nodes to end of list.
   
     // Use vertAdjacencyOffsets array as temporary storage.
   vertAdjacencyOffsets.resize( vertexHandlesArray.size() + 1 );
   size_t* vertex_index_map = &vertAdjacencyOffsets[0];
   
     // Note which are mid-nodes (1) and which are corner vertices (0)
   for (i = 0; i < elementArray.size(); ++i)
   {
     MsqMeshEntity& elem = elementArray[i];
     size_t* conn_array = elem.get_vertex_index_array();
     size_t num_vertices = elem.vertex_count();
     size_t num_nodes = elem.node_count();
     for (j = 0; j < num_vertices; ++j)
       vertex_index_map[ conn_array[j] ] = 0;
     for ( ; j < num_nodes; ++j)
       vertex_index_map[ conn_array[j] ] = 1;
   }
   
     // Shuffle nodes around such that all higher-order nodes
     // are at the end of the array.
     // Store new index for each node in index_map, replacing
     // flag value currently there for each node.
   i = 0;
   j = vertexHandlesArray.size() - 1;
   while (i < j)
   {
     if (!vertex_index_map[i])
     {
       // Is a corner vertex in first part of array, skip it.
       vertex_index_map[i] = i;
       ++i;
     }
     else if (vertex_index_map[j])
     {
       // Is a mid-node in latter part of array, skip it
       vertex_index_map[j] = j;
       --j;
     }
     else
     {
       // Swap mid-node from first part of array with 
       // corner vertex from latter part of array.
       msq_std::swap( vertexHandlesArray[i], vertexHandlesArray[j] );
       
       vertex_index_map[i] = j;
       vertex_index_map[j] = i;
       ++i;
       --j;
     }
   }
   
     // Finish up - set numCornerVertices to indicate 
     // where corner vertices end and mid-nodes begin in
     // vertexArray, and get the handle remaining vertex
     // if missed in the above loop.
   if (i > j)
   {
     numCornerVertices = i;
   }
   else // (i == j)
   {
     if (vertex_index_map[i])
       numCornerVertices = i;
     else
       numCornerVertices = i+1;
     vertex_index_map[i] = i;
   }
   
     // Update element connectivity data for new vertex indices
   for (i = 0; i < elemConnectivityArray.size(); ++i)
     elemConnectivityArray[i] = vertex_index_map[elemConnectivityArray[i]];
     
   vertAdjacencyOffsets.clear();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void move_free_vertices_constrained	(	Vector3D	dk[],
		size_t	nb_vtx,
		double	step_size,
		MsqError &	err
	)

Moves free vertices and then snaps the free vertices to the domain.

void move_free_vertices_constrained	(	Vector3D	dk[],
		size_t	nb_vtx,
		double	step_size,
		MsqError &	err
	)

Moves free vertices and then snaps the free vertices to the domain.

Definition at line 580 of file Mesh/PatchData.cpp.

References MsqError::INVALID_ARG, MSQ_DBG, MSQ_DBGOUT, MSQ_ERRRTN, MSQ_SETERR, MsqFreeVertexIndexIterator::next(), PatchData::num_vertices(), MsqFreeVertexIndexIterator::reset(), PatchData::snap_vertex_to_domain(), MsqFreeVertexIndexIterator::value(), and PatchData::vertexArray.

Referenced by SteepestDescent::optimize_vertex_positions(), and FeasibleNewton::optimize_vertex_positions().

 {
   if (nb_vtx != num_vertices())
   {
     MSQ_SETERR(err)("The directional vector must be of length numVertices.",
                     MsqError::INVALID_ARG);
     return;
   }
   
   MsqFreeVertexIndexIterator free_iter(this, err);
   free_iter.reset();
   while (free_iter.next())
   {
     vertexArray[free_iter.value()] += (step_size * dk[free_iter.value()]);
     snap_vertex_to_domain(free_iter.value(), err);
     MSQ_ERRRTN(err);
   }
   
     // Checks that moving direction is zero for fixed vertices.
   if (MSQ_DBG(3)) {
   for (size_t m=0; m<num_vertices(); ++m) {
     Vector3D zero_3d(0.,0.,0.);
     if (!vertexArray[m].is_free_vertex() 
      && dk[m] != zero_3d 
      && dk[m] != -zero_3d ) 
     {
       MSQ_DBGOUT(3) << "dk["<<m<<"]: " << dk[m] << endl;
       MSQ_DBGOUT(3) << "moving a fixed vertex." << endl;
     }
   }     
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void note_have_info ( ComputedInfo info )

inlineprivate

Definition at line 436 of file src/Mesh/PatchData.hpp.

References PatchData::haveComputedInfos, and cimg_library::cimg::info().

437 { haveComputedInfos |= (1<<info); }

unsigned haveComputedInfos

Definition: includeLinks/PatchData.hpp:460

void info()

Print informations about CImg environement variables.

Definition: CImg.h:5702

Here is the call graph for this function:

void note_have_info ( ComputedInfo info )

inlineprivate

Definition at line 436 of file includeLinks/PatchData.hpp.

References PatchData::haveComputedInfos, and cimg_library::cimg::info().

Referenced by PatchData::get_average_Lambda_3d(), PatchData::get_barrier_delta(), and PatchData::get_minmax_element_unsigned_area().

437 { haveComputedInfos |= (1<<info); }

unsigned haveComputedInfos

Definition: includeLinks/PatchData.hpp:460

void info()

Print informations about CImg environement variables.

Definition: CImg.h:5702

Here is the call graph for this function:

Here is the caller graph for this function:

size_t num_corners ( )

number of elements corners in the Patch.

size_t num_corners ( )

number of elements corners in the Patch.

Definition at line 1491 of file Mesh/PatchData.cpp.

References PatchData::elementArray, and i.

 {
   size_t result = 0;
   for (unsigned i = 0; i < elementArray.size(); ++i)
     result += elementArray[i].vertex_count();
   return result;
 }

size_t num_elements ( ) const

inline

number of elements in the Patch.

Definition at line 179 of file src/Mesh/PatchData.hpp.

References PatchData::elementArray.

180 { return elementArray.size(); }

Referenced by VertexMover::check_feasible(), LPtoPTemplate::compute_analytical_gradient(), LPtoPTemplate::compute_analytical_hessian(), TargetCalculator::compute_default_target_matrices(), TargetCalculator::compute_reference_corner_matrices(), WTargetCalculator::compute_target_matrices(), LVQDTargetCalculator::compute_target_matrices(), TargetCalculator::compute_target_matrices_and_check_det(), LInfTemplate::concrete_evaluate(), MaxTemplate::concrete_evaluate(), LPtoPTemplate::concrete_evaluate(), PatchData::get_barrier_delta(), PatchData::get_minmax_element_unsigned_area(), MsqHessian::initialize(), QualityAssessor::loop_over_mesh(), Mesquite::operator<<(), NonSmoothSteepestDescent::optimize_vertex_positions(), PatchData::reorder(), MeshSet::write_gnuplot(), and MeshSet::write_vtk().

PatchDataMem< MsqMeshEntity > elementArray

Definition: includeLinks/PatchData.hpp:450

size_t num_elements ( ) const

inline

number of elements in the Patch.

Definition at line 179 of file includeLinks/PatchData.hpp.

References PatchData::elementArray.

180 { return elementArray.size(); }