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 */