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 (testNetGenNonOriented)
	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, bool flip_some_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	testNetGenNonOriented ()
void	testNetGenHole ()
void	testNetGenSphereShell ()

Detailed Description

Definition at line 38 of file mesh_tet_test.C.

Member Function Documentation

CPPUNIT_TEST() [1/7]

MeshTetTest::CPPUNIT_TEST

(

testNetGen

)

CPPUNIT_TEST() [2/7]

MeshTetTest::CPPUNIT_TEST

(

testNetGenError

)

CPPUNIT_TEST() [3/7]

MeshTetTest::CPPUNIT_TEST

(

testNetGenTets

)

CPPUNIT_TEST() [4/7]

MeshTetTest::CPPUNIT_TEST

(

testNetGenFlippedTris

)

CPPUNIT_TEST() [5/7]

MeshTetTest::CPPUNIT_TEST

(

testNetGenNonOriented

)

CPPUNIT_TEST() [6/7]

MeshTetTest::CPPUNIT_TEST

(

testNetGenHole

)

CPPUNIT_TEST() [7/7]

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

{}

tearDown()

void MeshTetTest::tearDown ( )

inline

Definition at line 86 of file mesh_tet_test.C.

{}

testBcids()

void MeshTetTest::testBcids ( UnstructuredMesh &  mesh )

inline

Definition at line 149 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 88 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 180 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 372 of file mesh_tet_test.C.

References mesh, libMesh::MeshTetInterface::set_verbosity(), and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);
    NetGenMeshInterface net_tet(mesh);

    // This should give no output for our correctly-set-up inputs
    net_tet.set_verbosity(50);

    testTrisToTets(mesh, net_tet);
    testBcids(mesh);
  }

testNetGenError()

void MeshTetTest::testNetGenError ( )

inline

Definition at line 387 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 408 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 430 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);
  }

testNetGenNonOriented()

void MeshTetTest::testNetGenNonOriented ( )

inline

Definition at line 419 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, true);
    testBcids(mesh);
  }

testNetGenSphereShell()

void MeshTetTest::testNetGenSphereShell ( )

inline

Definition at line 442 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 397 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 207 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 326 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 336 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 120 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 289 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, bool  flip_some_tris = false  )

inline

Definition at line 234 of file mesh_tet_test.C.

References libMesh::MeshBase::get_boundary_info(), mesh, libMesh::Real, and libMesh::MeshBase::unset_is_prepared().

  {
    // 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);

    // Flip a couple tri, breaking the mesh in a way we can fix
    if (flip_some_tris)
      for (auto elem : mesh.element_ptr_range())
        {
          Point center = elem->vertex_average();
          if ((center(0) > 0 &&
               center(1) > 0 &&
               center(2) > 0) ||
              (center(0) < 0 &&
               center(1) < 0 &&
               center(2) < 0))
            elem->flip(&mesh.get_boundary_info());

          mesh.unset_is_prepared();
        }

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