TargetCalculator Class Reference

Base class that provides the interface for computing the target corner matrices used in the context based smoothing. More...

#include <TargetCalculator.hpp>

Inheritance diagram for TargetCalculator:

Collaboration diagram for TargetCalculator:

Public Types
enum	Lambda_type { REGULAR, AVERAGE, REGULAR, AVERAGE }
enum	guide_type {   Ad, AK, A0, Ar,   As, Ab, Ac, Ap,   Ae, Af, Ax, Ad,   AK, A0, Ar, As,   Ab, Ac, Ap, Ae,   Af, Ax }
enum	Lambda_type { REGULAR, AVERAGE, REGULAR, AVERAGE }
enum	guide_type {   Ad, AK, A0, Ar,   As, Ab, Ac, Ap,   Ae, Af, Ax, Ad,   AK, A0, Ar, As,   Ab, Ac, Ap, Ae,   Af, Ax }
Public Types inherited from PatchDataUser
enum	AlgorithmType {   QUALITY_IMPROVER, QUALITY_ASSESSOR, MESH_TRANSFORM, TARGET_CALCULATOR,   QUALITY_IMPROVER, QUALITY_ASSESSOR, MESH_TRANSFORM, TARGET_CALCULATOR }
enum	AlgorithmType {   QUALITY_IMPROVER, QUALITY_ASSESSOR, MESH_TRANSFORM, TARGET_CALCULATOR,   QUALITY_IMPROVER, QUALITY_ASSESSOR, MESH_TRANSFORM, TARGET_CALCULATOR }

Public Member Functions
	TargetCalculator ()
virtual	~TargetCalculator ()
	virtual destructor ensures use of polymorphism during destruction More...
void	compute_guide_matrices (enum guide_type type, PatchData &ref_pd, size_t elem_ind, Matrix3D A[], int num, MsqError &err)
	Computes the guide corner matrices A for a given element index in the reference patch. More...
Matrix3D	compute_V_3D (const Matrix3D &A, MsqError &err)
Matrix3D	compute_Q_3D (const Matrix3D &A, MsqError &err)
Matrix3D	compute_Delta_3D (const Matrix3D &A, MsqError &err)
void	compute_default_target_matrices (PatchData &pd, MsqError &err)
	Compute the default "isotropic" target matrices that are often used in the computation of reference-based target matrices. More...
void	compute_reference_corner_matrices (PatchData &pd, MsqError &err)
	Compute the corner matrices for the reference mesh refMesh. More...
void	compute_target_matrices_and_check_det (PatchData &pd, MsqError &err)
	This function wraps compute_target_matrices and checks that the determinant of each target is positive. More...
void	reset_reference_meshset (MsqError &err)
	Reset the reference mesh so it starts from the first vertex again. More...
virtual void	compute_target_matrices (PatchData &pd, MsqError &err)=0
	This function provides the corner matrices for all elements on the Patch. More...
virtual double	loop_over_mesh (MeshSet &ms, MsqError &err)
	This is the "run" function of PatchDataUser. It can do anything really. More...
virtual msq_std::string	get_name ()
	Returns the algorithm name. More...
virtual AlgorithmType	get_algorithm_type ()
	Return the algorithm type (to avoid RTTI use). More...
	TargetCalculator ()
virtual	~TargetCalculator ()
	virtual destructor ensures use of polymorphism during destruction More...
void	compute_guide_matrices (enum guide_type type, PatchData &ref_pd, size_t elem_ind, Matrix3D A[], int num, MsqError &err)
	Computes the guide corner matrices A for a given element index in the reference patch. More...
Matrix3D	compute_V_3D (const Matrix3D &A, MsqError &err)
Matrix3D	compute_Q_3D (const Matrix3D &A, MsqError &err)
Matrix3D	compute_Delta_3D (const Matrix3D &A, MsqError &err)
void	compute_default_target_matrices (PatchData &pd, MsqError &err)
	Compute the default "isotropic" target matrices that are often used in the computation of reference-based target matrices. More...
void	compute_reference_corner_matrices (PatchData &pd, MsqError &err)
	Compute the corner matrices for the reference mesh refMesh. More...
void	compute_target_matrices_and_check_det (PatchData &pd, MsqError &err)
	This function wraps compute_target_matrices and checks that the determinant of each target is positive. More...
void	reset_reference_meshset (MsqError &err)
	Reset the reference mesh so it starts from the first vertex again. More...
virtual void	compute_target_matrices (PatchData &pd, MsqError &err)=0
	This function provides the corner matrices for all elements on the Patch. More...
virtual double	loop_over_mesh (MeshSet &ms, MsqError &err)
	This is the "run" function of PatchDataUser. It can do anything really. More...
virtual msq_std::string	get_name ()
	Returns the algorithm name. More...
virtual AlgorithmType	get_algorithm_type ()
	Return the algorithm type (to avoid RTTI use). More...
Public Member Functions inherited from PatchDataUser
virtual	~PatchDataUser ()
virtual void	set_patch_type (PatchData::PatchType patch_type, MsqError &err, int param1=0, int param2=0)
	Sets the Patch Type. More...
PatchData::PatchType	get_patch_type ()
	Returns the Patch Type. More...
int	get_nb_layers (MsqError &err)
	Returns number of layers (if relevant for partition algorythm). More...
void	add_culling_method (enum PatchData::culling_method cm)
	Sets on the culling method passed as argument. More...
void	no_culling_method ()
	Sets off all culling methods. More...
void	remove_culling_method (enum PatchData::culling_method cm)
	Sets off the culling method passed as argument. More...
long unsigned int	get_culling_method_bits ()
	Returns the bitset containing culling methods flags. More...
void	set_all_parameters (PatchDataParameters &params)
PatchDataParameters &	get_all_parameters ()
	Returns the PatchDataParameters object. More...
void	set_global_patch (PatchData *pd, MsqError &err)
	Sets the Global Patch, so that it can be use by contiguoug PatchDataUser. More...
PatchData *	get_global_patch ()
	Returns the Global Patch. More...
void	no_global_patch ()
	Sets the Global Patch pointer to NULL. More...
virtual	~PatchDataUser ()
virtual void	set_patch_type (PatchData::PatchType patch_type, MsqError &err, int param1=0, int param2=0)
	Sets the Patch Type. More...
PatchData::PatchType	get_patch_type ()
	Returns the Patch Type. More...
int	get_nb_layers (MsqError &err)
	Returns number of layers (if relevant for partition algorythm). More...
void	add_culling_method (enum PatchData::culling_method cm)
	Sets on the culling method passed as argument. More...
void	no_culling_method ()
	Sets off all culling methods. More...
void	remove_culling_method (enum PatchData::culling_method cm)
	Sets off the culling method passed as argument. More...
long unsigned int	get_culling_method_bits ()
	Returns the bitset containing culling methods flags. More...
void	set_all_parameters (PatchDataParameters &params)
PatchDataParameters &	get_all_parameters ()
	Returns the PatchDataParameters object. More...
void	set_global_patch (PatchData *pd, MsqError &err)
	Sets the Global Patch, so that it can be use by contiguoug PatchDataUser. More...
PatchData *	get_global_patch ()
	Returns the Global Patch. More...
void	no_global_patch ()
	Sets the Global Patch pointer to NULL. More...

Static Public Member Functions
static void	initialize_default_target_matrices (Matrix3D &tri_M3D, Matrix3D &quad_M3D, Matrix3D &tet_M3D, Matrix3D &hex_M3D)
static double	compute_Lambda (const Matrix3D &A, MsqError &err)
	Note that this function is static, i.e. it can be used independently of an object. More...
static void	initialize_default_target_matrices (Matrix3D &tri_M3D, Matrix3D &quad_M3D, Matrix3D &tet_M3D, Matrix3D &hex_M3D)
static double	compute_Lambda (const Matrix3D &A, MsqError &err)

Protected Attributes
MeshSet *	refMesh

Additional Inherited Members
Protected Member Functions inherited from PatchDataUser
	PatchDataUser ()
	PatchDataUser ()

Detailed Description

Base class that provides the interface for computing the target corner matrices used in the context based smoothing.

To implement a concrete TargetCalculator, one inherits from this class and then overrides the compute_target_matrices function itself to provide corner matrices for all elements in the patch.

Note that an implementation is provided in TargetCalculator::compute_default_target_matrices for default target matrices often used in the computation of more complex, reference-based target matrices.

The target calculator is set on the QualityImprover. At runtime, it associates with each mesh corner (i.e. a corner of an element. Most of the time, one vertex corresponds to many corners.) with a TargetMatrix through an MsqTag mechanism available in the MsqMeshEntity class.

Definition at line 74 of file includeLinks/TargetCalculator.hpp.

Member Enumeration Documentation

enum guide_type

Enumerator
Ad	Default Guide.
AK	Conductivity Guide.
A0	Initial Mesh Guide.
Ar	Reference Mesh Guide.
As	Locally-smoothed IM Guide.
Ab	Bounding-box Guide.
Ac	Geometric Curvature Guide.
Ap	Parametric Guide.
Ae	Error Indicator Guide.
Af	Flux-based Guide.
Ax	Solution Feature-based Guide.
Ad	Default Guide.
AK	Conductivity Guide.
A0	Initial Mesh Guide.
Ar	Reference Mesh Guide.
As	Locally-smoothed IM Guide.
Ab	Bounding-box Guide.
Ac	Geometric Curvature Guide.
Ap	Parametric Guide.
Ae	Error Indicator Guide.
Af	Flux-based Guide.
Ax	Solution Feature-based Guide.

Definition at line 96 of file includeLinks/TargetCalculator.hpp.

                    {
      Ad, 
      AK, 
      A0, 
      Ar, 
      As, 
      Ab, 
      Ac, 
      Ap, 
      Ae, 
      Af, 
      Ax  
    };

enum guide_type

Enumerator
Ad	Default Guide.
AK	Conductivity Guide.
A0	Initial Mesh Guide.
Ar	Reference Mesh Guide.
As	Locally-smoothed IM Guide.
Ab	Bounding-box Guide.
Ac	Geometric Curvature Guide.
Ap	Parametric Guide.
Ae	Error Indicator Guide.
Af	Flux-based Guide.
Ax	Solution Feature-based Guide.
Ad	Default Guide.
AK	Conductivity Guide.
A0	Initial Mesh Guide.
Ar	Reference Mesh Guide.
As	Locally-smoothed IM Guide.
Ab	Bounding-box Guide.
Ac	Geometric Curvature Guide.
Ap	Parametric Guide.
Ae	Error Indicator Guide.
Af	Flux-based Guide.
Ax	Solution Feature-based Guide.

Definition at line 96 of file src/TargetCalculator/TargetCalculator.hpp.

                    {
      Ad, 
      AK, 
      A0, 
      Ar, 
      As, 
      Ab, 
      Ac, 
      Ap, 
      Ae, 
      Af, 
      Ax  
    };

enum Lambda_type

Enumerator
REGULAR	Each element has a lambda coefficient.
AVERAGE	The Lambda coefficient is the average on the mesh.
REGULAR	Each element has a lambda coefficient.
AVERAGE	The Lambda coefficient is the average on the mesh.

Definition at line 90 of file src/TargetCalculator/TargetCalculator.hpp.

                     {
      REGULAR, 
      AVERAGE  
    };

enum Lambda_type

Enumerator
REGULAR	Each element has a lambda coefficient.
AVERAGE	The Lambda coefficient is the average on the mesh.
REGULAR	Each element has a lambda coefficient.
AVERAGE	The Lambda coefficient is the average on the mesh.

Definition at line 90 of file includeLinks/TargetCalculator.hpp.

                     {
      REGULAR, 
      AVERAGE  
    };

Constructor & Destructor Documentation

TargetCalculator ( )

inline

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

References PatchDataUser::get_all_parameters(), and PatchDataParameters::set_global_patch_type().

                       : refMesh(0) 
      { get_all_parameters().set_global_patch_type(); }

Here is the call graph for this function:

virtual ~TargetCalculator ( )

inlinevirtual

virtual destructor ensures use of polymorphism during destruction

Definition at line 82 of file includeLinks/TargetCalculator.hpp.

    {};

TargetCalculator ( )

inline

Definition at line 78 of file src/TargetCalculator/TargetCalculator.hpp.

References PatchDataUser::get_all_parameters(), and PatchDataParameters::set_global_patch_type().

                       : refMesh(0) 
      { get_all_parameters().set_global_patch_type(); }

Here is the call graph for this function:

virtual ~TargetCalculator ( )

inlinevirtual

virtual destructor ensures use of polymorphism during destruction

Definition at line 82 of file src/TargetCalculator/TargetCalculator.hpp.

    {};

Member Function Documentation

void compute_default_target_matrices	(	PatchData &	pd,
		MsqError &	err
	)

Compute the default "isotropic" target matrices that are often used in the computation of reference-based target matrices.

The resulting corner matrices are stored in tags on the elements of the PatchData.

Definition at line 81 of file TargetCalculator/TargetCalculator.cpp.

References PatchData::get_element_array(), MsqMeshEntity::get_element_type(), Mesquite::HEXAHEDRON, i, TargetCalculator::initialize_default_target_matrices(), MSQ_ERRRTN, MSQ_FUNCTION_TIMER, MSQ_SETERR, MsqError::NOT_IMPLEMENTED, PatchData::num_elements(), Mesquite::QUADRILATERAL, PatchData::targetMatrices, Mesquite::TETRAHEDRON, and Mesquite::TRIANGLE.

{
  MSQ_FUNCTION_TIMER( "TargetCalculator::compute_default_target_matrices" );
    
  MsqMeshEntity* elems=pd.get_element_array(err); MSQ_ERRRTN(err);
  size_t num_elements=pd.num_elements();

  Matrix3D tmp_tri, tmp_quad, tmp_tet, tmp_hex;
  initialize_default_target_matrices(tmp_tri, tmp_quad, tmp_tet, tmp_hex);
  
  TargetMatrix matrices[8];
  
  // set the corner matrices to the correct value for each tag.
  for (size_t i=0; i<num_elements; ++i) {

    EntityTopology type = elems[i].get_element_type();
    switch (type)
      {
      case TRIANGLE:
        matrices[0] = tmp_tri; 
        matrices[1] = tmp_tri; 
        matrices[2] = tmp_tri; 
        break;
      case QUADRILATERAL:
        matrices[0] = tmp_quad; 
        matrices[1] = tmp_quad; 
        matrices[2] = tmp_quad; 
        matrices[3] = tmp_quad; 
        break;
      case TETRAHEDRON:
        matrices[0] = tmp_tet; 
        matrices[1] = tmp_tet; 
        matrices[2] = tmp_tet; 
        matrices[3] = tmp_tet; 
        break;
      case HEXAHEDRON:
        matrices[0] = tmp_hex; 
        matrices[1] = tmp_hex; 
        matrices[2] = tmp_hex; 
        matrices[3] = tmp_hex; 
        matrices[4] = tmp_hex; 
        matrices[5] = tmp_hex; 
        matrices[6] = tmp_hex; 
        matrices[7] = tmp_hex; 
        break;
      default:
        MSQ_SETERR(err)("Type not implemented.",MsqError::NOT_IMPLEMENTED);
        return;
      } //end switch
      
    pd.targetMatrices.set_element_corner_tags( &pd, i, matrices, err ); MSQ_ERRRTN(err);
  } // end loop
}

Here is the call graph for this function:

void compute_default_target_matrices	(	PatchData &	pd,
		MsqError &	err
	)

Compute the default "isotropic" target matrices that are often used in the computation of reference-based target matrices.

The resulting corner matrices are stored in tags on the elements of the PatchData.

Matrix3D compute_Delta_3D	(	const Matrix3D &	A,
		MsqError &	err
	)

Matrix3D compute_Delta_3D ( const Matrix3D &  A, MsqError &  err  )

inline

Definition at line 227 of file includeLinks/TargetCalculator.hpp.

References Mesquite::cbrt(), Matrix3D::column_length(), MsqError::INVALID_STATE, and MSQ_SETERR.

Referenced by LVQDTargetCalculator::compute_target_matrices().

  {
    double a1_norm = A.column_length(0);
    double a2_norm = A.column_length(1);
    double a3_norm = A.column_length(2);
    
    double nu = Mesquite::cbrt(a1_norm*a2_norm*a3_norm);
    double fac = 1./nu ;
    if (!finite(fac)) {
      MSQ_SETERR(err)("Numerical error", MsqError::INVALID_STATE);
    }
    
    Matrix3D Delta;

    Delta[0][0] = fac * a1_norm;
    Delta[1][1] = fac * a2_norm;
    Delta[2][2] = fac * a3_norm;
    
    return Delta;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void compute_guide_matrices	(	enum guide_type	type,
		PatchData &	ref_pd,
		size_t	elem_ind,
		Matrix3D	A[],
		int	num,
		MsqError &	err
	)

Computes the guide corner matrices A for a given element index in the reference patch.

void compute_guide_matrices	(	enum guide_type	type,
		PatchData &	ref_pd,
		size_t	elem_ind,
		Matrix3D	A[],
		int	num,
		MsqError &	err
	)

Computes the guide corner matrices A for a given element index in the reference patch.

Definition at line 168 of file TargetCalculator/TargetCalculator.cpp.

References TargetCalculator::A0, TargetCalculator::Ad, TargetCalculator::Ar, MsqMeshEntity::compute_corner_matrices(), PatchData::get_element_array(), MsqMeshEntity::get_element_type(), Mesquite::HEXAHEDRON, i, TargetCalculator::initialize_default_target_matrices(), MSQ_ERRRTN, MSQ_SETERR, MsqError::NOT_IMPLEMENTED, Mesquite::QUADRILATERAL, Mesquite::TETRAHEDRON, Mesquite::TRIANGLE, and MsqMeshEntity::vertex_count().

Referenced by WTargetCalculator::compute_target_matrices(), and LVQDTargetCalculator::compute_target_matrices().

  {

    
    MsqMeshEntity* elems = ref_pd.get_element_array(err); MSQ_ERRRTN(err);
    size_t nve = elems[elem_ind].vertex_count();
    int i;

    switch(type) {
    case Ad:
      {
        Matrix3D tmp_tri, tmp_quad, tmp_tet, tmp_hex;
        initialize_default_target_matrices(tmp_tri, tmp_quad, tmp_tet, tmp_hex);
        EntityTopology elem_type = elems[elem_ind].get_element_type();
        switch (elem_type) {
        case TRIANGLE:
          for (i=0; i<3; ++i) W_k[i] = tmp_tri; 
          break;
        case QUADRILATERAL:
          for (i=0; i<4; ++i) W_k[i] = tmp_quad; 
          break;
        case TETRAHEDRON:
          for (i=0; i<4; ++i) W_k[i] = tmp_tet; 
          break;
        case HEXAHEDRON:
          for (i=0; i<8; ++i) W_k[i] = tmp_hex; 
          break;
        default:
          MSQ_SETERR(err)("Element type not implemented.",MsqError::NOT_IMPLEMENTED);
          return;
        }
      }
      return;
    case A0:
      elems[elem_ind].compute_corner_matrices(ref_pd, W_k, nve, err); MSQ_ERRRTN(err);
      return;
    case Ar:
      elems[elem_ind].compute_corner_matrices(ref_pd, W_k, nve, err); MSQ_ERRRTN(err);
      return;
    default:
      MSQ_SETERR(err)("Element type not implemented.",MsqError::NOT_IMPLEMENTED);
      return;
    }

  }

Here is the call graph for this function:

Here is the caller graph for this function:

static double compute_Lambda ( const Matrix3D &  A, MsqError &  err  )

static

double compute_Lambda ( const Matrix3D &  A, MsqError &  err  )

inlinestatic

Note that this function is static, i.e. it can be used independently of an object.

Definition at line 183 of file includeLinks/TargetCalculator.hpp.

References Mesquite::cbrt(), and Mesquite::det().

Referenced by LVQDTargetCalculator::compute_target_matrices(), and PatchData::get_average_Lambda_3d().

  {
    return Mesquite::cbrt(fabs(det(A)));
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Matrix3D compute_Q_3D ( const Matrix3D &  A, MsqError &  err  )

inline

Definition at line 191 of file includeLinks/TargetCalculator.hpp.

References Mesquite::cbrt(), Matrix3D::column_length(), Mesquite::det(), MsqError::INVALID_STATE, Vector3D::length(), and MSQ_SETERR.

Referenced by LVQDTargetCalculator::compute_target_matrices().

  {
    Vector3D a1(A[0][0], A[1][0], A[2][0]); 
    Vector3D a2(A[0][1], A[1][1], A[2][1]); 
    Vector3D a3(A[0][2], A[1][2], A[2][2]); 

    double a1_norm = A.column_length(0);
    double a2_norm = A.column_length(1);
    double a3_norm = A.column_length(2);
    
    Vector3D a1_x_a2 = a1 * a2;
    double a1_x_a2_norm = a1_x_a2.length();
    Vector3D a1_x_a3 = a1 * a3;

    double nu = Mesquite::cbrt(a1_norm*a2_norm*a3_norm);
    double det_A = det(A);
    double fac = nu / Mesquite::cbrt(fabs(det_A));
    
    Matrix3D Q;

    Q[0][0] = fac * 1.;
    Q[0][1] = fac * a1%a2 / (a1_norm*a2_norm);
    Q[0][2] = fac * a1%a3 / (a1_norm*a3_norm);
    Q[1][1] = fac * a1_x_a2_norm / (a1_norm*a2_norm);
    Q[1][2] = fac * a1_x_a2 % a1_x_a3 / (a1_x_a2_norm * a1_norm * a3_norm);
    Q[2][2] = fac * det_A / (a1_x_a2_norm*a3_norm); 
    
    if (!finite(Q[0][0]) || !finite(Q[0][1]) || !finite(Q[0][2]) ||
        !finite(Q[1][0]) || !finite(Q[1][2]) || !finite(Q[2][2])) {
      MSQ_SETERR(err)("Numerical error", MsqError::INVALID_STATE);
    }
    
    return Q;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Matrix3D compute_Q_3D	(	const Matrix3D &	A,
		MsqError &	err
	)

void compute_reference_corner_matrices	(	PatchData &	pd,
		MsqError &	err
	)

Compute the corner matrices for the reference mesh refMesh.

The refMesh data member is set by the constructors of a concrete TargetCalculator that requires a reference mesh.

Definition at line 137 of file TargetCalculator/TargetCalculator.cpp.

References A, MsqMeshEntity::compute_corner_matrices(), PatchDataUser::get_all_parameters(), PatchData::get_element_array(), MeshSet::get_next_patch(), i, MsqError::INVALID_STATE, MSQ_ERRRTN, MSQ_FUNCTION_TIMER, Mesquite::MSQ_MAX_NUM_VERT_PER_ENT, MSQ_SETERR, PatchData::num_elements(), PatchData::num_vertices(), TargetCalculator::refMesh, and PatchData::targetMatrices.

{
  MSQ_FUNCTION_TIMER( "TargetCalculator::compute_reference_corner_matrices" );

  PatchData ref_pd;
  if (refMesh)
    refMesh->get_next_patch(ref_pd, this->get_all_parameters(), err); 
  else 
    MSQ_SETERR(err)("No reference mesh", MsqError::INVALID_STATE);
  MSQ_ERRRTN(err);
  
  // Make sure topology of ref_pd and pd are equal
  size_t num_elements=pd.num_elements();
  assert( num_elements == ref_pd.num_elements() );
  size_t num_vertices=pd.num_vertices();
  assert( num_vertices == ref_pd.num_vertices() );
    
  // Compute corner matrices for ref_pd and store in pd tags.
  MsqMeshEntity* elems = pd.get_element_array(err);
  MsqMeshEntity* elems_ref = ref_pd.get_element_array(err); MSQ_ERRRTN(err);
  TargetMatrix A[MSQ_MAX_NUM_VERT_PER_ENT];
  for (size_t i=0; i<num_elements; ++i) {
    int nve = elems[i].vertex_count();
    assert( nve = elems_ref[i].vertex_count() );
    elems_ref[i].compute_corner_matrices(ref_pd, A, nve, err); MSQ_ERRRTN(err);
    pd.targetMatrices.set_element_corner_tags( &pd, i, A, err ); MSQ_ERRRTN(err);
  }
}

Here is the call graph for this function:

void compute_reference_corner_matrices	(	PatchData &	pd,
		MsqError &	err
	)

Compute the corner matrices for the reference mesh refMesh.

The refMesh data member is set by the constructors of a concrete TargetCalculator that requires a reference mesh.

virtual void compute_target_matrices ( PatchData &  pd, MsqError &  err  )

pure virtual

This function provides the corner matrices for all elements on the Patch.

Useful functionality includes: MsqMeshEntity::set_tag, MsqTag::target_matrix, MsqTag::scalar .

Implemented in LVQDTargetCalculator, LVQDTargetCalculator, WTargetCalculator, and WTargetCalculator.

Referenced by TargetCalculator::compute_target_matrices_and_check_det().

Here is the caller graph for this function:

virtual void compute_target_matrices ( PatchData &  pd, MsqError &  err  )

pure virtual

This function provides the corner matrices for all elements on the Patch.

Useful functionality includes: MsqMeshEntity::set_tag, MsqTag::target_matrix, MsqTag::scalar .

Implemented in LVQDTargetCalculator, LVQDTargetCalculator, WTargetCalculator, and WTargetCalculator.

void compute_target_matrices_and_check_det	(	PatchData &	pd,
		MsqError &	err
	)

This function wraps compute_target_matrices and checks that the determinant of each target is positive.

Definition at line 55 of file TargetCalculator/TargetCalculator.cpp.

References TargetCalculator::compute_target_matrices(), Mesquite::det(), PatchData::get_element_array(), i, MsqError::INVALID_STATE, j, MSQ_ERRRTN, MSQ_FUNCTION_TIMER, MSQ_SETERR, PatchData::num_elements(), PatchData::targetMatrices, and MsqMeshEntity::vertex_count().

Referenced by TargetCalculator::loop_over_mesh().

{
  MSQ_FUNCTION_TIMER( "TargetCalculator::compute_target_matrices_and_check_det" );

  // Compute the target matrices
  compute_target_matrices(pd, err); MSQ_ERRRTN(err);

  //checks that the determinant of each target matrix is positive.
  MsqMeshEntity* elems=pd.get_element_array(err); MSQ_ERRRTN(err);
  size_t num_elements=pd.num_elements();
  for (size_t i=0; i<num_elements; ++i) {
    const TargetMatrix* matrices = pd.targetMatrices.get_element_corner_tags(&pd, i, err);
    MSQ_ERRRTN(err);
    size_t num_corners = elems[i].vertex_count();
    for (size_t j=0; j<num_corners; ++j) {    
      if ( det(matrices[j]) <= 0 ) {
        MSQ_SETERR(err)("A Target matrix has a non-positive determinant. "
                        "Please review your target calculator.",
                        MsqError::INVALID_STATE);
        return;
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void compute_target_matrices_and_check_det	(	PatchData &	pd,
		MsqError &	err
	)

This function wraps compute_target_matrices and checks that the determinant of each target is positive.

Matrix3D compute_V_3D	(	const Matrix3D &	A,
		MsqError &	err
	)

Matrix3D compute_V_3D	(	const Matrix3D &	A,
		MsqError &	err
	)

Definition at line 216 of file TargetCalculator/TargetCalculator.cpp.

References Matrix3D::column_length(), MsqError::INVALID_STATE, Vector3D::length(), MSQ_SETERR, and Matrix3D::set_column().

Referenced by LVQDTargetCalculator::compute_target_matrices().

  {
    Vector3D a1(A[0][0], A[1][0], A[2][0]); 
    Vector3D a2(A[0][1], A[1][1], A[2][1]); 
    Vector3D a3(A[0][2], A[1][2], A[2][2]); 

    double a1_norm = A.column_length(0); 
    Vector3D a1_x_a2 = a1 * a2;
    double a1_x_a2_norm = a1_x_a2.length(); 
    
    Matrix3D V;
    Vector3D v1, v2, v3;
    
    double a1_norm_inv = 1./a1_norm;
    double a1_x_a2_norm_inv = 1./a1_x_a2_norm;
    if (!finite(a1_norm_inv) || !finite(a1_x_a2_norm_inv)) {
      MSQ_SETERR(err)("Numerical error", MsqError::INVALID_STATE);
    }
    
    // note : % is the dot product
    v1 = a1_norm_inv * a1;
    v2 = ((-(a1%a2) * a1) + (a1_norm*a1_norm)*a2) * a1_norm_inv * a1_x_a2_norm_inv;
    v3 = a1_x_a2_norm_inv * a1_x_a2;

    V.set_column(0, v1);
    V.set_column(1, v2);
    V.set_column(2, v3);

    return V;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual AlgorithmType get_algorithm_type ( )

virtual

Return the algorithm type (to avoid RTTI use).

Implements PatchDataUser.

PatchDataUser::AlgorithmType get_algorithm_type ( )

virtual

Return the algorithm type (to avoid RTTI use).

Implements PatchDataUser.

Definition at line 250 of file TargetCalculator/TargetCalculator.cpp.

References PatchDataUser::TARGET_CALCULATOR.

    { return PatchDataUser::TARGET_CALCULATOR; }

virtual msq_std::string get_name ( )

virtual

Returns the algorithm name.

Implements PatchDataUser.

msq_std::string get_name ( )

virtual

Returns the algorithm name.

Implements PatchDataUser.

Definition at line 247 of file TargetCalculator/TargetCalculator.cpp.

    { return "Target Calculator"; }

void initialize_default_target_matrices ( Matrix3D &  tri_M3D, Matrix3D &  quad_M3D, Matrix3D &  tet_M3D, Matrix3D &  hex_M3D  )

inlinestatic

Definition at line 153 of file includeLinks/TargetCalculator.hpp.

References Mesquite::MSQ_3RT_2_OVER_6RT_3, Mesquite::MSQ_SQRT_THREE, Mesquite::MSQ_SQRT_TWO, and Mesquite::pow().

Referenced by TargetCalculator::compute_default_target_matrices(), and TargetCalculator::compute_guide_matrices().

  {
    static const double SIXTH_ROOT_OF_TWO = msq_stdc::pow(2., 1./6.);
    
    const double v_tri[] = {1., 0.5, 0., 0., MSQ_SQRT_THREE/2., 0., 0., 0., 1.};
    Matrix3D m1(v_tri);
    tri_M3D = m1 * MSQ_3RT_2_OVER_6RT_3;

//     const double v_tri[] = {1., 0.5, 0., 0., MSQ_SQRT_THREE/2., 0., 0., 0., sqrt(MSQ_SQRT_THREE/2.)};
//     Matrix3D m1(v_tri);
//     tri_M3D = m1 * sqrt(2./MSQ_SQRT_THREE);

    const double v_quad[] = {1., 0., 0., 0., 1., 0., 0., 0., 1.};
    Matrix3D m2(v_quad);
    quad_M3D = m2;
    
    const double v_tet[] = {1., 0.5, 0.5, 0., MSQ_SQRT_THREE/2., MSQ_SQRT_THREE/6., 0., 0., MSQ_SQRT_TWO/MSQ_SQRT_THREE};
    Matrix3D m3(v_tet);
    tet_M3D =  m3 * SIXTH_ROOT_OF_TWO;

    const double v_hex[] = {1., 0., 0.,  0., 1., 0.,  0., 0., 1.};
    Matrix3D m4(v_hex);
    hex_M3D = m4;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static void initialize_default_target_matrices ( Matrix3D &  tri_M3D, Matrix3D &  quad_M3D, Matrix3D &  tet_M3D, Matrix3D &  hex_M3D  )

static

double loop_over_mesh ( MeshSet &  ms, MsqError &  err  )

virtual

This is the "run" function of PatchDataUser. It can do anything really.

Implements PatchDataUser.

Definition at line 253 of file TargetCalculator/TargetCalculator.cpp.

References TargetCalculator::compute_target_matrices_and_check_det(), PatchDataUser::get_global_patch(), PatchDataUser::get_patch_type(), PatchData::GLOBAL_PATCH, MsqError::INVALID_STATE, MSQ_CHKERR, and MSQ_SETERR.

  {
      // Currently, target calculators only work with global patches.
      // The constructor for TargetCalculator sets the patch type
      // to global, so if we don't have a global patch here something is
      // really messed up.
    PatchData* pd = get_global_patch();
    if (get_patch_type() != PatchData::GLOBAL_PATCH || NULL == pd)
    {
      MSQ_SETERR(err)(MsqError::INVALID_STATE);
      return 0.0;
    }
    
      // Compute the target matrices.
    compute_target_matrices_and_check_det( *pd, err );
    return MSQ_CHKERR(err);
  }

Here is the call graph for this function:

virtual double loop_over_mesh ( MeshSet &  ms, MsqError &  err  )

virtual

This is the "run" function of PatchDataUser. It can do anything really.

Implements PatchDataUser.

void reset_reference_meshset

(

MsqError &

err

)

Reset the reference mesh so it starts from the first vertex again.

Definition at line 47 of file TargetCalculator/TargetCalculator.cpp.

References MSQ_CHKERR, TargetCalculator::refMesh, and MeshSet::reset().

{
  if (refMesh)
    refMesh->reset(err);
  MSQ_CHKERR(err);
} 

Here is the call graph for this function:

void reset_reference_meshset

(

MsqError &

err

)

Reset the reference mesh so it starts from the first vertex again.

Member Data Documentation

MeshSet * refMesh

protected

Definition at line 149 of file includeLinks/TargetCalculator.hpp.

Referenced by TargetCalculator::compute_reference_corner_matrices(), WTargetCalculator::compute_target_matrices(), LVQDTargetCalculator::compute_target_matrices(), DeformingDomainGuides841::DeformingDomainGuides841(), DeformingDomainGuides843::DeformingDomainGuides843(), DeformingDomainGuides844::DeformingDomainGuides844(), TargetCalculator::reset_reference_meshset(), RezoneGuides832::RezoneGuides832(), ShapeGuides812::ShapeGuides812(), ShapeSizeGuides821::ShapeSizeGuides821(), ShapeSizeGuides822::ShapeSizeGuides822(), ShapeSizeGuides823::ShapeSizeGuides823(), and ShapeSizeGuides824::ShapeSizeGuides824().

---

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

• includeLinks/TargetCalculator.hpp
• src/TargetCalculator/TargetCalculator.hpp
• TargetCalculator/TargetCalculator.cpp
• inks/TargetCalculator.cpp