MeshSmootherTest Class Reference

Inheritance diagram for MeshSmootherTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (MeshSmootherTest)
	The goal of this test is to verify proper operation of the MeshSmoother subclasses. More...
	CPPUNIT_TEST (testLaplaceQuad)
	CPPUNIT_TEST (testLaplaceTri)
	CPPUNIT_TEST (testVariationalEdge2)
	CPPUNIT_TEST (testVariationalEdge3)
	CPPUNIT_TEST (testVariationalEdge3MultipleSubdomains)
	CPPUNIT_TEST (testVariationalQuad)
	CPPUNIT_TEST (testVariationalQuadMultipleSubdomains)
	CPPUNIT_TEST (testVariationalTri3)
	CPPUNIT_TEST (testVariationalTri6)
	CPPUNIT_TEST (testVariationalTri6MultipleSubdomains)
	CPPUNIT_TEST (testVariationalHex8)
	CPPUNIT_TEST (testVariationalHex20)
	CPPUNIT_TEST (testVariationalHex27)
	CPPUNIT_TEST (testVariationalHex27MultipleSubdomains)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
void	testLaplaceSmoother (ReplicatedMesh &mesh, MeshSmoother &smoother, ElemType type)
void	testVariationalSmoother (ReplicatedMesh &mesh, MeshSmoother &smoother, const ElemType type, const bool multiple_subdomains=false)
void	testLaplaceQuad ()
void	testLaplaceTri ()
void	testVariationalEdge2 ()
void	testVariationalEdge3 ()
void	testVariationalEdge3MultipleSubdomains ()
void	testVariationalQuad ()
void	testVariationalQuadMultipleSubdomains ()
void	testVariationalTri3 ()
void	testVariationalTri6 ()
void	testVariationalTri6MultipleSubdomains ()
void	testVariationalHex8 ()
void	testVariationalHex20 ()
void	testVariationalHex27 ()
void	testVariationalHex27MultipleSubdomains ()

Detailed Description

Definition at line 173 of file mesh_smoother_test.C.

Member Function Documentation

CPPUNIT_TEST() [1/14]

MeshSmootherTest::CPPUNIT_TEST

(

testLaplaceQuad

)

CPPUNIT_TEST() [2/14]

MeshSmootherTest::CPPUNIT_TEST

(

testLaplaceTri

)

CPPUNIT_TEST() [3/14]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalEdge2

)

CPPUNIT_TEST() [4/14]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalEdge3

)

CPPUNIT_TEST() [5/14]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalEdge3MultipleSubdomains

)

CPPUNIT_TEST() [6/14]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalQuad

)

CPPUNIT_TEST() [7/14]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalQuadMultipleSubdomains

)

CPPUNIT_TEST() [8/14]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalTri3

)

CPPUNIT_TEST() [9/14]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalTri6

)

CPPUNIT_TEST() [10/14]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalTri6MultipleSubdomains

)

CPPUNIT_TEST() [11/14]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalHex8

)

CPPUNIT_TEST() [12/14]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalHex20

)

CPPUNIT_TEST() [13/14]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalHex27

)

CPPUNIT_TEST() [14/14]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalHex27MultipleSubdomains

)

CPPUNIT_TEST_SUITE_END()

MeshSmootherTest::CPPUNIT_TEST_SUITE_END

(

)

LIBMESH_CPPUNIT_TEST_SUITE()

MeshSmootherTest::LIBMESH_CPPUNIT_TEST_SUITE

(

MeshSmootherTest

)

The goal of this test is to verify proper operation of the MeshSmoother subclasses.

setUp()

void MeshSmootherTest::setUp ( )

inline

Definition at line 207 of file mesh_smoother_test.C.

{}

tearDown()

void MeshSmootherTest::tearDown ( )

inline

Definition at line 209 of file mesh_smoother_test.C.

{}

testLaplaceQuad()

void MeshSmootherTest::testLaplaceQuad ( )

inline

Definition at line 480 of file mesh_smoother_test.C.

References mesh, libMesh::QUAD4, and TestCommWorld.

  {
    ReplicatedMesh mesh(*TestCommWorld);
    LaplaceMeshSmoother laplace(mesh);

    testLaplaceSmoother(mesh, laplace, QUAD4);
  }

testLaplaceSmoother()

void MeshSmootherTest::testLaplaceSmoother ( ReplicatedMesh &  mesh, MeshSmoother &  smoother, ElemType  type  )

inline

Definition at line 211 of file mesh_smoother_test.C.

References libMesh::MeshTools::Generation::build_square(), mesh, libMesh::Real, libMesh::MeshTools::Modification::redistribute(), libMesh::MeshSmoother::smooth(), and libMesh::TOLERANCE.

  {
    LOG_UNIT_TEST;

    constexpr unsigned int n_elems_per_side = 4;

    MeshTools::Generation::build_square(
        mesh, n_elems_per_side, n_elems_per_side, 0., 1., 0., 1., type);

    // Move it around so we have something that needs smoothing
    DistortSquare ds;
    MeshTools::Modification::redistribute(mesh, ds);

    // Assert the distortion is as expected
    auto center_distortion_is =
        [](const Node & node, int d, bool distortion, Real distortion_tol = TOLERANCE) {
          const Real r = node(d);
          const Real R = r * n_elems_per_side;
          CPPUNIT_ASSERT_GREATER(-TOLERANCE * TOLERANCE, r);
          CPPUNIT_ASSERT_GREATER(-TOLERANCE * TOLERANCE, 1 - r);

          // If we're at the boundaries we should *never* be distorted
          if (std::abs(node(0)) < TOLERANCE * TOLERANCE ||
              std::abs(node(0) - 1) < TOLERANCE * TOLERANCE)
            {
              const Real R1 = node(1) * n_elems_per_side;
              CPPUNIT_ASSERT_LESS(TOLERANCE * TOLERANCE, std::abs(R1 - std::round(R1)));
              return true;
            }

          if (std::abs(node(1)) < TOLERANCE * TOLERANCE ||
              std::abs(node(1) - 1) < TOLERANCE * TOLERANCE)
            {
              const Real R0 = node(0) * n_elems_per_side;
              CPPUNIT_ASSERT_LESS(TOLERANCE * TOLERANCE, std::abs(R0 - std::round(R0)));

              return true;
            }

          // If we're at the center we're fine
          if (std::abs(r - 0.5) < TOLERANCE * TOLERANCE)
            return true;

          return ((std::abs(R - std::round(R)) > distortion_tol) == distortion);
        };

    for (auto node : mesh.node_ptr_range())
      {
        CPPUNIT_ASSERT(center_distortion_is(*node, 0, true));
        CPPUNIT_ASSERT(center_distortion_is(*node, 1, true));
      }

    // Enough iterations to mostly fix us up.  Laplace seems to be at 1e-3
    // tolerance by iteration 6, so hopefully everything is there on any
    // system by 8.
    for (unsigned int i = 0; i != 8; ++i)
      smoother.smooth();

    // Make sure we're not too distorted anymore.
    for (auto node : mesh.node_ptr_range())
      {
        CPPUNIT_ASSERT(center_distortion_is(*node, 0, false, 1e-3));
        CPPUNIT_ASSERT(center_distortion_is(*node, 1, false, 1e-3));
      }
  }

testLaplaceTri()

void MeshSmootherTest::testLaplaceTri ( )

inline

Definition at line 488 of file mesh_smoother_test.C.

References mesh, TestCommWorld, and libMesh::TRI3.

  {
    ReplicatedMesh mesh(*TestCommWorld);
    LaplaceMeshSmoother laplace(mesh);

    testLaplaceSmoother(mesh, laplace, TRI3);
  }

testVariationalEdge2()

void MeshSmootherTest::testVariationalEdge2 ( )

inline

Definition at line 497 of file mesh_smoother_test.C.

References libMesh::EDGE2, mesh, and TestCommWorld.

  {
    ReplicatedMesh mesh(*TestCommWorld);
    VariationalMeshSmoother variational(mesh);

    testVariationalSmoother(mesh, variational, EDGE2);
  }

testVariationalEdge3()

void MeshSmootherTest::testVariationalEdge3 ( )

inline

Definition at line 505 of file mesh_smoother_test.C.

References libMesh::EDGE3, mesh, and TestCommWorld.

  {
    ReplicatedMesh mesh(*TestCommWorld);
    VariationalMeshSmoother variational(mesh);

    testVariationalSmoother(mesh, variational, EDGE3);
  }

testVariationalEdge3MultipleSubdomains()

void MeshSmootherTest::testVariationalEdge3MultipleSubdomains ( )

inline

Definition at line 513 of file mesh_smoother_test.C.

References libMesh::EDGE3, mesh, and TestCommWorld.

  {
    ReplicatedMesh mesh(*TestCommWorld);
    VariationalMeshSmoother variational(mesh);

    testVariationalSmoother(mesh, variational, EDGE3, true);
  }

testVariationalHex20()

void MeshSmootherTest::testVariationalHex20 ( )

inline

Definition at line 569 of file mesh_smoother_test.C.

References libMesh::HEX20, mesh, and TestCommWorld.

  {
    ReplicatedMesh mesh(*TestCommWorld);
    VariationalMeshSmoother variational(mesh);

    testVariationalSmoother(mesh, variational, HEX20);
  }

testVariationalHex27()

void MeshSmootherTest::testVariationalHex27 ( )

inline

Definition at line 577 of file mesh_smoother_test.C.

References libMesh::HEX27, mesh, and TestCommWorld.

  {
    ReplicatedMesh mesh(*TestCommWorld);
    VariationalMeshSmoother variational(mesh);

    testVariationalSmoother(mesh, variational, HEX27);
  }

testVariationalHex27MultipleSubdomains()

void MeshSmootherTest::testVariationalHex27MultipleSubdomains ( )

inline

Definition at line 585 of file mesh_smoother_test.C.

References libMesh::HEX27, mesh, and TestCommWorld.

  {
    ReplicatedMesh mesh(*TestCommWorld);
    VariationalMeshSmoother variational(mesh);

    testVariationalSmoother(mesh, variational, HEX27, true);
  }

testVariationalHex8()

void MeshSmootherTest::testVariationalHex8 ( )

inline

Definition at line 561 of file mesh_smoother_test.C.

References libMesh::HEX8, mesh, and TestCommWorld.

  {
    ReplicatedMesh mesh(*TestCommWorld);
    VariationalMeshSmoother variational(mesh);

    testVariationalSmoother(mesh, variational, HEX8);
  }

testVariationalQuad()

void MeshSmootherTest::testVariationalQuad ( )

inline

Definition at line 521 of file mesh_smoother_test.C.

References mesh, libMesh::QUAD4, and TestCommWorld.

  {
    ReplicatedMesh mesh(*TestCommWorld);
    VariationalMeshSmoother variational(mesh);

    testVariationalSmoother(mesh, variational, QUAD4);
  }

testVariationalQuadMultipleSubdomains()

void MeshSmootherTest::testVariationalQuadMultipleSubdomains ( )

inline

Definition at line 529 of file mesh_smoother_test.C.

References mesh, libMesh::QUAD4, and TestCommWorld.

  {
    ReplicatedMesh mesh(*TestCommWorld);
    VariationalMeshSmoother variational(mesh);

    testVariationalSmoother(mesh, variational, QUAD4, true);
  }

testVariationalSmoother()

void MeshSmootherTest::testVariationalSmoother ( ReplicatedMesh &  mesh, MeshSmoother &  smoother, const ElemType  type, const bool  multiple_subdomains = false  )

inline

Definition at line 277 of file mesh_smoother_test.C.

References libMesh::absolute_fuzzy_equals(), libMesh::BoundaryInfo::boundary_ids(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_line(), libMesh::MeshTools::Generation::build_square(), dim, libMesh::MeshBase::elem_default_orders(), libMesh::Utility::enum_to_string(), libMesh::ReferenceElem::get(), libMesh::MeshBase::get_boundary_info(), libMesh::make_range(), mesh, libMesh::Real, libMesh::MeshTools::Modification::redistribute(), libMesh::relative_fuzzy_equals(), libMesh::MeshSmoother::smooth(), and libMesh::TOLERANCE.

  {
    LOG_UNIT_TEST;

    // Get mesh dimension, determine whether type is triangular
    const auto * ref_elem = &(ReferenceElem::get(type));
    const auto dim = ref_elem->dim();
    const bool type_is_tri = Utility::enum_to_string(type).compare(0, 3, "TRI") == 0;

    unsigned int n_elems_per_side = 5;

    // The current distortion mechanism in DistortHyperCube, combined with the
    // way multiple subdomains are assigned below, has the property that:
    //   - When n_elems_per_side is even, some of the subdomain boundary nodes
    //     are colinear, leading to sliding node constraints.
    //   - When n_elems_per_side is odd, none of the subdomain boundary nodes
    //     are colinear, leading to all subdomain boundary nodes being fixed.
    // Our check for preserved subdomain boundaries is overly restrictive
    // because we error if any subdomain boundary nodes move during smoothing.
    // To avoid this error, instead of implementing a more elaborate check for
    // sliding subdomain boundary nodes, we require n_elems_per_side to be odd.
    libmesh_error_msg_if(n_elems_per_side % 2 != 1,
                         "n_elems_per_side should be odd.");

    switch (dim)
      {
        case 1:
          MeshTools::Generation::build_line(mesh, n_elems_per_side, 0., 1., type);
          break;
        case 2:
          MeshTools::Generation::build_square(
              mesh, n_elems_per_side, n_elems_per_side, 0., 1., 0., 1., type);
          break;

        case 3:
          MeshTools::Generation::build_cube(mesh,
                                            n_elems_per_side,
                                            n_elems_per_side,
                                            n_elems_per_side,
                                            0.,
                                            1.,
                                            0.,
                                            1.,
                                            0.,
                                            1.,
                                            type);
          break;

        default:
          libmesh_error_msg("Unsupported dimension " << dim);
      }

    // Move it around so we have something that needs smoothing
    DistortHyperCube dh(dim);
    MeshTools::Modification::redistribute(mesh, dh);

    // Add multiple subdomains if requested
    std::unordered_map<dof_id_type, Point> subdomain_boundary_node_id_to_point;
    if (multiple_subdomains)
      {
        // Modify the subdomain ids in an interesting way
        for (auto * elem : mesh.active_element_ptr_range())
          {
            unsigned int subdomain_id = 0;
            for (const auto d : make_range(dim))
              if (elem->vertex_average()(d) > 0.5)
                ++subdomain_id;
            elem->subdomain_id() += subdomain_id;
          }

        // This loop should NOT be combined with the one above because we need to
        // finish checking and updating subdomain ids for all elements before
        // recording the final subdomain boundary.
        for (auto * elem : mesh.active_element_ptr_range())
          for (const auto & s : elem->side_index_range())
            {
              const auto * neighbor = elem->neighbor_ptr(s);
              if (neighbor == nullptr)
                continue;

              if (elem->subdomain_id() != neighbor->subdomain_id())
                // This side is part of a subdomain boundary, record the
                // corresponding node locations
                for (const auto & n : elem->nodes_on_side(s))
                  subdomain_boundary_node_id_to_point[elem->node_id(n)] =
                      Point(*(elem->get_nodes()[n]));
            }
      }


      // Get the mesh order
      const auto &elem_orders = mesh.elem_default_orders();
      libmesh_error_msg_if(
          elem_orders.size() != 1,
          "The variational smoother cannot be used for mixed-order meshes!");
      const auto fe_order = *elem_orders.begin();

      // Function to assert the distortion is as expected
      const auto &boundary_info = mesh.get_boundary_info();
      auto distortion_is = [
        &n_elems_per_side, &dim, &boundary_info, &fe_order
      ](const Node &node, bool distortion, Real distortion_tol = TOLERANCE)
      {
        // Get boundary ids associated with the node
        std::vector<boundary_id_type> boundary_ids;
        boundary_info.boundary_ids(&node, boundary_ids);

        // This tells us what type of node we are: internal, sliding, or fixed
        const auto num_dofs = dim - boundary_ids.size();
        /*
         * The following cases of num_dofs are possible, ASSUMING all boundaries
         * are non-overlapping
         * 3D: 3-0,     3-1,     3-2,     3-3
         *   = 3        2        1        0
         *     internal sliding, sliding, fixed
         * 2D: 2-0,     2-1,     2-2
         *   = 2        1        0
         *     internal sliding, fixed
         * 1D: 1-0,     1-1
         *   = 1        0
         *     internal fixed
         *
         * We expect that R is an integer in [0, n_elems_per_side] for
         * num_dofs of the node's cooridinantes, while the remaining coordinates
         * are fixed to the boundary with value 0 or 1. In other words, at LEAST
         * dim - num_dofs coordinantes should be 0 or 1.
         */

        std::size_t num_zero_or_one = 0;

        bool distorted = false;
        for (const auto d : make_range(dim))
          {
            const Real r = node(d);
            const Real R = r * n_elems_per_side * fe_order;
            CPPUNIT_ASSERT_GREATER(-distortion_tol * distortion_tol, r);
            CPPUNIT_ASSERT_GREATER(-distortion_tol * distortion_tol, 1 - r);

            const bool d_distorted = std::abs(R - std::round(R)) > distortion_tol;
            distorted |= d_distorted;
            num_zero_or_one +=
                (absolute_fuzzy_equals(r, 0.) || absolute_fuzzy_equals(r, 1.));
          }

        CPPUNIT_ASSERT_GREATEREQUAL(dim - num_dofs, num_zero_or_one);

        // We can never expect a fixed node to be distorted
        if (num_dofs == 0)
          // if (num_dofs < dim)
          return true;
        return distorted == distortion;
      };

    // Function to check if a given node has changed based on previous mapping
    auto is_subdomain_boundary_node_the_same = [&subdomain_boundary_node_id_to_point](
                                                   const Node & node) {
      auto it = subdomain_boundary_node_id_to_point.find(node.id());
      if (it != subdomain_boundary_node_id_to_point.end())
        return (relative_fuzzy_equals(Point(node), subdomain_boundary_node_id_to_point[node.id()]));
      else
        // node is not a subdomain boundary node, just return true
        return true;
    };

    // Make sure our DistortSquare transformation has distorted the mesh
    for (auto node : mesh.node_ptr_range())
      CPPUNIT_ASSERT(distortion_is(*node, true));

    // Transform the square mesh of triangles to a parallelogram mesh of
    // triangles. This will allow the Variational Smoother to smooth the mesh
    // to the optimal case of equilateral triangles
    if (type_is_tri)
      {
        SquareToParallelogram stp;
        MeshTools::Modification::redistribute(mesh, stp);
      }

    smoother.smooth();

    // Transform the parallelogram mesh back to a square mesh. In the case of
    // the Variational Smoother, equilateral triangular elements will be
    // transformed into right triangular elements that align with the original
    // undistorted mesh.
    if (type_is_tri)
      {
        ParallelogramToSquare pts;
        MeshTools::Modification::redistribute(mesh, pts);
      }

    // Make sure we're not too distorted anymore OR that interval subdomain boundary nodes did not
    // change.
    for (auto node : mesh.node_ptr_range())
      {
        if (multiple_subdomains)
          CPPUNIT_ASSERT(is_subdomain_boundary_node_the_same(*node));
        else
          CPPUNIT_ASSERT(distortion_is(*node, false, 1e-3));
      }
  }

testVariationalTri3()

void MeshSmootherTest::testVariationalTri3 ( )

inline

Definition at line 537 of file mesh_smoother_test.C.

References mesh, TestCommWorld, and libMesh::TRI3.

  {
    ReplicatedMesh mesh(*TestCommWorld);
    VariationalMeshSmoother variational(mesh);

    testVariationalSmoother(mesh, variational, TRI3);
  }

testVariationalTri6()

void MeshSmootherTest::testVariationalTri6 ( )

inline

Definition at line 545 of file mesh_smoother_test.C.

References mesh, TestCommWorld, and libMesh::TRI6.

  {
    ReplicatedMesh mesh(*TestCommWorld);
    VariationalMeshSmoother variational(mesh);

    testVariationalSmoother(mesh, variational, TRI6);
  }

testVariationalTri6MultipleSubdomains()

void MeshSmootherTest::testVariationalTri6MultipleSubdomains ( )

inline

Definition at line 553 of file mesh_smoother_test.C.

References mesh, TestCommWorld, and libMesh::TRI3.

  {
    ReplicatedMesh mesh(*TestCommWorld);
    VariationalMeshSmoother variational(mesh);

    testVariationalSmoother(mesh, variational, TRI3, true);
  }

---

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

• tests/mesh/mesh_smoother_test.C