SlitMeshRefinedSystemTest Class Reference

Inheritance diagram for SlitMeshRefinedSystemTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (SlitMeshRefinedSystemTest)
	The goal of this test is the same as the previous, but now we create a system and set dof values to make sure they are properly interpolated after refinement. More...
	CPPUNIT_TEST (testMesh)
	CPPUNIT_TEST (testSystem)
	CPPUNIT_TEST (testRestart)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
void	testMesh ()
void	testSystem ()
void	testRestart ()
	LIBMESH_CPPUNIT_TEST_SUITE (SlitMeshTest)
	The goal of this test is to ensure that a 2D mesh with nodes overlapping on opposite sides of an internal, "slit" edge is usable. More...

Protected Member Functions
void	build_mesh ()

Protected Attributes
System *	_sys
std::unique_ptr< EquationSystems >	_es
std::unique_ptr< Mesh >	_mesh

Detailed Description

Definition at line 268 of file slit_mesh_test.C.

Member Function Documentation

build_mesh()

void SlitMeshTest::build_mesh ( )

inlineprotectedinherited

Definition at line 90 of file slit_mesh_test.C.

References libMesh::Elem::build_with_id(), libMesh::QUAD4, and libMesh::Elem::set_node().

  {
    _mesh = std::make_unique<Mesh>(*TestCommWorld);

    // (-1,1)     (0,1)      (1,1)      (2,1)      (3,1)
    // o----------o----------o----------o----------o
    // |          |          |          |          |
    // |          |          |          |          |
    // |          |          |          |          |
    // |          |          |          |          |
    // o----------o==========8==========o----------o
    // (-1,0)     (0,0)      (1,0)      (2,0)      (3,0)
    // |          |          |          |          |
    // |          |          |          |          |
    // |          |          |          |          |
    // o----------o----------o----------o----------o
    // (-1,-1)    (0,-1)     (1,-1)     (2,-1)     (3,-1)

    _mesh->set_mesh_dimension(2);

    _mesh->add_point( Point(0.0, 0.0), 0 );
    _mesh->add_point( Point(1.0, 0.0), 1 );
    _mesh->add_point( Point(1.0, 1.0), 2 );
    _mesh->add_point( Point(0.0, 1.0), 3 );
    _mesh->add_point( Point(0.0,-1.0), 4 );
    _mesh->add_point( Point(1.0,-1.0), 5 );
    _mesh->add_point( Point(1.0, 0.0), 6 ); // Doubled!
    _mesh->add_point( Point(2.0, 0.0), 7 );
    _mesh->add_point( Point(2.0, 1.0), 8 );
    _mesh->add_point( Point(2.0,-1.0), 9 );
    _mesh->add_point( Point(-1.0,-1.0), 10);
    _mesh->add_point( Point(-1.0, 0.0), 11);
    _mesh->add_point( Point(-1.0, 1.0), 12);
    _mesh->add_point( Point(3.0,-1.0), 13);
    _mesh->add_point( Point(3.0, 0.0), 14);
    _mesh->add_point( Point(3.0, 1.0), 15);

    {
      Elem * elem_top_left = _mesh->add_elem(Elem::build_with_id(QUAD4, 0));
      elem_top_left->set_node(0, _mesh->node_ptr(0));
      elem_top_left->set_node(1, _mesh->node_ptr(1));
      elem_top_left->set_node(2, _mesh->node_ptr(2));
      elem_top_left->set_node(3, _mesh->node_ptr(3));

      Elem * elem_bottom_left = _mesh->add_elem(Elem::build_with_id(QUAD4, 1));
      elem_bottom_left->set_node(0, _mesh->node_ptr(4));
      elem_bottom_left->set_node(1, _mesh->node_ptr(5));
      elem_bottom_left->set_node(2, _mesh->node_ptr(6));
      elem_bottom_left->set_node(3, _mesh->node_ptr(0));

      Elem * elem_top_right = _mesh->add_elem(Elem::build_with_id(QUAD4, 2));
      elem_top_right->set_node(0, _mesh->node_ptr(1));
      elem_top_right->set_node(1, _mesh->node_ptr(7));
      elem_top_right->set_node(2, _mesh->node_ptr(8));
      elem_top_right->set_node(3, _mesh->node_ptr(2));

      Elem * elem_bottom_right = _mesh->add_elem(Elem::build_with_id(QUAD4, 3));
      elem_bottom_right->set_node(0, _mesh->node_ptr(5));
      elem_bottom_right->set_node(1, _mesh->node_ptr(9));
      elem_bottom_right->set_node(2, _mesh->node_ptr(7));
      elem_bottom_right->set_node(3, _mesh->node_ptr(6));

      Elem * elem_top_leftleft = _mesh->add_elem(Elem::build_with_id(QUAD4, 4));
      elem_top_leftleft->set_node(0, _mesh->node_ptr(11));
      elem_top_leftleft->set_node(1, _mesh->node_ptr(0));
      elem_top_leftleft->set_node(2, _mesh->node_ptr(3));
      elem_top_leftleft->set_node(3, _mesh->node_ptr(12));

      Elem * elem_bottom_leftleft = _mesh->add_elem(Elem::build_with_id(QUAD4, 5));
      elem_bottom_leftleft->set_node(0, _mesh->node_ptr(10));
      elem_bottom_leftleft->set_node(1, _mesh->node_ptr(4));
      elem_bottom_leftleft->set_node(2, _mesh->node_ptr(0));
      elem_bottom_leftleft->set_node(3, _mesh->node_ptr(11));

      Elem * elem_top_rightright = _mesh->add_elem(Elem::build_with_id(QUAD4, 6));
      elem_top_rightright->set_node(0, _mesh->node_ptr(7));
      elem_top_rightright->set_node(1, _mesh->node_ptr(14));
      elem_top_rightright->set_node(2, _mesh->node_ptr(15));
      elem_top_rightright->set_node(3, _mesh->node_ptr(8));

      Elem * elem_bottom_rightright = _mesh->add_elem(Elem::build_with_id(QUAD4, 7));
      elem_bottom_rightright->set_node(0, _mesh->node_ptr(9));
      elem_bottom_rightright->set_node(1, _mesh->node_ptr(13));
      elem_bottom_rightright->set_node(2, _mesh->node_ptr(14));
      elem_bottom_rightright->set_node(3, _mesh->node_ptr(7));
    }

    // libMesh shouldn't renumber, or our based-on-initial-id
    // assertions later may fail.
    _mesh->allow_renumbering(false);

    _mesh->prepare_for_use();
  }

CPPUNIT_TEST() [1/3]

SlitMeshRefinedSystemTest::CPPUNIT_TEST

(

testMesh

)

CPPUNIT_TEST() [2/3]

SlitMeshRefinedSystemTest::CPPUNIT_TEST

(

testSystem

)

CPPUNIT_TEST() [3/3]

SlitMeshRefinedSystemTest::CPPUNIT_TEST

(

testRestart

)

CPPUNIT_TEST_SUITE_END()

SlitMeshRefinedSystemTest::CPPUNIT_TEST_SUITE_END

(

)

LIBMESH_CPPUNIT_TEST_SUITE() [1/2]

SlitMeshTest::LIBMESH_CPPUNIT_TEST_SUITE ( SlitMeshTest  )

inherited

The goal of this test is to ensure that a 2D mesh with nodes overlapping on opposite sides of an internal, "slit" edge is usable.

The mesh has to be connected at more than one node on each side of the slit, however, to ensure that we can find point neighbors of each node.

LIBMESH_CPPUNIT_TEST_SUITE() [2/2]

SlitMeshRefinedSystemTest::LIBMESH_CPPUNIT_TEST_SUITE

(

SlitMeshRefinedSystemTest

)

The goal of this test is the same as the previous, but now we create a system and set dof values to make sure they are properly interpolated after refinement.

setUp()

void SlitMeshRefinedSystemTest::setUp ( )

inline

Definition at line 296 of file slit_mesh_test.C.

References libMesh::DofMap::add_algebraic_ghosting_functor(), libMesh::System::add_variable(), libMesh::FIRST, libMesh::System::get_dof_map(), libMesh::System::project_solution(), and libMesh::MeshRefinement::uniformly_refine().

  {
#if LIBMESH_DIM > 1
    this->build_mesh();

    // libMesh *should* renumber now, or a DistributedMesh might not
    // have contiguous ids, which is a requirement to write xda files.
    _mesh->allow_renumbering(true);

    _es = std::make_unique<EquationSystems>(*_mesh);
    _sys = &_es->add_system<System> ("SimpleSystem");
    _sys->add_variable("u", FIRST);

    // We're going to be integrating across the slit in the mesh, so
    // let's make sure we can *see* elements and data across the slit.
    _mesh->allgather();
    _sys->get_dof_map().add_algebraic_ghosting_functor
      (std::make_shared<OverlapCoupling>());
    _mesh->delete_remote_elements();

    _es->init();
    SlitFunc slitfunc;
    _sys->project_solution(&slitfunc);

#ifdef LIBMESH_ENABLE_AMR
    MeshRefinement(*_mesh).uniformly_refine(1);
    _es->reinit();
    MeshRefinement(*_mesh).uniformly_refine(1);
    _es->reinit();
#endif
#endif
  }

tearDown()

void SlitMeshRefinedSystemTest::tearDown ( )

inline

Definition at line 329 of file slit_mesh_test.C.

{}

testMesh()

void SlitMeshRefinedSystemTest::testMesh ( )

inline

Definition at line 331 of file slit_mesh_test.C.

  {
    LOG_UNIT_TEST;

#ifdef LIBMESH_ENABLE_AMR
    // We should have 168 total and 128 active elements.
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(8+32+128), _mesh->n_elem());
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(128), _mesh->n_active_elem());

    // We should have 160 nodes
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(160), _mesh->n_nodes());
#endif
  }

testRestart()

void SlitMeshRefinedSystemTest::testRestart ( )

inline

Definition at line 396 of file slit_mesh_test.C.

References dim, libMesh::FEGenericBase< OutputType >::get_phi(), libMesh::EquationSystems::get_system(), libMesh::FEAbstract::get_xyz(), libMesh::System::n_vars(), libMesh::Elem::node_ref(), libMesh::UnstructuredMesh::read(), libMesh::EquationSystems::read(), TestCommWorld, libMesh::TOLERANCE, libMesh::DofObject::unique_id(), libMesh::EquationSystems::WRITE_DATA, and libMesh::EquationSystems::WRITE_SERIAL_FILES.

  {
    LOG_UNIT_TEST;

    SlitFunc slitfunc;

    _mesh->write("slit_mesh.xda");
    _es->write("slit_solution.xda",
               EquationSystems::WRITE_DATA |
               EquationSystems::WRITE_SERIAL_FILES);

    Mesh mesh2(*TestCommWorld);
    mesh2.read("slit_mesh.xda");
    EquationSystems es2(mesh2);
    es2.read("slit_solution.xda");

    System & sys2 = es2.get_system<System> ("SimpleSystem");

    unsigned int dim = 2;

    CPPUNIT_ASSERT_EQUAL( sys2.n_vars(), 1u );

    FEMContext context(sys2);
    FEBase * fe = NULL;
    context.get_element_fe( 0, fe, dim );
    const std::vector<Point> & xyz = fe->get_xyz();
    fe->get_phi();

    // While we're in the middle of a unique id based test case, let's
    // make sure our unique ids were all read in correctly too.
    std::unique_ptr<PointLocatorBase> locator = _mesh->sub_point_locator();

    if (!_mesh->is_serial())
      locator->enable_out_of_mesh_mode();

    for (const auto & elem : mesh2.active_local_element_ptr_range())
      {
        const Elem * mesh1_elem = (*locator)(elem->vertex_average());
        if (mesh1_elem)
          {
            CPPUNIT_ASSERT_EQUAL( elem->unique_id(),
                                  mesh1_elem->unique_id() );

            for (unsigned int n=0; n != elem->n_nodes(); ++n)
              {
                const Node & node       = elem->node_ref(n);
                const Node & mesh1_node = mesh1_elem->node_ref(n);
                CPPUNIT_ASSERT_EQUAL( node.unique_id(),
                                      mesh1_node.unique_id() );
              }
          }

        context.pre_fe_reinit(sys2, elem);
        context.elem_fe_reinit();

        const unsigned int n_qp = xyz.size();

        for (unsigned int qp=0; qp != n_qp; ++qp)
          {
            const Number exact_val = slitfunc(context, xyz[qp]);

            const Number discrete_val = context.interior_value(0, qp);

            LIBMESH_ASSERT_NUMBERS_EQUAL
              (exact_val, discrete_val, TOLERANCE*TOLERANCE);
          }
      }
  }

testSystem()

void SlitMeshRefinedSystemTest::testSystem ( )

inline

Definition at line 345 of file slit_mesh_test.C.

References dim, libMesh::JumpErrorEstimator::estimate_error(), libMesh::FEGenericBase< OutputType >::get_phi(), libMesh::FEAbstract::get_xyz(), libMesh::JumpErrorEstimator::integrate_slits, libMesh::ErrorVector::mean(), libMesh::System::n_vars(), libMesh::Real, and libMesh::TOLERANCE.

  {
    LOG_UNIT_TEST;

    SlitFunc slitfunc;

    unsigned int dim = 2;

    CPPUNIT_ASSERT_EQUAL( _sys->n_vars(), 1u );

    FEMContext context(*_sys);
    FEBase * fe = NULL;
    context.get_element_fe( 0, fe, dim );
    const std::vector<Point> & xyz = fe->get_xyz();
    fe->get_phi();

    for (const auto & elem : _mesh->active_local_element_ptr_range())
      {
        context.pre_fe_reinit(*_sys, elem);
        context.elem_fe_reinit();

        const unsigned int n_qp = xyz.size();

        for (unsigned int qp=0; qp != n_qp; ++qp)
          {
            const Number exact_val = slitfunc(context, xyz[qp]);

            const Number discrete_val = context.interior_value(0, qp);

            LIBMESH_ASSERT_NUMBERS_EQUAL
              (exact_val, discrete_val, TOLERANCE*TOLERANCE);
          }
      }

    // We should have no discontinuities (beyond floating-point error)
    // between topologically connected elements
    DiscontinuityMeasure connected_dm;
    ErrorVector connected_err;
    connected_dm.estimate_error(*_sys, connected_err);
    const Real mean_connected_disc = connected_err.mean();
    CPPUNIT_ASSERT_LESS(Real(1e-14), mean_connected_disc);

    // We should be able to see the discontinuity along the slit
    DiscontinuityMeasure slit_dm;
    slit_dm.integrate_slits = true;
    ErrorVector slit_disc;
    slit_dm.estimate_error(*_sys, slit_disc);
    const Real mean_slit_disc = slit_disc.mean();
    CPPUNIT_ASSERT_GREATER(Real(1e-3), mean_slit_disc);
  }

Member Data Documentation

_es

std::unique_ptr<EquationSystems> SlitMeshRefinedSystemTest::_es

protected

Definition at line 292 of file slit_mesh_test.C.

_mesh

std::unique_ptr<Mesh> SlitMeshTest::_mesh

protectedinherited

Definition at line 88 of file slit_mesh_test.C.

_sys

System* SlitMeshRefinedSystemTest::_sys

protected

Definition at line 291 of file slit_mesh_test.C.

---

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

• tests/mesh/slit_mesh_test.C