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. More...
	CPPUNIT_TEST (testTriangleHoleArea)
	CPPUNIT_TEST (testTriangleHoleContains)
	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 (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 (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	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	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	testPoly2TriMeshedHoles ()
void	testPoly2TriEdge3ToTri6 ()
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 90 of file mesh_triangulation.C.

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

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

CPPUNIT_TEST() [1/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleHoleArea

)

CPPUNIT_TEST() [2/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleHoleContains

)

CPPUNIT_TEST() [3/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2Tri

)

CPPUNIT_TEST() [4/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriHalfDomain

)

CPPUNIT_TEST() [5/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriHalfDomainEdge3

)

CPPUNIT_TEST() [6/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriInterp

)

CPPUNIT_TEST() [7/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriInterp2

)

CPPUNIT_TEST() [8/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriHoles

)

CPPUNIT_TEST() [9/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriMeshedHoles

)

CPPUNIT_TEST() [10/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriEdge3ToTri6

)

CPPUNIT_TEST() [11/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriRoundHole

)

CPPUNIT_TEST() [12/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriEdges

)

CPPUNIT_TEST() [13/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriEdge3s

)

CPPUNIT_TEST() [14/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriBadEdges

)

CPPUNIT_TEST() [15/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriBad1DMultiBoundary

)

CPPUNIT_TEST() [16/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriBad2DMultiBoundary

)

CPPUNIT_TEST() [17/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriEdgesRefined

)

CPPUNIT_TEST() [18/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriSegments

)

CPPUNIT_TEST() [19/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriRefined

)

CPPUNIT_TEST() [20/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriNonRefined

)

CPPUNIT_TEST() [21/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriExtraRefined

)

CPPUNIT_TEST() [22/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriHolesRefined

)

CPPUNIT_TEST() [23/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriHolesInterpRefined

)

CPPUNIT_TEST() [24/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriHolesInteriorRefined

)

CPPUNIT_TEST() [25/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriHolesInteriorExtraRefined

)

CPPUNIT_TEST() [26/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriHolesExtraRefined

)

CPPUNIT_TEST() [27/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriNonUniformRefined

)

CPPUNIT_TEST() [28/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testPoly2TriHolesNonUniformRefined

)

CPPUNIT_TEST() [29/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangle

)

CPPUNIT_TEST() [30/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleHalfDomain

)

CPPUNIT_TEST() [31/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleInterp

)

CPPUNIT_TEST() [32/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleInterp2

)

CPPUNIT_TEST() [33/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleHoles

)

CPPUNIT_TEST() [34/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleMeshedHoles

)

CPPUNIT_TEST() [35/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleRoundHole

)

CPPUNIT_TEST() [36/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleEdges

)

CPPUNIT_TEST() [37/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleSegments

)

CPPUNIT_TEST() [38/38]

MeshTriangulationTest::CPPUNIT_TEST

(

testTriangleEdge3ToTri6

)

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 86 of file mesh_triangulation.C.

{}

tearDown()

void MeshTriangulationTest::tearDown ( )

inline

Definition at line 88 of file mesh_triangulation.C.

{}

testEdge3Mesh()

void MeshTriangulationTest::testEdge3Mesh ( MeshBase &  mesh )

inline

Definition at line 698 of file mesh_triangulation.C.

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

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

testEdge3ToTri6Base()

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

inline

Definition at line 336 of file mesh_triangulation.C.

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

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

testEdgesMesh()

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

inline

Definition at line 658 of file mesh_triangulation.C.

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

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

testExceptionBase()

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

inline

Definition at line 104 of file mesh_triangulation.C.

References mesh.

  {
#ifdef LIBMESH_ENABLE_EXCEPTIONS
    // We can't just CPPUNIT_ASSERT_THROW, because we want to make
    // sure we were thrown from the right place with the right error
    // message!
    bool threw_desired_exception = false;
    try {
      this->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
  }

testFoundCenters()

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

inline

Definition at line 436 of file mesh_triangulation.C.

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

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

testHalfDomain()

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

inline

Definition at line 731 of file mesh_triangulation.C.

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

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

testPoly2Tri()

void MeshTriangulationTest::testPoly2Tri ( )

inline

Definition at line 901 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testPoly2TriBad1DMultiBoundary()

void MeshTriangulationTest::testPoly2TriBad1DMultiBoundary ( )

inline

Definition at line 1049 of file mesh_triangulation.C.

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

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

testPoly2TriBad2DMultiBoundary()

void MeshTriangulationTest::testPoly2TriBad2DMultiBoundary ( )

inline

Definition at line 1090 of file mesh_triangulation.C.

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

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

testPoly2TriBadEdges()

void MeshTriangulationTest::testPoly2TriBadEdges ( )

inline

Definition at line 1019 of file mesh_triangulation.C.

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

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

testPoly2TriEdge3s()

void MeshTriangulationTest::testPoly2TriEdge3s ( )

inline

Definition at line 1007 of file mesh_triangulation.C.

References libMesh::EDGE3, mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator triangulator(mesh);
    testEdgesMesh(mesh, EDGE3);

    this->testTriangulatorBase(mesh, triangulator);
  }

testPoly2TriEdge3ToTri6()

void MeshTriangulationTest::testPoly2TriEdge3ToTri6 ( )

inline

Definition at line 970 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator triangulator(mesh);

    testEdge3Mesh(mesh);

    this->testEdge3ToTri6Base(mesh, triangulator);
  }

testPoly2TriEdges()

void MeshTriangulationTest::testPoly2TriEdges ( )

inline

Definition at line 995 of file mesh_triangulation.C.

References libMesh::EDGE2, mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);
    Poly2TriTriangulator triangulator(mesh);
    testEdgesMesh(mesh, EDGE2);

    this->testTriangulatorBase(mesh, triangulator);
  }

testPoly2TriEdgesRefined()

void MeshTriangulationTest::testPoly2TriEdgesRefined ( )

inline

Definition at line 1121 of file mesh_triangulation.C.

References libMesh::EDGE2, mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testPoly2TriExtraRefined()

void MeshTriangulationTest::testPoly2TriExtraRefined ( )

inline

Definition at line 1216 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testPoly2TriHalfDomain()

void MeshTriangulationTest::testPoly2TriHalfDomain ( )

inline

Definition at line 911 of file mesh_triangulation.C.

References libMesh::EDGE2, mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testPoly2TriHalfDomainEdge3()

void MeshTriangulationTest::testPoly2TriHalfDomainEdge3 ( )

inline

Definition at line 921 of file mesh_triangulation.C.

References libMesh::EDGE3, mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testPoly2TriHoles()

void MeshTriangulationTest::testPoly2TriHoles ( )

inline

Definition at line 951 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testPoly2TriHolesExtraRefined()

void MeshTriangulationTest::testPoly2TriHolesExtraRefined ( )

inline

Definition at line 1333 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

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

testPoly2TriHolesInteriorExtraRefined()

void MeshTriangulationTest::testPoly2TriHolesInteriorExtraRefined ( )

inline

Definition at line 1325 of file mesh_triangulation.C.

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

testPoly2TriHolesInteriorRefined()

void MeshTriangulationTest::testPoly2TriHolesInteriorRefined ( )

inline

Definition at line 1318 of file mesh_triangulation.C.

  {
    LOG_UNIT_TEST;
    testPoly2TriHolesInteriorRefinedBase(25, 0.05);
  }

testPoly2TriHolesInteriorRefinedBase()

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

inline

Definition at line 1287 of file mesh_triangulation.C.

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(), and TestCommWorld.

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

testPoly2TriHolesInterpRefined()

void MeshTriangulationTest::testPoly2TriHolesInterpRefined ( )

inline

Definition at line 1248 of file mesh_triangulation.C.

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

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

testPoly2TriHolesNonUniformRefined()

void MeshTriangulationTest::testPoly2TriHolesNonUniformRefined ( )

inline

Definition at line 1344 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

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

testPoly2TriHolesRefined()

void MeshTriangulationTest::testPoly2TriHolesRefined ( )

inline

Definition at line 1235 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

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

testPoly2TriInterp()

void MeshTriangulationTest::testPoly2TriInterp ( )

inline

Definition at line 931 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testPoly2TriInterp2()

void MeshTriangulationTest::testPoly2TriInterp2 ( )

inline

Definition at line 941 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testPoly2TriMeshedHoles()

void MeshTriangulationTest::testPoly2TriMeshedHoles ( )

inline

Definition at line 961 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testPoly2TriNonRefined()

void MeshTriangulationTest::testPoly2TriNonRefined ( )

inline

Definition at line 1205 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

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

testPoly2TriNonUniformRefined()

void MeshTriangulationTest::testPoly2TriNonUniformRefined ( )

inline

Definition at line 1225 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

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

testPoly2TriRefined()

void MeshTriangulationTest::testPoly2TriRefined ( )

inline

Definition at line 1196 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

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 1142 of file mesh_triangulation.C.

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

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

testPoly2TriRoundHole()

void MeshTriangulationTest::testPoly2TriRoundHole ( )

inline

Definition at line 984 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testPoly2TriSegments()

void MeshTriangulationTest::testPoly2TriSegments ( )

inline

Definition at line 1132 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testTriangle()

void MeshTriangulationTest::testTriangle ( )

inline

Definition at line 793 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testTriangleEdge3ToTri6()

void MeshTriangulationTest::testTriangleEdge3ToTri6 ( )

inline

Definition at line 885 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);
    TriangleInterface triangulator(mesh);

    testEdge3Mesh(mesh);

    this->testEdge3ToTri6Base(mesh, triangulator);
  }

testTriangleEdges()

void MeshTriangulationTest::testTriangleEdges ( )

inline

Definition at line 865 of file mesh_triangulation.C.

References libMesh::EDGE2, mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);
    TriangleInterface triangulator(mesh);
    testEdgesMesh(mesh, EDGE2);

    this->testTriangulatorBase(mesh, triangulator);
  }

testTriangleHalfDomain()

void MeshTriangulationTest::testTriangleHalfDomain ( )

inline

Definition at line 803 of file mesh_triangulation.C.

References libMesh::EDGE2, mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testTriangleHoleArea()

void MeshTriangulationTest::testTriangleHoleArea ( )

inline

Definition at line 132 of file mesh_triangulation.C.

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

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

testTriangleHoleContains()

void MeshTriangulationTest::testTriangleHoleContains ( )

inline

Definition at line 177 of file mesh_triangulation.C.

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

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

testTriangleHoles()

void MeshTriangulationTest::testTriangleHoles ( )

inline

Definition at line 833 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testTriangleInterp()

void MeshTriangulationTest::testTriangleInterp ( )

inline

Definition at line 813 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testTriangleInterp2()

void MeshTriangulationTest::testTriangleInterp2 ( )

inline

Definition at line 823 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testTriangleMeshedHoles()

void MeshTriangulationTest::testTriangleMeshedHoles ( )

inline

Definition at line 843 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testTriangleRoundHole()

void MeshTriangulationTest::testTriangleRoundHole ( )

inline

Definition at line 854 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testTriangleSegments()

void MeshTriangulationTest::testTriangleSegments ( )

inline

Definition at line 876 of file mesh_triangulation.C.

References mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

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

testTriangulator()

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

inline

Definition at line 369 of file mesh_triangulation.C.

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

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

testTriangulatorBase()

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

inline

Definition at line 282 of file mesh_triangulation.C.

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

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

testTriangulatorHoles()

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

inline

Definition at line 476 of file mesh_triangulation.C.

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

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

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 398 of file mesh_triangulation.C.

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

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

testTriangulatorMeshedHoles()

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

inline

Definition at line 512 of file mesh_triangulation.C.

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

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

testTriangulatorRoundHole()

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

inline

Definition at line 563 of file mesh_triangulation.C.

References libMesh::MeshBase::add_point(), libMesh::TriangulatorInterface::attach_hole_list(), libMesh::MeshTools::Generation::build_sphere(), libMesh::ParallelObject::comm(), 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().

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

testTriangulatorSegments()

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

inline

Definition at line 642 of file mesh_triangulation.C.

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

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

testTriangulatorTrapMesh()

void MeshTriangulationTest::testTriangulatorTrapMesh ( UnstructuredMesh &  mesh )

inline

Definition at line 385 of file mesh_triangulation.C.

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

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

---

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

• tests/mesh/mesh_triangulation.C