MeshTetTest Class Reference

Inheritance diagram for MeshTetTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (MeshTetTest)
	The goal of this test is to verify proper operation of the interfaces to tetrahedralization libraries. More...
	CPPUNIT_TEST (testNetGen)
	CPPUNIT_TEST (testNetGenError)
	CPPUNIT_TEST (testNetGenTets)
	CPPUNIT_TEST (testNetGenFlippedTris)
	CPPUNIT_TEST (testNetGenHole)
	CPPUNIT_TEST (testNetGenSphereShell)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
void	testExceptionBase (const char *re, MeshBase &mesh, MeshTetInterface &tetinterface, dof_id_type expected_n_elem=DofObject::invalid_id, dof_id_type expected_n_nodes=DofObject::invalid_id, Real expected_volume=0)
void	testTetInterfaceBase (MeshBase &mesh, MeshTetInterface &triangulator, dof_id_type expected_n_elem=DofObject::invalid_id, dof_id_type expected_n_nodes=DofObject::invalid_id, Real expected_volume=0)
void	testBcids (UnstructuredMesh &mesh)
void	testHole (UnstructuredMesh &mesh, MeshTetInterface &triangulator)
void	testSphereShell (UnstructuredMesh &mesh, MeshTetInterface &triangulator)
void	testTrisToTets (UnstructuredMesh &mesh, MeshTetInterface &triangulator, bool flip_tris=false)
void	testTrisToTetsError (UnstructuredMesh &mesh, MeshTetInterface &triangulator, bool flip_tris=false)
void	testTetsToTets (MeshBase &mesh, MeshTetInterface &triangulator)
void	testTetGen ()
void	testTetGenError ()
void	testNetGen ()
void	testNetGenError ()
void	testNetGenTets ()
void	testNetGenFlippedTris ()
void	testNetGenHole ()
void	testNetGenSphereShell ()

Detailed Description

Definition at line 38 of file mesh_tet_test.C.

Member Function Documentation

CPPUNIT_TEST() [1/6]

MeshTetTest::CPPUNIT_TEST

(

testNetGen

)

CPPUNIT_TEST() [2/6]

MeshTetTest::CPPUNIT_TEST

(

testNetGenError

)

CPPUNIT_TEST() [3/6]

MeshTetTest::CPPUNIT_TEST

(

testNetGenTets

)

CPPUNIT_TEST() [4/6]

MeshTetTest::CPPUNIT_TEST

(

testNetGenFlippedTris

)

CPPUNIT_TEST() [5/6]

MeshTetTest::CPPUNIT_TEST

(

testNetGenHole

)

CPPUNIT_TEST() [6/6]

MeshTetTest::CPPUNIT_TEST

(

testNetGenSphereShell

)

CPPUNIT_TEST_SUITE_END()

MeshTetTest::CPPUNIT_TEST_SUITE_END

(

)

LIBMESH_CPPUNIT_TEST_SUITE()

MeshTetTest::LIBMESH_CPPUNIT_TEST_SUITE

(

MeshTetTest

)

The goal of this test is to verify proper operation of the interfaces to tetrahedralization libraries.

setUp()

void MeshTetTest::setUp ( )

inline

Definition at line 83 of file mesh_tet_test.C.

{}

tearDown()

void MeshTetTest::tearDown ( )

inline

Definition at line 85 of file mesh_tet_test.C.

{}

testBcids()

void MeshTetTest::testBcids ( UnstructuredMesh &  mesh )

inline

Definition at line 148 of file mesh_tet_test.C.

References libMesh::MeshBase::get_boundary_info(), libMesh::BoundaryInfo::has_boundary_id(), mesh, and libMesh::BoundaryInfo::n_boundary_ids().

  {
    BoundaryInfo & bi = mesh.get_boundary_info();
    for (const auto & elem : mesh.element_ptr_range())
      {
        for (auto s : elem->side_index_range())
          {
            auto neigh = elem->neighbor_ptr(s);

            if (neigh)
            {
              CPPUNIT_ASSERT_EQUAL(bi.n_boundary_ids(elem, s), 0u);
              continue;
            }

            CPPUNIT_ASSERT_EQUAL(bi.n_boundary_ids(elem, s), 1u);

            auto side = elem->side_ptr(s);
            auto normal = (side->point(1) - side->point(0)).cross
                          (side->point(2) - side->point(0));
            // Outer faces, in these tests
            if (normal * side->vertex_average() > 0)
              CPPUNIT_ASSERT(bi.has_boundary_id(elem, s, 0));
            // Inner faces, with one-hole tests
            else
              CPPUNIT_ASSERT(bi.has_boundary_id(elem, s, 1));
          }
      }
  }

testExceptionBase()

void MeshTetTest::testExceptionBase ( const char *  re, MeshBase &  mesh, MeshTetInterface &  tetinterface, dof_id_type  expected_n_elem = DofObject::invalid_id, dof_id_type  expected_n_nodes = DofObject::invalid_id, Real  expected_volume = 0  )

inline

Definition at line 87 of file mesh_tet_test.C.

References mesh.

  {
#ifdef LIBMESH_ENABLE_EXCEPTIONS
    // We can't just CPPUNIT_ASSERT_THROW, because we want to make
    // sure we were thrown from the right place with the right error
    // message!
    bool threw_desired_exception = false;
    try {
      this->testTetInterfaceBase(mesh, tetinterface, expected_n_elem,
                                 expected_n_nodes, expected_volume);
    }
    catch (libMesh::LogicError & e) {
      std::regex msg_regex(re);
      CPPUNIT_ASSERT(std::regex_search(e.what(), msg_regex));
      threw_desired_exception = true;
    }
    catch (CppUnit::Exception & e) {
      throw e;
    }
    catch (...) {
      CPPUNIT_ASSERT_MESSAGE("Unexpected exception type thrown", false);
    }
    CPPUNIT_ASSERT(threw_desired_exception);
#endif
  }

testHole()

void MeshTetTest::testHole ( UnstructuredMesh &  mesh, MeshTetInterface &  triangulator  )

inline

Definition at line 179 of file mesh_tet_test.C.

References libMesh::MeshTetInterface::attach_hole_list(), libMesh::MeshTools::Generation::build_cube(), mesh, libMesh::Real, and libMesh::MeshTools::volume().

  {
    std::unique_ptr<UnstructuredMesh> holemesh =
      std::make_unique<Mesh>(*TestCommWorld);

    MeshTools::Generation::build_cube (mesh, 1, 1, 1,
                                       -2, 2, -2, 2, -2, 2);

    const Real hole_volume =
      build_octahedron(*holemesh, false, -1, 1, -1, 1, -1, 1);

    auto holes =
      std::make_unique<std::vector<std::unique_ptr<UnstructuredMesh>>>();

    holes->push_back(std::move(holemesh));

    triangulator.attach_hole_list(std::move(holes));

    const Real expected_volume =
      MeshTools::volume(mesh) - hole_volume;
    this->testTetInterfaceBase(mesh, triangulator, 32, 14,
                               expected_volume);
  }

testNetGen()

void MeshTetTest::testNetGen ( )

inline

Definition at line 354 of file mesh_tet_test.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);
    NetGenMeshInterface net_tet(mesh);
    testTrisToTets(mesh, net_tet);
    testBcids(mesh);
  }

testNetGenError()

void MeshTetTest::testNetGenError ( )

inline

Definition at line 365 of file mesh_tet_test.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);
    NetGenMeshInterface net_tet(mesh);
    testTrisToTetsError(mesh, net_tet);
  }

testNetGenFlippedTris()

void MeshTetTest::testNetGenFlippedTris ( )

inline

Definition at line 386 of file mesh_tet_test.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);
    NetGenMeshInterface net_tet(mesh);
    testTrisToTets(mesh, net_tet, true);
    testBcids(mesh);
  }

testNetGenHole()

void MeshTetTest::testNetGenHole ( )

inline

Definition at line 397 of file mesh_tet_test.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);
    NetGenMeshInterface net_tet(mesh);
    testHole(mesh, net_tet);
    testBcids(mesh);
  }

testNetGenSphereShell()

void MeshTetTest::testNetGenSphereShell ( )

inline

Definition at line 409 of file mesh_tet_test.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);
    NetGenMeshInterface net_tet(mesh);
    testSphereShell(mesh, net_tet);
    testBcids(mesh);
  }

testNetGenTets()

void MeshTetTest::testNetGenTets ( )

inline

Definition at line 375 of file mesh_tet_test.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);
    NetGenMeshInterface net_tet(mesh);
    testTetsToTets(mesh, net_tet);
    testBcids(mesh);
  }

testSphereShell()

void MeshTetTest::testSphereShell ( UnstructuredMesh &  mesh, MeshTetInterface &  triangulator  )

inline

Definition at line 206 of file mesh_tet_test.C.

References libMesh::MeshTetInterface::attach_hole_list(), libMesh::MeshTools::Generation::build_sphere(), libMesh::MeshTetInterface::desired_volume(), mesh, and libMesh::TET4.

  {
    std::unique_ptr<UnstructuredMesh> holemesh =
      std::make_unique<Mesh>(*TestCommWorld);

    MeshTools::Generation::build_sphere (*holemesh, 1, 2, TET4);

    MeshTools::Generation::build_sphere (mesh, 1.25, 2, TET4);

    auto holes =
      std::make_unique<std::vector<std::unique_ptr<UnstructuredMesh>>>();

    holes->push_back(std::move(holemesh));

    triangulator.attach_hole_list(std::move(holes));

    // Netgen can't seem to triangulate this without inserting points,
    // so let MeshNetgenInterface know that we're allowed to insert
    // points
    triangulator.desired_volume() = 1000;

    this->testTetInterfaceBase(mesh, triangulator);
  }

testTetGen()

void MeshTetTest::testTetGen ( )

inline

Definition at line 308 of file mesh_tet_test.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);
    TetGenMeshInterface tet_tet(mesh);
    testTrisToTets(mesh, tet_tet);
  }

testTetGenError()

void MeshTetTest::testTetGenError ( )

inline

Definition at line 318 of file mesh_tet_test.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);
    TetGenMeshInterface tet_tet(mesh);
      testTrisToTetsError(mesh, tet_tet);
  }

testTetInterfaceBase()

void MeshTetTest::testTetInterfaceBase ( MeshBase &  mesh, MeshTetInterface &  triangulator, dof_id_type  expected_n_elem = DofObject::invalid_id, dof_id_type  expected_n_nodes = DofObject::invalid_id, Real  expected_volume = 0  )

inline

Definition at line 119 of file mesh_tet_test.C.

References libMesh::DofObject::invalid_id, mesh, libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::TET4, libMesh::TOLERANCE, libMesh::MeshTetInterface::triangulate(), and libMesh::MeshTools::volume().

  {
    triangulator.triangulate();

    if (expected_n_elem != DofObject::invalid_id)
      CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), expected_n_elem);

    if (expected_n_nodes != DofObject::invalid_id)
      CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(), expected_n_nodes);

    if (expected_volume != 0)
      LIBMESH_ASSERT_FP_EQUAL(MeshTools::volume(mesh),
                              expected_volume,
                              TOLERANCE*TOLERANCE);

    for (const auto & elem : mesh.element_ptr_range())
      {
        CPPUNIT_ASSERT_EQUAL(elem->type(), TET4);

        // Make sure we're not getting any inverted elements
        CPPUNIT_ASSERT(!elem->is_flipped());
      }
  }

testTetsToTets()

void MeshTetTest::testTetsToTets ( MeshBase &  mesh, MeshTetInterface &  triangulator  )

inline

Definition at line 271 of file mesh_tet_test.C.

References libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::Elem::build(), mesh, libMesh::MeshBase::node_ptr(), libMesh::MeshBase::prepare_for_use(), libMesh::Real, libMesh::Elem::set_node(), libMesh::TET4, and libMesh::MeshTools::volume().

  {
    // An asymmetric octahedron, so we hopefully have an unambiguous
    // choice of shortest diagonal for a Delaunay algorithm to pick.
    mesh.add_point(Point(0,0,-0.1), 0);
    mesh.add_point(Point(1,0,0), 1);
    mesh.add_point(Point(0,1,0), 2);
    mesh.add_point(Point(-1,0,0), 3);
    mesh.add_point(Point(0,-1,0), 4);
    mesh.add_point(Point(0,0,0.1), 5);

    auto add_tet = [&mesh](std::array<dof_id_type,4> nodes)
    {
      auto elem = mesh.add_elem(Elem::build(TET4));
      elem->set_node(0, mesh.node_ptr(nodes[0]));
      elem->set_node(1, mesh.node_ptr(nodes[1]));
      elem->set_node(2, mesh.node_ptr(nodes[2]));
      elem->set_node(3, mesh.node_ptr(nodes[3]));
    };

    // Split along a different diagonal to start
    add_tet({1,3,4,5});
    add_tet({1,3,5,2});
    add_tet({1,3,2,0});
    add_tet({1,3,0,4});

    mesh.prepare_for_use();

    const Real expected_volume = MeshTools::volume(mesh);

    this->testTetInterfaceBase(mesh, triangulator, /* n_elem = */ 4,
                               /* n_nodes = */ 6, expected_volume);
  }

testTrisToTets()

void MeshTetTest::testTrisToTets ( UnstructuredMesh &  mesh, MeshTetInterface &  triangulator, bool  flip_tris = false  )

inline

Definition at line 233 of file mesh_tet_test.C.

References mesh, and libMesh::Real.

  {
    // An asymmetric octahedron, so we hopefully have an unambiguous
    // choice of shortest diagonal for a Delaunay algorithm to pick.
    const Real expected_volume =
      build_octahedron(mesh, flip_tris, -1, 1, -1, 1, -0.1, 0.1);

    this->testTetInterfaceBase(mesh, triangulator, /* n_elem = */ 4,
                               /* n_nodes = */ 6, expected_volume);
  }

testTrisToTetsError()

void MeshTetTest::testTrisToTetsError ( UnstructuredMesh &  mesh, MeshTetInterface &  triangulator, bool  flip_tris = false  )

inline

Definition at line 247 of file mesh_tet_test.C.

References libMesh::MeshBase::delete_elem(), mesh, libMesh::MeshBase::prepare_for_use(), and libMesh::Real.

  {
    const Real expected_volume =
      build_octahedron(mesh, flip_tris, -1, 1, -1, 1, -0.1, 0.1);

    // Remove one tri, breaking the mesh
    for (auto elem : mesh.element_ptr_range())
      {
        Point center = elem->vertex_average();
        if (center(0) > 0 &&
            center(1) > 0 &&
            center(2) > 0)
          mesh.delete_elem(elem);
      }
    mesh.prepare_for_use();

    this->testExceptionBase("element with a null neighbor", mesh, triangulator,
                            /* n_elem = */ 4, /* n_nodes = */ 6,
                            expected_volume);
  }

---

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

• tests/mesh/mesh_tet_test.C