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 (testVariationalQuad)
	CPPUNIT_TEST (testVariationalTri)
	CPPUNIT_TEST (testVariationalQuadMultipleSubdomains)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
void	testSmoother (ReplicatedMesh &mesh, MeshSmoother &smoother, const ElemType type, const bool multiple_subdomains=false)
void	testLaplaceQuad ()
void	testLaplaceTri ()
void	testVariationalQuad ()
void	testVariationalTri ()
void	testVariationalQuadMultipleSubdomains ()

Detailed Description

Definition at line 94 of file mesh_smoother_test.C.

Member Function Documentation

CPPUNIT_TEST() [1/5]

MeshSmootherTest::CPPUNIT_TEST

(

testLaplaceQuad

)

CPPUNIT_TEST() [2/5]

MeshSmootherTest::CPPUNIT_TEST

(

testLaplaceTri

)

CPPUNIT_TEST() [3/5]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalQuad

)

CPPUNIT_TEST() [4/5]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalTri

)

CPPUNIT_TEST() [5/5]

MeshSmootherTest::CPPUNIT_TEST

(

testVariationalQuadMultipleSubdomains

)

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

{}

tearDown()

void MeshSmootherTest::tearDown ( )

inline

Definition at line 118 of file mesh_smoother_test.C.

{}

testLaplaceQuad()

void MeshSmootherTest::testLaplaceQuad ( )

inline

Definition at line 279 of file mesh_smoother_test.C.

References mesh, libMesh::QUAD4, and TestCommWorld.

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

    testSmoother(mesh, laplace, QUAD4);
  }

testLaplaceTri()

void MeshSmootherTest::testLaplaceTri ( )

inline

Definition at line 288 of file mesh_smoother_test.C.

References mesh, TestCommWorld, and libMesh::TRI3.

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

    testSmoother(mesh, laplace, TRI3);
  }

testSmoother()

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

inline

Definition at line 120 of file mesh_smoother_test.C.

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

  {
    LOG_UNIT_TEST;

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

    std::unordered_map<dof_id_type, Point> subdomain_boundary_node_id_to_point;
    if (multiple_subdomains)
    {
      // Increment the subdomain id on the right half by 1
      for (auto * elem : mesh.active_element_ptr_range())
        if (elem->vertex_average()(0) > 0.5)
          ++elem->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]));
        }
      }

    const auto & boundary_info = mesh.get_boundary_info();

    // Function to assert the distortion is as expected
    auto center_distortion_is = [&boundary_info, n_elems_per_side]
      (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(-distortion_tol*distortion_tol, r);
      CPPUNIT_ASSERT_GREATER(-distortion_tol*distortion_tol, 1-r);

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

      // Boundary nodes are allowed to slide along the boundary.
      // However, nodes that are part of more than one boundary (i.e., corners) should remain fixed.

      // Get boundary ids associated with the node
      std::vector<boundary_id_type> boundary_ids;
      boundary_info.boundary_ids(&node, boundary_ids);

      switch (boundary_ids.size())
      {
        // Internal node
        case 0:
          return ((std::abs(R-std::round(R)) > distortion_tol) == distortion);
          break;
        // Sliding boundary node
        case 1:
          // Since sliding boundary nodes may or may not already be in the optimal
          // position, they may or may not be different from the originally distorted
          // mesh. Return true here to avoid issues.
          return true;
          break;
        // Fixed boundary node, should not have moved
        case 2:
          if (std::abs(node(0)) < distortion_tol*distortion_tol ||
              std::abs(node(0)-1) < distortion_tol*distortion_tol)
            {
              const Real R1 = node(1) * n_elems_per_side;
              CPPUNIT_ASSERT_LESS(distortion_tol*distortion_tol, std::abs(R1-std::round(R1)));
              return true;
            }

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

              return true;
            }
            return false;
          break;
          default:
            libmesh_error_msg("Node has unsupported number of boundary ids = " << boundary_ids.size());
      }
    };

    // Function to check if a given node has changed based on previous mapping
    auto is_internal_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 (Point(node) == subdomain_boundary_node_id_to_point[node.id()]);
      else
        // node is not an internal 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(center_distortion_is(*node, 0, true));
        CPPUNIT_ASSERT(center_distortion_is(*node, 1, 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
   const bool is_variational_smoother_type = (dynamic_cast<VariationalMeshSmoother*>(&smoother) != nullptr);
   if (type == TRI3 && is_variational_smoother_type)
    {
      SquareToParallelogram stp;
      MeshTools::Modification::redistribute(mesh, stp);
    }

    // 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.
    const unsigned int num_iterations = is_variational_smoother_type ? 1 : 8;
    for (unsigned int i=0; i != num_iterations; ++i)
      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 == TRI3 && is_variational_smoother_type)
    {
      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_internal_subdomain_boundary_node_the_same(*node));
        }
        else
        {
          CPPUNIT_ASSERT(center_distortion_is(*node, 0, false, 1e-3));
          CPPUNIT_ASSERT(center_distortion_is(*node, 1, false, 1e-3));
        }
      }
  }

testVariationalQuad()

void MeshSmootherTest::testVariationalQuad ( )

inline

Definition at line 298 of file mesh_smoother_test.C.

References mesh, libMesh::QUAD4, and TestCommWorld.

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

    testSmoother(mesh, variational, QUAD4);
  }

testVariationalQuadMultipleSubdomains()

void MeshSmootherTest::testVariationalQuadMultipleSubdomains ( )

inline

Definition at line 315 of file mesh_smoother_test.C.

References mesh, libMesh::QUAD4, and TestCommWorld.

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

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

testVariationalTri()

void MeshSmootherTest::testVariationalTri ( )

inline

Definition at line 307 of file mesh_smoother_test.C.

References mesh, TestCommWorld, and libMesh::TRI3.

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

    testSmoother(mesh, variational, TRI3);
  }

---

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

• tests/mesh/mesh_smoother_test.C