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 264 of file slit_mesh_test.C.

Member Function Documentation

build_mesh()

void SlitMeshTest::build_mesh ( )

inlineprotectedinherited

Definition at line 86 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 292 of file slit_mesh_test.C.

References libMesh::System::add_variable(), libMesh::FIRST, 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);

    _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 318 of file slit_mesh_test.C.

{}

testMesh()

void SlitMeshRefinedSystemTest::testMesh ( )

inline

Definition at line 320 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 370 of file slit_mesh_test.C.

References dim, libMesh::FEGenericBase< OutputType >::get_phi(), libMesh::EquationSystems::get_system(), libMesh::FEAbstract::get_xyz(), libMesh::libmesh_real(), 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_FP_EQUAL(libmesh_real(exact_val),
                                    libmesh_real(discrete_val),
                                    TOLERANCE*TOLERANCE);
          }
      }
  }

testSystem()

void SlitMeshRefinedSystemTest::testSystem ( )

inline

Definition at line 334 of file slit_mesh_test.C.

References dim, libMesh::FEGenericBase< OutputType >::get_phi(), libMesh::FEAbstract::get_xyz(), libMesh::libmesh_real(), libMesh::System::n_vars(), 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_FP_EQUAL(libmesh_real(exact_val),
                                    libmesh_real(discrete_val),
                                    TOLERANCE*TOLERANCE);
          }
      }
  }

Member Data Documentation

_es

std::unique_ptr<EquationSystems> SlitMeshRefinedSystemTest::_es

protected

Definition at line 288 of file slit_mesh_test.C.

_mesh

std::unique_ptr<Mesh> SlitMeshTest::_mesh

protectedinherited

Definition at line 84 of file slit_mesh_test.C.

_sys

System* SlitMeshRefinedSystemTest::_sys

protected

Definition at line 287 of file slit_mesh_test.C.

---

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

• tests/mesh/slit_mesh_test.C