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	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.

{}

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 148 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 323 of file mesh_tet_test.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testNetGenError()

void MeshTetTest::testNetGenError ( )

inline

Definition at line 333 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 353 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);
  }

testNetGenHole()

void MeshTetTest::testNetGenHole ( )

inline

Definition at line 363 of file mesh_tet_test.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testNetGenSphereShell()

void MeshTetTest::testNetGenSphereShell ( )

inline

Definition at line 374 of file mesh_tet_test.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testNetGenTets()

void MeshTetTest::testNetGenTets ( )

inline

Definition at line 343 of file mesh_tet_test.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testSphereShell()

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

inline

Definition at line 175 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 277 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 287 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 240 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 202 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 216 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