MeshTriangulationTest Class Reference

Inheritance diagram for MeshTriangulationTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (MeshTriangulationTest)
	The goal of this test is to verify proper operation of the interfaces to triangulation libraries.
	CPPUNIT_TEST (testTriangleHoleArea)
	CPPUNIT_TEST (testTriangleHoleContains)
	CPPUNIT_TEST (testHoleContainsRayDegeneracies)
	CPPUNIT_TEST (testPoly2Tri)
	CPPUNIT_TEST (testPoly2TriHalfDomain)
	CPPUNIT_TEST (testPoly2TriHalfDomainEdge3)
	CPPUNIT_TEST (testPoly2TriInterp)
	CPPUNIT_TEST (testPoly2TriInterp2)
	CPPUNIT_TEST (testPoly2TriHoles)
	CPPUNIT_TEST (testPoly2TriMeshedHoles)
	CPPUNIT_TEST (testPoly2TriEdge3ToTri6)
	CPPUNIT_TEST (testPoly2TriEdge3ToTri7CenterFixup)
	CPPUNIT_TEST (testPoly2TriEdge3ToTri6FlipThrows)
	CPPUNIT_TEST (testPoly2TriRoundHole)
	CPPUNIT_TEST (testPoly2TriEdges)
	CPPUNIT_TEST (testPoly2TriEdge3s)
	CPPUNIT_TEST (testPoly2TriBadEdges)
	CPPUNIT_TEST (testPoly2TriBad1DMultiBoundary)
	CPPUNIT_TEST (testPoly2TriBad2DMultiBoundary)
	CPPUNIT_TEST (testPoly2TriEdgesRefined)
	CPPUNIT_TEST (testPoly2TriSegments)
	CPPUNIT_TEST (testPoly2TriRefined)
	CPPUNIT_TEST (testPoly2TriNonRefined)
	CPPUNIT_TEST (testPoly2TriExtraRefined)
	CPPUNIT_TEST (testPoly2TriHolesRefined)
	CPPUNIT_TEST (testPoly2TriHolesInterpRefined)
	CPPUNIT_TEST (testPoly2TriHolesInteriorRefined)
	CPPUNIT_TEST (testPoly2TriHolesInteriorExtraRefined)
	CPPUNIT_TEST (testPoly2TriHolesExtraRefined)
	CPPUNIT_TEST (testPoly2TriHolePerturbed)
	CPPUNIT_TEST (testPoly2TriHoleTangentPerturbed)
	CPPUNIT_TEST (testPoly2TriNonUniformRefined)
	CPPUNIT_TEST (testPoly2TriHolesNonUniformRefined)
	CPPUNIT_TEST (testTriangle)
	CPPUNIT_TEST (testTriangleHalfDomain)
	CPPUNIT_TEST (testTriangleInterp)
	CPPUNIT_TEST (testTriangleInterp2)
	CPPUNIT_TEST (testTriangleHoles)
	CPPUNIT_TEST (testTriangleMeshedHoles)
	CPPUNIT_TEST (testTriangleRoundHole)
	CPPUNIT_TEST (testTriangleEdges)
	CPPUNIT_TEST (testTriangleSegments)
	CPPUNIT_TEST (testTriangleEdge3ToTri6)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
void	commonSettings (TriangulatorInterface &triangulator)
void	testExceptionBase (MeshBase &mesh, TriangulatorInterface &triangulator, const char *re)
void	testTriangleHoleArea ()
void	testTriangleHoleContains ()
void	testHoleContainsRayDegeneracies ()
void	testTriangulatorBase (MeshBase &mesh, TriangulatorInterface &triangulator)
void	testEdge3ToTri6Base (MeshBase &mesh, TriangulatorInterface &triangulator)
void	testTriangulator (MeshBase &mesh, TriangulatorInterface &triangulator)
void	testTriangulatorTrapMesh (UnstructuredMesh &mesh)
void	testTriangulatorInterp (UnstructuredMesh &mesh, TriangulatorInterface &triangulator, int interpolate_boundary_points, dof_id_type n_expected_elem, Real expected_total_area=1.5, Real desired_area=1000)
void	testFoundCenters (const MeshBase &mesh, const std::vector< Point > &expected_centers)
void	testTriangulatorHoles (MeshBase &mesh, TriangulatorInterface &triangulator)
void	testTriangulatorHolePerturbed (MeshBase &mesh, TriangulatorInterface &triangulator)
void	testTriangulatorHoleTangentPerturbed (MeshBase &mesh, TriangulatorInterface &triangulator)
void	testTriangulatorMeshedHoles (MeshBase &mesh, TriangulatorInterface &triangulator)
void	testTriangulatorRoundHole (MeshBase &mesh, TriangulatorInterface &triangulator)
void	testTriangulatorSegments (MeshBase &mesh, TriangulatorInterface &triangulator)
void	testEdgesMesh (MeshBase &mesh, ElemType elem_type)
void	testEdge3Mesh (MeshBase &mesh)
void	testHalfDomain (MeshBase &mesh, TriangulatorInterface &triangulator, ElemType elem_type)
void	testTriangle ()
void	testTriangleHalfDomain ()
void	testTriangleInterp ()
void	testTriangleInterp2 ()
void	testTriangleHoles ()
void	testTriangleMeshedHoles ()
void	testTriangleRoundHole ()
void	testTriangleEdges ()
void	testTriangleSegments ()
void	testTriangleEdge3ToTri6 ()
void	testPoly2Tri ()
void	testPoly2TriHalfDomain ()
void	testPoly2TriHalfDomainEdge3 ()
void	testPoly2TriInterp ()
void	testPoly2TriInterp2 ()
void	testPoly2TriHoles ()
void	testPoly2TriHolePerturbed ()
void	testPoly2TriHoleTangentPerturbed ()
void	testPoly2TriMeshedHoles ()
void	testPoly2TriEdge3ToTri6 ()
void	testPoly2TriEdge3ToTri7CenterFixup ()
void	testPoly2TriEdge3ToTri6FlipThrows ()
void	testPoly2TriRoundHole ()
void	testPoly2TriEdges ()
void	testPoly2TriEdge3s ()
void	testPoly2TriBadEdges ()
void	testPoly2TriBad1DMultiBoundary ()
void	testPoly2TriBad2DMultiBoundary ()
void	testPoly2TriEdgesRefined ()
void	testPoly2TriSegments ()
void	testPoly2TriRefinementBase (UnstructuredMesh &mesh, const std::vector< TriangulatorInterface::Hole * > *holes, Real expected_total_area, dof_id_type n_original_elem, Real desired_area=0.1, FunctionBase< Real > *area_func=nullptr)
void	testPoly2TriRefined ()
void	testPoly2TriNonRefined ()
void	testPoly2TriExtraRefined ()
void	testPoly2TriNonUniformRefined ()
void	testPoly2TriHolesRefined ()
void	testPoly2TriHolesInterpRefined ()
void	testPoly2TriHolesInteriorRefinedBase (dof_id_type n_original_elem, Real desired_area)
void	testPoly2TriHolesInteriorRefined ()
void	testPoly2TriHolesInteriorExtraRefined ()
void	testPoly2TriHolesExtraRefined ()
void	testPoly2TriHolesNonUniformRefined ()

Detailed Description

Definition at line 23 of file mesh_triangulation.C.

Member Function Documentation

commonSettings()

void MeshTriangulationTest::commonSettings ( TriangulatorInterface &  triangulator )

inline

Definition at line 97 of file mesh_triangulation.C.

  {
    // Use the point order to define the boundary, because our
    // Poly2Tri implementation doesn't do convex hulls yet, even when
    // that would give the same answer.
    triangulator.triangulation_type() = TriangulatorInterface::PSLG;
 
    // Don't try to insert points unless we're requested to later
    triangulator.desired_area() = 1000;
    triangulator.minimum_angle() = 0;
    triangulator.smooth_after_generating() = false;
    triangulator.set_verify_hole_boundaries(true);
  }

References libMesh::TriangulatorInterface::desired_area(), libMesh::TriangulatorInterface::minimum_angle(), libMesh::TriangulatorInterface::PSLG, libMesh::TriangulatorInterface::set_verify_hole_boundaries(), libMesh::TriangulatorInterface::smooth_after_generating(), and libMesh::TriangulatorInterface::triangulation_type().

Referenced by testEdge3ToTri6Base(), testPoly2TriEdge3ToTri6FlipThrows(), testPoly2TriEdge3ToTri7CenterFixup(), testPoly2TriRefinementBase(), testTriangulatorBase(), testTriangulatorHolePerturbed(), testTriangulatorHoles(), testTriangulatorHoleTangentPerturbed(), testTriangulatorInterp(), testTriangulatorMeshedHoles(), and testTriangulatorRoundHole().

CPPUNIT_TEST() [1/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testHoleContainsRayDegeneracies

)

CPPUNIT_TEST() [2/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2Tri

)

CPPUNIT_TEST() [3/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriBad1DMultiBoundary

)

CPPUNIT_TEST() [4/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriBad2DMultiBoundary

)

CPPUNIT_TEST() [5/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriBadEdges

)

CPPUNIT_TEST() [6/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriEdge3s

)

CPPUNIT_TEST() [7/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriEdge3ToTri6

)

CPPUNIT_TEST() [8/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriEdge3ToTri6FlipThrows

)

CPPUNIT_TEST() [9/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriEdge3ToTri7CenterFixup

)

CPPUNIT_TEST() [10/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriEdges

)

CPPUNIT_TEST() [11/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriEdgesRefined

)

CPPUNIT_TEST() [12/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriExtraRefined

)

CPPUNIT_TEST() [13/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriHalfDomain

)

CPPUNIT_TEST() [14/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriHalfDomainEdge3

)

CPPUNIT_TEST() [15/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriHolePerturbed

)

CPPUNIT_TEST() [16/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriHoles

)

CPPUNIT_TEST() [17/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriHolesExtraRefined

)

CPPUNIT_TEST() [18/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriHolesInteriorExtraRefined

)

CPPUNIT_TEST() [19/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriHolesInteriorRefined

)

CPPUNIT_TEST() [20/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriHolesInterpRefined

)

CPPUNIT_TEST() [21/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriHolesNonUniformRefined

)

CPPUNIT_TEST() [22/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriHolesRefined

)

CPPUNIT_TEST() [23/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriHoleTangentPerturbed

)

CPPUNIT_TEST() [24/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriInterp

)

CPPUNIT_TEST() [25/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriInterp2

)

CPPUNIT_TEST() [26/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriMeshedHoles

)

CPPUNIT_TEST() [27/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriNonRefined

)

CPPUNIT_TEST() [28/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriNonUniformRefined

)

CPPUNIT_TEST() [29/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriRefined

)

CPPUNIT_TEST() [30/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriRoundHole

)

CPPUNIT_TEST() [31/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriSegments

)

CPPUNIT_TEST() [32/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangle

)

CPPUNIT_TEST() [33/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleEdge3ToTri6

)

CPPUNIT_TEST() [34/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleEdges

)

CPPUNIT_TEST() [35/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleHalfDomain

)

CPPUNIT_TEST() [36/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleHoleArea

)

CPPUNIT_TEST() [37/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleHoleContains

)

CPPUNIT_TEST() [38/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleHoles

)

CPPUNIT_TEST() [39/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleInterp

)

CPPUNIT_TEST() [40/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleInterp2

)

CPPUNIT_TEST() [41/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleMeshedHoles

)

CPPUNIT_TEST() [42/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleRoundHole

)

CPPUNIT_TEST() [43/43]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleSegments

)

CPPUNIT_TEST_SUITE_END()

MeshTriangulationTest::CPPUNIT_TEST_SUITE_END

(

)

LIBMESH_CPPUNIT_TEST_SUITE()

MeshTriangulationTest::LIBMESH_CPPUNIT_TEST_SUITE

(

MeshTriangulationTest

)

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

setUp()

void MeshTriangulationTest::setUp ( )

inline

Definition at line 93 of file mesh_triangulation.C.

{}

tearDown()

void MeshTriangulationTest::tearDown ( )

inline

Definition at line 95 of file mesh_triangulation.C.

{}

testEdge3Mesh()

void MeshTriangulationTest::testEdge3Mesh ( MeshBase &  mesh )

inline

Definition at line 849 of file mesh_triangulation.C.

  {
    const Real hsq2 = std::sqrt(2) / 2.0;
    auto node0 = mesh.add_point(Point(1,0), 0);
    auto node1 = mesh.add_point(Point(hsq2,hsq2), 1);
    auto node2 = mesh.add_point(Point(0,1), 2);
    auto node3 = mesh.add_point(Point(-hsq2,hsq2), 3);
    auto node4 = mesh.add_point(Point(-1,0), 4);
    auto node5 = mesh.add_point(Point(-hsq2,-hsq2), 5);
    auto node6 = mesh.add_point(Point(0,-1), 6);
    auto node7 = mesh.add_point(Point(hsq2,-hsq2), 7);
 
    auto edge021 = mesh.add_elem(Elem::build(EDGE3));
    edge021->set_node(0, node0);
    edge021->set_node(1, node2);
    edge021->set_node(2, node1);
    auto edge243 = mesh.add_elem(Elem::build(EDGE3));
    edge243->set_node(0, node2);
    edge243->set_node(1, node4);
    edge243->set_node(2, node3);
    auto edge465 = mesh.add_elem(Elem::build(EDGE3));
    edge465->set_node(0, node4);
    edge465->set_node(1, node6);
    edge465->set_node(2, node5);
    auto edge607 = mesh.add_elem(Elem::build(EDGE3));
    edge607->set_node(0, node6);
    edge607->set_node(1, node0);
    edge607->set_node(2, node7);
 
    mesh.prepare_for_use();
  }

References libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::Elem::build(), libMesh::EDGE3, mesh, libMesh::MeshBase::prepare_for_use(), libMesh::Real, and libMesh::Elem::set_node().

Referenced by testPoly2TriEdge3ToTri6(), testPoly2TriEdge3ToTri7CenterFixup(), and testTriangleEdge3ToTri6().

testEdge3ToTri6Base()

void MeshTriangulationTest::testEdge3ToTri6Base ( MeshBase &  mesh, TriangulatorInterface &  triangulator  )

inline

Definition at line 371 of file mesh_triangulation.C.

  {
    commonSettings(triangulator);
 
    triangulator.elem_type() = TRI6;
    triangulator.triangulate();
    const Real hsq2 = std::sqrt(2) / 2.0;
 
    // Check element number
    CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), (dof_id_type)2);
    for (const auto & elem : mesh.element_ptr_range())
    {
      // Check element type
      CPPUNIT_ASSERT_EQUAL(elem->type(), TRI6);
 
      for (const auto & i_side : make_range(elem->n_sides()))
      {
        // We only want to check the sides on the external boundary
        if (elem->neighbor_ptr(i_side) == nullptr)
        {
          const Point & side_pt_0 = *(elem->node_ptr(i_side));
          const Point & side_pt_1 = *(elem->node_ptr((i_side + 1) % 3));
          const Point & side_pt_2 = *(elem->node_ptr(i_side + 3));
          const bool x_sign = (side_pt_0(0) == 1 || side_pt_1(0) == 1);
          const bool y_sign = (side_pt_0(1) == 1 || side_pt_1(1) == 1);
          const Point ref_side_pt_2 = Point (x_sign ? hsq2 : -hsq2, y_sign ? hsq2 : -hsq2);
          CPPUNIT_ASSERT_EQUAL(ref_side_pt_2, side_pt_2);
        }
      }
    }
  }

References commonSettings(), libMesh::TriangulatorInterface::elem_type(), libMesh::make_range(), mesh, libMesh::MeshBase::n_elem(), libMesh::Real, libMesh::TRI6, and libMesh::TriangulatorInterface::triangulate().

Referenced by testPoly2TriEdge3ToTri6(), and testTriangleEdge3ToTri6().

testEdgesMesh()

void MeshTriangulationTest::testEdgesMesh ( MeshBase &  mesh, ElemType  elem_type  )

inline

Definition at line 809 of file mesh_triangulation.C.

  {
    // The same quad as testTriangulator, but out of order
    auto node0 = mesh.add_point(Point(0,0), 0);
    auto node1 = mesh.add_point(Point(1,2), 1);
    auto node2 = mesh.add_point(Point(1,0), 2);
    auto node3 = mesh.add_point(Point(0,1), 3);
 
    // Edges, also out of order, but enough to put them in order
    auto edge13 = mesh.add_elem(Elem::build(elem_type));
    edge13->set_node(0, node1);
    edge13->set_node(1, node3);
    auto edge02 = mesh.add_elem(Elem::build(elem_type));
    edge02->set_node(0, node0);
    edge02->set_node(1, node2);
    auto edge30 = mesh.add_elem(Elem::build(elem_type));
    edge30->set_node(0, node3);
    edge30->set_node(1, node0);
    auto edge21 = mesh.add_elem(Elem::build(elem_type));
    edge21->set_node(0, node2);
    edge21->set_node(1, node1);
 
    // Add mid-edge nodes if asked to
    if (elem_type == EDGE3)
      {
        auto node4 = mesh.add_point(Point(.5,1.5), 4);
        edge13->set_node(2, node4);
        auto node5 = mesh.add_point(Point(.5,0), 5);
        edge02->set_node(2, node5);
        auto node6 = mesh.add_point(Point(0,.5), 6);
        edge30->set_node(2, node6);
        auto node7 = mesh.add_point(Point(1,1), 7);
        edge21->set_node(2, node7);
      }
    else
      libmesh_assert(elem_type == EDGE2);
 
    mesh.prepare_for_use();
  }

References libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::Elem::build(), libMesh::EDGE2, libMesh::EDGE3, libMesh::libmesh_assert(), mesh, libMesh::MeshBase::prepare_for_use(), and libMesh::Elem::set_node().

Referenced by testHalfDomain(), testPoly2TriEdge3s(), testPoly2TriEdges(), testPoly2TriEdgesRefined(), and testTriangleEdges().

testExceptionBase()

void MeshTriangulationTest::testExceptionBase ( MeshBase &  mesh, TriangulatorInterface &  triangulator, const char *  re  )

inline

Definition at line 111 of file mesh_triangulation.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->testTriangulatorBase(mesh, triangulator);
    }
    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 testTriangulatorBase().

Referenced by testPoly2TriBad1DMultiBoundary(), testPoly2TriBad2DMultiBoundary(), and testPoly2TriBadEdges().

testFoundCenters()

void MeshTriangulationTest::testFoundCenters ( const MeshBase &  mesh, const std::vector< Point > &  expected_centers  )

inline

Definition at line 471 of file mesh_triangulation.C.

  {
    std::vector<bool> found_centers(expected_centers.size(), false);
 
    for (const auto & elem : mesh.element_ptr_range())
      {
        CPPUNIT_ASSERT_EQUAL(elem->type(), TRI3);
 
        // Make sure we're not getting any inverted elements
        auto cross_prod =
          (elem->point(1) - elem->point(0)).cross
            (elem->point(2) - elem->point(0));
 
        CPPUNIT_ASSERT_GREATER(Real(0), cross_prod(2));
 
        // Make sure we're finding all the elements we expect
        Point center = elem->vertex_average();
 
        bool found_mine = false;
        for (auto i : index_range(expected_centers))
          {
            Point possible = expected_centers[i];
 
            if (possible.absolute_fuzzy_equals(center, TOLERANCE*TOLERANCE))
              {
                found_mine = true;
                found_centers[i] = true;
              }
          }
        CPPUNIT_ASSERT(found_mine);
      }
 
    mesh.comm().max(found_centers);
 
    for (auto found_it : found_centers)
      CPPUNIT_ASSERT(found_it);
  }

References libMesh::TypeVector< T >::absolute_fuzzy_equals(), libMesh::ParallelObject::comm(), libMesh::index_range(), libMesh::Parallel::Communicator::max(), mesh, libMesh::Real, libMesh::TOLERANCE, and libMesh::TRI3.

Referenced by testTriangulatorHolePerturbed(), testTriangulatorHoles(), testTriangulatorHoleTangentPerturbed(), and testTriangulatorMeshedHoles().

testHalfDomain()

void MeshTriangulationTest::testHalfDomain ( MeshBase &  mesh, TriangulatorInterface &  triangulator, ElemType  elem_type  )

inline

Definition at line 882 of file mesh_triangulation.C.

  {
    // We might have 4 or 8 nodes on the outer boundary, depending on
    // whether it has mid-edge nodes
    const dof_id_type off = (elem_type == EDGE3)*4;
 
    // A pentagon we'll avoid via subdomain ids
    auto node4 = mesh.add_point(Point(2,0), 4+off);
    auto node5 = mesh.add_point(Point(3,0), 5+off);
    auto node6 = mesh.add_point(Point(3,2), 6+off);
    auto node7 = mesh.add_point(Point(2,2), 7+off);
    auto node8 = mesh.add_point(Point(2,1), 8+off);
 
    auto edge45 = mesh.add_elem(Elem::build(elem_type));
    edge45->set_node(0, node4);
    edge45->set_node(1, node5);
    edge45->subdomain_id() = 1;
    auto edge56 = mesh.add_elem(Elem::build(elem_type));
    edge56->set_node(0, node5);
    edge56->set_node(1, node6);
    edge56->subdomain_id() = 1;
    auto edge67 = mesh.add_elem(Elem::build(elem_type));
    edge67->set_node(0, node6);
    edge67->set_node(1, node7);
    edge67->subdomain_id() = 1;
    auto edge78 = mesh.add_elem(Elem::build(elem_type));
    edge78->set_node(0, node7);
    edge78->set_node(1, node8);
    edge78->subdomain_id() = 1;
    auto edge84 = mesh.add_elem(Elem::build(elem_type));
    edge84->set_node(0, node8);
    edge84->set_node(1, node4);
    edge84->subdomain_id() = 1;
 
    if (elem_type == EDGE3)
      {
        auto node9 = mesh.add_point(Point(2.5,0), 9+off);
        edge45->set_node(2, node9);
        auto node10 = mesh.add_point(Point(3,1), 10+off);
        edge56->set_node(2, node10);
        auto node11 = mesh.add_point(Point(2.5,2), 11+off);
        edge67->set_node(2, node11);
        auto node12 = mesh.add_point(Point(2,1.5), 12+off);
        edge78->set_node(2, node12);
        auto node13 = mesh.add_point(Point(2,.5), 13+off);
        edge84->set_node(2, node13);
      }
    else
      libmesh_assert(elem_type == EDGE2);
 
    testEdgesMesh(mesh, elem_type);
 
    std::set<std::size_t> bdy_ids {0};
    triangulator.set_outer_boundary_ids(bdy_ids);
 
    this->testTriangulatorBase(mesh, triangulator);
  }

References libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::Elem::build(), libMesh::EDGE2, libMesh::EDGE3, libMesh::libmesh_assert(), mesh, libMesh::Elem::set_node(), libMesh::TriangulatorInterface::set_outer_boundary_ids(), testEdgesMesh(), and testTriangulatorBase().

Referenced by testPoly2TriHalfDomain(), testPoly2TriHalfDomainEdge3(), and testTriangleHalfDomain().

testHoleContainsRayDegeneracies()

void MeshTriangulationTest::testHoleContainsRayDegeneracies ( )

inline

Definition at line 299 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    // Every vertex of a hole has to test as inside a boundary that
    // encloses it, however nearly collinear the ray from it is with the
    // boundary's own vertices.
    const TriangulatorInterface::PolygonHole
      perturbed(Point(0,4.e-16), std::sqrt(2_R)/2, 4);
    const TriangulatorInterface::ArbitraryHole outer_bdy
      {{0,0}, {{100,0},{100,100},{0,100},{-100,100},
               {-100,0},{-100,-100},{0,-100},{100,-100}}};
 
    for (auto i : make_range(perturbed.n_points()))
      CPPUNIT_ASSERT(outer_bdy.contains(perturbed.point(i)));
  }

References libMesh::make_range(), libMesh::TriangulatorInterface::PolygonHole::n_points(), and libMesh::TriangulatorInterface::PolygonHole::point().

testPoly2Tri()

void MeshTriangulationTest::testPoly2Tri ( )

inline

Definition at line 1052 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator p2t_tri(mesh);
    testTriangulator(mesh, p2t_tri);
  }

References mesh, TestCommWorld, and testTriangulator().

testPoly2TriBad1DMultiBoundary()

void MeshTriangulationTest::testPoly2TriBad1DMultiBoundary ( )

inline

Definition at line 1343 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator triangulator(mesh);
 
    // Two separate triangles
    auto node0 = mesh.add_point(Point(0,0), 0);
    auto node1 = mesh.add_point(Point(0,1), 1);
    auto node2 = mesh.add_point(Point(1,0), 2);
 
    auto node3 = mesh.add_point(Point(2,0), 3);
    auto node4 = mesh.add_point(Point(2,1), 4);
    auto node5 = mesh.add_point(Point(3,0), 5);
 
    auto edge01 = mesh.add_elem(Elem::build(EDGE2));
    edge01->set_node(0, node0);
    edge01->set_node(1, node1);
    auto edge12 = mesh.add_elem(Elem::build(EDGE2));
    edge12->set_node(0, node1);
    edge12->set_node(1, node2);
    auto edge20 = mesh.add_elem(Elem::build(EDGE2));
    edge20->set_node(0, node2);
    edge20->set_node(1, node0);
 
    auto edge34 = mesh.add_elem(Elem::build(EDGE2));
    edge34->set_node(0, node3);
    edge34->set_node(1, node4);
    auto edge45 = mesh.add_elem(Elem::build(EDGE2));
    edge45->set_node(0, node4);
    edge45->set_node(1, node5);
    auto edge53 = mesh.add_elem(Elem::build(EDGE2));
    edge53->set_node(0, node5);
    edge53->set_node(1, node3);
 
    mesh.prepare_for_use();
 
    testExceptionBase(mesh, triangulator, "multiple loops of Edge");
  }

References libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::Elem::build(), libMesh::EDGE2, mesh, libMesh::MeshBase::prepare_for_use(), libMesh::Elem::set_node(), TestCommWorld, and testExceptionBase().

testPoly2TriBad2DMultiBoundary()

void MeshTriangulationTest::testPoly2TriBad2DMultiBoundary ( )

inline

Definition at line 1384 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator triangulator(mesh);
 
    // Two separate triangles
    auto node0 = mesh.add_point(Point(0,0), 0);
    auto node1 = mesh.add_point(Point(1,0), 1);
    auto node2 = mesh.add_point(Point(0,1), 2);
 
    auto node3 = mesh.add_point(Point(2,0), 3);
    auto node4 = mesh.add_point(Point(3,0), 4);
    auto node5 = mesh.add_point(Point(2,1), 5);
 
    auto tri012 = mesh.add_elem(Elem::build(TRI3));
    tri012->set_node(0, node0);
    tri012->set_node(1, node1);
    tri012->set_node(2, node2);
    auto tri345 = mesh.add_elem(Elem::build(TRI3));
    tri345->set_node(0, node3);
    tri345->set_node(1, node4);
    tri345->set_node(2, node5);
 
    mesh.prepare_for_use();
 
    testExceptionBase(mesh, triangulator, "cannot choose one");
  }

References libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::Elem::build(), mesh, libMesh::MeshBase::prepare_for_use(), libMesh::Elem::set_node(), TestCommWorld, testExceptionBase(), and libMesh::TRI3.

testPoly2TriBadEdges()

void MeshTriangulationTest::testPoly2TriBadEdges ( )

inline

Definition at line 1313 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator triangulator(mesh);
 
    // The same quad as testTriangulator, but out of order
    auto node0 = mesh.add_point(Point(0,0), 0);
    auto node1 = mesh.add_point(Point(1,2), 1);
    auto node2 = mesh.add_point(Point(1,0), 2);
    auto node3 = mesh.add_point(Point(0,1), 3);
 
    // Edges, but not enough to complete the quad
    auto edge13 = mesh.add_elem(Elem::build(EDGE2));
    edge13->set_node(0, node1);
    edge13->set_node(1, node3);
    auto edge02 = mesh.add_elem(Elem::build(EDGE2));
    edge02->set_node(0, node0);
    edge02->set_node(1, node2);
    auto edge30 = mesh.add_elem(Elem::build(EDGE2));
    edge30->set_node(0, node3);
    edge30->set_node(1, node0);
 
    mesh.prepare_for_use();
 
    testExceptionBase(mesh, triangulator, "Bad edge topology");
  }

References libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::Elem::build(), libMesh::EDGE2, mesh, libMesh::MeshBase::prepare_for_use(), libMesh::Elem::set_node(), TestCommWorld, and testExceptionBase().

testPoly2TriEdge3s()

void MeshTriangulationTest::testPoly2TriEdge3s ( )

inline

Definition at line 1301 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator triangulator(mesh);
    testEdgesMesh(mesh, EDGE3);
 
    this->testTriangulatorBase(mesh, triangulator);
  }

References libMesh::EDGE3, mesh, TestCommWorld, testEdgesMesh(), and testTriangulatorBase().

testPoly2TriEdge3ToTri6()

void MeshTriangulationTest::testPoly2TriEdge3ToTri6 ( )

inline

Definition at line 1141 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator triangulator(mesh);
 
    testEdge3Mesh(mesh);
 
    this->testEdge3ToTri6Base(mesh, triangulator);
  }

References mesh, TestCommWorld, testEdge3Mesh(), and testEdge3ToTri6Base().

testPoly2TriEdge3ToTri6FlipThrows()

void MeshTriangulationTest::testPoly2TriEdge3ToTri6FlipThrows ( )

inline

Definition at line 1215 of file mesh_triangulation.C.

  {
#ifdef LIBMESH_ENABLE_EXCEPTIONS
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
 
    // Build a triangular domain (0,0)-(4,0)-(2,2) using three Edge3
    // segments.  The bottom segment's mid-edge node is placed at
    // (2, 1.95) -- almost on top of the apex (2, 2) -- so that
    // snapping the resulting TRI6 mid-edge node to that location
    // tangles the element (the curved bottom edge folds across the
    // apex).  TriangulatorInterface::verify_quadratic_elements()
    // should detect the non-positive Jacobian and throw.
    auto vA = mesh.add_point(Point(0, 0),    0);
    auto vB = mesh.add_point(Point(4, 0),    1);
    auto vC = mesh.add_point(Point(2, 2),    2);
    auto mAB = mesh.add_point(Point(2, 1.95), 3);  // pathological
    auto mBC = mesh.add_point(Point(3, 1),   4);
    auto mCA = mesh.add_point(Point(1, 1),   5);
 
    auto edgeAB = mesh.add_elem(Elem::build(EDGE3));
    edgeAB->set_node(0, vA);
    edgeAB->set_node(1, vB);
    edgeAB->set_node(2, mAB);
 
    auto edgeBC = mesh.add_elem(Elem::build(EDGE3));
    edgeBC->set_node(0, vB);
    edgeBC->set_node(1, vC);
    edgeBC->set_node(2, mBC);
 
    auto edgeCA = mesh.add_elem(Elem::build(EDGE3));
    edgeCA->set_node(0, vC);
    edgeCA->set_node(1, vA);
    edgeCA->set_node(2, mCA);
 
    mesh.prepare_for_use();
 
    Poly2TriTriangulator triangulator(mesh);
    commonSettings(triangulator);
    triangulator.elem_type() = TRI6;
 
    bool threw_desired_exception = false;
    try {
      triangulator.triangulate();
    }
    catch (libMesh::LogicError & e) {
      const std::regex msg_regex("tangled quadratic triangle");
      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 libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::Elem::build(), commonSettings(), libMesh::EDGE3, libMesh::TriangulatorInterface::elem_type(), mesh, libMesh::MeshBase::prepare_for_use(), libMesh::Elem::set_node(), TestCommWorld, libMesh::TRI6, and libMesh::Poly2TriTriangulator::triangulate().

testPoly2TriEdge3ToTri7CenterFixup()

void MeshTriangulationTest::testPoly2TriEdge3ToTri7CenterFixup ( )

inline

Definition at line 1154 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator triangulator(mesh);
 
    // Re-use the curved (unit-circle) Edge3 boundary from testEdge3Mesh:
    // four arcs whose midpoints lie on the unit circle.  After
    // triangulation with TRI7 + boundary-midpoint snap, every TRI7
    // element's interior node should land at the curved Tri6 image of
    // the reference centroid (1/3, 1/3) -- the formula applied by
    // TriangulatorInterface::fixup_tri7_center_nodes() -- *not* at the
    // straight-edge vertex centroid (P0+P1+P2)/3 that
    // MeshBase::all_complete_order() initially placed there.
    testEdge3Mesh(mesh);
 
    commonSettings(triangulator);
    triangulator.elem_type() = TRI7;
    // The interior-node relocation is opt-in (off by default), so
    // enable it here -- this is the behavior under test.
    triangulator.set_fixup_tri7_center_nodes(true);
    triangulator.triangulate();
 
    CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), (dof_id_type)2);
 
    bool saw_curved_element = false;
    for (const auto & elem : mesh.element_ptr_range())
      {
        CPPUNIT_ASSERT_EQUAL(elem->type(), TRI7);
 
        const Point & x0 = elem->point(0);
        const Point & x1 = elem->point(1);
        const Point & x2 = elem->point(2);
        const Point & x3 = elem->point(3);
        const Point & x4 = elem->point(4);
        const Point & x5 = elem->point(5);
        const Point & x6 = elem->point(6);
 
        const Point expected =
          (Real(-1)/9) * (x0 + x1 + x2) +
          (Real( 4)/9) * (x3 + x4 + x5);
        const Point straight = (x0 + x1 + x2) / Real(3);
 
        // Centroid must match the curved-mapping formula exactly.
        CPPUNIT_ASSERT(x6.relative_fuzzy_equals(expected, TOLERANCE));
 
        // On the inscribed-square triangulation of the unit circle
        // each triangle has at least one curved external side, so the
        // curved-mapping centroid is strictly different from the
        // straight-edge vertex average -- otherwise the fixup would
        // be a no-op and we wouldn't actually be testing it.
        if (!x6.relative_fuzzy_equals(straight, TOLERANCE))
          saw_curved_element = true;
      }
 
    mesh.comm().max(saw_curved_element);
    CPPUNIT_ASSERT(saw_curved_element);
  }

References libMesh::ParallelObject::comm(), commonSettings(), libMesh::TriangulatorInterface::elem_type(), libMesh::Parallel::Communicator::max(), mesh, libMesh::MeshBase::n_elem(), libMesh::Real, libMesh::TypeVector< T >::relative_fuzzy_equals(), libMesh::TriangulatorInterface::set_fixup_tri7_center_nodes(), TestCommWorld, testEdge3Mesh(), libMesh::TOLERANCE, libMesh::TRI7, and libMesh::Poly2TriTriangulator::triangulate().

testPoly2TriEdges()

void MeshTriangulationTest::testPoly2TriEdges ( )

inline

Definition at line 1289 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator triangulator(mesh);
    testEdgesMesh(mesh, EDGE2);
 
    this->testTriangulatorBase(mesh, triangulator);
  }

References libMesh::EDGE2, mesh, TestCommWorld, testEdgesMesh(), and testTriangulatorBase().

testPoly2TriEdgesRefined()

void MeshTriangulationTest::testPoly2TriEdgesRefined ( )

inline

Definition at line 1415 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator triangulator(mesh);
    testEdgesMesh(mesh, EDGE2);
    testPoly2TriRefinementBase(mesh, nullptr, 1.5, 14);
  }

References libMesh::EDGE2, mesh, TestCommWorld, testEdgesMesh(), and testPoly2TriRefinementBase().

testPoly2TriExtraRefined()

void MeshTriangulationTest::testPoly2TriExtraRefined ( )

inline

Definition at line 1510 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    testTriangulatorTrapMesh(mesh);
    testPoly2TriRefinementBase(mesh, nullptr, 1.5, 150, 0.01);
  }

References mesh, TestCommWorld, testPoly2TriRefinementBase(), and testTriangulatorTrapMesh().

testPoly2TriHalfDomain()

void MeshTriangulationTest::testPoly2TriHalfDomain ( )

inline

Definition at line 1062 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator p2t_tri(mesh);
    testHalfDomain(mesh, p2t_tri, EDGE2);
  }

References libMesh::EDGE2, mesh, TestCommWorld, and testHalfDomain().

testPoly2TriHalfDomainEdge3()

void MeshTriangulationTest::testPoly2TriHalfDomainEdge3 ( )

inline

Definition at line 1072 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator p2t_tri(mesh);
    testHalfDomain(mesh, p2t_tri, EDGE3);
  }

References libMesh::EDGE3, mesh, TestCommWorld, and testHalfDomain().

testPoly2TriHolePerturbed()

void MeshTriangulationTest::testPoly2TriHolePerturbed ( )

inline

Definition at line 1112 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator p2t_tri(mesh);
    testTriangulatorHolePerturbed(mesh, p2t_tri);
  }

References mesh, TestCommWorld, and testTriangulatorHolePerturbed().

testPoly2TriHoles()

void MeshTriangulationTest::testPoly2TriHoles ( )

inline

Definition at line 1102 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator p2t_tri(mesh);
    testTriangulatorHoles(mesh, p2t_tri);
  }

References mesh, TestCommWorld, and testTriangulatorHoles().

testPoly2TriHolesExtraRefined()

void MeshTriangulationTest::testPoly2TriHolesExtraRefined ( )

inline

Definition at line 1627 of file mesh_triangulation.C.

  {
    // Add a diamond hole
    TriangulatorInterface::PolygonHole diamond(Point(0.5,0.5), std::sqrt(2_R)/4, 4);
    const std::vector<TriangulatorInterface::Hole*> holes { &diamond };
 
    Mesh mesh(*TestCommWorld);
    testTriangulatorTrapMesh(mesh);
    testPoly2TriRefinementBase(mesh, &holes, 1.25, 125, 0.01);
  }

References mesh, TestCommWorld, testPoly2TriRefinementBase(), and testTriangulatorTrapMesh().

testPoly2TriHolesInteriorExtraRefined()

void MeshTriangulationTest::testPoly2TriHolesInteriorExtraRefined ( )

inline

Definition at line 1619 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
    // 0.01 creates slivers triggering a poly2tri exception for me - RHS
    testPoly2TriHolesInteriorRefinedBase(60, 0.02);
  }

References testPoly2TriHolesInteriorRefinedBase().

testPoly2TriHolesInteriorRefined()

void MeshTriangulationTest::testPoly2TriHolesInteriorRefined ( )

inline

Definition at line 1612 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
    testPoly2TriHolesInteriorRefinedBase(25, 0.05);
  }

References testPoly2TriHolesInteriorRefinedBase().

testPoly2TriHolesInteriorRefinedBase()

void MeshTriangulationTest::testPoly2TriHolesInteriorRefinedBase ( dof_id_type  n_original_elem, Real  desired_area  )

inline

Definition at line 1580 of file mesh_triangulation.C.

  {
    // Add a diamond hole, disallowing refinement of it
    TriangulatorInterface::PolygonHole diamond(Point(0.5,0.5), std::sqrt(2_R)/4, 4);
 
    CPPUNIT_ASSERT_EQUAL(diamond.refine_boundary_allowed(), true);
 
    diamond.set_refine_boundary_allowed(false);
 
    const std::vector<TriangulatorInterface::Hole*> holes { &diamond };
 
    // Doing extra refinement here to ensure that we had the
    // *opportunity* to refine the hole boundaries.
    Mesh mesh(*TestCommWorld);
    testTriangulatorTrapMesh(mesh);
    testPoly2TriRefinementBase(mesh, &holes, 1.25, n_original_elem, desired_area);
 
    // Checking that we have more outer boundary sides than we started
    // with, and exactly the 4 hole boundary sides we started with.
    auto side_bcs = mesh.get_boundary_info().build_side_list();
 
    int n_outer_sides = std::count_if(side_bcs.begin(), side_bcs.end(),
                                      [](auto t){return std::get<2>(t) == 0;});
    CPPUNIT_ASSERT_GREATER(4, n_outer_sides); // n_outer_sides > 4
    int n_hole_sides = std::count_if(side_bcs.begin(), side_bcs.end(),
                                     [](auto t){return std::get<2>(t) == 1;});
    CPPUNIT_ASSERT_EQUAL(n_hole_sides, 4);
  }

References libMesh::BoundaryInfo::build_side_list(), libMesh::MeshBase::get_boundary_info(), mesh, libMesh::TriangulatorInterface::Hole::refine_boundary_allowed(), libMesh::TriangulatorInterface::Hole::set_refine_boundary_allowed(), TestCommWorld, testPoly2TriRefinementBase(), and testTriangulatorTrapMesh().

Referenced by testPoly2TriHolesInteriorExtraRefined(), and testPoly2TriHolesInteriorRefined().

testPoly2TriHolesInterpRefined()

void MeshTriangulationTest::testPoly2TriHolesInterpRefined ( )

inline

Definition at line 1542 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    testTriangulatorTrapMesh(mesh);
    Poly2TriTriangulator p2t_tri(mesh);
 
    Real total_area = 1.5;
 
    // Try a narrower point
    mesh.node_ref(2)(1) = 3;
    total_area += 0.5;
 
    // Add a bunch of tiny diamond holes
    const int N=3, M=3;
    TriangulatorInterface::PolygonHole diamond(Point(), std::sqrt(2_R)/20, 4);
 
    std::vector<TriangulatorInterface::AffineHole> hole_data;
    // Reserve so we don't invalidate pointers
    hole_data.reserve(M*N);
    std::vector<TriangulatorInterface::Hole*> holes;
    for (int i : make_range(M))
      for (int j : make_range(N))
        {
          Point shift(Real(i+1)/(M+1),Real(j+1)/(N+1));
          hole_data.emplace_back(diamond, 0, shift);
          holes.push_back(&hole_data.back());
          total_area -= hole_data.back().area();
        }
 
    p2t_tri.attach_hole_list(&holes);
 
    p2t_tri.set_refine_boundary_allowed(false);
 
    testTriangulatorInterp(mesh, p2t_tri, 4, 0, total_area, 0.03_R);
  }

References libMesh::TriangulatorInterface::attach_hole_list(), libMesh::make_range(), mesh, libMesh::MeshBase::node_ref(), libMesh::Real, libMesh::Poly2TriTriangulator::set_refine_boundary_allowed(), TestCommWorld, testTriangulatorInterp(), and testTriangulatorTrapMesh().

testPoly2TriHolesNonUniformRefined()

void MeshTriangulationTest::testPoly2TriHolesNonUniformRefined ( )

inline

Definition at line 1638 of file mesh_triangulation.C.

  {
#ifdef LIBMESH_HAVE_FPARSER
    // Add a diamond hole
    TriangulatorInterface::PolygonHole diamond(Point(0.5,0.5), std::sqrt(2_R)/4, 4);
    const std::vector<TriangulatorInterface::Hole*> holes { &diamond };
 
    ParsedFunction<Real> var_area {"0.002*(0.25+2*x)*(0.25+2*y)"};
    Mesh mesh(*TestCommWorld);
    testTriangulatorTrapMesh(mesh);
    testPoly2TriRefinementBase(mesh, &holes, 1.25, 150, 0, &var_area);
#endif // LIBMESH_HAVE_FPARSER
  }

References mesh, TestCommWorld, testPoly2TriRefinementBase(), and testTriangulatorTrapMesh().

testPoly2TriHolesRefined()

void MeshTriangulationTest::testPoly2TriHolesRefined ( )

inline

Definition at line 1529 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    // Add a diamond hole
    TriangulatorInterface::PolygonHole diamond(Point(0.5,0.5), std::sqrt(2_R)/4, 4);
    const std::vector<TriangulatorInterface::Hole*> holes { &diamond };
 
    Mesh mesh(*TestCommWorld);
    testTriangulatorTrapMesh(mesh);
    testPoly2TriRefinementBase(mesh, &holes, 1.25, 13);
  }

References mesh, TestCommWorld, testPoly2TriRefinementBase(), and testTriangulatorTrapMesh().

testPoly2TriHoleTangentPerturbed()

void MeshTriangulationTest::testPoly2TriHoleTangentPerturbed ( )

inline

Definition at line 1122 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator p2t_tri(mesh);
    testTriangulatorHoleTangentPerturbed(mesh, p2t_tri);
  }

References mesh, TestCommWorld, and testTriangulatorHoleTangentPerturbed().

testPoly2TriInterp()

void MeshTriangulationTest::testPoly2TriInterp ( )

inline

Definition at line 1082 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator p2t_tri(mesh);
    testTriangulatorInterp(mesh, p2t_tri, 1, 6);
  }

References mesh, TestCommWorld, and testTriangulatorInterp().

testPoly2TriInterp2()

void MeshTriangulationTest::testPoly2TriInterp2 ( )

inline

Definition at line 1092 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator p2t_tri(mesh);
    testTriangulatorInterp(mesh, p2t_tri, 2, 10);
  }

References mesh, TestCommWorld, and testTriangulatorInterp().

testPoly2TriMeshedHoles()

void MeshTriangulationTest::testPoly2TriMeshedHoles ( )

inline

Definition at line 1132 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator p2t_tri(mesh);
    testTriangulatorMeshedHoles(mesh, p2t_tri);
  }

References mesh, TestCommWorld, and testTriangulatorMeshedHoles().

testPoly2TriNonRefined()

void MeshTriangulationTest::testPoly2TriNonRefined ( )

inline

Definition at line 1499 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    testTriangulatorTrapMesh(mesh);
    // Make sure we see 0 as "don't refine", not "infinitely refine"
    testPoly2TriRefinementBase(mesh, nullptr, 1.5, 2, 0);
  }

References mesh, TestCommWorld, testPoly2TriRefinementBase(), and testTriangulatorTrapMesh().

testPoly2TriNonUniformRefined()

void MeshTriangulationTest::testPoly2TriNonUniformRefined ( )

inline

Definition at line 1519 of file mesh_triangulation.C.

  {
#ifdef LIBMESH_HAVE_FPARSER
    ParsedFunction<Real> var_area {"0.002*(1+2*x)*(1+2*y)"};
    Mesh mesh(*TestCommWorld);
    testTriangulatorTrapMesh(mesh);
    testPoly2TriRefinementBase(mesh, nullptr, 1.5, 150, 0, &var_area);
#endif // LIBMESH_HAVE_FPARSER
  }

References mesh, TestCommWorld, testPoly2TriRefinementBase(), and testTriangulatorTrapMesh().

testPoly2TriRefined()

void MeshTriangulationTest::testPoly2TriRefined ( )

inline

Definition at line 1490 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    testTriangulatorTrapMesh(mesh);
    testPoly2TriRefinementBase(mesh, nullptr, 1.5, 15);
  }

References mesh, TestCommWorld, testPoly2TriRefinementBase(), and testTriangulatorTrapMesh().

testPoly2TriRefinementBase()

void MeshTriangulationTest::testPoly2TriRefinementBase ( UnstructuredMesh &  mesh, const std::vector< TriangulatorInterface::Hole * > *  holes, Real  expected_total_area, dof_id_type  n_original_elem, Real  desired_area = 0.1, FunctionBase< Real > *  area_func = nullptr  )

inline

Definition at line 1435 of file mesh_triangulation.C.

  {
    Poly2TriTriangulator triangulator(mesh);
 
    commonSettings(triangulator);
 
    if (holes)
      triangulator.attach_hole_list(holes);
 
    // Try to insert points!
    triangulator.desired_area() = desired_area;
    triangulator.set_desired_area_function(area_func);
 
    triangulator.triangulate();
 
    // If refinement should have increased our element count, check it
    if (desired_area || area_func)
      CPPUNIT_ASSERT_GREATER(n_original_elem, mesh.n_elem()); // n_elem+++
    else
      CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), n_original_elem);
 
    Real area = 0;
    for (const auto & elem : mesh.active_local_element_ptr_range())
      {
        CPPUNIT_ASSERT_EQUAL(elem->level(), 0u);
        CPPUNIT_ASSERT_EQUAL(elem->type(), TRI3);
 
        const Real my_area = elem->volume();
 
        // my_area <= desired_area, wow this macro ordering hurts
        if (desired_area != 0)
          CPPUNIT_ASSERT_LESSEQUAL(desired_area, my_area);
 
        if (area_func != nullptr)
          for (auto v : make_range(elem->n_vertices()))
            {
              const Real local_desired_area =
                (*area_func)(elem->point(v));
              CPPUNIT_ASSERT_LESSEQUAL(local_desired_area, my_area);
            }
 
        area += my_area;
      }
 
    mesh.comm().sum(area);
 
    LIBMESH_ASSERT_FP_EQUAL(area, expected_total_area, TOLERANCE*TOLERANCE);
  }

References libMesh::TriangulatorInterface::attach_hole_list(), libMesh::ParallelObject::comm(), commonSettings(), libMesh::TriangulatorInterface::desired_area(), libMesh::make_range(), mesh, libMesh::MeshBase::n_elem(), libMesh::Real, libMesh::Poly2TriTriangulator::set_desired_area_function(), libMesh::Parallel::Communicator::sum(), libMesh::TOLERANCE, libMesh::TRI3, and libMesh::Poly2TriTriangulator::triangulate().

Referenced by testPoly2TriEdgesRefined(), testPoly2TriExtraRefined(), testPoly2TriHolesExtraRefined(), testPoly2TriHolesInteriorRefinedBase(), testPoly2TriHolesNonUniformRefined(), testPoly2TriHolesRefined(), testPoly2TriNonRefined(), testPoly2TriNonUniformRefined(), and testPoly2TriRefined().

testPoly2TriRoundHole()

void MeshTriangulationTest::testPoly2TriRoundHole ( )

inline

Definition at line 1278 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator p2t_tri(mesh);
    testTriangulatorRoundHole(mesh, p2t_tri);
  }

References mesh, TestCommWorld, and testTriangulatorRoundHole().

testPoly2TriSegments()

void MeshTriangulationTest::testPoly2TriSegments ( )

inline

Definition at line 1426 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator p2t_tri(mesh);
    testTriangulatorSegments(mesh, p2t_tri);
  }

References mesh, TestCommWorld, and testTriangulatorSegments().

testTriangle()

void MeshTriangulationTest::testTriangle ( )

inline

Definition at line 944 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    TriangleInterface triangle(mesh);
    testTriangulator(mesh, triangle);
  }

References mesh, TestCommWorld, and testTriangulator().

testTriangleEdge3ToTri6()

void MeshTriangulationTest::testTriangleEdge3ToTri6 ( )

inline

Definition at line 1036 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    TriangleInterface triangulator(mesh);
 
    testEdge3Mesh(mesh);
 
    this->testEdge3ToTri6Base(mesh, triangulator);
  }

References mesh, TestCommWorld, testEdge3Mesh(), and testEdge3ToTri6Base().

testTriangleEdges()

void MeshTriangulationTest::testTriangleEdges ( )

inline

Definition at line 1016 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    TriangleInterface triangulator(mesh);
    testEdgesMesh(mesh, EDGE2);
 
    this->testTriangulatorBase(mesh, triangulator);
  }

References libMesh::EDGE2, mesh, TestCommWorld, testEdgesMesh(), and testTriangulatorBase().

testTriangleHalfDomain()

void MeshTriangulationTest::testTriangleHalfDomain ( )

inline

Definition at line 954 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    TriangleInterface triangle(mesh);
    testHalfDomain(mesh, triangle, EDGE2);
  }

References libMesh::EDGE2, mesh, TestCommWorld, and testHalfDomain().

testTriangleHoleArea()

void MeshTriangulationTest::testTriangleHoleArea ( )

inline

Definition at line 139 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    // Using center=(1,0), radius=2 for the heck of it
    Point center{1};
    Real radius = 2;
    std::vector<TriangulatorInterface::PolygonHole> polyholes;
 
    // Line
    polyholes.emplace_back(center, radius, 2);
    // Triangle
    polyholes.emplace_back(center, radius, 3);
    // Square
    polyholes.emplace_back(center, radius, 4);
    // Pentagon
    polyholes.emplace_back(center, radius, 5);
    // Hexagon
    polyholes.emplace_back(center, radius, 6);
 
    for (int i=0; i != 5; ++i)
      {
        const int n_sides = i+2;
        const TriangulatorInterface::Hole & hole = polyholes[i];
 
        const Real computed_area = hole.area();
        const Real theta = pi/n_sides;
        const Real half_side_length = radius*std::cos(theta);
        const Real apothem = radius*std::sin(theta);
        const Real area = n_sides * apothem * half_side_length;
 
        LIBMESH_ASSERT_FP_EQUAL(computed_area, area, TOLERANCE*TOLERANCE);
      }
 
    TriangulatorInterface::ArbitraryHole arbhole {center, {{0,-1},{2,-1},{2,1},{0,2}}};
    LIBMESH_ASSERT_FP_EQUAL(arbhole.area(), Real(5), TOLERANCE*TOLERANCE);
 
#ifdef LIBMESH_HAVE_TRIANGLE
    // Make sure we're compatible with the old naming structure too
    TriangleInterface::PolygonHole square(center, radius, 4);
    LIBMESH_ASSERT_FP_EQUAL(square.area(), 2*radius*radius, TOLERANCE*TOLERANCE);
#endif
  }

References libMesh::TriangulatorInterface::Hole::area(), libMesh::pi, radius, libMesh::Real, and libMesh::TOLERANCE.

testTriangleHoleContains()

void MeshTriangulationTest::testTriangleHoleContains ( )

inline

Definition at line 184 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    // Using center=(1,2), radius=2 for the heck of it
    Point center{1,2};
    Real radius = 2;
    std::vector<TriangulatorInterface::PolygonHole> polyholes;
 
    auto check_corners = [center, radius]
      (const TriangulatorInterface::Hole & hole,
       unsigned int np)
      {
        CPPUNIT_ASSERT_EQUAL(np, hole.n_points());
        for (auto i : make_range(np))
          {
            const Real theta = i * 2 * libMesh::pi / np;
            const Real xin = center(0) + radius * .99 * std::cos(theta);
            const Real xout = center(0) + radius * 1.01 * std::cos(theta);
            const Real yin = center(1) + radius * .99 * std::sin(theta);
            const Real yout = center(1) + radius * 1.01 * std::sin(theta);
 
            CPPUNIT_ASSERT(hole.contains(Point(xin, yin)));
            CPPUNIT_ASSERT(!hole.contains(Point(xout, yout)));
          }
      };
 
    const TriangulatorInterface::PolygonHole triangle(center, radius, 3);
    check_corners(triangle, 3);
    const TriangulatorInterface::PolygonHole diamond(center, radius, 4);
    check_corners(diamond, 4);
    const TriangulatorInterface::PolygonHole hexagon(center, radius, 6);
    check_corners(hexagon, 6);
 
    TriangulatorInterface::ArbitraryHole jaggy
    {{1,0}, {{0,-1},{2,-1},{2,1},{1.75,-.5},{1.5,1},{1.25,-.5},
             {1,1},{.75,-.5},{.5,1},{.25,-.5},{0,1}}};
 
    CPPUNIT_ASSERT(jaggy.contains({.1,-.3}));
    CPPUNIT_ASSERT(jaggy.contains({.5,.9}));
    CPPUNIT_ASSERT(jaggy.contains({.9,-.3}));
    CPPUNIT_ASSERT(jaggy.contains({1,0}));
    CPPUNIT_ASSERT(jaggy.contains({1.1,-.4}));
    CPPUNIT_ASSERT(jaggy.contains({1.5,.9}));
    CPPUNIT_ASSERT(jaggy.contains({1.9,-.3}));
 
    CPPUNIT_ASSERT(jaggy.contains({1.9,-.5}));
    CPPUNIT_ASSERT(jaggy.contains({1.6,-.5}));
    CPPUNIT_ASSERT(jaggy.contains({1.1,-.5}));
    CPPUNIT_ASSERT(jaggy.contains({.5,-.5}));
    CPPUNIT_ASSERT(jaggy.contains({.2,-.5}));
 
    CPPUNIT_ASSERT(!jaggy.contains({.1,.7}));
    CPPUNIT_ASSERT(!jaggy.contains({.5,1.1}));
    CPPUNIT_ASSERT(!jaggy.contains({.9,.7}));
    CPPUNIT_ASSERT(!jaggy.contains({1,-1.1}));
    CPPUNIT_ASSERT(!jaggy.contains({1.1,.8}));
    CPPUNIT_ASSERT(!jaggy.contains({1.5,1.1}));
    CPPUNIT_ASSERT(!jaggy.contains({1.9,.9}));
 
    CPPUNIT_ASSERT(!jaggy.contains({1.9,1}));
    CPPUNIT_ASSERT(!jaggy.contains({1.4,1}));
    CPPUNIT_ASSERT(!jaggy.contains({.9,1}));
    CPPUNIT_ASSERT(!jaggy.contains({.4,1}));
    CPPUNIT_ASSERT(!jaggy.contains({-.2,1}));
    CPPUNIT_ASSERT(!jaggy.contains({-.2,0}));
    CPPUNIT_ASSERT(!jaggy.contains({1.2,0}));
 
    TriangulatorInterface::ArbitraryHole square_jaggy
    {{1,0}, {{-.25,-1},{2,-1},{2,1},{1.75,1},{1.75,-.5},{1.5,-.5},
             {1.5,1},{1.25,1},{1.25,-.5},{1,-.5},{1,1},{.75,1},
             {.75,-.5},{.5,-.5},{.5,1},{.25,1},{.25,-.5},{0,-.5},
             {0,1},{-.25,1}}};
 
    CPPUNIT_ASSERT(square_jaggy.contains({-.1,-.3}));
    CPPUNIT_ASSERT(square_jaggy.contains({.4,.9}));
    CPPUNIT_ASSERT(square_jaggy.contains({.9,-.3}));
    CPPUNIT_ASSERT(square_jaggy.contains({.9,0}));
    CPPUNIT_ASSERT(square_jaggy.contains({1.1,-.6}));
    CPPUNIT_ASSERT(square_jaggy.contains({1.4,.9}));
    CPPUNIT_ASSERT(square_jaggy.contains({1.9,-.3}));
 
    CPPUNIT_ASSERT(!square_jaggy.contains({.1,-.3}));
    CPPUNIT_ASSERT(!square_jaggy.contains({.6,.9}));
    CPPUNIT_ASSERT(!square_jaggy.contains({1.1,-.3}));
    CPPUNIT_ASSERT(!square_jaggy.contains({1.1,0}));
    CPPUNIT_ASSERT(!square_jaggy.contains({1.1,-1.6}));
    CPPUNIT_ASSERT(!square_jaggy.contains({1.6,.9}));
    CPPUNIT_ASSERT(!square_jaggy.contains({2.1,-.3}));
 
    CPPUNIT_ASSERT(square_jaggy.contains({-.1,-.5}));
    CPPUNIT_ASSERT(square_jaggy.contains({.3,-.5}));
    CPPUNIT_ASSERT(square_jaggy.contains({.9,-.5}));
    CPPUNIT_ASSERT(square_jaggy.contains({1.3,-.5}));
    CPPUNIT_ASSERT(square_jaggy.contains({1.9,-.5}));
 
    CPPUNIT_ASSERT(!square_jaggy.contains({-.3,1}));
    CPPUNIT_ASSERT(!square_jaggy.contains({.2,1}));
    CPPUNIT_ASSERT(!square_jaggy.contains({.6,1}));
    CPPUNIT_ASSERT(!square_jaggy.contains({1.1,1}));
    CPPUNIT_ASSERT(!square_jaggy.contains({1.6,1}));
    CPPUNIT_ASSERT(!square_jaggy.contains({2.1,1}));
  }

References libMesh::make_range(), libMesh::pi, radius, and libMesh::Real.

testTriangleHoles()

void MeshTriangulationTest::testTriangleHoles ( )

inline

Definition at line 984 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    TriangleInterface triangle(mesh);
    testTriangulatorHoles(mesh, triangle);
  }

References mesh, TestCommWorld, and testTriangulatorHoles().

testTriangleInterp()

void MeshTriangulationTest::testTriangleInterp ( )

inline

Definition at line 964 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    TriangleInterface triangle(mesh);
    testTriangulatorInterp(mesh, triangle, 1, 6);
  }

References mesh, TestCommWorld, and testTriangulatorInterp().

testTriangleInterp2()

void MeshTriangulationTest::testTriangleInterp2 ( )

inline

Definition at line 974 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    TriangleInterface triangle(mesh);
    testTriangulatorInterp(mesh, triangle, 2, 10);
  }

References mesh, TestCommWorld, and testTriangulatorInterp().

testTriangleMeshedHoles()

void MeshTriangulationTest::testTriangleMeshedHoles ( )

inline

Definition at line 994 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    TriangleInterface triangle(mesh);
    testTriangulatorMeshedHoles(mesh, triangle);
  }

References mesh, TestCommWorld, and testTriangulatorMeshedHoles().

testTriangleRoundHole()

void MeshTriangulationTest::testTriangleRoundHole ( )

inline

Definition at line 1005 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    TriangleInterface triangle(mesh);
    testTriangulatorRoundHole(mesh, triangle);
  }

References mesh, TestCommWorld, and testTriangulatorRoundHole().

testTriangleSegments()

void MeshTriangulationTest::testTriangleSegments ( )

inline

Definition at line 1027 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    TriangleInterface triangle(mesh);
    testTriangulatorSegments(mesh, triangle);
  }

References mesh, TestCommWorld, and testTriangulatorSegments().

testTriangulator()

void MeshTriangulationTest::testTriangulator ( MeshBase &  mesh, TriangulatorInterface &  triangulator  )

inline

Definition at line 404 of file mesh_triangulation.C.

  {
    // A non-square quad, so we don't have ambiguity about which
    // diagonal a Delaunay algorithm will pick.
    // Manually-numbered points, so we can use the point numbering as
    // a segment ordering even on DistributedMesh.
    mesh.add_point(Point(0,0), 0);
    mesh.add_point(Point(1,0), 1);
    mesh.add_point(Point(1,2), 2);
    mesh.add_point(Point(0,1), 3);
 
    this->testTriangulatorBase(mesh, triangulator);
  }

References libMesh::MeshBase::add_point(), mesh, and testTriangulatorBase().

Referenced by testPoly2Tri(), and testTriangle().

testTriangulatorBase()

void MeshTriangulationTest::testTriangulatorBase ( MeshBase &  mesh, TriangulatorInterface &  triangulator  )

inline

Definition at line 317 of file mesh_triangulation.C.

  {
    commonSettings(triangulator);
 
    triangulator.triangulate();
 
    CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), static_cast<dof_id_type>(2));
    for (const auto & elem : mesh.element_ptr_range())
      {
        CPPUNIT_ASSERT_EQUAL(elem->type(), TRI3);
 
        // Make sure we're not getting any inverted elements
        auto cross_prod =
          (elem->point(1) - elem->point(0)).cross
            (elem->point(2) - elem->point(0));
 
        CPPUNIT_ASSERT_GREATER(Real(0), cross_prod(2));
 
        bool found_triangle = false;
        for (const auto & node : elem->node_ref_range())
          {
            const Point & point = node;
            if (point == Point(0,0))
              {
                found_triangle = true;
                CPPUNIT_ASSERT((elem->point(0) == Point(0,0) &&
                                elem->point(1) == Point(1,0) &&
                                elem->point(2) == Point(0,1)) ||
                               (elem->point(1) == Point(0,0) &&
                                elem->point(2) == Point(1,0) &&
                                elem->point(0) == Point(0,1)) ||
                               (elem->point(2) == Point(0,0) &&
                                elem->point(0) == Point(1,0) &&
                                elem->point(1) == Point(0,1)));
              }
            if (point == Point(1,2))
              {
                found_triangle = true;
                CPPUNIT_ASSERT((elem->point(0) == Point(0,1) &&
                                elem->point(1) == Point(1,0) &&
                                elem->point(2) == Point(1,2)) ||
                               (elem->point(1) == Point(0,1) &&
                                elem->point(2) == Point(1,0) &&
                                elem->point(0) == Point(1,2)) ||
                               (elem->point(2) == Point(0,1) &&
                                elem->point(0) == Point(1,0) &&
                                elem->point(1) == Point(1,2)));
              }
          }
        CPPUNIT_ASSERT(found_triangle);
      }
  }

References commonSettings(), mesh, libMesh::MeshBase::n_elem(), libMesh::Real, libMesh::TRI3, and libMesh::TriangulatorInterface::triangulate().

Referenced by testExceptionBase(), testHalfDomain(), testPoly2TriEdge3s(), testPoly2TriEdges(), testTriangleEdges(), testTriangulator(), and testTriangulatorSegments().

testTriangulatorHolePerturbed()

void MeshTriangulationTest::testTriangulatorHolePerturbed ( MeshBase &  mesh, TriangulatorInterface &  triangulator  )

inline

Definition at line 547 of file mesh_triangulation.C.

  {
    // Points based on a simplification of a hole verification failure
    // case
    mesh.add_point(Point(100,0), 0);
    mesh.add_point(Point(100,100), 1);
    mesh.add_point(Point(0,100), 2);
    mesh.add_point(Point(-100,100), 3);
    mesh.add_point(Point(-100,0), 4);
    mesh.add_point(Point(-100,-100), 5);
    mesh.add_point(Point(0,-100), 6);
    mesh.add_point(Point(100,-100), 7);
 
    commonSettings(triangulator);
 
    // Don't insert points here; we want the triangulation determined
    // purely by the boundary and hole points
    triangulator.desired_area() = 1e16;
 
    // Add a diamond hole in *almost* the center; the tiny perturbation
    // puts a hole vertex ray-collinear with a boundary vertex, which
    // used to trip up the hole verification
    TriangulatorInterface::PolygonHole
      diamond(Point(0,4.e-16),
              std::sqrt(2_R)/2, 4);
    const std::vector<TriangulatorInterface::Hole*> holes { &diamond };
    triangulator.attach_hole_list(&holes);
 
    triangulator.triangulate();
 
    CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), dof_id_type(12));
 
    // Center coordinates for all the elements we expect
    const Real r2p200o6 = (std::sqrt(2_R)+200)/6,
               r2p400o6 = (std::sqrt(2_R)+400)/6;
 
    std::vector <Point> expected_centers
    { {r2p400o6,100./3}, {-r2p400o6,100./3},
      {r2p400o6,-100./3}, {-r2p400o6,-100./3},
      {100./3,r2p400o6}, {-100./3,r2p400o6},
      {100./3,-r2p400o6}, {-100./3,-r2p400o6},
      {r2p200o6,r2p200o6}, {-r2p200o6,r2p200o6},
      {r2p200o6,-r2p200o6}, {-r2p200o6,-r2p200o6},
    };
 
    testFoundCenters(mesh, expected_centers);
  }

References libMesh::MeshBase::add_point(), libMesh::TriangulatorInterface::attach_hole_list(), commonSettings(), libMesh::TriangulatorInterface::desired_area(), mesh, libMesh::MeshBase::n_elem(), libMesh::Real, testFoundCenters(), and libMesh::TriangulatorInterface::triangulate().

Referenced by testPoly2TriHolePerturbed().

testTriangulatorHoles()

void MeshTriangulationTest::testTriangulatorHoles ( MeshBase &  mesh, TriangulatorInterface &  triangulator  )

inline

Definition at line 511 of file mesh_triangulation.C.

  {
    // A square quad; we'll put a diamond hole in the middle to make
    // the Delaunay selection unambiguous.
    mesh.add_point(Point(-1,-1), 0);
    mesh.add_point(Point(1,-1), 1);
    mesh.add_point(Point(1,1), 2);
    mesh.add_point(Point(-1,1), 3);
 
    commonSettings(triangulator);
 
    // Add a diamond hole in the center
    TriangulatorInterface::PolygonHole diamond(Point(0), std::sqrt(2_R)/2, 4);
    const std::vector<TriangulatorInterface::Hole*> holes { &diamond };
    triangulator.attach_hole_list(&holes);
 
    triangulator.triangulate();
 
    CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), static_cast<dof_id_type>(8));
 
    // Center coordinates for all the elements we expect
    Real r2p2o6 = (std::sqrt(2_R)+2)/6;
    Real r2p4o6 = (std::sqrt(2_R)+4)/6;
 
    std::vector <Point> expected_centers
    { {r2p2o6,r2p2o6}, {r2p2o6,-r2p2o6},
      {-r2p2o6,r2p2o6}, {-r2p2o6,-r2p2o6},
      {0,r2p4o6}, {r2p4o6, 0},
      {0,-r2p4o6}, {-r2p4o6, 0}
    };
 
    testFoundCenters(mesh, expected_centers);
  }

References libMesh::MeshBase::add_point(), libMesh::TriangulatorInterface::attach_hole_list(), commonSettings(), mesh, libMesh::MeshBase::n_elem(), libMesh::Real, testFoundCenters(), and libMesh::TriangulatorInterface::triangulate().

Referenced by testPoly2TriHoles(), and testTriangleHoles().

testTriangulatorHoleTangentPerturbed()

void MeshTriangulationTest::testTriangulatorHoleTangentPerturbed ( MeshBase &  mesh, TriangulatorInterface &  triangulator  )

inline

Definition at line 597 of file mesh_triangulation.C.

  {
    // Points based on a simplification of a hole verification failure
    // case
    mesh.add_point(Point(200,0), 0);
    mesh.add_point(Point(200,100), 1);
    mesh.add_point(Point(100,100), 2);
    mesh.add_point(Point(0,100), 3);
    mesh.add_point(Point(-100,100), 4);
    mesh.add_point(Point(-200,100), 5);
    mesh.add_point(Point(-200,0), 6);
    mesh.add_point(Point(-200,-100), 7);
    mesh.add_point(Point(-100,-100), 8);
    mesh.add_point(Point(0,-100), 9);
    mesh.add_point(Point(100,-100), 10);
    mesh.add_point(Point(200,-100), 11);
 
    commonSettings(triangulator);
 
    // Don't insert points here; we want the triangulation determined
    // purely by the boundary and hole points
    triangulator.desired_area() = 1e16;
 
    // Two diamond holes, in *almost* the center of each half of that
    // rectangle.  The tiny perturbations make a ray from one hole
    // vertex "tangent" to a vertex of the other hole, which used to
    // trip up the hole verification double-intersection check.
    TriangulatorInterface::PolygonHole
      left_diamond(Point(-100,4.e-16),
                   std::sqrt(2_R)/2, 4),
      right_diamond(Point(100,-4.e-16),
                    std::sqrt(2_R)/2, 4);
    const std::vector<TriangulatorInterface::Hole*> holes
      { &left_diamond, &right_diamond };
    triangulator.attach_hole_list(&holes);
 
    triangulator.triangulate();
 
    CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), dof_id_type(22));
 
    // Center coordinates for all the elements we expect
    const Real r2p200o6 = (std::sqrt(2_R)+200)/6,
               r2p400o6 = (std::sqrt(2_R)+400)/6;
 
    std::vector <Point> expected_centers
    { // Right half, around the diamond hole near x = 100
      {100+r2p400o6,100./3}, {100+r2p400o6,-100./3},
      {100+100./3,r2p400o6}, {100-100./3,r2p400o6},
      {100+100./3,-r2p400o6}, {100-100./3,-r2p400o6},
      {100+r2p200o6,r2p200o6}, {100-r2p200o6,r2p200o6},
      {100+r2p200o6,-r2p200o6}, {100-r2p200o6,-r2p200o6},
      // Left half, mirror of the right around the hole near x = -100
      {-100-r2p400o6,100./3}, {-100-r2p400o6,-100./3},
      {-100-100./3,r2p400o6}, {-100+100./3,r2p400o6},
      {-100-100./3,-r2p400o6}, {-100+100./3,-r2p400o6},
      {-100-r2p200o6,r2p200o6}, {-100+r2p200o6,r2p200o6},
      {-100-r2p200o6,-r2p200o6}, {-100+r2p200o6,-r2p200o6},
      // The two elements meeting the shared wall at x = 0
      {0,100./3}, {0,-100./3}
    };
 
    testFoundCenters(mesh, expected_centers);
  }

References libMesh::MeshBase::add_point(), libMesh::TriangulatorInterface::attach_hole_list(), commonSettings(), libMesh::TriangulatorInterface::desired_area(), mesh, libMesh::MeshBase::n_elem(), libMesh::Real, testFoundCenters(), and libMesh::TriangulatorInterface::triangulate().

Referenced by testPoly2TriHoleTangentPerturbed().

testTriangulatorInterp()

void MeshTriangulationTest::testTriangulatorInterp ( UnstructuredMesh &  mesh, TriangulatorInterface &  triangulator, int  interpolate_boundary_points, dof_id_type  n_expected_elem, Real  expected_total_area = 1.5, Real  desired_area = 1000  )

inline

Definition at line 433 of file mesh_triangulation.C.

  {
    commonSettings(triangulator);
 
    if (!mesh.n_nodes())
      testTriangulatorTrapMesh(mesh);
 
    // Interpolate points!
    triangulator.set_interpolate_boundary_points(interpolate_boundary_points);
 
    // Try to insert points?
    triangulator.desired_area() = desired_area;
 
    triangulator.triangulate();
 
    if (n_expected_elem)
      CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), n_expected_elem);
 
    Real area = 0;
    for (const auto & elem : mesh.active_local_element_ptr_range())
      {
        CPPUNIT_ASSERT_EQUAL(elem->level(), 0u);
        CPPUNIT_ASSERT_EQUAL(elem->type(), TRI3);
 
        area += elem->volume();
      }
 
    mesh.comm().sum(area);
 
    LIBMESH_ASSERT_FP_EQUAL(area, expected_total_area, TOLERANCE*TOLERANCE);
  }

References libMesh::ParallelObject::comm(), commonSettings(), libMesh::TriangulatorInterface::desired_area(), mesh, libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::Real, libMesh::TriangulatorInterface::set_interpolate_boundary_points(), libMesh::Parallel::Communicator::sum(), testTriangulatorTrapMesh(), libMesh::TOLERANCE, libMesh::TRI3, and libMesh::TriangulatorInterface::triangulate().

Referenced by testPoly2TriHolesInterpRefined(), testPoly2TriInterp(), testPoly2TriInterp2(), testTriangleInterp(), and testTriangleInterp2().

testTriangulatorMeshedHoles()

void MeshTriangulationTest::testTriangulatorMeshedHoles ( MeshBase &  mesh, TriangulatorInterface &  triangulator  )

inline

Definition at line 663 of file mesh_triangulation.C.

  {
    // A square quad; we'll put a square hole in the middle.  Offset
    // this to catch a potential bug I missed on the first try.
    mesh.add_point(Point(19,19), 0);
    mesh.add_point(Point(21,19), 1);
    mesh.add_point(Point(21,21), 2);
    mesh.add_point(Point(19,21), 3);
 
    commonSettings(triangulator);
 
    // Add a square meshed hole in the center
    Mesh centermesh { mesh.comm() };
    MeshTools::Generation::build_square (centermesh, 2, 2, 19.5, 20.5, 19.5, 20.5, QUAD4);
 
    TriangulatorInterface::MeshedHole centerhole { centermesh };
 
    CPPUNIT_ASSERT_EQUAL(centerhole.n_points(), 8u);
    CPPUNIT_ASSERT_EQUAL(centerhole.area(), Real(1));
    Point inside = centerhole.inside();
    CPPUNIT_ASSERT_EQUAL(inside(0), Real(20));
    CPPUNIT_ASSERT_EQUAL(inside(1), Real(20));
 
    const std::vector<TriangulatorInterface::Hole*> holes { &centerhole };
    triangulator.attach_hole_list(&holes);
 
    triangulator.triangulate();
 
    CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), static_cast<dof_id_type>(12));
 
    // Center coordinates for all the elements we expect
    std::vector <Point> expected_centers
      { {-0.5, Real(2)/3}, {0, Real(5)/6},
        {0.5, Real(2)/3},
        {Real(2)/3, -0.5}, {Real(5)/6, 0},
        {Real(2)/3, 0.5},
        {-0.5, -Real(2)/3}, {0, -Real(5)/6},
        {0.5, -Real(2)/3},
        {-Real(2)/3, -0.5}, {-Real(5)/6, 0},
        {-Real(2)/3, 0.5} };
 
    // With the same offset
    for (auto & p : expected_centers)
      p += Point(20,20);
 
    testFoundCenters(mesh, expected_centers);
  }

References libMesh::MeshBase::add_point(), libMesh::TriangulatorInterface::attach_hole_list(), libMesh::MeshTools::Generation::build_square(), libMesh::ParallelObject::comm(), commonSettings(), mesh, libMesh::MeshBase::n_elem(), libMesh::QUAD4, libMesh::Real, testFoundCenters(), and libMesh::TriangulatorInterface::triangulate().

Referenced by testPoly2TriMeshedHoles(), and testTriangleMeshedHoles().

testTriangulatorRoundHole()

void MeshTriangulationTest::testTriangulatorRoundHole ( MeshBase &  mesh, TriangulatorInterface &  triangulator  )

inline

Definition at line 714 of file mesh_triangulation.C.

  {
    // A square quad; we'll put a round hole in the middle.
    mesh.add_point(Point(19,19), 0);
    mesh.add_point(Point(21,19), 1);
    mesh.add_point(Point(21,21), 2);
    mesh.add_point(Point(19,21), 3);
 
    commonSettings(triangulator);
 
    // Add a square meshed hole in the center
    const Real radius = 0.5;
    const Point center{20,20};
 
    Mesh centermesh { mesh.comm() };
    MeshTools::Generation::build_sphere(centermesh, radius, 1, QUAD9, 0);
    MeshTools::Modification::translate(centermesh, center(0), center(1));
 
    TriangulatorInterface::MeshedHole centerhole { centermesh };
 
    CPPUNIT_ASSERT_EQUAL(centerhole.n_points(), 8u);
    Point inside = centerhole.inside();
    CPPUNIT_ASSERT_EQUAL(inside(0), Real(20));
    CPPUNIT_ASSERT_EQUAL(inside(1), Real(20));
 
    const std::vector<TriangulatorInterface::Hole*> holes { &centerhole };
    triangulator.attach_hole_list(&holes);
    triangulator.elem_type() = TRI6;
 
    triangulator.triangulate();
 
    CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), static_cast<dof_id_type>(12));
    CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(), static_cast<dof_id_type>(36));
 
    // Make sure we didn't screw up the outer sides.  We should
    // have exact values for the outer vertices, so we can use
    // those for a map.
    std::map<std::pair<Real, Real>, Point> outer_midpoints
      {{{19, 19}, {20, 19}},
       {{21, 19}, {21, 20}},
       {{21, 21}, {20, 21}},
       {{19, 21}, {19, 20}}
      };
 
    for (const auto & elem : mesh.active_local_element_ptr_range())
      for (const auto n : make_range(elem->n_sides()))
        {
          if (elem->neighbor_ptr(n))
            continue;
 
          auto it =
            outer_midpoints.find(std::make_pair(elem->point(n)(0),
                                                elem->point(n)(1)));
          if (it != outer_midpoints.end())
            {
              const Point error = it->second - elem->point(n+3);
              CPPUNIT_ASSERT_LESS(TOLERANCE*TOLERANCE,
                                  error.norm_sq());
            }
          else
            {
              const Point radius1 = elem->point(n) - center;
              CPPUNIT_ASSERT_LESS(TOLERANCE*TOLERANCE,
                                  std::abs(radius1.norm()-radius));
 
              const Point radius2 = elem->point((n+1)%3) - center;
              CPPUNIT_ASSERT_LESS(TOLERANCE*TOLERANCE,
                                  std::abs(radius2.norm()-radius));
 
              const Point radius3 = elem->point(n+3) - center;
              CPPUNIT_ASSERT_LESS(TOLERANCE*TOLERANCE,
                                  std::abs(radius3.norm()-radius));
            }
        }
  }

References libMesh::MeshBase::add_point(), libMesh::TriangulatorInterface::attach_hole_list(), libMesh::MeshTools::Generation::build_sphere(), libMesh::ParallelObject::comm(), commonSettings(), libMesh::TriangulatorInterface::elem_type(), libMesh::make_range(), mesh, libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::TypeVector< T >::norm(), libMesh::TypeVector< T >::norm_sq(), libMesh::QUAD9, radius, libMesh::Real, libMesh::TOLERANCE, libMesh::MeshTools::Modification::translate(), libMesh::TRI6, and libMesh::TriangulatorInterface::triangulate().

Referenced by testPoly2TriRoundHole(), and testTriangleRoundHole().

testTriangulatorSegments()

void MeshTriangulationTest::testTriangulatorSegments ( MeshBase &  mesh, TriangulatorInterface &  triangulator  )

inline

Definition at line 793 of file mesh_triangulation.C.

  {
    // The same quad as testTriangulator, but out of order
    mesh.add_point(Point(0,0), 0);
    mesh.add_point(Point(1,2), 1);
    mesh.add_point(Point(1,0), 2);
    mesh.add_point(Point(0,1), 3);
 
    // Segments to put them in order
    triangulator.segments = {{0,2},{2,1},{1,3},{3,0}};
 
    this->testTriangulatorBase(mesh, triangulator);
  }

References libMesh::MeshBase::add_point(), mesh, libMesh::TriangulatorInterface::segments, and testTriangulatorBase().

Referenced by testPoly2TriSegments(), and testTriangleSegments().

testTriangulatorTrapMesh()

void MeshTriangulationTest::testTriangulatorTrapMesh ( UnstructuredMesh &  mesh )

inline

Definition at line 420 of file mesh_triangulation.C.

  {
    // A non-square quad, so we don't have ambiguity about which
    // diagonal a Delaunay algorithm will pick.
    // Manually-numbered points, so we can use the point numbering as
    // a segment ordering even on DistributedMesh.
    mesh.add_point(Point(0,0), 0);
    mesh.add_point(Point(1,0), 1);
    mesh.add_point(Point(1,2), 2);
    mesh.add_point(Point(0,1), 3);
  }

References libMesh::MeshBase::add_point(), and mesh.

Referenced by testPoly2TriExtraRefined(), testPoly2TriHolesExtraRefined(), testPoly2TriHolesInteriorRefinedBase(), testPoly2TriHolesInterpRefined(), testPoly2TriHolesNonUniformRefined(), testPoly2TriHolesRefined(), testPoly2TriNonRefined(), testPoly2TriNonUniformRefined(), testPoly2TriRefined(), and testTriangulatorInterp().

---

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

• tests/mesh/mesh_triangulation.C