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 (testVariationalQuadTangled)
	CPPUNIT_TEST (testVariationalTri3)
	CPPUNIT_TEST (testVariationalTri6)
	CPPUNIT_TEST (testVariationalTri6MultipleSubdomains)
	CPPUNIT_TEST (testVariationalHex8)
	CPPUNIT_TEST (testVariationalHex20)
	CPPUNIT_TEST (testVariationalHex27)
	CPPUNIT_TEST (testVariationalHex27Tangled)
	CPPUNIT_TEST (testVariationalHex27MultipleSubdomains)
	CPPUNIT_TEST (testVariationalPyramid5)
	CPPUNIT_TEST (testVariationalPyramid13)
	CPPUNIT_TEST (testVariationalPyramid14)
	CPPUNIT_TEST (testVariationalPyramid18)
	CPPUNIT_TEST (testVariationalPyramid18MultipleSubdomains)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
void	testLaplaceSmoother (ReplicatedMesh &mesh, MeshSmoother &smoother, ElemType type)
void	testVariationalSmoother (ReplicatedMesh &mesh, VariationalMeshSmoother &smoother, const ElemType type, const bool multiple_subdomains=false, const bool tangle_mesh=false, const Real tangle_damping_factor=1.0)
void	testLaplaceQuad ()
void	testLaplaceTri ()
void	testVariationalEdge2 ()
void	testVariationalEdge3 ()
void	testVariationalEdge3MultipleSubdomains ()
void	testVariationalQuad ()
void	testVariationalQuadMultipleSubdomains ()
void	testVariationalQuadTangled ()
void	testVariationalTri3 ()
void	testVariationalTri6 ()
void	testVariationalTri6MultipleSubdomains ()
void	testVariationalHex8 ()
void	testVariationalHex20 ()
void	testVariationalHex27 ()
void	testVariationalHex27MultipleSubdomains ()
void	testVariationalHex27Tangled ()
void	testVariationalPyramid5 ()
void	testVariationalPyramid13 ()
void	testVariationalPyramid14 ()
void	testVariationalPyramid18 ()
void	testVariationalPyramid18MultipleSubdomains ()

Detailed Description

Definition at line 161 of file mesh_smoother_test.C.

Member Function Documentation

CPPUNIT_TEST() [1/21]

MeshSmootherTest::CPPUNIT_TEST

(

testLaplaceQuad

)

CPPUNIT_TEST() [2/21]

MeshSmootherTest::CPPUNIT_TEST

(

testLaplaceTri

)

CPPUNIT_TEST() [3/21]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalEdge2

)

CPPUNIT_TEST() [4/21]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalEdge3

)

CPPUNIT_TEST() [5/21]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalEdge3MultipleSubdomains

)

CPPUNIT_TEST() [6/21]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalQuad

)

CPPUNIT_TEST() [7/21]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalQuadMultipleSubdomains

)

CPPUNIT_TEST() [8/21]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalQuadTangled

)

CPPUNIT_TEST() [9/21]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalTri3

)

CPPUNIT_TEST() [10/21]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalTri6

)

CPPUNIT_TEST() [11/21]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalTri6MultipleSubdomains

)

CPPUNIT_TEST() [12/21]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalHex8

)

CPPUNIT_TEST() [13/21]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalHex20

)

CPPUNIT_TEST() [14/21]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalHex27

)

CPPUNIT_TEST() [15/21]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalHex27Tangled

)

CPPUNIT_TEST() [16/21]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalHex27MultipleSubdomains

)

CPPUNIT_TEST() [17/21]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalPyramid5

)

CPPUNIT_TEST() [18/21]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalPyramid13

)

CPPUNIT_TEST() [19/21]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalPyramid14

)

CPPUNIT_TEST() [20/21]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalPyramid18

)

CPPUNIT_TEST() [21/21]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalPyramid18MultipleSubdomains

)

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 203 of file mesh_smoother_test.C.

{}

tearDown()

void MeshSmootherTest::tearDown ( )

inline

Definition at line 205 of file mesh_smoother_test.C.

{}

testLaplaceQuad()

void MeshSmootherTest::testLaplaceQuad ( )

inline

Definition at line 591 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 207 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 599 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 608 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 616 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 624 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 688 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 696 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 704 of file mesh_smoother_test.C.

References libMesh::HEX27, mesh, and TestCommWorld.

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

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

testVariationalHex27Tangled()

void MeshSmootherTest::testVariationalHex27Tangled ( )

inline

Definition at line 712 of file mesh_smoother_test.C.

References libMesh::HEX27, mesh, and TestCommWorld.

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

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

testVariationalHex8()

void MeshSmootherTest::testVariationalHex8 ( )

inline

Definition at line 680 of file mesh_smoother_test.C.

References libMesh::HEX8, mesh, and TestCommWorld.

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

    testVariationalSmoother(mesh, variational, HEX8);
  }

testVariationalPyramid13()

void MeshSmootherTest::testVariationalPyramid13 ( )

inline

Definition at line 728 of file mesh_smoother_test.C.

References mesh, libMesh::PYRAMID13, and TestCommWorld.

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

    testVariationalSmoother(mesh, variational, PYRAMID13);
  }

testVariationalPyramid14()

void MeshSmootherTest::testVariationalPyramid14 ( )

inline

Definition at line 736 of file mesh_smoother_test.C.

References mesh, libMesh::PYRAMID14, and TestCommWorld.

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

    testVariationalSmoother(mesh, variational, PYRAMID14);
  }

testVariationalPyramid18()

void MeshSmootherTest::testVariationalPyramid18 ( )

inline

Definition at line 744 of file mesh_smoother_test.C.

References mesh, libMesh::PYRAMID18, and TestCommWorld.

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

    testVariationalSmoother(mesh, variational, PYRAMID18);
  }

testVariationalPyramid18MultipleSubdomains()

void MeshSmootherTest::testVariationalPyramid18MultipleSubdomains ( )

inline

Definition at line 752 of file mesh_smoother_test.C.

References mesh, libMesh::PYRAMID18, and TestCommWorld.

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

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

testVariationalPyramid5()

void MeshSmootherTest::testVariationalPyramid5 ( )

inline

Definition at line 720 of file mesh_smoother_test.C.

References mesh, libMesh::PYRAMID5, and TestCommWorld.

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

    testVariationalSmoother(mesh, variational, PYRAMID5);
  }

testVariationalQuad()

void MeshSmootherTest::testVariationalQuad ( )

inline

Definition at line 632 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 640 of file mesh_smoother_test.C.

References mesh, libMesh::QUAD4, and TestCommWorld.

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

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

testVariationalQuadTangled()

void MeshSmootherTest::testVariationalQuadTangled ( )

inline

Definition at line 648 of file mesh_smoother_test.C.

References mesh, libMesh::QUAD4, and TestCommWorld.

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

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

testVariationalSmoother()

void MeshSmootherTest::testVariationalSmoother ( ReplicatedMesh &  mesh, VariationalMeshSmoother &  smoother, const ElemType  type, const bool  multiple_subdomains = false, const bool  tangle_mesh = false, const Real  tangle_damping_factor = 1.0  )

inline

Definition at line 273 of file mesh_smoother_test.C.

References libMesh::absolute_fuzzy_equals(), TIMPI::Communicator::broadcast(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_line(), libMesh::MeshTools::Generation::build_square(), libMesh::ParallelObject::comm(), dim, libMesh::MeshBase::elem_default_orders(), libMesh::Utility::enum_to_string(), libMesh::ReferenceElem::get(), libMesh::MeshBase::get_boundary_info(), libMesh::VariationalMeshSmoother::get_mesh_info(), libMesh::DofObject::invalid_id, libMesh::libmesh_assert(), libMesh::make_range(), mesh, TIMPI::Communicator::minloc(), libMesh::MeshBase::node_ref(), libMesh::TensorTools::norm(), libMesh::PYRAMID18, libMesh::Real, libMesh::MeshTools::Modification::redistribute(), libMesh::relative_fuzzy_equals(), libMesh::VariationalMeshSmoother::setup(), libMesh::VariationalMeshSmoother::smooth(), libMesh::Parallel::sync_dofobject_data_by_id(), libMesh::TOLERANCE, and libMesh::Elem::type_to_default_order_map.

  {
    LOG_UNIT_TEST;

    if (multiple_subdomains && tangle_mesh)
      libmesh_not_implemented_msg(
          "Arbitrary mesh tangling with multiple subdomains is not supported.");

    // 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;
    const bool type_is_pyramid = Utility::enum_to_string(type).compare(0, 7, "PYRAMID") == 0;

    // Used fewer elems for higher order types, as extra midpoint nodes will add
    // enough complexity
    unsigned int n_elems_per_side = 4 / Elem::type_to_default_order_map[type];

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

    const auto & boundary_info = mesh.get_boundary_info();

    if (tangle_mesh)
      {
        // We tangle the mesh by (partially) swapping the locations of 2 nodes.
        // If the n-dimentional hypercube is represented as a grid with
        // (undistorted) divisions occuring at integer numbers, we will
        // (partially) swap the nodes nearest p1 = (1,1,1) and p2 = (2,1,2).

        // Define p1 and p2 given the integer indices
        // Undistorted elem side length
        const Real dr = 1. / (n_elems_per_side * Elem::type_to_default_order_map[type]);
        const Point p1 = Point(dr, dim > 1 ? dr : 0, dim > 2 ? dr : 0);
        const Point p2 = Point(2. * dr, dim > 1 ? dr : 0, dim > 2 ? 2. * dr : 0);

        // ids and distances of mesh nodes nearest p1 and p2
        dof_id_type node1_id = DofObject::invalid_id;
        Real dist1_closest = std::numeric_limits<Real>::max();
        dof_id_type node2_id = DofObject::invalid_id;
        Real dist2_closest = std::numeric_limits<Real>::max();

        for (const auto * node : mesh.local_node_ptr_range())
          {
            const auto dist1 = (*node - p1).norm();
            if (dist1 < dist1_closest)
              {
                dist1_closest = dist1;
                node1_id = node->id();
              }

            const auto dist2 = (*node - p2).norm();
            if (dist2 < dist2_closest)
              {
                dist2_closest = dist2;
                node2_id = node->id();
              }
          }

        // parallel communication
        unsigned int node1_rank;
        mesh.comm().minloc(dist1_closest, node1_rank);
        mesh.comm().broadcast(node1_id, node1_rank);

        unsigned int node2_rank;
        mesh.comm().minloc(dist2_closest, node2_rank);
        mesh.comm().broadcast(node2_id, node2_rank);

        // modify the nodes
        if ((node1_id != DofObject::invalid_id) && (node2_id != DofObject::invalid_id))
          {
            libmesh_assert(node1_id != node2_id);

            auto & node1 = mesh.node_ref(node1_id);
            auto & node2 = mesh.node_ref(node2_id);

            const Point diff = node1 - node2;
            // Note that a damping factor of 1 will swap the nodes and one
            // of 0.5 will move the nodes to the mean of their original
            // locations.
            node1 -= tangle_damping_factor * diff;
            node2 += tangle_damping_factor * diff;
          }

        SyncNodalPositions sync_object(mesh);
        Parallel::sync_dofobject_data_by_id (mesh.comm(), mesh.nodes_begin(), mesh.nodes_end(), sync_object);

        // Make sure the mesh is tangled
        smoother.setup(); // Need this to create the system we are about to access
        const auto & unsmoothed_info = smoother.get_mesh_info();
        CPPUNIT_ASSERT(unsmoothed_info.mesh_is_tangled);
      }

    // Add multiple subdomains if requested
    std::unordered_map<subdomain_id_type, Real> distorted_subdomain_volumes;
    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 volumes.
        for (auto * elem : mesh.active_element_ptr_range())
          distorted_subdomain_volumes[elem->subdomain_id()] += elem->volume();
      }

    // 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!");
    // For pyramids, the factor 2 accounts for the account that cubes of side
    // length s are divided into pyramids of base side length s and height s/2.
    // The factor 4 lets us catch triangular face midpoint nodes for PYRAMID18 elements.
    const auto scale_factor = *elem_orders.begin() * (type_is_pyramid ? 2 * 4 : 1);

    // Function to assert the node distortion is as expected
    auto node_distortion_is = [&n_elems_per_side, &dim, &boundary_info, &scale_factor](
                             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 * scale_factor;
          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;
    };

    // Make sure our DistortHyperCube transformation has distorted the mesh
    for (auto node : mesh.node_ptr_range())
      CPPUNIT_ASSERT(node_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);
      }

    if (multiple_subdomains)
      {
        // Make sure the subdomain volumes didn't change. Although this doesn't
        // guarantee that the subdomain didn't change, it is a good indicator
        // and is friedly to sliding subdomain boundary nodes.
        std::unordered_map<subdomain_id_type, Real> smoothed_subdomain_volumes;
        for (auto * elem : mesh.active_element_ptr_range())
          smoothed_subdomain_volumes[elem->subdomain_id()] += elem->volume();

        for (const auto & pair : distorted_subdomain_volumes)
          {
            const auto & subdomain_id = pair.first;
            CPPUNIT_ASSERT(
                relative_fuzzy_equals(libmesh_map_find(distorted_subdomain_volumes, subdomain_id),
                                      libmesh_map_find(smoothed_subdomain_volumes, subdomain_id),
                                      TOLERANCE));
          }
      }
    else
      {
        // Make sure we're not too distorted anymore
        std::set<dof_id_type> nodes_checked;
        for (const auto * elem : mesh.active_element_ptr_range())
          {
            for (const auto local_node_id : make_range(elem->n_nodes()))
              {
                const auto & node = elem->node_ref(local_node_id);
                if (nodes_checked.find(node.id()) != nodes_checked.end())
                  continue;

                nodes_checked.insert(node.id());

                // Check for special case where pyramidal base-to-apex midpoint
                // nodes are not smoothed to the actual midpoints.
                if (type_is_pyramid)
                  {
                    if (local_node_id > 8 && local_node_id < 13)
                      {
                        // Base-Apex midpoint nodes
                        //
                        // Due to the nature of the pyramidal target element and the
                        // cubic nature of the test mesh, for a dilation weight o
                        // 0.5, smoothed base-apex midpoint nodes are smoothed to
                        // the point base + x * (apex - base) instead of
                        // base + 0.5 (apex - base), where x is in (0,1) and
                        // depends on the number of nodes in the element.
                        // We hard-code this check below.

                        const auto & base = elem->node_ref(local_node_id - 9);
                        const auto & apex = elem->node_ref(4);
                        const Real x = (type == PYRAMID18) ? 0.569332 : 0.549876;

                        CPPUNIT_ASSERT(node.relative_fuzzy_equals(base + x * (apex - base), 1e-3));
                        continue;
                      }
                    else if (local_node_id > 13)
                      {
                        // Triangular face midpoint nodes
                        //
                        // Due to the nature of the pyramidal target element and the
                        // cubic nature of the test mesh, for a dilation weight o
                        // 0.5, smoothed triangular face midpoint nodes are
                        // smoothed a weighted average of the constituent
                        // vertices instead of an unweighted average.
                        // We hard-code this check below.
                        const auto & base1 = elem->node_ref(local_node_id - 14);
                        const auto & base2 = elem->node_ref((local_node_id - 13) % 4);
                        const auto & apex = elem->node_ref(4);

                        const auto node_approx = (0.3141064847 * base1 +
                                                  0.3141064847 * base2 +
                                                  0.3717870306 * apex);
                        CPPUNIT_ASSERT(node.relative_fuzzy_equals(node_approx, 1e-3));
                        continue;
                      }
                  }

                CPPUNIT_ASSERT(node_distortion_is(node, false, 1e-2));

              }
          }
      }
  }

testVariationalTri3()

void MeshSmootherTest::testVariationalTri3 ( )

inline

Definition at line 656 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 664 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 672 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