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.
	CPPUNIT_TEST (testNetGen)
	CPPUNIT_TEST (testNetGenError)
	CPPUNIT_TEST (testNetGenTets)
	CPPUNIT_TEST (testNetGenFlippedTris)
	CPPUNIT_TEST (testNetGenNonOriented)
	CPPUNIT_TEST (testNetGenHole)
	CPPUNIT_TEST (testNetGenQuadratic)
	CPPUNIT_TEST (testNetGenQuadraticCurved)
	CPPUNIT_TEST (testNetGenTet14)
	CPPUNIT_TEST (testNetGenTet14Curved)
	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	testNetGenQuadratic ()
void	testNetGenTet14 ()
void	testNetGenQuadraticCurved ()
void	testNetGenTet14Curved ()
void	testNetGenSphereShell ()

Detailed Description

Definition at line 40 of file mesh_tet_test.C.

Member Function Documentation

CPPUNIT_TEST() [1/11]

MeshTetTest::CPPUNIT_TEST

(

testNetGen

)

CPPUNIT_TEST() [2/11]

MeshTetTest::CPPUNIT_TEST

(

testNetGenError

)

CPPUNIT_TEST() [3/11]

MeshTetTest::CPPUNIT_TEST

(

testNetGenFlippedTris

)

CPPUNIT_TEST() [4/11]

MeshTetTest::CPPUNIT_TEST

(

testNetGenHole

)

CPPUNIT_TEST() [5/11]

MeshTetTest::CPPUNIT_TEST

(

testNetGenNonOriented

)

CPPUNIT_TEST() [6/11]

MeshTetTest::CPPUNIT_TEST

(

testNetGenQuadratic

)

CPPUNIT_TEST() [7/11]

MeshTetTest::CPPUNIT_TEST

(

testNetGenQuadraticCurved

)

CPPUNIT_TEST() [8/11]

MeshTetTest::CPPUNIT_TEST

(

testNetGenSphereShell

)

CPPUNIT_TEST() [9/11]

MeshTetTest::CPPUNIT_TEST

(

testNetGenTet14

)

CPPUNIT_TEST() [10/11]

MeshTetTest::CPPUNIT_TEST

(

testNetGenTet14Curved

)

CPPUNIT_TEST() [11/11]

MeshTetTest::CPPUNIT_TEST

(

testNetGenTets

)

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

{}

tearDown()

void MeshTetTest::tearDown ( )

inline

Definition at line 92 of file mesh_tet_test.C.

{}

testBcids()

void MeshTetTest::testBcids ( UnstructuredMesh &  mesh )

inline

Definition at line 155 of file mesh_tet_test.C.

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

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

Referenced by testNetGen(), testNetGenFlippedTris(), testNetGenHole(), testNetGenNonOriented(), testNetGenQuadratic(), testNetGenQuadraticCurved(), testNetGenSphereShell(), testNetGenTet14(), testNetGenTet14Curved(), and testNetGenTets().

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

  {
#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
  }

References testTetInterfaceBase().

Referenced by testTrisToTetsError().

testHole()

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

inline

Definition at line 186 of file mesh_tet_test.C.

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

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

Referenced by testNetGenHole().

testNetGen()

void MeshTetTest::testNetGen ( )

inline

Definition at line 378 of file mesh_tet_test.C.

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

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

testNetGenError()

void MeshTetTest::testNetGenError ( )

inline

Definition at line 393 of file mesh_tet_test.C.

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

References mesh, TestCommWorld, and testTrisToTetsError().

testNetGenFlippedTris()

void MeshTetTest::testNetGenFlippedTris ( )

inline

Definition at line 414 of file mesh_tet_test.C.

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

References mesh, testBcids(), TestCommWorld, and testTrisToTets().

testNetGenHole()

void MeshTetTest::testNetGenHole ( )

inline

Definition at line 436 of file mesh_tet_test.C.

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

References mesh, testBcids(), TestCommWorld, and testHole().

testNetGenNonOriented()

void MeshTetTest::testNetGenNonOriented ( )

inline

Definition at line 425 of file mesh_tet_test.C.

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

References mesh, testBcids(), TestCommWorld, and testTrisToTets().

testNetGenQuadratic()

void MeshTetTest::testNetGenQuadratic ( )

inline

Definition at line 447 of file mesh_tet_test.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    NetGenMeshInterface net_tet(mesh);
    net_tet.elem_type() = TET10;
 
    const Real expected_volume =
      build_octahedron(mesh, false, -1, 1, -1, 1, -0.1, 0.1);
 
    net_tet.triangulate();
 
    LIBMESH_ASSERT_FP_EQUAL(MeshTools::volume(mesh),
                             expected_volume,
                             TOLERANCE*TOLERANCE);
 
    for (const auto & elem : mesh.element_ptr_range())
      {
        CPPUNIT_ASSERT_EQUAL(elem->type(), TET10);
        CPPUNIT_ASSERT_EQUAL(elem->n_nodes(), 10u);
        CPPUNIT_ASSERT(!elem->is_flipped());
      }
 
    // Boundary ids should survive the increase to second order
    testBcids(mesh);
  }

References libMesh::MeshTetInterface::elem_type(), mesh, libMesh::Real, testBcids(), TestCommWorld, libMesh::TET10, libMesh::TOLERANCE, libMesh::NetGenMeshInterface::triangulate(), and libMesh::MeshTools::volume().

testNetGenQuadraticCurved()

void MeshTetTest::testNetGenQuadraticCurved ( )

inline

Definition at line 505 of file mesh_tet_test.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    NetGenMeshInterface net_tet(mesh);
    net_tet.elem_type() = TET10;
 
    // Build TRI3 octahedron then upconvert to TRI6 with geometric midpoints.
    build_octahedron(mesh, false, -1, 1, -1, 1, -0.1, 0.1);
    mesh.all_second_order();
    mesh.prepare_for_use();
 
    // Perturb every TRI6 midpoint outward to simulate a curved boundary.
    // Key by sorted pair of corner positions (same scheme as record_and_strip).
    const Real eps = 0.05;
    std::map<std::pair<Point,Point>, Point> expected;
 
    for (const auto & elem : mesh.element_ptr_range())
      {
        libmesh_assert_equal_to(elem->type(), TRI6);
        for (auto e : make_range(3u))
          {
            const Point & pa = elem->point(e);
            const Point & pb = elem->point((e+1)%3);
            auto key = pa < pb ? std::make_pair(pa, pb)
                               : std::make_pair(pb, pa);
            if (expected.count(key))
              continue;
 
            // Perturb midpoint radially outward via mutable Point & ref.
            Point & mid = elem->point(e+3);
            mid += eps * mid.unit();
            expected[key] = mid;
          }
      }
 
    net_tet.triangulate();
 
    // For every boundary face of the resulting TET10 mesh, verify that edge
    // midpoints match the perturbed positions — not geometric averages.
    unsigned int n_checked = 0;
    for (const auto & elem : mesh.element_ptr_range())
      for (auto s : elem->side_index_range())
        {
          if (elem->neighbor_ptr(s)) continue;
 
          auto side = elem->build_side_ptr(s);  // TRI6, nodes into mesh
          for (auto e : make_range(3u))
            {
              const Point & pa = side->point(e);
              const Point & pb = side->point((e+1)%3);
              auto key = pa < pb ? std::make_pair(pa, pb)
                                 : std::make_pair(pb, pa);
              auto it = expected.find(key);
              if (it == expected.end())
                continue;
              const Point & exp = it->second;
              const Point & got = side->point(e+3);
              LIBMESH_ASSERT_FP_EQUAL(exp(0), got(0), TOLERANCE);
              LIBMESH_ASSERT_FP_EQUAL(exp(1), got(1), TOLERANCE);
              LIBMESH_ASSERT_FP_EQUAL(exp(2), got(2), TOLERANCE);
              ++n_checked;
            }
        }
 
    CPPUNIT_ASSERT_GREATER(0u, n_checked);
 
    // Boundary ids should survive the increase to second order, even with
    // perturbed (curved) boundary midpoints
    testBcids(mesh);
  }

References libMesh::MeshBase::all_second_order(), libMesh::MeshTetInterface::elem_type(), libMesh::make_range(), mesh, libMesh::MeshBase::prepare_for_use(), libMesh::Real, testBcids(), TestCommWorld, libMesh::TET10, libMesh::TOLERANCE, libMesh::TRI6, libMesh::NetGenMeshInterface::triangulate(), and libMesh::TypeVector< T >::unit().

testNetGenSphereShell()

void MeshTetTest::testNetGenSphereShell ( )

inline

Definition at line 666 of file mesh_tet_test.C.

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

References mesh, testBcids(), TestCommWorld, and testSphereShell().

testNetGenTet14()

void MeshTetTest::testNetGenTet14 ( )

inline

Definition at line 476 of file mesh_tet_test.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    NetGenMeshInterface net_tet(mesh);
    net_tet.elem_type() = TET14;
 
    const Real expected_volume =
      build_octahedron(mesh, false, -1, 1, -1, 1, -0.1, 0.1);
 
    net_tet.triangulate();
 
    LIBMESH_ASSERT_FP_EQUAL(MeshTools::volume(mesh),
                             expected_volume,
                             TOLERANCE*TOLERANCE);
 
    for (const auto & elem : mesh.element_ptr_range())
      {
        CPPUNIT_ASSERT_EQUAL(elem->type(), TET14);
        CPPUNIT_ASSERT_EQUAL(elem->n_nodes(), 14u);
        CPPUNIT_ASSERT(!elem->is_flipped());
      }
 
    // Boundary ids should survive the increase to complete order
    testBcids(mesh);
  }

References libMesh::MeshTetInterface::elem_type(), mesh, libMesh::Real, testBcids(), TestCommWorld, libMesh::TET14, libMesh::TOLERANCE, libMesh::NetGenMeshInterface::triangulate(), and libMesh::MeshTools::volume().

testNetGenTet14Curved()

void MeshTetTest::testNetGenTet14Curved ( )

inline

Definition at line 579 of file mesh_tet_test.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    NetGenMeshInterface net_tet(mesh);
    net_tet.elem_type() = TET14;
 
    // Build TRI3 octahedron then upconvert to TRI7 (edge mids + centroid).
    build_octahedron(mesh, false, -1, 1, -1, 1, -0.1, 0.1);
    mesh.all_complete_order();
    mesh.prepare_for_use();
 
    const Real eps = 0.05;
    std::map<std::pair<Point,Point>, Point> expected_mid;
    std::map<std::array<Point,3>, Point> expected_cen;
 
    for (const auto & elem : mesh.element_ptr_range())
      {
        libmesh_assert_equal_to(elem->type(), TRI7);
        for (auto e : make_range(3u))
          {
            const Point & pa = elem->point(e);
            const Point & pb = elem->point((e+1)%3);
            auto key = pa < pb ? std::make_pair(pa, pb)
                               : std::make_pair(pb, pa);
            if (!expected_mid.count(key))
              {
                Point & mid = elem->point(e+3);
                mid += eps * mid.unit();
                expected_mid[key] = mid;
              }
          }
        // Perturb the face-centroid node (index 6) radially outward.
        std::array<Point,3> corners =
          {elem->point(0), elem->point(1), elem->point(2)};
        std::sort(corners.begin(), corners.end());
        Point & cen = elem->point(6);
        cen += eps * cen.unit();
        expected_cen[corners] = cen;
      }
 
    net_tet.triangulate();
 
    unsigned int n_mid = 0, n_cen = 0;
    for (const auto & elem : mesh.element_ptr_range())
      for (auto s : elem->side_index_range())
        {
          if (elem->neighbor_ptr(s)) continue;
          auto side = elem->build_side_ptr(s);
          CPPUNIT_ASSERT_EQUAL(side->type(), TRI7);
          for (auto e : make_range(3u))
            {
              const Point & pa = side->point(e);
              const Point & pb = side->point((e+1)%3);
              auto key = pa < pb ? std::make_pair(pa, pb)
                                 : std::make_pair(pb, pa);
              auto it = expected_mid.find(key);
              if (it == expected_mid.end()) continue;
              const Point & exp = it->second;
              const Point & got = side->point(e+3);
              LIBMESH_ASSERT_FP_EQUAL(exp(0), got(0), TOLERANCE);
              LIBMESH_ASSERT_FP_EQUAL(exp(1), got(1), TOLERANCE);
              LIBMESH_ASSERT_FP_EQUAL(exp(2), got(2), TOLERANCE);
              ++n_mid;
            }
          std::array<Point,3> corners =
            {side->point(0), side->point(1), side->point(2)};
          std::sort(corners.begin(), corners.end());
          auto it = expected_cen.find(corners);
          if (it == expected_cen.end()) continue;
          const Point & exp = it->second;
          const Point & got = side->point(6);
          LIBMESH_ASSERT_FP_EQUAL(exp(0), got(0), TOLERANCE);
          LIBMESH_ASSERT_FP_EQUAL(exp(1), got(1), TOLERANCE);
          LIBMESH_ASSERT_FP_EQUAL(exp(2), got(2), TOLERANCE);
          ++n_cen;
        }
 
    CPPUNIT_ASSERT_GREATER(0u, n_mid);
    CPPUNIT_ASSERT_GREATER(0u, n_cen);
 
    testBcids(mesh);
  }

References libMesh::MeshBase::all_complete_order(), libMesh::MeshTetInterface::elem_type(), libMesh::make_range(), mesh, libMesh::MeshBase::prepare_for_use(), libMesh::Real, testBcids(), TestCommWorld, libMesh::TET14, libMesh::TOLERANCE, libMesh::TRI7, libMesh::NetGenMeshInterface::triangulate(), and libMesh::TypeVector< T >::unit().

testNetGenTets()

void MeshTetTest::testNetGenTets ( )

inline

Definition at line 403 of file mesh_tet_test.C.

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

References mesh, testBcids(), TestCommWorld, and testTetsToTets().

testSphereShell()

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

inline

Definition at line 213 of file mesh_tet_test.C.

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

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

Referenced by testNetGenSphereShell().

testTetGen()

void MeshTetTest::testTetGen ( )

inline

Definition at line 332 of file mesh_tet_test.C.

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

References mesh, TestCommWorld, and testTrisToTets().

testTetGenError()

void MeshTetTest::testTetGenError ( )

inline

Definition at line 342 of file mesh_tet_test.C.

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

References mesh, TestCommWorld, and testTrisToTetsError().

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

  {
    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());
      }
  }

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

Referenced by testExceptionBase(), testHole(), testSphereShell(), testTetsToTets(), and testTrisToTets().

testTetsToTets()

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

inline

Definition at line 295 of file mesh_tet_test.C.

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

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(), testTetInterfaceBase(), libMesh::TET4, and libMesh::MeshTools::volume().

Referenced by testNetGenTets().

testTrisToTets()

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

inline

Definition at line 240 of file mesh_tet_test.C.

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

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

Referenced by testNetGen(), testNetGenFlippedTris(), testNetGenNonOriented(), and testTetGen().

testTrisToTetsError()

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

inline

Definition at line 271 of file mesh_tet_test.C.

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

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

Referenced by testNetGenError(), and testTetGenError().

---

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

• tests/mesh/mesh_tet_test.C