MeshGenerationTest Class Reference

Inheritance diagram for MeshGenerationTest:

Public Types
typedef void(MeshGenerationTest::*	Builder) (UnstructuredMesh &, unsigned int, ElemType)

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (MeshGenerationTest)
	The goal of this test is to verify proper operation of MeshGeneration functions, as well as to indirectly verify the MeshBase functions they rely on.
	CPPUNIT_TEST (buildLineEdge2)
	CPPUNIT_TEST (buildLineEdge3)
	CPPUNIT_TEST (buildLineEdge4)
	CPPUNIT_TEST (buildSphereEdge2)
	CPPUNIT_TEST (buildSphereEdge3)
	CPPUNIT_TEST (buildSquareTri3)
	CPPUNIT_TEST (buildSquareTri6)
	CPPUNIT_TEST (buildSquareTri7)
	CPPUNIT_TEST (buildSquareQuad4)
	CPPUNIT_TEST (buildSquareQuad8)
	CPPUNIT_TEST (buildSquareQuad9)
	CPPUNIT_TEST (buildSquareC0PolygonEven)
	CPPUNIT_TEST (buildSquareC0PolygonOdd)
	CPPUNIT_TEST (buildSphereTri3)
	CPPUNIT_TEST (buildSphereQuad4)
	CPPUNIT_TEST (buildCubeTet4)
	CPPUNIT_TEST (buildCubeTet10)
	CPPUNIT_TEST (buildCubeTet14)
	CPPUNIT_TEST (buildCubeHex8)
	CPPUNIT_TEST (buildCubeHex20)
	CPPUNIT_TEST (buildCubeHex27)
	CPPUNIT_TEST (buildCubeC0Polyhedron)
	CPPUNIT_TEST (polyhedronTetNeighbor)
	CPPUNIT_TEST (buildCubePrism6)
	CPPUNIT_TEST (buildCubePrism15)
	CPPUNIT_TEST (buildCubePrism18)
	CPPUNIT_TEST (buildCubePrism20)
	CPPUNIT_TEST (buildCubePrism21)
	CPPUNIT_TEST (buildCubePyramid5)
	CPPUNIT_TEST (buildCubePyramid13)
	CPPUNIT_TEST (buildCubePyramid14)
	CPPUNIT_TEST (buildSphereHex27)
	CPPUNIT_TEST (buildSphereHex8)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
void	testBuildLine (UnstructuredMesh &mesh, unsigned int n, ElemType type)
void	testBuildSquare (UnstructuredMesh &mesh, unsigned int n, ElemType type)
void	testBuildCube (UnstructuredMesh &mesh, unsigned int n, ElemType type)
void	testBuildSphere (unsigned int n_ref, ElemType type)
void	tester (Builder f, unsigned int n, ElemType type)
void	buildLineEdge2 ()
void	buildLineEdge3 ()
void	buildLineEdge4 ()
void	buildSphereEdge2 ()
void	buildSphereEdge3 ()
void	buildSphereEdge4 ()
void	buildSquareTri3 ()
void	buildSquareTri6 ()
void	buildSquareTri7 ()
void	buildSquareQuad4 ()
void	buildSquareQuad8 ()
void	buildSquareQuad9 ()
void	buildSquareC0PolygonOdd ()
void	buildSquareC0PolygonEven ()
void	buildSphereTri3 ()
void	buildSphereQuad4 ()
void	buildCubeTet4 ()
void	buildCubeTet10 ()
void	buildCubeTet14 ()
void	buildCubeHex8 ()
void	buildCubeHex20 ()
void	buildCubeHex27 ()
void	buildCubeC0Polyhedron ()
void	polyhedronTetNeighbor ()
void	buildCubePrism6 ()
void	buildCubePrism15 ()
void	buildCubePrism18 ()
void	buildCubePrism20 ()
void	buildCubePrism21 ()
void	buildCubePyramid5 ()
void	buildCubePyramid13 ()
void	buildCubePyramid14 ()
void	buildSphereHex8 ()
void	buildSphereHex27 ()

Protected Member Functions
std::unique_ptr< UnstructuredMesh >	new_mesh (bool is_replicated)

Detailed Description

Definition at line 23 of file mesh_generation_test.C.

Member Typedef Documentation

Builder

typedef void(MeshGenerationTest::* MeshGenerationTest::Builder) (UnstructuredMesh &, unsigned int, ElemType)

Definition at line 383 of file mesh_generation_test.C.

Member Function Documentation

buildCubeC0Polyhedron()

void MeshGenerationTest::buildCubeC0Polyhedron ( )

inline

Definition at line 425 of file mesh_generation_test.C.

  { LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildCube, 2, C0POLYHEDRON); }

References libMesh::C0POLYHEDRON, testBuildCube(), and tester().

buildCubeHex20()

void MeshGenerationTest::buildCubeHex20 ( )

inline

Definition at line 423 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildCube, 2, HEX20); }

References libMesh::HEX20, testBuildCube(), and tester().

buildCubeHex27()

void MeshGenerationTest::buildCubeHex27 ( )

inline

Definition at line 424 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildCube, 2, HEX27); }

References libMesh::HEX27, testBuildCube(), and tester().

buildCubeHex8()

void MeshGenerationTest::buildCubeHex8 ( )

inline

Definition at line 422 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildCube, 2, HEX8); }

References libMesh::HEX8, testBuildCube(), and tester().

buildCubePrism15()

void MeshGenerationTest::buildCubePrism15 ( )

inline

Definition at line 528 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildCube, 2, PRISM15); }

References libMesh::PRISM15, testBuildCube(), and tester().

buildCubePrism18()

void MeshGenerationTest::buildCubePrism18 ( )

inline

Definition at line 529 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildCube, 2, PRISM18); }

References libMesh::PRISM18, testBuildCube(), and tester().

buildCubePrism20()

void MeshGenerationTest::buildCubePrism20 ( )

inline

Definition at line 530 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildCube, 2, PRISM20); }

References libMesh::PRISM20, testBuildCube(), and tester().

buildCubePrism21()

void MeshGenerationTest::buildCubePrism21 ( )

inline

Definition at line 531 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildCube, 2, PRISM21); }

References libMesh::PRISM21, testBuildCube(), and tester().

buildCubePrism6()

void MeshGenerationTest::buildCubePrism6 ( )

inline

Definition at line 527 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildCube, 2, PRISM6); }

References libMesh::PRISM6, testBuildCube(), and tester().

buildCubePyramid13()

void MeshGenerationTest::buildCubePyramid13 ( )

inline

Definition at line 537 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildCube, 2, PYRAMID13); }

References libMesh::PYRAMID13, testBuildCube(), and tester().

buildCubePyramid14()

void MeshGenerationTest::buildCubePyramid14 ( )

inline

Definition at line 538 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildCube, 2, PYRAMID14); }

References libMesh::PYRAMID14, testBuildCube(), and tester().

buildCubePyramid5()

void MeshGenerationTest::buildCubePyramid5 ( )

inline

Definition at line 536 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildCube, 2, PYRAMID5); }

References libMesh::PYRAMID5, testBuildCube(), and tester().

buildCubeTet10()

void MeshGenerationTest::buildCubeTet10 ( )

inline

Definition at line 420 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildCube, 2, TET10); }

References testBuildCube(), tester(), and libMesh::TET10.

buildCubeTet14()

void MeshGenerationTest::buildCubeTet14 ( )

inline

Definition at line 421 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildCube, 2, TET14); }

References testBuildCube(), tester(), and libMesh::TET14.

buildCubeTet4()

void MeshGenerationTest::buildCubeTet4 ( )

inline

Definition at line 419 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildCube, 2, TET4); }

References testBuildCube(), tester(), and libMesh::TET4.

buildLineEdge2()

void MeshGenerationTest::buildLineEdge2 ( )

inline

Definition at line 399 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildLine, 5, EDGE2); }

References libMesh::EDGE2, testBuildLine(), and tester().

buildLineEdge3()

void MeshGenerationTest::buildLineEdge3 ( )

inline

Definition at line 400 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildLine, 5, EDGE3); }

References libMesh::EDGE3, testBuildLine(), and tester().

buildLineEdge4()

void MeshGenerationTest::buildLineEdge4 ( )

inline

Definition at line 401 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildLine, 5, EDGE4); }

References libMesh::EDGE4, testBuildLine(), and tester().

buildSphereEdge2()

void MeshGenerationTest::buildSphereEdge2 ( )

inline

Definition at line 403 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; testBuildSphere(2, EDGE2); }

References libMesh::EDGE2, and testBuildSphere().

buildSphereEdge3()

void MeshGenerationTest::buildSphereEdge3 ( )

inline

Definition at line 404 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; testBuildSphere(2, EDGE3); }

References libMesh::EDGE3, and testBuildSphere().

buildSphereEdge4()

void MeshGenerationTest::buildSphereEdge4 ( )

inline

Definition at line 405 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; testBuildSphere(2, EDGE4); }

References libMesh::EDGE4, and testBuildSphere().

buildSphereHex27()

void MeshGenerationTest::buildSphereHex27 ( )

inline

Definition at line 542 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; testBuildSphere(2, HEX27); }

References libMesh::HEX27, and testBuildSphere().

buildSphereHex8()

void MeshGenerationTest::buildSphereHex8 ( )

inline

Definition at line 541 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; testBuildSphere(2, HEX8); }

References libMesh::HEX8, and testBuildSphere().

buildSphereQuad4()

void MeshGenerationTest::buildSphereQuad4 ( )

inline

Definition at line 417 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; testBuildSphere(2, QUAD4); }

References libMesh::QUAD4, and testBuildSphere().

buildSphereTri3()

void MeshGenerationTest::buildSphereTri3 ( )

inline

Definition at line 416 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; testBuildSphere(2, TRI3); }

References testBuildSphere(), and libMesh::TRI3.

buildSquareC0PolygonEven()

void MeshGenerationTest::buildSquareC0PolygonEven ( )

inline

Definition at line 414 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildSquare, 6, C0POLYGON); }

References libMesh::C0POLYGON, testBuildSquare(), and tester().

buildSquareC0PolygonOdd()

void MeshGenerationTest::buildSquareC0PolygonOdd ( )

inline

Definition at line 413 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildSquare, 5, C0POLYGON); }

References libMesh::C0POLYGON, testBuildSquare(), and tester().

buildSquareQuad4()

void MeshGenerationTest::buildSquareQuad4 ( )

inline

Definition at line 410 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildSquare, 4, QUAD4); }

References libMesh::QUAD4, testBuildSquare(), and tester().

buildSquareQuad8()

void MeshGenerationTest::buildSquareQuad8 ( )

inline

Definition at line 411 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildSquare, 4, QUAD8); }

References libMesh::QUAD8, testBuildSquare(), and tester().

buildSquareQuad9()

void MeshGenerationTest::buildSquareQuad9 ( )

inline

Definition at line 412 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildSquare, 4, QUAD9); }

References libMesh::QUAD9, testBuildSquare(), and tester().

buildSquareTri3()

void MeshGenerationTest::buildSquareTri3 ( )

inline

Definition at line 407 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildSquare, 3, TRI3); }

References testBuildSquare(), tester(), and libMesh::TRI3.

buildSquareTri6()

void MeshGenerationTest::buildSquareTri6 ( )

inline

Definition at line 408 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildSquare, 4, TRI6); }

References testBuildSquare(), tester(), and libMesh::TRI6.

buildSquareTri7()

void MeshGenerationTest::buildSquareTri7 ( )

inline

Definition at line 409 of file mesh_generation_test.C.

{ LOG_UNIT_TEST; tester(&MeshGenerationTest::testBuildSquare, 4, TRI7); }

References testBuildSquare(), tester(), and libMesh::TRI7.

CPPUNIT_TEST() [1/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildCubeC0Polyhedron

)

CPPUNIT_TEST() [2/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildCubeHex20

)

CPPUNIT_TEST() [3/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildCubeHex27

)

CPPUNIT_TEST() [4/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildCubeHex8

)

CPPUNIT_TEST() [5/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildCubePrism15

)

CPPUNIT_TEST() [6/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildCubePrism18

)

CPPUNIT_TEST() [7/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildCubePrism20

)

CPPUNIT_TEST() [8/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildCubePrism21

)

CPPUNIT_TEST() [9/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildCubePrism6

)

CPPUNIT_TEST() [10/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildCubePyramid13

)

CPPUNIT_TEST() [11/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildCubePyramid14

)

CPPUNIT_TEST() [12/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildCubePyramid5

)

CPPUNIT_TEST() [13/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildCubeTet10

)

CPPUNIT_TEST() [14/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildCubeTet14

)

CPPUNIT_TEST() [15/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildCubeTet4

)

CPPUNIT_TEST() [16/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildLineEdge2

)

CPPUNIT_TEST() [17/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildLineEdge3

)

CPPUNIT_TEST() [18/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildLineEdge4

)

CPPUNIT_TEST() [19/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildSphereEdge2

)

CPPUNIT_TEST() [20/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildSphereEdge3

)

CPPUNIT_TEST() [21/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildSphereHex27

)

CPPUNIT_TEST() [22/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildSphereHex8

)

CPPUNIT_TEST() [23/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildSphereQuad4

)

CPPUNIT_TEST() [24/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildSphereTri3

)

CPPUNIT_TEST() [25/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildSquareC0PolygonEven

)

CPPUNIT_TEST() [26/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildSquareC0PolygonOdd

)

CPPUNIT_TEST() [27/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildSquareQuad4

)

CPPUNIT_TEST() [28/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildSquareQuad8

)

CPPUNIT_TEST() [29/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildSquareQuad9

)

CPPUNIT_TEST() [30/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildSquareTri3

)

CPPUNIT_TEST() [31/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildSquareTri6

)

CPPUNIT_TEST() [32/33]

MeshGenerationTest::CPPUNIT_TEST

(

buildSquareTri7

)

CPPUNIT_TEST() [33/33]

MeshGenerationTest::CPPUNIT_TEST

(

polyhedronTetNeighbor

)

CPPUNIT_TEST_SUITE_END()

MeshGenerationTest::CPPUNIT_TEST_SUITE_END

(

)

LIBMESH_CPPUNIT_TEST_SUITE()

MeshGenerationTest::LIBMESH_CPPUNIT_TEST_SUITE

(

MeshGenerationTest

)

The goal of this test is to verify proper operation of MeshGeneration functions, as well as to indirectly verify the MeshBase functions they rely on.

new_mesh()

std::unique_ptr< UnstructuredMesh > MeshGenerationTest::new_mesh ( bool  is_replicated )

inlineprotected

Definition at line 91 of file mesh_generation_test.C.

  {
    if (is_replicated)
      return std::make_unique<ReplicatedMesh>(*TestCommWorld);
    return std::make_unique<DistributedMesh>(*TestCommWorld);
  }

References TestCommWorld.

Referenced by polyhedronTetNeighbor(), and tester().

polyhedronTetNeighbor()

void MeshGenerationTest::polyhedronTetNeighbor ( )

inline

Definition at line 434 of file mesh_generation_test.C.

  {
    LOG_UNIT_TEST;
 
    // Exercise both a replicated and a (genuinely) distributed mesh; on
    // a DistributedMesh with more ranks than elements this used to be
    // built in a way that dereferenced elements deleted by
    // delete_remote_elements(), so we must not hold element pointers
    // across prepare_for_use() and must reduce counts across ranks.
    for (int is_replicated = 0; is_replicated != 2; ++is_replicated)
      {
        std::unique_ptr<UnstructuredMesh> mesh_ptr = new_mesh(is_replicated);
        UnstructuredMesh & mesh = *mesh_ptr;
 
        // Five nodes: {0,1,2,3} form a tet-shaped polyhedron, and the
        // TET4 is {1,2,3,4} on the far side of the shared face {1,2,3}.
        mesh.add_point(Point(0,0,0), 0);
        mesh.add_point(Point(1,0,0), 1);
        mesh.add_point(Point(0,1,0), 2);
        mesh.add_point(Point(0,0,1), 3);
        mesh.add_point(Point(1,1,1), 4);
 
        auto tri = [&mesh](dof_id_type a, dof_id_type b, dof_id_type c)
        {
          auto p = std::make_shared<C0Polygon>(3);
          p->set_node(0, mesh.node_ptr(a));
          p->set_node(1, mesh.node_ptr(b));
          p->set_node(2, mesh.node_ptr(c));
          return std::shared_ptr<Polygon>(std::move(p));
        };
 
        std::vector<std::shared_ptr<Polygon>> faces =
          { tri(0,1,2), tri(0,1,3), tri(1,2,3), tri(0,2,3) };
 
        std::unique_ptr<Node> mid_elem_node;
        std::unique_ptr<Elem> poly =
          std::make_unique<C0Polyhedron>(faces, mid_elem_node);
        if (mid_elem_node)
          mesh.add_node(std::move(mid_elem_node));
        poly->set_id() = 0;
        mesh.add_elem(std::move(poly));
 
        std::unique_ptr<Elem> tet = Elem::build(TET4);
        tet->set_id() = 1;
        tet->set_node(0, mesh.node_ptr(1));
        tet->set_node(1, mesh.node_ptr(2));
        tet->set_node(2, mesh.node_ptr(3));
        tet->set_node(3, mesh.node_ptr(4));
        mesh.add_elem(std::move(tet));
 
        mesh.prepare_for_use();
 
        // find_neighbors() must link the polyhedron's C0POLYGON face to
        // the tet's TRI3 face.  Count the interface from each owned
        // element's side and reduce, so the check is valid however the
        // two elements are partitioned.
        int poly_to_tet = 0, tet_to_poly = 0;
        for (const Elem * elem : mesh.active_local_element_ptr_range())
          for (auto s : elem->side_index_range())
            {
              const Elem * neigh = elem->neighbor_ptr(s);
              if (!neigh)
                continue;
 
              if (elem->type() == C0POLYHEDRON)
                {
                  ++poly_to_tet;
                  if (!neigh->is_remote())
                    {
                      CPPUNIT_ASSERT_EQUAL(neigh->type(), TET4);
                      CPPUNIT_ASSERT(neigh->neighbor_ptr
                                     (neigh->which_neighbor_am_i(elem)) == elem);
                    }
                }
              else if (elem->type() == TET4)
                {
                  ++tet_to_poly;
                  if (!neigh->is_remote())
                    {
                      CPPUNIT_ASSERT_EQUAL(neigh->type(), C0POLYHEDRON);
                      CPPUNIT_ASSERT(neigh->neighbor_ptr
                                     (neigh->which_neighbor_am_i(elem)) == elem);
                    }
                }
            }
        mesh.comm().sum(poly_to_tet);
        mesh.comm().sum(tet_to_poly);
 
        CPPUNIT_ASSERT_EQUAL(1, poly_to_tet);
        CPPUNIT_ASSERT_EQUAL(1, tet_to_poly);
      }
  }

References libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_node(), libMesh::MeshBase::add_point(), b, libMesh::Elem::build(), libMesh::C0POLYHEDRON, libMesh::ParallelObject::comm(), libMesh::Elem::is_remote(), mesh, libMesh::Elem::neighbor_ptr(), new_mesh(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::prepare_for_use(), libMesh::DofObject::set_id(), libMesh::Parallel::Communicator::sum(), libMesh::TET4, libMesh::Elem::type(), and libMesh::Elem::which_neighbor_am_i().

setUp()

void MeshGenerationTest::setUp ( )

inline

Definition at line 99 of file mesh_generation_test.C.

{}

tearDown()

void MeshGenerationTest::tearDown ( )

inline

Definition at line 101 of file mesh_generation_test.C.

{}

testBuildCube()

void MeshGenerationTest::testBuildCube ( UnstructuredMesh &  mesh, unsigned int  n, ElemType  type  )

inline

Definition at line 190 of file mesh_generation_test.C.

  {
    MeshTools::Generation::build_cube (mesh, n, n, n, -2.0, 3.0, -4.0, 5.0, -6.0, 7.0, type);
    if (type == C0POLYHEDRON)
      {
        const dof_id_type grid_nodes = cast_int<dof_id_type>((n+1)*(n+1)*(n+1));
 
        CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), cast_int<dof_id_type>(n*n*n));
        CPPUNIT_ASSERT(mesh.n_nodes() >= grid_nodes);
        CPPUNIT_ASSERT(mesh.n_nodes() <= grid_nodes + cast_int<dof_id_type>(n*n*n));
      }
    else
      {
        switch (Elem::type_to_n_sides_map[type])
          {
          case 4: // tets
            CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), cast_int<dof_id_type>(n*n*n*24));
            break;
          case 5: // prisms, pyramids
            if (type == PRISM6 || type == PRISM15 || type == PRISM18 ||
                type == PRISM20 || type == PRISM21)
              CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), cast_int<dof_id_type>(n*n*n*2));
            else
              CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), cast_int<dof_id_type>(n*n*n*6));
            break;
          case 6: // hexes
            CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), cast_int<dof_id_type>(n*n*n));
            break;
          default:
            libmesh_error();
          }
 
 
        switch (Elem::type_to_n_nodes_map[type])
          {
          case 4: // First-order tets
            CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(),
                                 cast_int<dof_id_type>((n+1)*(n+1)*(n+1) + n*n*n + 3*(n+1)*n*n));
            break;
          case 6: // First-order prisms and hexes use the same nodes
          case 8:
            CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(),
                                 cast_int<dof_id_type>((n+1)*(n+1)*(n+1)));
            break;
          case 10: // Second-order tets
            CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(),
                                 cast_int<dof_id_type>((2*n+1)*(2*n+1)*(2*n+1) + 14*n*n*n + 4*3*(n+1)*n*n));
            break;
          case 18:
          case 27: // Second-order prisms and hexes use the same nodes
            CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(),
                                 cast_int<dof_id_type>((2*n+1)*(2*n+1)*(2*n+1)));
            break;
          case 20:
            if (type == HEX20)
              CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(),
                                   cast_int<dof_id_type>((2*n+1)*(2*n+1)*(2*n+1) - n*n*n - 3*(n+1)*n*n));
            if (type == PRISM20)
              CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(),
                                   cast_int<dof_id_type>((2*n+1)*(2*n+1)*(2*n+1) + 2*(n+1)*n*n));
            break;
          case 21: // Prisms based on full Tri7 cross sections
            CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(),
                                 cast_int<dof_id_type>((2*n+1)*(2*n+1)*(2*n+1) + 2*(2*n+1)*n*n));
            break;
          case 15: // weird partial order prism
            CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(),
                                 cast_int<dof_id_type>((2*n+1)*(2*n+1)*(2*n+1) - n*n*n - 2*(n+1)*n*n));
            break;
          case 5: // pyramids
            CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(),
                                 cast_int<dof_id_type>((n+1)*(n+1)*(n+1) + n*n*n));
            break;
          case 13:
            CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(),
                                 cast_int<dof_id_type>((2*n+1)*(2*n+1)*(2*n+1) + 8*n*n*n - 3*(n+1)*n*n));
            break;
          case 14: // pyramids, tets
            if (type == PYRAMID14)
              CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(),
                                   cast_int<dof_id_type>((2*n+1)*(2*n+1)*(2*n+1) + 8*n*n*n));
            else // TET14
            CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(),
                                 cast_int<dof_id_type>((2*n+1)*(2*n+1)*(2*n+1) + 14*n*n*n + 4*3*(n+1)*n*n +
                                                       36*n*n*n + 4*3*(n+1)*n*n));
            break;
          default:
            libmesh_error();
          }
      }
 
    // Our bounding boxes can be loose on higher order elements, but
    // we can at least assert that they're not too tight
    BoundingBox bbox = MeshTools::create_bounding_box(mesh);
    CPPUNIT_ASSERT(bbox.min()(0) <= Real(-2.0));
    CPPUNIT_ASSERT(bbox.max()(0) >= Real(3.0));
    CPPUNIT_ASSERT(bbox.min()(1) <= Real(-4.0));
    CPPUNIT_ASSERT(bbox.max()(1) >= Real(5.0));
    CPPUNIT_ASSERT(bbox.min()(2) <= Real(-6.0));
    CPPUNIT_ASSERT(bbox.max()(2) >= Real(7.0));
 
    if (type == C0POLYHEDRON)
      {
        BoundingBox nodal_bbox = MeshTools::create_nodal_bounding_box(mesh);
        const Real expected_volume = Real(5) * Real(9) * Real(13);
 
        LIBMESH_ASSERT_FP_EQUAL(nodal_bbox.min()(0),
                                Real(-2.0),
                                TOLERANCE*TOLERANCE);
        LIBMESH_ASSERT_FP_EQUAL(nodal_bbox.max()(0),
                                Real(3.0),
                                TOLERANCE*TOLERANCE);
        LIBMESH_ASSERT_FP_EQUAL(nodal_bbox.min()(1),
                                Real(-4.0),
                                TOLERANCE*TOLERANCE);
        LIBMESH_ASSERT_FP_EQUAL(nodal_bbox.max()(1),
                                Real(5.0),
                                TOLERANCE*TOLERANCE);
        LIBMESH_ASSERT_FP_EQUAL(nodal_bbox.min()(2),
                                Real(-6.0),
                                TOLERANCE*TOLERANCE);
        LIBMESH_ASSERT_FP_EQUAL(nodal_bbox.max()(2),
                                Real(7.0),
                                TOLERANCE*TOLERANCE);
        LIBMESH_ASSERT_FP_EQUAL(MeshTools::volume(mesh),
                                expected_volume,
                                TOLERANCE*TOLERANCE);
 
        for (auto & elem : mesh.element_ptr_range())
          {
            CPPUNIT_ASSERT_EQUAL(elem->type(), C0POLYHEDRON);
            CPPUNIT_ASSERT_EQUAL(elem->n_sides(), 6u);
            CPPUNIT_ASSERT(elem->n_sub_elem() > 0);
            CPPUNIT_ASSERT(elem->volume() > 0);
          }
 
        // Verify that find_neighbors() actually linked the polyhedra to
        // one another.  This is a regression test for a bug where
        // Polyhedron::low_order_key() hashed a face's nodes in their
        // stored (winding) order rather than sorted; since two adjacent
        // cells wind their shared face in opposite orders, the keys
        // never matched and every interior face was left looking like a
        // boundary face with no neighbor.  For an n x n x n cube there
        // are 3*(n-1)*n*n interior faces, each shared by two elements,
        // so 2*3*(n-1)*n*n sides should carry a neighbor link.
        int n_neighbor_links = 0;
        for (auto & elem : mesh.active_local_element_ptr_range())
          for (auto s : elem->side_index_range())
            {
              const Elem * neigh = elem->neighbor_ptr(s);
              if (!neigh)
                continue;
              ++n_neighbor_links;
 
              // Links to a non-remote neighbor must be reciprocal.
              if (!neigh->is_remote())
                {
                  const unsigned int ns = neigh->which_neighbor_am_i(elem);
                  CPPUNIT_ASSERT(ns < neigh->n_sides());
                  CPPUNIT_ASSERT(neigh->neighbor_ptr(ns) == elem);
                }
            }
        mesh.comm().sum(n_neighbor_links);
 
        CPPUNIT_ASSERT_EQUAL(n_neighbor_links,
                             static_cast<int>(2 * 3 * (n-1) * n * n));
 
        return;
      }
 
    // We don't yet try to do affine map optimizations on pyramids
    if (type == PYRAMID5 ||
        type == PYRAMID13 ||
        type == PYRAMID14)
      return;
 
    // Do serial assertions *after* all parallel assertions, so we
    // stay in sync after failure on only some processor(s)
    for (auto & elem : mesh.element_ptr_range())
      CPPUNIT_ASSERT(elem->has_affine_map());
  }

References libMesh::MeshTools::Generation::build_cube(), libMesh::C0POLYHEDRON, libMesh::ParallelObject::comm(), libMesh::MeshTools::create_bounding_box(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::HEX20, libMesh::Elem::is_remote(), libMesh::BoundingBox::max(), mesh, libMesh::BoundingBox::min(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::Elem::neighbor_ptr(), libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM20, libMesh::PRISM21, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID5, libMesh::Real, libMesh::Parallel::Communicator::sum(), libMesh::TOLERANCE, libMesh::Elem::type_to_n_nodes_map, libMesh::Elem::type_to_n_sides_map, libMesh::MeshTools::volume(), and libMesh::Elem::which_neighbor_am_i().

Referenced by buildCubeC0Polyhedron(), buildCubeHex20(), buildCubeHex27(), buildCubeHex8(), buildCubePrism15(), buildCubePrism18(), buildCubePrism20(), buildCubePrism21(), buildCubePrism6(), buildCubePyramid13(), buildCubePyramid14(), buildCubePyramid5(), buildCubeTet10(), buildCubeTet14(), and buildCubeTet4().

testBuildLine()

void MeshGenerationTest::testBuildLine ( UnstructuredMesh &  mesh, unsigned int  n, ElemType  type  )

inline

Definition at line 103 of file mesh_generation_test.C.

  {
    MeshTools::Generation::build_line (mesh, n, -1.0, 2.0, type);
    CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), cast_int<dof_id_type>(n));
    CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(),
                         cast_int<dof_id_type>((Elem::type_to_n_nodes_map[type]-1)*n + 1));
 
    BoundingBox bbox = MeshTools::create_bounding_box(mesh);
    CPPUNIT_ASSERT_EQUAL(bbox.min()(0), Real(-1.0));
    CPPUNIT_ASSERT_EQUAL(bbox.max()(0), Real(2.0));
 
    // Do serial assertions *after* all parallel assertions, so we
    // stay in sync after failure on only some processor(s)
    for (auto & elem : mesh.element_ptr_range())
      CPPUNIT_ASSERT(elem->has_affine_map());
  }

References libMesh::MeshTools::Generation::build_line(), libMesh::MeshTools::create_bounding_box(), libMesh::BoundingBox::max(), mesh, libMesh::BoundingBox::min(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::Real, and libMesh::Elem::type_to_n_nodes_map.

Referenced by buildLineEdge2(), buildLineEdge3(), and buildLineEdge4().

testBuildSphere()

void MeshGenerationTest::testBuildSphere ( unsigned int  n_ref, ElemType  type  )

inline

Definition at line 372 of file mesh_generation_test.C.

  {
    ReplicatedMesh rmesh(*TestCommWorld);
    MeshTools::Generation::build_sphere (rmesh, 2.0, n_ref, type);
 
    DistributedMesh dmesh(*TestCommWorld);
    dmesh.allow_renumbering(false);
    MeshTools::Generation::build_sphere (dmesh, 2.0, n_ref, type);
  }

References libMesh::MeshBase::allow_renumbering(), libMesh::MeshTools::Generation::build_sphere(), and TestCommWorld.

Referenced by buildSphereEdge2(), buildSphereEdge3(), buildSphereEdge4(), buildSphereHex27(), buildSphereHex8(), buildSphereQuad4(), and buildSphereTri3().

testBuildSquare()

void MeshGenerationTest::testBuildSquare ( UnstructuredMesh &  mesh, unsigned int  n, ElemType  type  )

inline

Definition at line 120 of file mesh_generation_test.C.

  {
    MeshTools::Generation::build_square (mesh, n, n, -2.0, 3.0, -4.0, 5.0, type);
    if (type == C0POLYGON)
      CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), cast_int<dof_id_type>(n*n + 4 + 2 * (n - 1) + ((n - 1) / 2)));
    else if (Elem::type_to_n_sides_map[type] == 4)
      CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), cast_int<dof_id_type>(n*n));
    else
      CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), cast_int<dof_id_type>(n*n*2));
 
    switch (type)
      {
      case TRI3: // First-order elements
      case QUAD4:
        CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(),
                             cast_int<dof_id_type>((n+1)*(n+1)));
        break;
      case TRI6: // Second-order elements
      case QUAD9:
        CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(),
                             cast_int<dof_id_type>((2*n+1)*(2*n+1)));
        break;
      case QUAD8: // Not-really-second-order element missing center nodes
        CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(),
                             cast_int<dof_id_type>((2*n+1)*(2*n+1) - n*n));
        break;
      case TRI7: // Not-really-second-order element with extra center nodes
        CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(),
                             cast_int<dof_id_type>((2*n+1)*(2*n+1) + 2*n*n));
        break;
      case C0POLYGON:
        CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(),
                             cast_int<dof_id_type>(4 + 2*n*n + (n - 1) + 2*n + 2 * (n%2)));
        break;
      default: // Wait, what did we try to build?
        CPPUNIT_ASSERT(false);
      }
 
    // Our bounding boxes can be loose on higher order elements, but
    // we can at least assert that they're not too tight
    BoundingBox bbox = MeshTools::create_bounding_box(mesh);
    CPPUNIT_ASSERT(bbox.min()(0) <= Real(-2.0));
    CPPUNIT_ASSERT(bbox.max()(0) >= Real(3.0));
    CPPUNIT_ASSERT(bbox.min()(1) <= Real(-4.0));
    CPPUNIT_ASSERT(bbox.max()(1) >= Real(5.0));
 
    if (type == C0POLYGON)
      {
        BoundingBox nodal_bbox = MeshTools::create_nodal_bounding_box(mesh);
        LIBMESH_ASSERT_FP_EQUAL(nodal_bbox.min()(0),
                                Real(-2.0),
                                TOLERANCE*TOLERANCE);
        LIBMESH_ASSERT_FP_EQUAL(nodal_bbox.max()(0),
                                Real(3.0),
                                TOLERANCE*TOLERANCE);
        LIBMESH_ASSERT_FP_EQUAL(nodal_bbox.min()(1),
                                Real(-4.0),
                                TOLERANCE*TOLERANCE);
        LIBMESH_ASSERT_FP_EQUAL(nodal_bbox.max()(1),
                                Real(5.0),
                                TOLERANCE*TOLERANCE);
      }
 
    // Do serial assertions *after* all parallel assertions, so we
    // stay in sync after failure on only some processor(s)
    if (type != C0POLYGON)
      for (auto & elem : mesh.element_ptr_range())
        CPPUNIT_ASSERT(elem->has_affine_map());
  }

References libMesh::MeshTools::Generation::build_square(), libMesh::C0POLYGON, libMesh::MeshTools::create_bounding_box(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::BoundingBox::max(), mesh, libMesh::BoundingBox::min(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::Real, libMesh::TOLERANCE, libMesh::TRI3, libMesh::TRI6, libMesh::TRI7, and libMesh::Elem::type_to_n_sides_map.

Referenced by buildSquareC0PolygonEven(), buildSquareC0PolygonOdd(), buildSquareQuad4(), buildSquareQuad8(), buildSquareQuad9(), buildSquareTri3(), buildSquareTri6(), and buildSquareTri7().

tester()

void MeshGenerationTest::tester ( Builder  f, unsigned int  n, ElemType  type  )

inline

Definition at line 385 of file mesh_generation_test.C.

  {
    for (int is_replicated = 0; is_replicated != 2; ++is_replicated)
      {
        for (int skip_renumber = 0 ; skip_renumber != 2; ++skip_renumber)
          {
            std::unique_ptr<UnstructuredMesh> mesh =
              new_mesh(is_replicated);
            mesh->allow_renumbering(!skip_renumber);
            (this->*f)(*mesh, n, type);
          }
      }
  }

References libMesh::MeshBase::allow_renumbering(), mesh, and new_mesh().

Referenced by buildCubeC0Polyhedron(), buildCubeHex20(), buildCubeHex27(), buildCubeHex8(), buildCubePrism15(), buildCubePrism18(), buildCubePrism20(), buildCubePrism21(), buildCubePrism6(), buildCubePyramid13(), buildCubePyramid14(), buildCubePyramid5(), buildCubeTet10(), buildCubeTet14(), buildCubeTet4(), buildLineEdge2(), buildLineEdge3(), buildLineEdge4(), buildSquareC0PolygonEven(), buildSquareC0PolygonOdd(), buildSquareQuad4(), buildSquareQuad8(), buildSquareQuad9(), buildSquareTri3(), buildSquareTri6(), and buildSquareTri7().

---

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

• tests/mesh/mesh_generation_test.C