ug4
Functions | Variables
ug::hex_rules Namespace Reference

Functions

bool IsRegularRefRule (const int edgeMarks)
 returns true if the specified edgeMarks would lead to a regular refinement More...
 
int Refine (int *newIndsOut, int *newEdgeVrts, bool &newCenterOut, vector3 *, bool *isSnapPoint)
 
void RotateQuad (int vrtsOut[4], const int quad[4], int steps)
 Output are the vertices of a rotated quadrilateral. More...
 

Variables

const int EDGE_FROM_VRTS [8][8]
 Associates the index of the connecting edge with each tuple of vertices. More...
 
const int EDGE_VRT_INDS [][2]
 the local vertex indices of the given edge More...
 
const int FACE_CONTAINS_EDGE [][12]
 tells whether the i-th face contains the j-th edge More...
 
const int FACE_EDGE_INDS [6][4]
 returns the j-th edge of the i-th face More...
 
const int FACE_FROM_EDGES [][12]
 given two edges, the table returns the face, which contains both (or -1) More...
 
const int FACE_FROM_VRTS [8][8][8]
 Associates the index of the connecting face with each triple of vertices. More...
 
const int FACE_VRT_INDS [][4]
 the local vertex indices of the given face More...
 
const int MAX_NUM_CONVERT_TO_TETS_INDS_OUT = 30
 
const int MAX_NUM_INDS_OUT = 256
 
const int NUM_EDGES = 12
 
const int NUM_FACES = 6
 
const int NUM_QUADS = 6
 
const int NUM_TRIS = 0
 
const int NUM_VERTICES = 8
 
const int OPPOSED_FACE [NUM_FACES] = {5, 3, 4, 1, 2, 0}
 contains the index of the opposed face of each face More...
 
const int OPPOSED_FACE_VRT_INDS [][4]
 vertex indices of the face on the opposite side of the i-th face. More...
 
const int OPPOSED_OBJECT [][NUM_VERTICES]
 

Function Documentation

◆ IsRegularRefRule()

bool ug::hex_rules::IsRegularRefRule ( const int  edgeMarks)

returns true if the specified edgeMarks would lead to a regular refinement

A regular refinement leads to new elements which are all similar to the original element. I.e. which are of the same type and which have similar angles.

Note
this method does not perform refinement. Use 'Refine' with the specified edges instead.
Parameters
edgeMarksIf the i-th edge shall be refined, the expression 'edgeMarks & (1<<i) != 0' has to be true. You can specify multiple refine-edges using or-combinations. E.g., 'edgeMarks = (1<<i) | (1<<j)' would indicate that the i-th and the j-th edge shall be refined.

Referenced by ug::Tetrahedron::is_regular_ref_rule(), ug::Hexahedron::is_regular_ref_rule(), ug::Prism::is_regular_ref_rule(), ug::Pyramid::is_regular_ref_rule(), and ug::Octahedron::is_regular_ref_rule().

◆ Refine()

int ug::hex_rules::Refine ( int *  newIndsOut,
int *  newEdgeVrts,
bool &  newCenterOut,
vector3 *  corners = NULL,
bool *  isSnapPoint = NULL 
)

returns an array of integers, which contains the indices of the objects resulting from the refinement of a hexahedron.

Parameters
newIndsOutArray which has to be of size MAX_NUM_INDS_OUT. When the algorithm is done, the array will contain sequences of integers: {{gridObjectID, ind1, ind2, ...}, ...}. gridObjectID is a constant enumerated in GridObjectID and describes the type of the grid-object that is built from the following set of corner indices. Old vertices are referenced by their local index. Vertices created on an edge are indexed by the index of the edge + NUM_VERTICES. Vertices created on a face are referenced by NUM_VERTICES + NUM_EDGES + index_of_face. If an inner vertex has to be created, it is referenced by NUM_VERTICES + NUM_EDGES + NUM_FACES (in this case newCenterOut is set to true).
newEdgeVrtsArray of size NUM_EDGES, which has to contain 1 for each edge, which shall be refined and 0 for each edge, which won't be refined.
newCenterOutIf the refinement-rule requires a center vertex, then this parameter will be set to true. If not, it is set to false.
cornersIgnored.
isSnapPoint(optional) An array of size NUM_VERTICES. If all entries are set to 'false' the behaviour is the same as if the array wasn't specified. If a corner of a quadrilateral is a snap-point and if edges of that quadrilateral are refined, then only new edges connected to the snap-point are introduced. Note that only special snap-point constellations are supported.
Returns
the number of entries written to newIndsOut or 0, if the refinement could not be performed.

References EDGE_FROM_VRTS, EDGE_VRT_INDS, FACE_CONTAINS_EDGE, FACE_EDGE_INDS, FACE_FROM_EDGES, FACE_VRT_INDS, ug::GOID_HEXAHEDRON, ug::GOID_PRISM, ug::GOID_PYRAMID, NUM_EDGES, NUM_FACES, NUM_VERTICES, OPPOSED_FACE, OPPOSED_FACE_VRT_INDS, ug::shared_rules::RecursiveRefine(), RotateQuad(), and UG_LOG.

◆ RotateQuad()

void ug::hex_rules::RotateQuad ( int  vrtsOut[4],
const int  quad[4],
int  steps 
)

Output are the vertices of a rotated quadrilateral.

Referenced by Refine().

Variable Documentation

◆ EDGE_FROM_VRTS

const int ug::hex_rules::EDGE_FROM_VRTS[8][8]
Initial value:
=
{{-1, 0, -1, 3, 4, -1, -1, -1}, {0, -1, 1, -1, -1, 5, -1, -1},
{-1, 1, -1, 2, -1, -1, 6, -1}, {3, -1, 2, -1, -1, -1, -1, 7},
{4, -1, -1, -1, -1, 8, -1, 11}, {-1, 5, -1, -1, 8, -1, 9, -1},
{-1, -1, 6, -1, -1, 9, -1, 10}, {-1, -1, -1, 7, 11, -1, 10, -1}}

Associates the index of the connecting edge with each tuple of vertices.

Use two vertex indices to index into this table to retrieve the index of their connecting edge.

Referenced by ug::Tetrahedron::get_edge_index_from_vertices(), ug::Hexahedron::get_edge_index_from_vertices(), ug::Prism::get_edge_index_from_vertices(), ug::Pyramid::get_edge_index_from_vertices(), ug::Octahedron::get_edge_index_from_vertices(), and Refine().

◆ EDGE_VRT_INDS

const int ug::hex_rules::EDGE_VRT_INDS[][2]
Initial value:
= { {0, 1}, {1, 2}, {2, 3}, {3, 0},
{0, 4}, {1, 5}, {2, 6}, {3, 7},
{4, 5}, {5, 6}, {6, 7}, {7, 4}}

the local vertex indices of the given edge

Referenced by ug::Prism::collapse_edge(), ug::Pyramid::collapse_edge(), ug::Tetrahedron::create_edge(), ug::Hexahedron::create_edge(), ug::Prism::create_edge(), ug::Pyramid::create_edge(), ug::Octahedron::create_edge(), ug::Tetrahedron::edge_desc(), ug::Hexahedron::edge_desc(), ug::Prism::edge_desc(), ug::Pyramid::edge_desc(), ug::Octahedron::edge_desc(), ug::Tetrahedron::get_vertex_indices_of_edge(), ug::Hexahedron::get_vertex_indices_of_edge(), ug::Prism::get_vertex_indices_of_edge(), ug::Pyramid::get_vertex_indices_of_edge(), ug::Octahedron::get_vertex_indices_of_edge(), ug::IntersectPlaneWithTetrahedron(), main(), and Refine().

◆ FACE_CONTAINS_EDGE

const int ug::hex_rules::FACE_CONTAINS_EDGE[][12]
Initial value:
= {{1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0},
{1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0},
{0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0},
{0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0},
{0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1},
{0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1}}

tells whether the i-th face contains the j-th edge

Referenced by Refine().

◆ FACE_EDGE_INDS

const int ug::hex_rules::FACE_EDGE_INDS[6][4]
Initial value:
=
{{0, 1, 2, 3}, {4, 8, 5, 0}, {5, 9, 6, 1},
{6, 10, 7, 2}, {7, 11, 4, 3}, {11, 10, 9, 8}}

returns the j-th edge of the i-th face

Referenced by ug::Tetrahedron::get_face_edge_index(), ug::Hexahedron::get_face_edge_index(), ug::Prism::get_face_edge_index(), ug::Pyramid::get_face_edge_index(), ug::Octahedron::get_face_edge_index(), and Refine().

◆ FACE_FROM_EDGES

const int ug::hex_rules::FACE_FROM_EDGES[][12]
Initial value:
= {{0, 0, 0, 0, 1, 1, -1, -1, 1, -1, -1, -1},
{0, 0, 0, 0, -1, 2, 2, -1, -1, 2, -1, -1},
{0, 0, 0, 0, -1, -1, 3, 3, -1, -1, 3, -1},
{0, 0, 0, 0, 4, -1, -1, 4, -1, -1, -1, 4},
{1, -1, -1, 4, 1, 1, -1, 4, 1, -1, -1, 4},
{1, 2, -1, -1, 1, 1, 2, -1, 1, 2, -1, -1},
{-1, 2, 3, -1, -1, 2, 2, 3, -1, 2, 3, -1},
{-1, -1, 3, 4, 4, -1, 3, 3, -1, -1, 3, 4},
{1, -1, -1, -1, 1, 1, -1, -1, 1, 5, 5, 5},
{-1, 2, -1, -1, -1, 2, 2, -1, 5, 2, 5, 5},
{-1, -1, 3, -1, -1, -1, 3, 3, 5, 5, 3, 5},
{-1, -1, -1, 4, 4, -1, -1, 4, 5, 5, 5, 4}}

given two edges, the table returns the face, which contains both (or -1)

Referenced by Refine().

◆ FACE_FROM_VRTS

const int ug::hex_rules::FACE_FROM_VRTS[8][8][8]

Associates the index of the connecting face with each triple of vertices.

Use three vertex indices to index into this table to retrieve the index of their connecting face.

◆ FACE_VRT_INDS

const int ug::hex_rules::FACE_VRT_INDS[][4]
Initial value:
= { {0, 1, 2, 3}, {0, 4, 5, 1},
{1, 5, 6, 2}, {2, 6, 7, 3},
{3, 7, 4, 0}, {4, 7, 6, 5}}

the local vertex indices of the given face

Referenced by ug::Tetrahedron::create_face(), ug::Hexahedron::create_face(), ug::Prism::create_face(), ug::Pyramid::create_face(), ug::Octahedron::create_face(), ug::Tetrahedron::face_desc(), ug::Hexahedron::face_desc(), ug::Prism::face_desc(), ug::Pyramid::face_desc(), ug::Octahedron::face_desc(), ug::Tetrahedron::get_vertex_indices_of_face(), ug::Hexahedron::get_vertex_indices_of_face(), ug::Prism::get_vertex_indices_of_face(), ug::Pyramid::get_vertex_indices_of_face(), ug::Octahedron::get_vertex_indices_of_face(), main(), and Refine().

◆ MAX_NUM_CONVERT_TO_TETS_INDS_OUT

const int ug::hex_rules::MAX_NUM_CONVERT_TO_TETS_INDS_OUT = 30

Referenced by ug::ConvertToTetrahedra().

◆ MAX_NUM_INDS_OUT

const int ug::hex_rules::MAX_NUM_INDS_OUT = 256

Referenced by ug::shared_rules::RecursiveRefine(), and ug::Refine().

◆ NUM_EDGES

const int ug::hex_rules::NUM_EDGES = 12

Referenced by ug::Tetrahedron::create_edge(), ug::Hexahedron::create_edge(), ug::Prism::create_edge(), ug::Pyramid::create_edge(), ug::Octahedron::create_edge(), ug::Tetrahedron::edge_desc(), ug::Hexahedron::edge_desc(), ug::Prism::edge_desc(), ug::Pyramid::edge_desc(), ug::Octahedron::edge_desc(), ug::Hexahedron::get_vertex_indices_of_edge(), ug::Prism::get_vertex_indices_of_edge(), ug::Pyramid::get_vertex_indices_of_edge(), ug::Octahedron::get_vertex_indices_of_edge(), ug::IntersectPlaneWithTetrahedron(), main(), ug::shared_rules::RecursiveRefine(), Refine(), and ug::Refine().

◆ NUM_FACES

const int ug::hex_rules::NUM_FACES = 6

Referenced by ug::Tetrahedron::create_face(), ug::Hexahedron::create_face(), ug::Prism::create_face(), ug::Pyramid::create_face(), ug::Octahedron::create_face(), ug::Tetrahedron::face_desc(), ug::Hexahedron::face_desc(), ug::Prism::face_desc(), ug::Pyramid::face_desc(), ug::Octahedron::face_desc(), ug::Hexahedron::get_vertex_indices_of_face(), ug::Prism::get_vertex_indices_of_face(), ug::Pyramid::get_vertex_indices_of_face(), ug::Octahedron::get_vertex_indices_of_face(), main(), Refine(), and ug::Refine().

◆ NUM_QUADS

const int ug::hex_rules::NUM_QUADS = 6

◆ NUM_TRIS

const int ug::hex_rules::NUM_TRIS = 0

◆ NUM_VERTICES

const int ug::hex_rules::NUM_VERTICES = 8

Referenced by ug::LSGFGlobAssembler< TDomain, TAlgebra, TExtrapolation >::AssembleDefect(), ug::StdGlobAssembler< TDomain, TAlgebra >::AssembleDefect(), ug::StdGlobAssembler< TDomain, TAlgebra >::AssembleErrorEstimator(), ug::LSGFGlobAssembler< TDomain, TAlgebra, TExtrapolation >::AssembleJacobian(), ug::StdGlobAssembler< TDomain, TAlgebra >::AssembleJacobian(), ug::LSGFGlobAssembler< TDomain, TAlgebra, TExtrapolation >::AssembleLinear(), ug::StdGlobAssembler< TDomain, TAlgebra >::AssembleLinear(), ug::LSGFGlobAssembler< TDomain, TAlgebra, TExtrapolation >::AssembleMassMatrix(), ug::StdGlobAssembler< TDomain, TAlgebra >::AssembleMassMatrix(), ug::StdGlobAssembler< TDomain, TAlgebra >::AssembleRhs(), ug::LSGFGlobAssembler< TDomain, TAlgebra, TExtrapolation >::AssembleStiffnessMatrix(), ug::StdGlobAssembler< TDomain, TAlgebra >::AssembleStiffnessMatrix(), ug::FillCornerCoordinates(), ug::LSGFGlobAssembler< TDomain, TAlgebra, TExtrapolation >::FinishTimestepElem(), ug::StdGlobAssembler< TDomain, TAlgebra >::FinishTimestepElem(), ug::Tetrahedron::get_opposing_object(), ug::Hexahedron::get_opposing_object(), ug::Prism::get_opposing_object(), ug::Pyramid::get_opposing_object(), ug::Octahedron::get_opposing_object(), main(), ug::LSGFGlobAssembler< TDomain, TAlgebra, TExtrapolation >::PrepareTimestepElem(), ug::StdGlobAssembler< TDomain, TAlgebra >::PrepareTimestepElem(), ug::shared_rules::RecursiveRefine(), Refine(), and ug::Refine().

◆ OPPOSED_FACE

const int ug::hex_rules::OPPOSED_FACE[NUM_FACES] = {5, 3, 4, 1, 2, 0}

contains the index of the opposed face of each face

Referenced by ug::Hexahedron::get_opposing_side(), ug::Prism::get_opposing_side(), and Refine().

◆ OPPOSED_FACE_VRT_INDS

const int ug::hex_rules::OPPOSED_FACE_VRT_INDS[][4]
Initial value:
= {{4, 5, 6, 7}, {3, 7, 6, 2},
{0, 4, 7, 3}, {1, 5, 4, 0},
{2, 6, 5, 1}, {0, 3, 2, 1}}

vertex indices of the face on the opposite side of the i-th face.

Note that the orientation of those faces are different from the orientation of the original faces. The j-th vertex i' is the one on the opposite site of the j-th vertex of face i.

Referenced by Refine().

◆ OPPOSED_OBJECT

const int ug::hex_rules::OPPOSED_OBJECT[][NUM_VERTICES]
Initial value:
= {{0, 6}, {0, 7}, {0, 4}, {0, 5},
{0, 2}, {0, 3}, {0, 0}, {0, 1}}

for each vertex, a pair containing the object type (0: vrt, 1: edge, 2: face) and an index into the associated array, which describe the object which lies on the opposite side of the hexahedron, to a given vertex.

Referenced by ug::Tetrahedron::get_opposing_object(), ug::Hexahedron::get_opposing_object(), ug::Prism::get_opposing_object(), ug::Pyramid::get_opposing_object(), and ug::Octahedron::get_opposing_object().