Rocstar: MsqMeshEntity Class Reference

EntityTopology mType

Definition: includeLinks/MsqMeshEntity.hpp:167

size_t numVertexIndices

Definition: includeLinks/MsqMeshEntity.hpp:174

size_t * vertexIndices

Pointer to connectivity array.

Definition: includeLinks/MsqMeshEntity.hpp:173

Mesquite::MIXED

Definition: Mesquite.hpp:103

MsqMeshEntity ( )

inline

Definition at line 73 of file src/Mesh/MsqMeshEntity.hpp.

74 : mType(MIXED), vertexIndices(0), numVertexIndices(0)

75 {}

EntityTopology mType

Definition: includeLinks/MsqMeshEntity.hpp:167

size_t numVertexIndices

Definition: includeLinks/MsqMeshEntity.hpp:174

size_t * vertexIndices

Pointer to connectivity array.

Definition: includeLinks/MsqMeshEntity.hpp:173

Mesquite::MIXED

Definition: Mesquite.hpp:103

Member Function Documentation

void append_node_indices ( msq_std::vector< msq_stdc::size_t > & vertex_list ) const

void append_vertex_indices ( msq_std::vector< msq_stdc::size_t > & vertex_list ) const

void compute_corner_matrices	(	PatchData &	pd,
		Matrix3D	A[],
		int	num_m3d,
		MsqError &	err
	)

Compute matrices which column are the vectors issued from a corner.

Stores those corner matrices in the mTag data member.

Parameters

pd	The PatchData the element belongs to. It contains the vertices coords.
c_m3d	An array of Matrix3D objects. There should be one matrix per element corner (4 for a tet, 8 for an hex). Each column of the matrix will contain a vector corresponding to a corner edge.
num_m3d	The number of matrices in the c_m3d array. The function will check this number corresponds to the number of corner in the element. If not, an error is set.

Definition at line 731 of file Mesh/MsqMeshEntity.cpp.

References MsqMeshEntity::compute_corner_normals(), MsqMeshEntity::get_element_type(), PatchData::get_vertex_array(), Mesquite::HEXAHEDRON, MsqError::INVALID_ARG, Mesquite::MSQ_3RT_2_OVER_6RT_3, MSQ_ERRRTN, MSQ_SETERR, MsqError::NOT_IMPLEMENTED, Mesquite::QUADRILATERAL, Matrix3D::set_column(), Mesquite::TETRAHEDRON, Mesquite::TRIANGLE, and MsqMeshEntity::vertexIndices.

Referenced by TargetCalculator::compute_guide_matrices(), TargetCalculator::compute_reference_corner_matrices(), and DistanceFromTarget::compute_T_matrices().

 {
   MsqVertex* vertices = pd.get_vertex_array(err); MSQ_ERRRTN(err); 
   const size_t* v_i = &vertexIndices[0];
 
   // If 2D element, we will get the surface normal 
   Vector3D normals[4], vec1, vec2, vec3, vec4;
 
   
   switch(get_element_type()){
     
   case TRIANGLE:
     if (num_m3d != 3) {
       MSQ_SETERR(err)("num_m3d incompatible with element type.", MsqError::INVALID_ARG); 
       return;
     }
     
     compute_corner_normals( normals, pd, err ); MSQ_ERRRTN(err);
 
     vec1 = vertices[v_i[1]]-vertices[v_i[0]];
     vec2 = vertices[v_i[2]]-vertices[v_i[0]];
     vec3 = vertices[v_i[2]]-vertices[v_i[1]];
     
     A[0].set_column(0, vec1);
     A[0].set_column(1, vec2);
     A[0].set_column(2, normals[0]*MSQ_3RT_2_OVER_6RT_3);
     
     A[1].set_column(0, vec3);
     A[1].set_column(1, -vec1);
     A[1].set_column(2, normals[1]*MSQ_3RT_2_OVER_6RT_3);
 
     A[2].set_column(0, -vec2);
     A[2].set_column(1, -vec3);
     A[2].set_column(2, normals[2]*MSQ_3RT_2_OVER_6RT_3);
 
     break;
     
   case QUADRILATERAL:
     if (num_m3d != 4)  {
       MSQ_SETERR(err)("num_m3d incompatible with element type.", MsqError::INVALID_ARG); 
       return;
     }
     vec1 = vertices[v_i[1]]-vertices[v_i[0]];
     vec2 = vertices[v_i[3]]-vertices[v_i[0]];
     vec3 = vertices[v_i[2]]-vertices[v_i[1]];
     vec4 = vertices[v_i[3]]-vertices[v_i[2]];
     
     compute_corner_normals( normals, pd, err ); MSQ_ERRRTN(err);
 
     A[0].set_column(0, vec1);
     A[0].set_column(1, vec2);
     A[0].set_column(2, normals[0]);
     
     A[1].set_column(0, vec3);
     A[1].set_column(1, -vec1);
     A[1].set_column(2, normals[1]);
 
     A[2].set_column(0, vec4);
     A[2].set_column(1, -vec3);
     A[2].set_column(2, normals[2]);
 
     A[3].set_column(0, -vec2);
     A[3].set_column(1, -vec4);
     A[3].set_column(2, normals[3]);
 
     break;
     
   case TETRAHEDRON:
     if (num_m3d != 4) {
       MSQ_SETERR(err)("num_m3d incompatible with element type.", MsqError::INVALID_ARG); 
       return;
     }
     A[0].set_column(0, vertices[v_i[1]]-vertices[v_i[0]]);
     A[0].set_column(1, vertices[v_i[2]]-vertices[v_i[0]]);
     A[0].set_column(2, vertices[v_i[3]]-vertices[v_i[0]]);
     
     A[1].set_column(0, vertices[v_i[0]]-vertices[v_i[1]]);
     A[1].set_column(1, vertices[v_i[3]]-vertices[v_i[1]]);
     A[1].set_column(2, vertices[v_i[2]]-vertices[v_i[1]]);
 
     A[2].set_column(0, vertices[v_i[3]]-vertices[v_i[2]]);
     A[2].set_column(1, vertices[v_i[0]]-vertices[v_i[2]]);
     A[2].set_column(2, vertices[v_i[1]]-vertices[v_i[2]]);
 
     A[3].set_column(0, vertices[v_i[2]]-vertices[v_i[3]]);
     A[3].set_column(1, vertices[v_i[1]]-vertices[v_i[3]]);
     A[3].set_column(2, vertices[v_i[0]]-vertices[v_i[3]]);
 
     break;
     
   /*
    case PYRAMID:
       //We compute the pyramid's "condition number" by averaging
       //the 4 tet's condition numbers, where the tets are created
       //by removing one of the four base vertices from the pyramid.
       //transform to origina v_i[0]
       temp_vec[3]=vertices[v_i[1]]-vertices[v_i[0]];
       temp_vec[4]=vertices[v_i[3]]-vertices[v_i[0]];
       temp_vec[5]=vertices[v_i[4]]-vertices[v_i[0]];
       //find AW_inverse
       temp_vec[0]=temp_vec[3];
       temp_vec[1]=temp_vec[4]-temp_vec[3];
       temp_vec[2]=MSQ_SQRT_TWO*(temp_vec[5]-(temp_vec[4]/2.0));
       return_flag=condition_number_3d(temp_vec,pd,met_vals[0],err);
       if(!return_flag)
       return return_flag;
       //transform to origina v_i[1]
       temp_vec[3]=vertices[v_i[2]]-vertices[v_i[1]];
       temp_vec[4]=vertices[v_i[3]]-vertices[v_i[1]];
       temp_vec[5]=vertices[v_i[4]]-vertices[v_i[1]];
       //find AW_inverse
       temp_vec[0]=temp_vec[3]-temp_vec[4];
       temp_vec[1]=temp_vec[3];
       temp_vec[2]=MSQ_SQRT_TWO*(temp_vec[5]-(temp_vec[4]/2.0));
       return_flag=condition_number_3d(temp_vec,pd,met_vals[1],err);
       if(!return_flag)
       return return_flag;
       //transform to origina v_i[1]     
       temp_vec[3]=vertices[v_i[3]]-vertices[v_i[2]];
       temp_vec[4]=vertices[v_i[0]]-vertices[v_i[2]];
       temp_vec[5]=vertices[v_i[4]]-vertices[v_i[2]];
       //find AW_inverse
       temp_vec[0]=-temp_vec[3];
       temp_vec[1]=temp_vec[3]-temp_vec[4];
       temp_vec[2]=MSQ_SQRT_TWO*(temp_vec[5]-(temp_vec[4]/2.0));
       return_flag=condition_number_3d(temp_vec,pd,met_vals[2],err);
       if(!return_flag)
       return return_flag;
       //transform to origina v_i[1]     
       temp_vec[3]=vertices[v_i[0]]-vertices[v_i[3]];
       temp_vec[4]=vertices[v_i[1]]-vertices[v_i[3]];
       temp_vec[5]=vertices[v_i[4]]-vertices[v_i[3]];
       //find AW_inverse
       temp_vec[0]=temp_vec[4]-temp_vec[3];
       temp_vec[1]=-temp_vec[3];
       temp_vec[2]=MSQ_SQRT_TWO*(temp_vec[5]-(temp_vec[4]/2.0));
       return_flag=condition_number_3d(temp_vec,pd,met_vals[3],err);
       fval=average_metrics(met_vals, 4, err);
       if(!return_flag)
       return return_flag;
       break;
     */
     
   case HEXAHEDRON:
     if (num_m3d != 8) {
       MSQ_SETERR(err)("num_m3d incompatible with element type.", MsqError::INVALID_ARG); 
       return;
     }
     A[0].set_column(0, vertices[v_i[1]]-vertices[v_i[0]]);
     A[0].set_column(1, vertices[v_i[3]]-vertices[v_i[0]]);
     A[0].set_column(2, vertices[v_i[4]]-vertices[v_i[0]]);
 
     A[1].set_column(0, vertices[v_i[2]]-vertices[v_i[1]]);
     A[1].set_column(1, vertices[v_i[0]]-vertices[v_i[1]]);
     A[1].set_column(2, vertices[v_i[5]]-vertices[v_i[1]]);
 
     A[2].set_column(0, vertices[v_i[3]]-vertices[v_i[2]]);
     A[2].set_column(1, vertices[v_i[1]]-vertices[v_i[2]]);
     A[2].set_column(2, vertices[v_i[6]]-vertices[v_i[2]]);
     
     A[3].set_column(0, vertices[v_i[0]]-vertices[v_i[3]]);
     A[3].set_column(1, vertices[v_i[2]]-vertices[v_i[3]]);
     A[3].set_column(2, vertices[v_i[7]]-vertices[v_i[3]]);
 
     A[4].set_column(0, vertices[v_i[7]]-vertices[v_i[4]]);
     A[4].set_column(1, vertices[v_i[5]]-vertices[v_i[4]]);
     A[4].set_column(2, vertices[v_i[0]]-vertices[v_i[4]]);
     
     A[5].set_column(0, vertices[v_i[4]]-vertices[v_i[5]]);
     A[5].set_column(1, vertices[v_i[6]]-vertices[v_i[5]]);
     A[5].set_column(2, vertices[v_i[1]]-vertices[v_i[5]]);
     
     A[6].set_column(0, vertices[v_i[5]]-vertices[v_i[6]]);
     A[6].set_column(1, vertices[v_i[7]]-vertices[v_i[6]]);
     A[6].set_column(2, vertices[v_i[2]]-vertices[v_i[6]]);
     
     A[7].set_column(0, vertices[v_i[6]]-vertices[v_i[7]]);
     A[7].set_column(1, vertices[v_i[4]]-vertices[v_i[7]]);
     A[7].set_column(2, vertices[v_i[3]]-vertices[v_i[7]]);
 
     break;
     
   default:
     MSQ_SETERR(err)("element type not implemented.", MsqError::NOT_IMPLEMENTED);
     return;
   }// end switch over element type
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void compute_corner_matrices	(	PatchData &	pd,
		Matrix3D	A[],
		int	num_m3d,
		MsqError &	err
	)

Compute matrices which column are the vectors issued from a corner.

Stores those corner matrices in the mTag data member.

void compute_corner_normals	(	Vector3D	normals[],
		PatchData &	pd,
		MsqError &	err
	)

Uses a MeshDomain call-back function to compute the normal at the corner.

Gives the normal at the surface point corner_pt ... but if not available, gives the normalized cross product of corner_vec1 and corner_vec2.

Definition at line 670 of file Mesh/MsqMeshEntity.cpp.

References PatchData::domain_set(), PatchData::get_domain_normals_at_corners(), PatchData::get_element_index(), MsqMeshEntity::get_element_type(), i, MsqError::INVALID_ARG, Vector3D::length(), Mesquite::length(), MSQ_ERRRTN, MSQ_SETERR, Vector3D::normalize(), Mesquite::POLYGON, Mesquite::QUADRILATERAL, Mesquite::TRIANGLE, PatchData::vertex_by_index(), MsqMeshEntity::vertex_count(), and MsqMeshEntity::vertexIndices.

Referenced by MsqMeshEntity::compute_corner_matrices(), I_DFT::compute_element_analytical_gradient(), I_DFT::compute_element_analytical_hessian(), and I_DFT::evaluate_element().

 {
   EntityTopology type = get_element_type();
   if (type != TRIANGLE && type != QUADRILATERAL && type != POLYGON)
   {
       MSQ_SETERR(err)("Should only be used for faces (tri, quads, ...).",
                     MsqError::INVALID_ARG);
       return;
   }
   
   
     // There are two cases where we cannot get a normal from the 
     // geometry that are not errors:
     // 1) There is no domain set
     // 2) The vertex is at a degenerate point on the geometry (e.g. 
     //     tip of a cone.)
 
     // Get normal from domain
   if (pd.domain_set()) 
   {
     size_t index = pd.get_element_index(this);
     pd.get_domain_normals_at_corners( index, normals, err );
     MSQ_ERRRTN(err);
   }
 
     // Check if normals are valid (none are valid if !pd.domain_set())
   const unsigned count = vertex_count();
   for (unsigned i = 0; i < count; ++i)
   {
       // If got valid normal from domain, 
       // make it a unit vector and continue.
     if (pd.domain_set()) 
     {
       double length = normals[i].length();
       if (length > DBL_EPSILON)
       {
         normals[i] /= length;
         continue;
       }
     }
     
     const size_t prev_idx = vertexIndices[(i + count - 1) % count];
     const size_t this_idx = vertexIndices[i];
     const size_t next_idx = vertexIndices[(i + 1) % count];
 
       // Calculate normal using edges adjacent to corner
     normals[i] = (pd.vertex_by_index(next_idx) - pd.vertex_by_index(this_idx))
                * (pd.vertex_by_index(prev_idx) - pd.vertex_by_index(this_idx));
     normals[i].normalize();
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void compute_corner_normals	(	Vector3D	normals[],
		PatchData &	pd,
		MsqError &	err
	)

Uses a MeshDomain call-back function to compute the normal at the corner.

double compute_signed_area	(	PatchData &	pd,
		MsqError &	err
	)

Computes the signed area of the element.

double compute_signed_area	(	PatchData &	pd,
		MsqError &	err
	)

Computes the signed area of the element.

Computes the area of the given element. Returned value can be negative. If the entity passed is not a two-dimensional element, an error is set.

Definition at line 419 of file Mesh/MsqMeshEntity.cpp.

References PatchData::get_domain_normal_at_element(), PatchData::get_element_index(), PatchData::get_vertex_array(), MsqError::INVALID_ARG, Vector3D::length(), MSQ_ERRZERO, MSQ_SETERR, MsqMeshEntity::mType, Mesquite::QUADRILATERAL, Mesquite::TRIANGLE, and MsqMeshEntity::vertexIndices.

                                                                       {
   MsqVertex* verts=pd.get_vertex_array(err);MSQ_ERRZERO(err);
   double tem=0.0;
   double tem2=0.0;
   Vector3D surface_normal;
   Vector3D cross_vec;
   size_t element_index=pd.get_element_index(this);
   
   switch (mType)
   {
     
     case TRIANGLE:
       cross_vec=((verts[vertexIndices[1]]-verts[vertexIndices[0]])*
       (verts[vertexIndices[2]]-verts[vertexIndices[0]]));
       pd.get_domain_normal_at_element(element_index,surface_normal,err);
       MSQ_ERRZERO(err);
       tem =  (cross_vec.length()/2.0);
         //if normals do not point in same general direction, negate area
       if(cross_vec%surface_normal<0){ 
         tem *= -1;
       }
       
       return tem;
       
     case QUADRILATERAL:
       cross_vec=((verts[vertexIndices[1]]-verts[vertexIndices[0]])*
                  (verts[vertexIndices[3]]-verts[vertexIndices[0]]));
       pd.get_domain_normal_at_element(element_index,surface_normal,err);
       MSQ_ERRZERO(err);
       tem =  (cross_vec.length()/2.0);
         //if normals do not point in same general direction, negate area
       if(cross_vec%surface_normal<0){ 
         tem *= -1;
       }
       cross_vec=((verts[vertexIndices[3]]-verts[vertexIndices[2]])*
                  (verts[vertexIndices[1]]-verts[vertexIndices[2]]));
       tem2 =  (cross_vec.length()/2.0);
         //if normals do not point in same general direction, negate area
       if(cross_vec%surface_normal<0){ 
         tem2 *= -1;
           //test to make sure surface normal existed
           //if(surface_normal.length_squared()<.5){
           //err.set_msg("compute_signed_area called without surface_normal available.");
           //}  
       }
       return (tem + tem2);
       
     default:
       MSQ_SETERR(err)("Invalid type of element passed to compute unsigned area.",
                        MsqError::INVALID_ARG);
       return 0;
   };
   return 0.0;
 }

Here is the call graph for this function:

double compute_signed_volume	(	PatchData &	pd,
		MsqError &	err
	)

Computes the signed volume of the element.

Computes the volume of the given element. Returned value can be negative. If the entity passed is not a three-dimensional element, an error is set.

Definition at line 478 of file Mesh/MsqMeshEntity.cpp.

References MsqMeshEntity::compute_weighted_jacobian(), PatchData::get_vertex_array(), Mesquite::HEXAHEDRON, MsqError::INVALID_ARG, MSQ_ERRZERO, MSQ_SETERR, MsqMeshEntity::mType, Mesquite::TETRAHEDRON, and MsqMeshEntity::vertexIndices.

                                                                         {
   Vector3D sample_point(.5,.5,.5);
   Vector3D jac_vecs[3];
   short num_jacobian_vectors=-1;
   double tem=0;
   MsqVertex *verts = pd.get_vertex_array(err);MSQ_ERRZERO(err);
   switch (mType)
   {
     case TETRAHEDRON:
       tem = (verts[vertexIndices[3]]-verts[vertexIndices[0]])%
         ((verts[vertexIndices[1]]-verts[vertexIndices[0]])*
          (verts[vertexIndices[2]]-verts[vertexIndices[0]]))/6.0;
       return tem;
       
     case HEXAHEDRON:
       compute_weighted_jacobian(pd,sample_point,jac_vecs,
                                 num_jacobian_vectors, err );
       MSQ_ERRZERO(err);
       return (jac_vecs[2]%(jac_vecs[0]*jac_vecs[1]));
       
     default:
       MSQ_SETERR(err)("Invalid type of element passed to compute signed volume.",
                        MsqError::INVALID_ARG);
       return 0;
   };
   return 0.0;      
 }

Here is the call graph for this function:

double compute_signed_volume	(	PatchData &	pd,
		MsqError &	err
	)

Computes the signed volume of the element.

double compute_unsigned_area	(	PatchData &	pd,
		MsqError &	err
	)

Computes the area of the element.

Computes the area of the given element. Returned value is always non-negative. If the entity passed is not a two-dimensional element, an error is set.

The returned value is always non-negative.

Definition at line 357 of file Mesh/MsqMeshEntity.cpp.

References PatchData::get_vertex_array(), MsqError::INVALID_ARG, Mesquite::length(), MSQ_ERRZERO, MSQ_SETERR, MsqMeshEntity::mType, Mesquite::QUADRILATERAL, Mesquite::TRIANGLE, and MsqMeshEntity::vertexIndices.

Referenced by ASMQualityMetric::evaluate_element(), and CornerJacobianQualityMetric::evaluate_element().

                                                                         {
   MsqVertex* verts=pd.get_vertex_array(err);MSQ_ERRZERO(err);
   double tem=0.0;
   switch (mType)
   {
    
     case TRIANGLE:
       tem =  ((verts[vertexIndices[1]]-verts[vertexIndices[0]])*
               (verts[vertexIndices[2]]-verts[vertexIndices[0]])).length()/2.0;
       return tem;
       
     case QUADRILATERAL:
       tem = ((verts[vertexIndices[1]]-verts[vertexIndices[0]])*
              (verts[vertexIndices[3]]-verts[vertexIndices[0]])).length();
       tem += ((verts[vertexIndices[3]]-verts[vertexIndices[2]])*
               (verts[vertexIndices[1]]-verts[vertexIndices[2]])).length();
       return (tem/2.0);
       
     default:
       MSQ_SETERR(err)("Invalid type of element passed to compute unsigned area.",
                       MsqError::INVALID_ARG);
       return 0;
   }
   return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double compute_unsigned_area	(	PatchData &	pd,
		MsqError &	err
	)

Computes the area of the element.

The returned value is always non-negative.

double compute_unsigned_volume	(	PatchData &	pd,
		MsqError &	err
	)

Computes the volume of the element.

Computes the volume of the given element. Returned value is always non-negative. If the entity passed is not a three-dimensional element, an error is set.

The returned value is always non-negative.

Definition at line 387 of file Mesh/MsqMeshEntity.cpp.

References MsqMeshEntity::compute_weighted_jacobian(), PatchData::get_vertex_array(), Mesquite::HEXAHEDRON, MsqError::INVALID_ARG, MSQ_ERRZERO, MSQ_SETERR, MsqMeshEntity::mType, Mesquite::TETRAHEDRON, and MsqMeshEntity::vertexIndices.

Referenced by ASMQualityMetric::evaluate_element(), and CornerJacobianQualityMetric::evaluate_element().

                                                                           {
   Vector3D sample_point(.5,.5,.5);
   Vector3D jac_vecs[3];
   short num_jacobian_vectors=-1;
   double tem=0;
   MsqVertex *verts = pd.get_vertex_array(err);MSQ_ERRZERO(err);
   switch (mType)
   {
     case TETRAHEDRON:
       tem = (verts[vertexIndices[3]]-verts[vertexIndices[0]])%
         ((verts[vertexIndices[1]]-verts[vertexIndices[0]])*
          (verts[vertexIndices[1]]-verts[vertexIndices[0]]))/6.0;
       return fabs(tem);
       
     case HEXAHEDRON:
       compute_weighted_jacobian(pd,sample_point,jac_vecs,
                                 num_jacobian_vectors, err ); MSQ_ERRZERO(err);
       return fabs(jac_vecs[2]%(jac_vecs[0]*jac_vecs[1]));
       
     default:
       MSQ_SETERR(err)("Invalid type of element passed to compute unsigned volume.",
                        MsqError::INVALID_ARG);
      return 0;
   }
   return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double compute_unsigned_volume	(	PatchData &	pd,
		MsqError &	err
	)

Computes the volume of the element.

The returned value is always non-negative.

void compute_weighted_jacobian	(	PatchData &	pd,
		Vector3D &	sample_point,
		Vector3D	jacobian_vectors[],
		short &	num_jacobian_vectors,
		MsqError &	err
	)

void compute_weighted_jacobian	(	PatchData &	pd,
		Vector3D &	sample_point,
		Vector3D	jacobian_vectors[],
		short &	num_jacobian_vectors,
		MsqError &	err
	)

fills array of Vector3D's with the jacobian vectors and the number of jacobian vecotors.

Definition at line 118 of file Mesh/MsqMeshEntity.cpp.

References PatchData::get_vertex_array(), Mesquite::HEXAHEDRON, MSQ_ERRRTN, MSQ_SETERR, Mesquite::MSQ_SQRT_THREE_INV, Mesquite::MSQ_SQRT_TWO_INV, MsqError::NOT_IMPLEMENTED, Mesquite::QUADRILATERAL, Vector3D::set(), Mesquite::TETRAHEDRON, and Mesquite::TRIANGLE.

Referenced by VertexMover::check_feasible(), MsqMeshEntity::compute_signed_volume(), MsqMeshEntity::compute_unsigned_volume(), and GeneralizedConditionNumberQualityMetric::evaluate_element().

 {
     // v_v is just an alias for vertexIndices
   const size_t* v_v = &vertexIndices[0];
   
     //   vector<size_t> v_v;
     //   get_vertex_indices(v_v);
   MsqVertex *vertices=pd.get_vertex_array(err); MSQ_ERRRTN(err);
   switch (mType)
   {
       //Note:: For the linear tri case we do not use sample pt.
     case TRIANGLE:
       jacobian_vectors[0].set(vertices[v_v[1]]-vertices[v_v[0]]);
       jacobian_vectors[1].set((2.0*vertices[v_v[2]]-vertices[v_v[0]]-
                                vertices[v_v[1]])*MSQ_SQRT_THREE_INV);
       num_jacobian_vectors=2;
       break;
       
     case QUADRILATERAL:
       jacobian_vectors[0]=(vertices[v_v[1]]-vertices[v_v[0]]+sample_point[1]*
                            (vertices[v_v[2]]+vertices[v_v[0]]-vertices[v_v[3]]-
                             vertices[v_v[1]]));
       jacobian_vectors[1]=(vertices[v_v[3]]-vertices[v_v[0]]+sample_point[0]*
                            (vertices[v_v[2]]+vertices[v_v[0]]-vertices[v_v[3]]-
                             vertices[v_v[1]]));
       num_jacobian_vectors=2;
       break;
       
     case TETRAHEDRON:
       jacobian_vectors[0]=vertices[v_v[1]]-vertices[v_v[0]];
       jacobian_vectors[1]=(2.0*vertices[v_v[2]]-vertices[v_v[0]]-
                            vertices[v_v[1]])*MSQ_SQRT_THREE_INV;
       jacobian_vectors[2]=(3.0*vertices[v_v[3]]-vertices[v_v[2]]-
                            vertices[v_v[1]]-vertices[v_v[0]])*
         MSQ_SQRT_TWO_INV*MSQ_SQRT_THREE_INV;
       num_jacobian_vectors=3;
       break;
       
     case HEXAHEDRON:
       
       jacobian_vectors[0]=vertices[v_v[1]]-vertices[v_v[0]]+
                            (sample_point[1]*(vertices[v_v[2]]+vertices[v_v[0]]-
                                              vertices[v_v[3]]-vertices[v_v[1]]))+
                            (sample_point[2]*(vertices[v_v[5]]+vertices[v_v[0]]-
                                              vertices[v_v[4]]-vertices[v_v[1]]))+
                            (sample_point[1]*sample_point[2]*(vertices[v_v[6]]+
                                                              vertices[v_v[4]]+
                                                              vertices[v_v[3]]+
                                                              vertices[v_v[1]]-
                                                              vertices[v_v[7]]-
                                                              vertices[v_v[5]]-
                                                              vertices[v_v[2]]-
                                                              vertices[v_v[0]])),
       jacobian_vectors[1]=vertices[v_v[3]]-vertices[v_v[0]]+
                            (sample_point[0]*(vertices[v_v[2]]+vertices[v_v[0]]-
                                              vertices[v_v[3]]-vertices[v_v[1]]))+
                            (sample_point[2]*(vertices[v_v[7]]+vertices[v_v[0]]-
                                              vertices[v_v[4]]-vertices[v_v[3]]))+
                            (sample_point[0]*sample_point[2]*(vertices[v_v[6]]+
                                                              vertices[v_v[4]]+
                                                              vertices[v_v[3]]+
                                                              vertices[v_v[1]]-
                                                              vertices[v_v[7]]-
                                                              vertices[v_v[5]]-
                                                              vertices[v_v[2]]-
                                                              vertices[v_v[0]]));
                            
       jacobian_vectors[2]=vertices[v_v[4]]-vertices[v_v[0]]+
                            (sample_point[0]*(vertices[v_v[5]]+vertices[v_v[0]]-
                                              vertices[v_v[4]]-vertices[v_v[1]]))+
                            (sample_point[1]*(vertices[v_v[7]]+vertices[v_v[0]]-
                                              vertices[v_v[4]]-vertices[v_v[3]]))+
                            (sample_point[0]*sample_point[1]*(vertices[v_v[6]]+
                                                              vertices[v_v[4]]+
                                                              vertices[v_v[3]]+
                                                              vertices[v_v[1]]-
                                                              vertices[v_v[7]]-
                                                              vertices[v_v[5]]-
                                                              vertices[v_v[2]]-
                                                              vertices[v_v[0]]));
 
       num_jacobian_vectors=3;
       break;
       
     default:
       MSQ_SETERR(err)(
         "Compute_weighted_jacobian not yet defined for this entity.",
         MsqError::NOT_IMPLEMENTED);
   } 
   
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void get_centroid	(	Vector3D &	centroid,
		const PatchData &	pd,
		MsqError &	err
	)		const

Returns the centroid of the element.

void get_centroid	(	Vector3D &	centroid,
		const PatchData &	pd,
		MsqError &	err
	)		const

Returns the centroid of the element.

The centroid of an element containing n vertices with equal masses is located at

$\b{x} = \frac{ \sum_{i=1}^{n} \b{x}_i }{ n }$

where $\b{x}_i ,\, i=1,...,n$ are the vertices coordinates.

Definition at line 106 of file Mesh/MsqMeshEntity.cpp.

References PatchData::get_vertex_array(), i, MSQ_ERRRTN, MsqMeshEntity::vertex_count(), and MsqMeshEntity::vertexIndices.

 {
   const MsqVertex* vtces = pd.get_vertex_array(err); MSQ_ERRRTN(err);
   size_t nve = vertex_count();
   for (size_t i=0; i<nve; ++i)
     centroid += vtces[vertexIndices[i]];
   centroid /= nve;
 }

Here is the call graph for this function:

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

Fills a vector<size_t> with vertices connected to the given vertex through the edges of this MsqMeshEntity.

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

Fills a vector<size_t> with vertices connected to the given vertex through the edges of this MsqMeshEntity.

Referenced by VertexConditionNumberQualityMetric::evaluate_vertex(), and LocalSizeQualityMetric::evaluate_vertex().

Here is the caller graph for this function:

EntityTopology get_element_type ( ) const

inline

Returns element type.

Definition at line 78 of file includeLinks/MsqMeshEntity.hpp.

References MsqMeshEntity::mType.

79 { return mType; }

EntityTopology mType

Definition: includeLinks/MsqMeshEntity.hpp:167

Here is the caller graph for this function:

EntityTopology get_element_type ( ) const

inline

Returns element type.

Definition at line 78 of file src/Mesh/MsqMeshEntity.hpp.

References MsqMeshEntity::mType.

79 { return mType; }

EntityTopology mType

Definition: includeLinks/MsqMeshEntity.hpp:167

void get_linear_quad_jac	(	Vector3D *	sp,
		Vector3D &	coord0,
		Vector3D &	coord1,
		Vector3D &	coord2,
		Vector3D &	coord3,
		Vector3D *	jac
	)

inlinestaticprivate

Definition at line 211 of file includeLinks/MsqMeshEntity.hpp.

   {
     jac[0]=coord1-coord0+(*sp)[1]*(coord2+coord0-coord3-coord1);
     jac[1]=coord3-coord0+(*sp)[0]*(coord2+coord0-coord3-coord1);
   }

static void get_linear_quad_jac	(	Vector3D *	sp,
		Vector3D &	coord0,
		Vector3D &	coord1,
		Vector3D &	coord2,
		Vector3D &	coord3,
		Vector3D *	jac
	)

staticprivate

void get_node_indices ( msq_std::vector< msq_stdc::size_t > & vertex_list ) const

gets the vertices of the mesh entity

void get_node_indices ( msq_std::vector< msq_stdc::size_t > & vertex_list ) const

gets the vertices of the mesh entity

void get_sample_points	(	QualityMetric::ElementEvaluationMode	mode,
		msq_std::vector< Vector3D > &	coords,
		MsqError &	err
	)

Returns a list of sample points given an evaluationmode.

void get_sample_points	(	QualityMetric::ElementEvaluationMode	mode,
		msq_std::vector< Vector3D > &	coords,
		MsqError &	err
	)

Returns a list of sample points given an evaluationmode.

Referenced by VertexMover::check_feasible(), and GeneralizedConditionNumberQualityMetric::evaluate_element().

Here is the caller graph for this function:

msq_stdc::size_t get_vertex_index ( msq_stdc::size_t vertex_in_element ) const

inline

Definition at line 203 of file includeLinks/MsqMeshEntity.hpp.

References MsqMeshEntity::vertex_count(), and MsqMeshEntity::vertexIndices.

Referenced by GeneralizedConditionNumberQualityMetric::compute_condition_number(), PatchData::get_subpatch(), and NonSmoothSteepestDescent::validity_check().

   {
       // Make sure we're in range
     assert(vertex_in_element < vertex_count());
       // Return the index
     return vertexIndices[vertex_in_element];
   }

Here is the call graph for this function:

Here is the caller graph for this function:

const msq_stdc::size_t* get_vertex_index_array ( ) const

inline

Very efficient retrieval of vertices indexes (corresponding to the PatchData vertex array).

const msq_stdc::size_t * get_vertex_index_array ( ) const

inline

Very efficient retrieval of vertices indexes (corresponding to the PatchData vertex array).

Definition at line 196 of file includeLinks/MsqMeshEntity.hpp.

References MsqMeshEntity::vertexIndices.

197 { return vertexIndices; }

size_t * vertexIndices

Pointer to connectivity array.

Definition: includeLinks/MsqMeshEntity.hpp:173

Here is the caller graph for this function:

msq_stdc::size_t* get_vertex_index_array ( )

inline

msq_stdc::size_t * get_vertex_index_array ( )

inline

Definition at line 199 of file includeLinks/MsqMeshEntity.hpp.

References MsqMeshEntity::vertexIndices.

200 { return vertexIndices; }

size_t * vertexIndices

Pointer to connectivity array.

Definition: includeLinks/MsqMeshEntity.hpp:173

void get_vertex_indices ( msq_std::vector< msq_stdc::size_t > & vertex_list ) const

gets the vertices of the mesh entity

void get_vertex_indices ( msq_std::vector< msq_stdc::size_t > & vertex_list ) const

gets the vertices of the mesh entity

Referenced by QualityMetric::compute_element_gradient_expanded(), QualityMetric::compute_element_hessian(), QualityMetric::compute_element_numerical_hessian(), and NonSmoothSteepestDescent::optimize_vertex_positions().

Here is the caller graph for this function:

msq_stdc::size_t node_count ( ) const

inline

Return number of nodes in element (number of corner vertices + number of higher-order nodes).

Definition at line 86 of file src/Mesh/MsqMeshEntity.hpp.

References MsqMeshEntity::numVertexIndices.

87 { return numVertexIndices; }

size_t numVertexIndices

Definition: includeLinks/MsqMeshEntity.hpp:174

msq_stdc::size_t node_count ( ) const

inline

Return number of nodes in element (number of corner vertices + number of higher-order nodes).

Definition at line 86 of file includeLinks/MsqMeshEntity.hpp.

References MsqMeshEntity::numVertexIndices.

Referenced by PatchData::get_subpatch(), PatchData::initialize_data(), MeanMidNodeMover::loop_over_mesh(), and MsqMeshEntity::vertex_count().

87 { return numVertexIndices; }

size_t numVertexIndices

Definition: includeLinks/MsqMeshEntity.hpp:174

Here is the caller graph for this function:

void set_connectivity	(	msq_stdc::size_t *	indices,
		size_t	num_vertices
	)

inline

Set connectivity data (vertex array) for element.

MsqMeshEntity keeps the pointer to the passed array, it does not copy it. The caller is still responsible for releasing the memory for the passed index array after the MsqMeshEntity is destroyed. The intention is that this is a pointer to a portion of a larger connectivity array managed by the owning PatchData.

Definition at line 189 of file includeLinks/MsqMeshEntity.hpp.

References MsqMeshEntity::numVertexIndices, and MsqMeshEntity::vertexIndices.

   {
     vertexIndices = indices;
     numVertexIndices = num_vertices;
   }

void set_connectivity	(	msq_stdc::size_t *	indices,
		size_t	num_vertices
	)

Set connectivity data (vertex array) for element.

MsqMeshEntity keeps the pointer to the passed array, it does not copy it. The caller is still responsible for releasing the memory for the passed index array after the MsqMeshEntity is destroyed. The intention is that this is a pointer to a portion of a larger connectivity array managed by the owning PatchData.

void set_element_type ( EntityTopology type )

inline

Sets element data.

Definition at line 101 of file src/Mesh/MsqMeshEntity.hpp.

References MsqMeshEntity::mType.

102 { mType = type; }