verdict.h

Go to the documentation of this file.

/*=========================================================================
 
 Module: $RCSfile: verdict.h,v $
 
 Copyright (c) 2006 Sandia Corporation.
 All rights reserved.
 See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE. See the above copyright notice for more information.
 
=========================================================================*/
 
/*! \file verdict.h
 \brief Header file for verdict library that calculates metrics for finite elements.
 Also see: \ref index "Main Page" 
 *
 * verdict.h is the header file for applications/libraries to include
 * to compute quality metrics.
 *
 * This file is part of VERDICT
 *
*/
 
/* note: changes to this file must be propagated to verdict.h.in so that 
 Verdict can be compiled using CMake and autoconf. */
 
#ifndef VERDICT_INC_LIB
#define VERDICT_INC_LIB
 
#ifndef VERDICT_VERSION
#define VERDICT_VERSION 120
#endif
 
#define VERDICT_DBL_MIN 1.0E-30
#define VERDICT_DBL_MAX 1.0E+30
#define VERDICT_PI 3.1415926535897932384626
 
#ifdef __cplusplus
#if defined( WIN32 ) && defined( VERDICT_SHARED_LIB )
#ifdef verdict_EXPORTS
#define C_FUNC_DEF extern "C" __declspec( dllexport )
#else
#define C_FUNC_DEF extern "C" __declspec( dllimport )
#endif
#else
#define C_FUNC_DEF extern "C"
#endif
#else
#if defined( WIN32 ) && defined( VERDICT_SHARED_LIB )
#ifdef verdict_EXPORTS
#define C_FUNC_DEF __declspec( dllexport )
#else
#define C_FUNC_DEF __declspec( dllimport )
#endif
#else
#define C_FUNC_DEF
#endif
#endif
 
/* typedef for the user if they want to use
 * function pointers */
#ifdef __cplusplus
extern "C" {
#endif
typedef double ( *VerdictFunction )( int, double[][3] );
typedef int ( *ComputeNormal )( double point[3], double normal[3] );
#ifdef __cplusplus
}
#endif
 
/** HexMetricVals is a <em>struct</em> used to return calculated metrics 
 when calling the function <em>v_hex_quality(...)</em> 
 
 HexMetricVals is used just as QuadMetricVals.
 For an example, see Detailed Description in QuadMetricVals 
*/
struct HexMetricVals
{
 /** \sa v_hex_edge_ratio */
 double edge_ratio;
 /** \sa v_hex_max_edge_ratio */
 double max_edge_ratio;
 /** \sa v_hex_skew */
 double skew;
 /** \sa v_hex_taper */
 double taper;
 /** \sa v_hex_volume */
 double volume;
 /** \sa v_hex_stretch */
 double stretch;
 /** \sa v_hex_diagonal */
 double diagonal;
 /** \sa v_hex_dimension */
 double dimension;
 /** \sa v_hex_oddy */
 double oddy;
 /** \sa v_hex_med_aspect_frobenius */
 double med_aspect_frobenius;
 /** \sa v_hex_condition */
 double condition;
 /** \sa v_hex_jacobian */
 double jacobian;
 /** \sa v_hex_scaled_jacobian */
 double scaled_jacobian;
 /** \sa v_hex_shear */
 double shear;
 /** \sa v_hex_shape */
 double shape;
 /** \sa v_hex_relative_size */
 double relative_size_squared;
 /** \sa v_hex_shape_and_size */
 double shape_and_size;
 /** \sa v_hex_shear_and_size */
 double shear_and_size;
 /** \sa v_hex_distortion */
 double distortion;
};
 
/** EdgeMetricVals is a <em>struct</em> used to return calculated metrics 
 when calling the function <em>v_edge_quality(...)</em> 
 
 EdgeMetricVals is used just as QuadMetricVals.
 For an example, see Detailed Description in QuadMetricVals 
*/
struct EdgeMetricVals
{
 double length;
};
 
/** KnifeMetricVals is a <em>struct</em> used to return calculated metrics 
 when calling the function <em>v_knife_quality(...)</em> 
 
 KnifeMetricVals is used just as QuadMetricVals.
 For an example, see Detailed Description in QuadMetricVals 
*/
struct KnifeMetricVals
{
 double volume;
};
 
/** QuadMetricVals is a <em>struct</em> used to return calculated metrics 
 when calling the function <em>v_quad_quality(...)</em> 
 
 The following is an example of how this struct is used with Verdict.
 
 Example: \code
 QuadMetricVals quad_metrics = {0};
 unsigned long metrics_flag = 0;
 metrics_flag += V_QUAD_SHAPE;
 metrics_flag += V_QUAD_DISTORTION;
 metrics_flag += V_QUAD_AREA; 
 double quad_nodes[4][3];
 get_quad_nodes( quad_nodes ); //some user-defined function to load 
 //xyz coordinate info. into array 
 v_quad_quality( 4, quad_nodes, metrics_flag, quad_metrics );
 double my_shape = quad_metrics.shape; 
 double my_distortion = quad_metrics.distortion; 
 double my_area = quad_metrics.area; \endcode
 
 */
 
struct QuadMetricVals
{
 /** \sa v_quad_edge_ratio function */
 double edge_ratio;
 /** \sa v_quad_max_edge_ratio function */
 double max_edge_ratio;
 /** \sa v_quad_aspect_ratio function */
 double aspect_ratio;
 /** \sa v_quad_radius_ratio function */
 double radius_ratio;
 /** \sa v_quad_med_aspect_frobenius function */
 double med_aspect_frobenius;
 /** \sa v_quad_max_aspect_frobenius function */
 double max_aspect_frobenius;
 /** \sa v_quad_skew function */
 double skew;
 /** \sa v_quad_taper function */
 double taper;
 /** \sa v_quad_warpage function */
 double warpage;
 /** \sa v_quad_area function */
 double area;
 /** \sa v_quad_stretch function */
 double stretch;
 /** \sa v_quad_smallest_angle function */
 double minimum_angle;
 /** \sa v_quad_largest_angle function */
 double maximum_angle;
 /** \sa v_quad_oddy function */
 double oddy;
 /** \sa v_quad_condition function */
 double condition;
 /** \sa v_quad_jacobian function */
 double jacobian;
 /** \sa v_quad_scaled_jacobian function */
 double scaled_jacobian;
 /** \sa v_quad_shear function */
 double shear;
 /** \sa v_quad_shape function */
 double shape;
 /** \sa v_quad_relative_size_squared function */
 double relative_size_squared;
 /** \sa v_quad_shape_and_size function */
 double shape_and_size;
 /** \sa v_quad_shear_and_size function */
 double shear_and_size;
 /** \sa v_quad_distortion function */
 double distortion;
};
 
/** PyramidMetricVals is a <em>struct</em> used to return calculated metrics 
 when calling the function <em>v_pyramid_quality(...)</em> 
 
 PyramidMetricVals is used just as QuadMetricVals.
 For an example, see Detailed Description in QuadMetricVals 
*/
struct PyramidMetricVals
{
 double volume;
};
 
/** WedgeMetricVals is a <em>struct</em> used to return calculated metrics 
 when calling the function <em>v_wedge_quality(...)</em> 
 
 WedgeMetricVals is used just as QuadMetricVals.
 For an example, see Detailed Description in QuadMetricVals 
*/
struct WedgeMetricVals
{
 double volume;
};
 
/** TetMetricVals is a <em>struct</em> used to return calculated metrics 
 when calling the function <em>v_tet_quality(...)</em> 
 
 TetMetricVals is used just as QuadMetricVals.
 For an example, see Detailed Description in QuadMetricVals 
*/
struct TetMetricVals
{
 /** \sa v_tet_edge_ratio*/
 double edge_ratio;
 /** \sa v_tet_radius_ratio*/
 double radius_ratio;
 /** \sa v_tet_aspect_beta*/
 double aspect_beta;
 /** \sa v_tet_aspect_ratio */
 double aspect_ratio;
 /** \sa v_tet_aspect_gamma */
 double aspect_gamma;
 /** \sa v_tet_aspect_frobenius */
 double aspect_frobenius;
 /** \sa v_tet_minimum_angle */
 double minimum_angle;
 /** \sa v_tet_collapse_ratio*/
 double collapse_ratio;
 /** \sa v_tet_volume */
 double volume;
 /** \sa v_tet_condition */
 double condition;
 /** \sa v_tet_jacobian */
 double jacobian;
 /** \sa v_tet_scaled_jacobian */
 double scaled_jacobian;
 /** \sa v_tet_shape */
 double shape;
 /** \sa v_tet_relative_size */
 double relative_size_squared;
 /** \sa v_tet_shape_and_size*/
 double shape_and_size;
 /** \sa v_tet_distortion */
 double distortion;
};
 
/** TriMetricVals is a <em>struct</em> used to return calculated metrics 
 when calling the function <em>v_tri_quality(...)</em> 
 
 TriMetricVals is used just as QuadMetricVals.
 For an example, see Detailed Description in QuadMetricVals 
*/
struct TriMetricVals
{
 /** \sa v_tri_edge_ratio */
 double edge_ratio;
 /** \sa v_tri_aspect_ratio */
 double aspect_ratio;
 /** \sa v_tri_radius_ratio */
 double radius_ratio;
 /** \sa v_tri_aspect_frobenius */
 double aspect_frobenius;
 /** \sa v_tri_area*/
 double area;
 /** \sa v_tri_minimum_angle*/
 double minimum_angle;
 /** \sa v_tri_maximum_angle */
 double maximum_angle;
 /** \sa v_tri_condition */
 double condition;
 /** \sa v_tri_scaled_jacobian */
 double scaled_jacobian;
 /** \sa v_tri_shape */
 double shape;
 /** \sa v_tri_relative_size_squared */
 double relative_size_squared;
 /** \sa v_tri_shape_and_size */
 double shape_and_size;
 /** \sa v_tri_distortion */
 double distortion;
};
 
/* definition of bit fields to determine which metrics to calculate */
 
//! \name Hex bit fields
//!
//@{
 
#define V_HEX_MAX_EDGE_RATIO 1 /*!< \hideinitializer */
#define V_HEX_SKEW 2 /*!< \hideinitializer */
#define V_HEX_TAPER 4 /*!< \hideinitializer */
#define V_HEX_VOLUME 8 /*!< \hideinitializer */
#define V_HEX_STRETCH 16 /*!< \hideinitializer */
#define V_HEX_DIAGONAL 32 /*!< \hideinitializer */
#define V_HEX_DIMENSION 64 /*!< \hideinitializer */
#define V_HEX_ODDY 128 /*!< \hideinitializer */
#define V_HEX_MAX_ASPECT_FROBENIUS 256 /*!< \hideinitializer */
#define V_HEX_CONDITION 256 /*!< \hideinitializer */
#define V_HEX_JACOBIAN 512 /*!< \hideinitializer */
#define V_HEX_SCALED_JACOBIAN 1024 /*!< \hideinitializer */
#define V_HEX_SHEAR 2048 /*!< \hideinitializer */
#define V_HEX_SHAPE 4096 /*!< \hideinitializer */
#define V_HEX_RELATIVE_SIZE_SQUARED 8192 /*!< \hideinitializer */
#define V_HEX_SHAPE_AND_SIZE 16384 /*!< \hideinitializer */
#define V_HEX_SHEAR_AND_SIZE 32768 /*!< \hideinitializer */
#define V_HEX_DISTORTION 65536 /*!< \hideinitializer */
#define V_HEX_EDGE_RATIO 131072 /*!< \hideinitializer */
#define V_HEX_MED_ASPECT_FROBENIUS 262144 /*!< \hideinitializer */
#define V_HEX_ALL 524287 /*!< \hideinitializer */
/*!< \hideinitializer */
#define V_HEX_TRADITIONAL \
 ( V_HEX_MAX_EDGE_RATIO + V_HEX_SKEW + V_HEX_TAPER + V_HEX_STRETCH + V_HEX_DIAGONAL + V_HEX_ODDY + \
 V_HEX_CONDITION + V_HEX_JACOBIAN + V_HEX_SCALED_JACOBIAN + V_HEX_DIMENSION )
 
/*!< \hideinitializer */
#define V_HEX_DIAGNOSTIC V_HEX_VOLUME
/*!< \hideinitializer */
#define V_HEX_ALGEBRAIC \
 ( V_HEX_SHAPE + V_HEX_SHEAR + V_HEX_RELATIVE_SIZE_SQUARED + V_HEX_SHAPE_AND_SIZE + V_HEX_SHEAR_AND_SIZE )
/*!< \hideinitializer */
#define V_HEX_ROBINSON ( V_HEX_SKEW + V_HEX_TAPER )
//@}
 
//! \name Tet bit fields
//!
//@{
#define V_TET_RADIUS_RATIO 1 /*!< \hideinitializer */
#define V_TET_ASPECT_BETA 2 /*!< \hideinitializer */
#define V_TET_ASPECT_GAMMA 4 /*!< \hideinitializer */
#define V_TET_VOLUME 8 /*!< \hideinitializer */
#define V_TET_CONDITION 16 /*!< \hideinitializer */
#define V_TET_JACOBIAN 32 /*!< \hideinitializer */
#define V_TET_SCALED_JACOBIAN 64 /*!< \hideinitializer */
#define V_TET_SHAPE 128 /*!< \hideinitializer */
#define V_TET_RELATIVE_SIZE_SQUARED 256 /*!< \hideinitializer */
#define V_TET_SHAPE_AND_SIZE 512 /*!< \hideinitializer */
#define V_TET_DISTORTION 1024 /*!< \hideinitializer */
#define V_TET_EDGE_RATIO 2048 /*!< \hideinitializer */
#define V_TET_ASPECT_RATIO 4096 /*!< \hideinitializer */
#define V_TET_ASPECT_FROBENIUS 8192 /*!< \hideinitializer */
#define V_TET_MINIMUM_ANGLE 16384 /*!< \hideinitializer */
#define V_TET_COLLAPSE_RATIO 32768 /*!< \hideinitializer */
#define V_TET_ALL 65535 /*!< \hideinitializer */
/*!< \hideinitializer */
#define V_TET_TRADITIONAL \
 ( V_TET_ASPECT_BETA + V_TET_ASPECT_GAMMA + V_TET_CONDITION + V_TET_JACOBIAN + V_TET_SCALED_JACOBIAN )
/*!< \hideinitializer */
#define V_TET_DIAGNOSTIC V_TET_VOLUME
/*!< \hideinitializer */
#define V_TET_ALGEBRAIC ( V_TET_SHAPE + V_TET_RELATIVE_SIZE_SQUARED + V_TET_SHAPE_AND_SIZE )
//@}
 
//! \name Pyramid bit fields
//!
//@{
#define V_PYRAMID_VOLUME 1 /*!< \hideinitializer */
//@}
 
//! \name Wedge bit fields
//!
//@{
#define V_WEDGE_VOLUME 1 /*!< \hideinitializer */
//@}
 
//! \name Knife bit fields
//!
//@{
#define V_KNIFE_VOLUME 1 /*!< \hideinitializer */
//@}
 
//! \name Quad bit fields
//!
//@{
#define V_QUAD_MAX_EDGE_RATIO 1 /*!< \hideinitializer */
#define V_QUAD_SKEW 2 /*!< \hideinitializer */
#define V_QUAD_TAPER 4 /*!< \hideinitializer */
#define V_QUAD_WARPAGE 8 /*!< \hideinitializer */
#define V_QUAD_AREA 16 /*!< \hideinitializer */
#define V_QUAD_STRETCH 32 /*!< \hideinitializer */
#define V_QUAD_MINIMUM_ANGLE 64 /*!< \hideinitializer */
#define V_QUAD_MAXIMUM_ANGLE 128 /*!< \hideinitializer */
#define V_QUAD_ODDY 256 /*!< \hideinitializer */
#define V_QUAD_CONDITION 512 /*!< \hideinitializer */
#define V_QUAD_JACOBIAN 1024 /*!< \hideinitializer */
#define V_QUAD_SCALED_JACOBIAN 2048 /*!< \hideinitializer */
#define V_QUAD_SHEAR 4096 /*!< \hideinitializer */
#define V_QUAD_SHAPE 8192 /*!< \hideinitializer */
#define V_QUAD_RELATIVE_SIZE_SQUARED 16384 /*!< \hideinitializer */
#define V_QUAD_SHAPE_AND_SIZE 32768 /*!< \hideinitializer */
#define V_QUAD_SHEAR_AND_SIZE 65536 /*!< \hideinitializer */
#define V_QUAD_DISTORTION 131072 /*!< \hideinitializer */
#define V_QUAD_EDGE_RATIO 262144 /*!< \hideinitializer */
#define V_QUAD_ASPECT_RATIO 524288 /*!< \hideinitializer */
#define V_QUAD_RADIUS_RATIO 1048576 /*!< \hideinitializer */
#define V_QUAD_MED_ASPECT_FROBENIUS 2097152 /*!< \hideinitializer */
#define V_QUAD_MAX_ASPECT_FROBENIUS 4194304 /*!< \hideinitializer */
#define V_QUAD_ALL 8388607 /*!< \hideinitializer */
/*!< \hideinitializer */
#define V_QUAD_TRADITIONAL \
 ( V_QUAD_MAX_EDGE_RATIO + V_QUAD_SKEW + V_QUAD_TAPER + V_QUAD_WARPAGE + V_QUAD_STRETCH + V_QUAD_MINIMUM_ANGLE + \
 V_QUAD_MAXIMUM_ANGLE + V_QUAD_ODDY + V_QUAD_CONDITION + V_QUAD_JACOBIAN + V_QUAD_SCALED_JACOBIAN )
/*!< \hideinitializer */
#define V_QUAD_DIAGNOSTIC V_QUAD_AREA
/*!< \hideinitializer */
#define V_QUAD_ALGEBRAIC ( V_QUAD_SHEAR + V_QUAD_SHAPE + V_QUAD_RELATIVE_SIZE_SQUARED + V_QUAD_SHAPE_AND_SIZE )
/*!< \hideinitializer */
#define V_QUAD_ROBINSON ( V_QUAD_MAX_EDGE_RATIO + V_QUAD_SKEW + V_QUAD_TAPER )
//@}
 
//! \name Tri bit fields
//!
//@{
#define V_TRI_ASPECT_FROBENIUS 1 /*!< \hideinitializer */
#define V_TRI_AREA 2 /*!< \hideinitializer */
#define V_TRI_MINIMUM_ANGLE 4 /*!< \hideinitializer */
#define V_TRI_MAXIMUM_ANGLE 8 /*!< \hideinitializer */
#define V_TRI_CONDITION 16 /*!< \hideinitializer */
#define V_TRI_SCALED_JACOBIAN 32 /*!< \hideinitializer */
#define V_TRI_SHAPE 64 /*!< \hideinitializer */
#define V_TRI_RELATIVE_SIZE_SQUARED 128 /*!< \hideinitializer */
#define V_TRI_SHAPE_AND_SIZE 256 /*!< \hideinitializer */
#define V_TRI_DISTORTION 512 /*!< \hideinitializer */
#define V_TRI_RADIUS_RATIO 1024 /*!< \hideinitializer */
#define V_TRI_EDGE_RATIO 2048 /*!< \hideinitializer */
#define V_TRI_ALL 4095 /*!< \hideinitializer */
/*!< \hideinitializer */
#define V_TRI_TRADITIONAL \
 ( V_TRI_ASPECT_FROBENIUS + V_TRI_MINIMUM_ANGLE + V_TRI_MAXIMUM_ANGLE + V_TRI_CONDITION + V_TRI_SCALED_JACOBIAN )
/*!< \hideinitializer */
#define V_TRI_DIAGNOSTIC V_TRI_AREA
/*!< \hideinitializer */
#define V_TRI_ALGEBRAIC ( V_TRI_SHAPE + V_TRI_SHAPE_AND_SIZE + V_TRI_RELATIVE_SIZE_SQUARED )
 
#define V_EDGE_LENGTH 1 /*!< \hideinitializer */
 //@}
 
/*! \mainpage
 Verdict is a library used to calculate metrics on the following type of elements:
 
 \li Hexahedra
 \li Tetrahedra
 \li Pryamid 
 \li Wedge 
 \li Knife 
 \li Quadrilateral
 \li Triangle
 \li Edge 
 
 Verdict calculates individual or multiple metrics on a single element.
 The v_*_quality(...) functions allow for efficient calculations of 
 multiple metrics on a single element. Individual metrics may be 
 calculated on a single element as well. 
 
 \section jack Using Verdict
 
 The v_*_quality functions take the following parameters: 
 
 \param num_nodes Number of nodes in the element. 
 \param coordinates 2D array containing x,y,z coordinate data of the nodes.
 \param metrics_request_flag Bitfield to define which metrics to calculate.
 \param metric_vals Struct to hold the metric calculated values. 
 
 All other functions take these parameters below and return the calculated
 metric value.
 
 \param num_nodes Number of nodes in the element. 
 \param coordinates 2D array containing x,y,z coordinate data of the nodes.
 
 
 \par Setting the metrics_request_flag: 
 In order to use v_*_quality functions you must know how to set the bitfield argument 
 correctly. To calculate aspect ratio, condition number, shape and shear metrics on a triangle, set
 the "metrics_request_flag" like so: 
 
 \code
 unsigned int metrics_request_flag = 0;
 metrics_request_flag += V_TRI_ASPECT_FROBENIUS; 
 metrics_request_flag += V_CONDITION;
 metrics_request_flag += V_SHAPE;
 metrics_request_flag += V_SHEAR;
 \endcode 
 
 The bitwise field can also be set for many metrics at once using #deinfed numbers. V_HEX_ALL,
 V_HEX_DIAGNOSTIC, V_TRI_ALGEBRAIC are examples.
 
 Below is an example of how use Verdict's functions:
 
 
 Example: \code
 QuadMetricVals quad_metrics = {0};
 unsigned long metrics_flag = 0;
 metrics_flag += V_QUAD_SHAPE;
 metrics_flag += V_QUAD_DISTORTION;
 metrics_flag += V_QUAD_AREA;
 double quad_nodes[4][3];
 
 //node 1
 quad_node[0][0] = 0; //x
 quad_node[0][1] = 0; //y
 quad_node[0][2] = 0; //z
 
 //node 2
 quad_node[1][0] = 1; 
 quad_node[1][1] = 0.1;
 quad_node[1][2] = 0.1;
 
 //node 3
 quad_node[2][0] = 0.9; 
 quad_node[2][1] = 0.9;
 quad_node[2][2] = -0.1;
 
 //node 4
 quad_node[3][0] = -0.05; 
 quad_node[3][1] = 1;
 quad_node[3][2] = 0;
 
 //calculate multiple metrics with one call
 v_quad_quality( 4, quad_nodes, metrics_flag, quad_metrics );
 double my_shape = quad_metrics.shape; 
 double my_distortion = quad_metrics.distortion; 
 double my_area = quad_metrics.area; 
 
 //calculate an individual metric 
 double my_relative_size = v_quad_relative_size( 4, quad_nodes );
 \endcode
 
*/
 
//! Calculates quality metrics for hexahedral elements.
C_FUNC_DEF void v_hex_quality( int num_nodes,
 double coordinates[][3],
 unsigned int metrics_request_flag,
 struct HexMetricVals* metric_vals );
 
//! Calculates quality metrics for tetrahedral elements.
C_FUNC_DEF void v_tet_quality( int num_nodes,
 double coordinates[][3],
 unsigned int metrics_request_flag,
 struct TetMetricVals* metric_vals );
 
//! Calculates quality metrics for pyramid elements.
C_FUNC_DEF void v_pyramid_quality( int num_nodes,
 double coordinates[][3],
 unsigned int metrics_request_flag,
 struct PyramidMetricVals* metric_vals );
 
//! Calculates quality metrics for wedge elements.
C_FUNC_DEF void v_wedge_quality( int num_nodes,
 double coordinates[][3],
 unsigned int metrics_request_flag,
 struct WedgeMetricVals* metric_vals );
 
//! Calculates quality metrics for knife elements.
C_FUNC_DEF void v_knife_quality( int num_nodes,
 double coordinates[][3],
 unsigned int metrics_request_flag,
 struct KnifeMetricVals* metric_vals );
 
//! Calculates quality metrics for quadrilateral elements.
C_FUNC_DEF void v_quad_quality( int num_nodes,
 double coordinates[][3],
 unsigned int metrics_request_flag,
 struct QuadMetricVals* metric_vals );
 
//! Calculates quality metrics for triangle elements.
C_FUNC_DEF void v_tri_quality( int num_nodes,
 double coordinates[][3],
 unsigned int metrics_request_flag,
 struct TriMetricVals* metric_vals );
 
//! Calculates quality metrics for edge elements.
C_FUNC_DEF void v_edge_quality( int num_nodes,
 double coordinates[][3],
 unsigned int metrics_request_flag,
 struct EdgeMetricVals* metric_vals );
 
/* individual quality functions for hex elements */
 
//! Sets average size (volume) of hex, needed for v_hex_relative_size(...)
C_FUNC_DEF void v_set_hex_size( double size );
 
//! Calculates hex edge ratio metric.
/** Hmax / Hmin where Hmax and Hmin are respectively the maximum and the
 minimum edge lengths */
C_FUNC_DEF double v_hex_edge_ratio( int num_nodes, double coordinates[][3] );
 
//! Calculates hex maximum of edge ratio
/**Maximum edge length ratio at hex center.
 Reference --- L.M. Taylor, and D.P. Flanagan, Pronto3D - A Three Dimensional Transient
 Solid Dynamics Program, SAND87-1912, Sandia National Laboratories, 1989. */
C_FUNC_DEF double v_hex_max_edge_ratio( int num_nodes, double coordinates[][3] );
 
//! Calculates hex skew metric.
/** Maximum |cos A| where A is the angle between edges at hex center. 
 Reference --- L.M. Taylor, and D.P. Flanagan, Pronto3D - A Three Dimensional Transient
 Solid Dynamics Program, SAND87-1912, Sandia National Laboratories, 1989. */
C_FUNC_DEF double v_hex_skew( int num_nodes, double coordinates[][3] );
 
//! Calculates hex taper metric
/** Maximum ratio of lengths derived from opposite edges. 
 Reference --- L.M. Taylor, and D.P. Flanagan, Pronto3D - A Three Dimensional Transient
 Solid Dynamics Program, SAND87-1912, Sandia National Laboratories, 1989. */
C_FUNC_DEF double v_hex_taper( int num_nodes, double coordinates[][3] );
 
//! Calculates hex volume
/** Jacobian at hex center. 
 Reference --- L.M. Taylor, and D.P. Flanagan, Pronto3D - A Three Dimensional Transient
 Solid Dynamics Program, SAND87-1912, Sandia National Laboratories, 1989. */
C_FUNC_DEF double v_hex_volume( int num_nodes, double coordinates[][3] );
 
//! Calculates hex stretch metric
/** Sqrt(3) * minimum edge length / maximum diagonal length. 
 Reference --- FIMESH code */
C_FUNC_DEF double v_hex_stretch( int num_nodes, double coordinates[][3] );
 
//! Calculates hex diagonal metric
/** Minimum diagonal length / maximum diagonal length. 
 Reference --- Unknown */
C_FUNC_DEF double v_hex_diagonal( int num_nodes, double coordinates[][3] );
 
//! Calculates hex dimension metric
/** Pronto-specific characteristic length for stable time step calculation. 
 Char_length = Volume / 2 grad Volume. 
 Reference --- L.M. Taylor, and D.P. Flanagan, Pronto3D - A Three Dimensional Transient
 Solid Dynamics Program, SAND87-1912, Sandia National Laboratories, 1989. */
C_FUNC_DEF double v_hex_dimension( int num_nodes, double coordinates[][3] );
 
//! Calculates hex oddy metric
C_FUNC_DEF double v_hex_oddy( int num_nodes, double coordinates[][3] );
 
//! Calculates hex condition metric
/** Average Frobenius condition number of the Jacobian matrix at 8 corners. */
C_FUNC_DEF double v_hex_med_aspect_frobenius( int num_nodes, double coordinates[][3] );
 
//! Calculates hex condition metric
/** Maximum Frobenius condition number of the Jacobian matrix at 8 corners.
 Reference --- P. Knupp, Achieving Finite Element Mesh Quality via 
 Optimization of the Jacobian Matrix Norm and Associated Quantities, 
 Intl. J. Numer. Meth. Engng. 2000, 48:1165-1185. */
C_FUNC_DEF double v_hex_max_aspect_frobenius( int num_nodes, double coordinates[][3] );
C_FUNC_DEF double v_hex_condition( int num_nodes, double coordinates[][3] );
 
//! Calculates hex jacobian metric
/** Minimum pointwise volume of local map at 8 corners & center of hex. 
 Reference --- P. Knupp, Achieving Finite Element Mesh Quality via 
 Optimization of the Jacobian Matrix Norm and Associated Quantities, 
 Intl. J. Numer. Meth. Engng. 2000, 48:1165-1185. */
C_FUNC_DEF double v_hex_jacobian( int num_nodes, double coordinates[][3] );
 
//! Calculates hex scaled jacobian metric
/** Minimum Jacobian divided by the lengths of the 3 edge vectors. 
 Reference --- P. Knupp, Achieving Finite Element Mesh Quality via 
 Optimization of the Jacobian Matrix Norm and Associated Quantities, 
 Intl. J. Numer. Meth. Engng. 2000, 48:1165-1185. */
C_FUNC_DEF double v_hex_scaled_jacobian( int num_nodes, double coordinates[][3] );
 
//! Calculates hex shear metric
/** 3/Mean Ratio of Jacobian Skew matrix.
 Reference --- P. Knupp, Algebraic Mesh Quality Metrics for
 Unstructured Initial Meshes, submitted for publication. */
C_FUNC_DEF double v_hex_shear( int num_nodes, double coordinates[][3] );
 
//! Calculates hex shape metric.
/** 3/Mean Ratio of weighted Jacobian matrix. 
 Reference --- P. Knupp, Algebraic Mesh Quality Metrics for
 Unstructured Initial Meshes, submitted for publication. */
C_FUNC_DEF double v_hex_shape( int num_nodes, double coordinates[][3] );
 
//! Calculates hex relative size metric.
/** 3/Mean Ratio of weighted Jacobian matrix.
 Reference --- P. Knupp, Algebraic Mesh Quality Metrics for
 Unstructured Initial Meshes, submitted for publication. */
C_FUNC_DEF double v_hex_relative_size_squared( int num_nodes, double coordinates[][3] );
 
//! Calculates hex shape-size metric.
/** Product of Shape and Relative Size.
 Reference --- P. Knupp, Algebraic Mesh Quality Metrics for
 Unstructured Initial Meshes, submitted for publication. */
C_FUNC_DEF double v_hex_shape_and_size( int num_nodes, double coordinates[][3] );
 
//! Calculates hex shear-size metric
/** Product of Shear and Relative Size.
 Reference --- P. Knupp, Algebraic Mesh Quality Metrics for
 Unstructured Initial Meshes, submitted for publication. */
C_FUNC_DEF double v_hex_shear_and_size( int num_nodes, double coordinates[][3] );
 
//! Calculates hex distortion metric
/** {min(|J|)/actual volume}*parent volume, parent volume = 8 for hex.
 Reference --- SDRC/IDEAS Simulation: Finite Element Modeling--User's Guide */
C_FUNC_DEF double v_hex_distortion( int num_nodes, double coordinates[][3] );
 
/* individual quality functions for tet elements */
 
//! Sets average size (volume) of tet, needed for v_tet_relative_size(...)
C_FUNC_DEF void v_set_tet_size( double size );
 
//! Calculates tet edge ratio metric.
/** Hmax / Hmin where Hmax and Hmin are respectively the maximum and the
 minimum edge lengths */
C_FUNC_DEF double v_tet_edge_ratio( int num_nodes, double coordinates[][3] );
 
//! Calculates tet radius ratio metric.
/** CR / (3.0 * IR) where CR = circumsphere radius, IR = inscribed sphere radius.
 Reference --- V. N. Parthasarathy et al, A comparison of tetrahedron 
 quality measures, Finite Elem. Anal. Des., Vol 15(1993), 255-261. */
C_FUNC_DEF double v_tet_radius_ratio( int num_nodes, double coordinates[][3] );
 
//! Calculates the radius ratio metric of a positively oriented tet.
/** CR / (3.0 * IR) where CR = circumsphere radius, IR = inscribed sphere radius
 if the element is positively-oriented.
 Reference --- V. N. Parthasarathy et al, A comparison of tetrahedron 
 quality measures, Finite Elem. Anal. Des., Vol 15(1993), 255-261. */
C_FUNC_DEF double v_tet_aspect_beta( int num_nodes, double coordinates[][3] );
 
//! Calculates tet aspect ratio metric.
/** Hmax / (2 sqrt(6) r) where Hmax and r respectively denote the greatest edge 
 length and the inradius of the tetrahedron
 Reference --- P. Frey and P.-L. George, Meshing, Hermes (2000). */
C_FUNC_DEF double v_tet_aspect_ratio( int num_nodes, double coordinates[][3] );
 
//! Calculates tet aspect gamma metric.
/** Srms**3 / (8.479670*V) where Srms = sqrt(Sum(Si**2)/6), Si = edge length. 
 Reference --- V. N. Parthasarathy et al, A comparison of tetrahedron 
 quality measures, Finite Elem. Anal. Des., Vol 15(1993), 255-261. */
C_FUNC_DEF double v_tet_aspect_gamma( int num_nodes, double coordinates[][3] );
 
//! Calculates tet aspect frobenius metric.
/** Frobenius condition number when the reference element is regular
 Reference --- P. Knupp, Achieving Finite Element Mesh Quality via 
 Optimization of the Jacobian Matrix Norm and Associated Quantities,
 Intl. J. Numer. Meth. Engng. 2000, 48:1165-1185. */
C_FUNC_DEF double v_tet_aspect_frobenius( int num_nodes, double coordinates[][3] );
 
//! Calculates tet minimum dihedral angle.
/** Minimum (nonoriented) dihedral angle of a tetrahedron, expressed in degrees. */
C_FUNC_DEF double v_tet_minimum_angle( int num_nodes, double coordinates[][3] );
 
//! Calculates tet collapse ratio metric.
/** Collapse ratio */
C_FUNC_DEF double v_tet_collapse_ratio( int num_nodes, double coordinates[][3] );
 
//! Calculates tet volume.
/** (1/6) * Jacobian at corner node.
 Reference --- V. N. Parthasarathy et al, A comparison of tetrahedron 
 quality measures, Finite Elem. Anal. Des., Vol 15(1993), 255-261. */
C_FUNC_DEF double v_tet_volume( int num_nodes, double coordinates[][3] );
 
//! Calculates tet condition metric.
/** Condition number of the Jacobian matrix at any corner. 
 Reference --- P. Knupp, Achieving Finite Element Mesh Quality via 
 Optimization of the Jacobian Matrix Norm and Associated Quantities,
 Intl. J. Numer. Meth. Engng. 2000, 48:1165-1185. */
C_FUNC_DEF double v_tet_condition( int num_nodes, double coordinates[][3] );
 
//! Calculates tet jacobian.
/** Minimum pointwise volume at any corner. 
 Reference --- P. Knupp, Achieving Finite Element Mesh Quality via 
 Optimization of the Jacobian Matrix Norm and Associated Quantities,
 Intl. J. Numer. Meth. Engng. 2000, 48:1165-1185. */
C_FUNC_DEF double v_tet_jacobian( int num_nodes, double coordinates[][3] );
 
//! Calculates tet scaled jacobian.
/** Minimum Jacobian divided by the lengths of 3 edge vectors 
 Reference --- P. Knupp, Achieving Finite Element Mesh Quality via 
 Optimization of the Jacobian Matrix Norm and Associated Quantities,
 Intl. J. Numer. Meth. Engng. 2000, 48:1165-1185. */
C_FUNC_DEF double v_tet_scaled_jacobian( int num_nodes, double coordinates[][3] );
 
//! Calculates tet shape metric.
/** 3/Mean Ratio of weighted Jacobian matrix.
 Reference --- P. Knupp, Algebraic Mesh Quality Metrics for
 Unstructured Initial Meshes, submitted for publication. */
C_FUNC_DEF double v_tet_shape( int num_nodes, double coordinates[][3] );
 
//! Calculates tet relative size metric.
/** Min( J, 1/J ), where J is determinant of weighted Jacobian matrix.
 Reference --- P. Knupp, Algebraic Mesh Quality Metrics for
 Unstructured Initial Meshes, submitted for publication. */
C_FUNC_DEF double v_tet_relative_size_squared( int num_nodes, double coordinates[][3] );
 
//! Calculates tet shape-size metric.
/** Product of Shape and Relative Size. 
 Reference --- P. Knupp, Algebraic Mesh Quality Metrics for
 Unstructured Initial Meshes, submitted for publication. */
C_FUNC_DEF double v_tet_shape_and_size( int num_nodes, double coordinates[][3] );
 
//! Calculates tet distortion metric.
/** {min(|J|)/actual volume}*parent volume, parent volume = 1/6 for tet.
 Reference --- SDRC/IDEAS Simulation: Finite Element Modeling--User's Guide */
C_FUNC_DEF double v_tet_distortion( int num_nodes, double coordinates[][3] );
 
/* individual quality functions for pyramid elements */
 
//! Calculates pyramid volume.
C_FUNC_DEF double v_pyramid_volume( int num_nodes, double coordinates[][3] );
 
/* individual quality functions for wedge elements */
 
//! Calculates wedge volume.
C_FUNC_DEF double v_wedge_volume( int num_nodes, double coordinates[][3] );
 
/* individual quality functions for knife elements */
 
//! Calculates knife volume.
C_FUNC_DEF double v_knife_volume( int num_nodes, double coordinates[][3] );
 
/* individual quality functions for edge elements */
 
//! Calculates edge length.
C_FUNC_DEF double v_edge_length( int num_nodes, double coordinates[][3] );
 
/* individual quality functions for quad elements */
//! Sets average size (area) of quad, needed for v_quad_relative_size(...)
C_FUNC_DEF void v_set_quad_size( double size );
 
//! Calculates quad edge ratio
/** edge ratio
 Reference --- P. P. Pebay, Planar Quadrangle Quality
 Measures, Eng. Comp., 2004, 20(2):157-173 */
C_FUNC_DEF double v_quad_edge_ratio( int num_nodes, double coordinates[][3] );
 
//! Calculates quad maximum of edge ratio.
/** Maximum edge length ratio at quad center.
 Reference --- J. Robinson, CRE Method of element testing and the 
 Jacobian shape parameters, Eng. Comput., Vol 4, 1987. */
C_FUNC_DEF double v_quad_max_edge_ratio( int num_nodes, double coordinates[][3] );
 
//! Calculates quad aspect ratio
/** aspect ratio
 Reference --- P. P. Pebay, Planar Quadrangle Quality
 Measures, Eng. Comp., 2004, 20(2):157-173 */
C_FUNC_DEF double v_quad_aspect_ratio( int num_nodes, double coordinates[][3] );
 
//! Calculates quad radius ratio
/** radius ratio
 Reference --- P. P. Pebay, Planar Quadrangle Quality
 Measures, Eng. Comp., 2004, 20(2):157-173 */
C_FUNC_DEF double v_quad_radius_ratio( int num_nodes, double coordinates[][3] );
 
//! Calculates quad average Frobenius aspect
/** average Frobenius aspect
 Reference --- P. P. Pebay, Planar Quadrangle Quality
 Measures, Eng. Comp., 2004, 20(2):157-173 */
C_FUNC_DEF double v_quad_med_aspect_frobenius( int num_nodes, double coordinates[][3] );
 
//! Calculates quad maximum Frobenius aspect
/** average Frobenius aspect
 Reference --- P. P. Pebay, Planar Quadrangle Quality
 Measures, Eng. Comp., 2004, 20(2):157-173 */
C_FUNC_DEF double v_quad_max_aspect_frobenius( int num_nodes, double coordinates[][3] );
 
//! Calculates quad skew metric.
/** Maximum |cos A| where A is the angle between edges at quad center. 
 Reference --- J. Robinson, CRE Method of element testing and the 
 Jacobian shape parameters, Eng. Comput., Vol 4, 1987. */
C_FUNC_DEF double v_quad_skew( int num_nodes, double coordinates[][3] );
 
//! Calculates quad taper metric.
/** Maximum ratio of lengths derived from opposite edges. 
 Reference --- J. Robinson, CRE Method of element testing and the 
 Jacobian shape parameters, Eng. Comput., Vol 4, 1987. */
C_FUNC_DEF double v_quad_taper( int num_nodes, double coordinates[][3] );
 
//! Calculates quad warpage metric.
/** Cosine of Minimum Dihedral Angle formed by Planes Intersecting in Diagonals. 
 Reference --- J. Robinson, CRE Method of element testing and the 
 Jacobian shape parameters, Eng. Comput., Vol 4, 1987. */
C_FUNC_DEF double v_quad_warpage( int num_nodes, double coordinates[][3] );
 
//! Calculates quad area.
/** Jacobian at quad center.
 Reference --- J. Robinson, CRE Method of element testing and the 
 Jacobian shape parameters, Eng. Comput., Vol 4, 1987. */
C_FUNC_DEF double v_quad_area( int num_nodes, double coordinates[][3] );
 
//! Calculates quad strech metric.
/** Sqrt(2) * minimum edge length / maximum diagonal length.
 Reference --- FIMESH code. */
C_FUNC_DEF double v_quad_stretch( int num_nodes, double coordinates[][3] );
 
//! Calculates quad's smallest angle.
/** Smallest included quad angle (degrees).
 Reference --- Unknown. */
C_FUNC_DEF double v_quad_minimum_angle( int num_nodes, double coordinates[][3] );
 
//! Calculates quad's largest angle.
/** Largest included quad angle (degrees). 
 Reference --- Unknown. */
C_FUNC_DEF double v_quad_maximum_angle( int num_nodes, double coordinates[][3] );
 
//! Calculates quad oddy metric.
C_FUNC_DEF double v_quad_oddy( int num_nodes, double coordinates[][3] );
 
//! Calculates quad condition number metric.
/** Maximum condition number of the Jacobian matrix at 4 corners.
 Reference --- P. Knupp, Achieving Finite Element Mesh Quality via 
 Optimization of the Jacobian Matrix Norm and Associated Quantities,
 Intl. J. Numer. Meth. Engng. 2000, 48:1165-1185. */
C_FUNC_DEF double v_quad_condition( int num_nodes, double coordinates[][3] );
 
//! Calculates quad jacobian.
/** Minimum pointwise volume of local map at 4 corners & center of quad. 
 Reference --- P. Knupp, Achieving Finite Element Mesh Quality via 
 Optimization of the Jacobian Matrix Norm and Associated Quantities,
 Intl. J. Numer. Meth. Engng. 2000, 48:1165-1185. */
C_FUNC_DEF double v_quad_jacobian( int num_nodes, double coordinates[][3] );
 
//! Calculates quad scaled jacobian.
/** Minimum Jacobian divided by the lengths of the 2 edge vectors. 
 Reference --- P. Knupp, Achieving Finite Element Mesh Quality via 
 Optimization of the Jacobian Matrix Norm and Associated Quantities,
 Intl. J. Numer. Meth. Engng. 2000, 48:1165-1185. */
C_FUNC_DEF double v_quad_scaled_jacobian( int num_nodes, double coordinates[][3] );
 
//! Calculates quad shear metric.
/** 2/Condition number of Jacobian Skew matrix.
 Reference --- P. Knupp, Algebraic Mesh Quality Metrics for
 Unstructured Initial Meshes, submitted for publication. */
C_FUNC_DEF double v_quad_shear( int num_nodes, double coordinates[][3] );
 
//! Calculates quad shape metric.
/** 2/Condition number of weighted Jacobian matrix. 
 Reference --- P. Knupp, Algebraic Mesh Quality Metrics for
 Unstructured Initial Meshes, submitted for publication. */
C_FUNC_DEF double v_quad_shape( int num_nodes, double coordinates[][3] );
 
//! Calculates quad relative size metric.
/** Min( J, 1/J ), where J is determinant of weighted Jacobian matrix. 
 Reference --- P. Knupp, Algebraic Mesh Quality Metrics for
 Unstructured Initial Meshes, submitted for publication. */
C_FUNC_DEF double v_quad_relative_size_squared( int num_nodes, double coordinates[][3] );
 
//! Calculates quad shape-size metric.
/** Product of Shape and Relative Size. 
 Reference --- P. Knupp, Algebraic Mesh Quality Metrics for
 Unstructured Initial Meshes, submitted for publication. */
C_FUNC_DEF double v_quad_shape_and_size( int num_nodes, double coordinates[][3] );
 
//! Calculates quad shear-size metric.
/** Product of Shear and Relative Size. 
 Reference --- P. Knupp, Algebraic Mesh Quality Metrics for
 Unstructured Initial Meshes, submitted for publication. */
C_FUNC_DEF double v_quad_shear_and_size( int num_nodes, double coordinates[][3] );
 
//! Calculates quad distortion metric.
/** {min(|J|)/actual area}*parent area, parent area = 4 for quad.
 Reference --- SDRC/IDEAS Simulation: Finite Element Modeling--User's Guide */
C_FUNC_DEF double v_quad_distortion( int num_nodes, double coordinates[][3] );
 
/* individual quality functions for tri elements */
 
//! Sets average size (area) of tri, needed for v_tri_relative_size(...)
C_FUNC_DEF void v_set_tri_size( double size );
 
//! Sets fuction pointer to calculate tri normal wrt surface
C_FUNC_DEF void v_set_tri_normal_func( ComputeNormal func );
 
//! Calculates tri metric.
/** edge ratio
 Reference --- P. P. Pebay & T. J. Baker, Analysis of Triangle Quality
 Measures, AMS Math. Comp., 2003, 72(244):1817-1839 */
C_FUNC_DEF double v_tri_edge_ratio( int num_nodes, double coordinates[][3] );
 
//! Calculates tri metric.
/** aspect ratio
 Reference --- P. P. Pebay & T. J. Baker, Analysis of Triangle Quality
 Measures, AMS Math. Comp., 2003, 72(244):1817-1839 */
C_FUNC_DEF double v_tri_aspect_ratio( int num_nodes, double coordinates[][3] );
 
//! Calculates tri metric.
/** radius ratio
 Reference --- P. P. Pebay & T. J. Baker, Analysis of Triangle Quality
 Measures, AMS Math. Comp., 2003, 72(244):1817-1839 */
C_FUNC_DEF double v_tri_radius_ratio( int num_nodes, double coordinates[][3] );
 
//! Calculates tri metric.
/** Frobenius aspect */
C_FUNC_DEF double v_tri_aspect_frobenius( int num_nodes, double coordinates[][3] );
 
//! Calculates tri metric.
/** Maximum included angle in triangle */
C_FUNC_DEF double v_tri_area( int num_nodes, double coordinates[][3] );
 
//! Calculates tri metric.
/** Minimum included angle in triangle */
C_FUNC_DEF double v_tri_minimum_angle( int num_nodes, double coordinates[][3] );
 
//! Calculates tri metric.
/** Maximum included angle in triangle */
C_FUNC_DEF double v_tri_maximum_angle( int num_nodes, double coordinates[][3] );
 
//! Calculates tri metric.
/** Condition number of the Jacobian matrix.
 Reference --- P. Knupp, Achieving Finite Element Mesh Quality via 
 Optimization of the Jacobian Matrix Norm and Associated Quantities,
 Intl. J. Numer. Meth. Engng. 2000, 48:1165-1185. */
C_FUNC_DEF double v_tri_condition( int num_nodes, double coordinates[][3] );
 
//! Calculates tri metric.
/** Minimum Jacobian divided by the lengths of 2 edge vectors. 
 Reference --- P. Knupp, Achieving Finite Element Mesh Quality via 
 Optimization of the Jacobian Matrix Norm and Associated Quantities,
 Intl. J. Numer. Meth. Engng. 2000, 48:1165-1185. */
C_FUNC_DEF double v_tri_scaled_jacobian( int num_nodes, double coordinates[][3] );
 
//! Calculates tri metric.
/** Min( J, 1/J ), where J is determinant of weighted Jacobian matrix. 
 Reference --- P. Knupp, Algebraic Mesh Quality Metrics for
 Unstructured Initial Meshes, submitted for publication. */
C_FUNC_DEF double v_tri_relative_size_squared( int num_nodes, double coordinates[][3] );
 
//! Calculates tri metric.
/** 2/Condition number of weighted Jacobian matrix. 
 Reference --- P. Knupp, Algebraic Mesh Quality Metrics for
 Unstructured Initial Meshes, submitted for publication. */
C_FUNC_DEF double v_tri_shape( int num_nodes, double coordinates[][3] );
 
//! Calculates tri metric.
/** Product of Shape and Relative Size. 
 Reference --- P. Knupp, Algebraic Mesh Quality Metrics for
 Unstructured Initial Meshes, submitted for publication. */
C_FUNC_DEF double v_tri_shape_and_size( int num_nodes, double coordinates[][3] );
 
//! Calculates tri metric.
/** {min(|J|)/actual area}*parent area, parent area = 1/2 for triangular element. 
 Reference --- SDRC/IDEAS Simulation: Finite Element Modeling--User's Guide */
C_FUNC_DEF double v_tri_distortion( int num_nodes, double coordinates[][3] );
 
#endif /* VERDICT_INC_LIB */