wmunstructuredgeometryfunctions.h

Go to the documentation of this file.

#ifndef WMUNSTRUCTUREDGEOMETRYFUNCTIONS_H_
#define WMUNSTRUCTUREDGEOMETRYFUNCTIONS_H_
 
// STL Includes
#include <cmath>
#include <array>
 
#include "warpxm/warpxm_config.h"
 
template<typename T> T sign(T a);
 
// Unstructured Grids Only -----------------------------
 
void resetVector(real v[3]);
 
void vectoralCrossProduct(const real vec1[3], const real vec2[3], real product[3]);
 
real vectoralDotProduct(const real vec1[3], const real vec2[3]);
 
real vectoralMagnitude(const real vec[3]);
 
void vectoralMultiplyByScalar(real vec[3], const real scalar);
 
real vectoralNormalize(real vec[3]);
 
void vectoralTangentNormalized(const real normal[3], real tangent[3]);
 
void vectoralTangent(const real vec[3], real tangent[3]);
 
void vectoralBinormal(const real normal[3], const real tangent[3], real binormal[3]);
 
void vectoralMatrixMultiply_left(const real M[3][3], const real v[3], real Mv[3]);
 
void vectoralRotateAroundNormalizedVector(const real v[3],
                                          const real n[3],
                                          const real angle,
                                          real r[3]);
 
// The following functions are the general form for creating element geometry information
// from the transform coordinates defined in WmUnstructuredGeometry
 
real generateElementGeometry_Line(const real tC[2*3], real areas[2], real* norms);
 
real generateElementGeometry_01_Line(const real tC[2*3], real areas[2], real* norms);
 
real generateElementGeometry_Triangle(const real tC[3*3], real areas[3], real* norms);
 
real generateElementGeometry_Quadrilateral(const real tC[4*3], real* areas, real* norms);
 
real generateElementGeometry_Tetrahedron(const real tC[4*3], real areas[4], real* norms);
 
real generateElementGeometry_Hexahedron(const real tC[8*3], real* areas, real* norms);
 
real generateElementGeometry_Point(const real tC[1*3], real areas[1], real* norms);
 
// This is where we generate and define the transform coordinates
 
void generateTransformCoordinates_Line(const real nodePositions[], real tC[]);
 
void generateTransformCoordinates_01_Line(const real nodePositions[], real tC[]);
 
void generateTransformCoordinates_Triangle(const real nodePositions[], real tC[]);
 
void generateTransformCoordinates_Quadrilateral(const real nodePositions[], real tC[]);
 
void generateTransformCoordinates_Tetrahedron(const real nodePositions[], real tC[]);
 
void generateTransformCoordinates_Hexahedron(const real nodePositions[], real tC[]);
 
void generateTransformCoordinates_Point(const real nodePositions[], real tC[]);
 
// These functions transform normalized coordinates to actual coordinates
 
void generatePositionInElement_Line(const real* tC,
                                    const real normalizedPosition[3],
                                    real position[3]);
 
void generatePositionInElement_01_Line(const real* tC,
                                       const real normalizedPosition[3],
                                       real position[3]);
 
void generatePositionInElement_Triangle(const real* tC,
                                        const real normalizedPosition[3],
                                        real position[3]);
 
void generatePositionInElement_Quadrilateral(const real* tC,
                                             const real normalizedPosition[3],
                                             real position[3]);
 
void generatePositionInElement_Tetrahedron(const real* tC,
                                           const real normalizedPosition[3],
                                           real position[3]);
 
void generatePositionInElement_Hexahedron(const real* tC,
                                          const real normalizedPosition[3],
                                          real position[3]);
 
void generatePositionInElement_Point(const real* tC,
                                     const real normalizedPosition[3],
                                     real position[3]);
 
// These functions transform coordinates to normalized coordinates
 
void generateNormalizedPositionInElement_Line(const real* tC,
                                    const real position[3],
                                    real normalizedPosition[3]);
 
void generateNormalizedPositionInElement_01_Line(const real* tC,
                                       const real position[3],
                                       real normalizedPosition[3]);
 
void generateNormalizedPositionInElement_Triangle(const real* tC,
                                        const real position[3],
                                        real normalizedPosition[3]);
 
void generateNormalizedPositionInElement_Quadrilateral(const real* tC,
                                             const real position[3],
                                             real normalizedPosition[3]);
 
void generateNormalizedPositionInElement_Tetrahedron(const real* tC,
                                           const real position[3],
                                           real normalizedPosition[3]);
 
void generateNormalizedPositionInElement_Hexahedron(const real* tC,
                                          const real position[3],
                                          real normalizedPosition[3]);
 
void generateNormalizedPositionInElement_Point(const real* tC,
                                     const real position[3],
                                     real normalizedPosition[3]);
 
// These functions transform normalized coordinates to element central coordinates (actual
// coordinates - element centroid)
 
void generateCentralPositionInElement_Line(const real tC[][3],
                                           const real normalizedPosition[3],
                                           real position[3]);
 
void generateCentralPositionInElement_01_Line(const real tC[][3],
                                              const real normalizedPosition[3],
                                              real position[3]);
 
void generateCentralPositionInElement_Triangle(const real tC[][3],
                                               const real normalizedPosition[3],
                                               real position[3]);
 
void generateCentralPositionInElement_Quadrilateral(const real tC[][3],
                                                    const real normalizedPosition[3],
                                                    real position[3]);
 
void generateCentralPositionInElement_Tetrahedron(const real tC[][3],
                                                  const real normalizedPosition[3],
                                                  real position[3]);
 
void generateCentralPositionInElement_Hexahedron(const real tC[][3],
                                                 const real normalizedPosition[3],
                                                 real position[3]);
 
void generateCentralPositionInElement_Point(const real tC[][3],
                                            const real normalizedPosition[3],
                                            real position[3]);
 
// These functions generate the element centroid from the transform coordinates (very
// simple for most primitives)
 
void generateCentroid_Line(const real tC[], real centroid[3]);
 
void generateCentroid_01_Line(const real tC[], real centroid[3]);
 
void generateCentroid_Triangle(const real tC[], real centroid[3]);
 
void generateCentroid_Quadrilateral(const real tC[], real centroid[3]);
 
void generateCentroid_Tetrahedron(const real tC[], real centroid[3]);
 
void generateCentroid_Hexahedron(const real tC[], real centroid[3]);
 
void generateCentroid_Point(const real tC[], real centroid[3]);
 
// These are volume Jacobians designed to work with WmUnstructuredQuadrature
 
real generateVolumeJacobian_Line(const real tC[], const real normalizedPosition[3]);
 
real generateVolumeJacobian_01_Line(const real tC[], const real normalizedPosition[3]);
 
real generateVolumeJacobian_Triangle(const real tC[],
                                     const real normalizedPosition[3]);
 
real generateVolumeJacobian_Quadrilateral(const real tC[],
                                          const real normalizedPosition[3]);
 
real generateVolumeJacobian_Tetrahedron(const real tC[],
                                        const real normalizedPosition[3]);
 
real generateVolumeJacobian_Hexahedron(const real tC[],
                                       const real normalizedPosition[3]);
 
real generateVolumeJacobian_Point(const real tC[], const real normalizedPosition[3]);
 
void generateJacobianMatrix_Line(const real tC[][3],
                                 const real normalizedPosition[3],
                                 real jacobian[][3]);
 
void generateJacobianMatrix_01_Line(const real tC[][3],
                                    const real normalizedPosition[3],
                                    real jacobian[][3]);
 
void generateJacobianMatrix_Triangle(const real tC[][3],
                                     const real normalizedPosition[3],
                                     real jacobian[][3]);
 
void generateJacobianMatrix_Quadrilateral(const real tC[][3],
                                          const real normalizedPosition[3],
                                          real jacobian[][3]);
 
void generateJacobianMatrix_Tetrahedron(const real tC[][3],
                                        const real normalizedPosition[3],
                                        real jacobian[][3]);
 
void generateJacobianMatrix_Hexahedron(const real tC[][3],
                                       const real normalizedPosition[3],
                                       real jacobian[][3]);
 
void generateJacobianMatrix_Point(const real tC[][3],
                                  const real normalizedPosition[3],
                                  real jacobian[][3]);
 
void invertTwoXTwoMatrix(const real a[2][2], real in[2][2]);
void invertTwoXTwoMatrix(const std::array<std::array<real, 2>, 2>& a,
                         std::array<std::array<real, 2>, 2>& in);
 
void invertThreeXThreeMatrix(const real a[3][3], real in[3][3]);
void invertThreeXThreeMatrix(const std::array<std::array<real, 3>, 3>& a,
                             std::array<std::array<real, 3>, 3>& in);
 
void convertFaceTransformCoordinates_Line_To_Point(const real v_tC[][3],
                                                   const int fIndex,
                                                   real f_tC[][3]);
 
void convertFaceTransformCoordinates_Triangle_To_Line(const real v_tC[][3],
                                                      const int fIndex,
                                                      real f_tC[][3]);
 
void convertFaceTransformCoordinates_Quadrilateral_To_Line(const real v_tC[][3],
                                                           const int fIndex,
                                                           real f_tC[][3]);
 
void convertFaceTransformCoordinates_Tetrahedron_To_Triangle(const real v_tC[][3],
                                                             const int fIndex,
                                                             real f_tC[][3]);
 
void convertFaceTransformCoordinates_Hexahedron_To_Quadrilateral(const real v_tC[][3],
                                                                 const int fIndex,
                                                                 real f_tC[][3]);
 
#endif // WMUNSTRUCTUREDGEOMETRYFUNCTIONS_H_