SlitMeshRefinedSystemTest Class Reference

Inheritance diagram for SlitMeshRefinedSystemTest:

Public Member Functions
	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 ()
	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
EquationSystems *	_es
Mesh *	_mesh

Detailed Description

Definition at line 236 of file slit_mesh_test.C.

Member Function Documentation

build_mesh()

void SlitMeshTest::build_mesh ( )

inlineprotectedinherited

Definition at line 79 of file slit_mesh_test.C.

  {
    _mesh = new Mesh(*TestCommWorld);
 
    // (0,1)           (1,1)           (2,1)
    // x---------------x---------------x
    // |               |               |
    // |               |               |
    // |               |               |
    // |               |               |
    // |               |               |
    // x---------------x---------------x
    // (0,0)           (1,0)          (2,0)
    // |               |               |
    // |               |               |
    // |               |               |
    // |               |               |
    // x---------------x---------------x
    // (0,-1)          (1,-1)         (2,-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 );
    _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 );
 
    {
      Elem* elem_top_left = new Quad4;
      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_top_left->set_id() = 0;
      _mesh->add_elem(elem_top_left);
 
      Elem* elem_bottom_left = new Quad4;
      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_bottom_left->set_id() = 1;
      _mesh->add_elem(elem_bottom_left);
 
      Elem* elem_top_right = new Quad4;
      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_top_right->set_id() = 2;
      _mesh->add_elem(elem_top_right);
 
      Elem* elem_bottom_right = new Quad4;
      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_bottom_right->set_id() = 3;
      _mesh->add_elem(elem_bottom_right);
    }
 
    // libMesh shouldn't renumber, or our based-on-initial-id
    // assertions later may fail.
    _mesh->allow_renumbering(false);
 
    _mesh->prepare_for_use();
  }

References libMesh::DistributedMesh::add_elem(), libMesh::DistributedMesh::add_point(), libMesh::MeshBase::allow_renumbering(), libMesh::DistributedMesh::node_ptr(), libMesh::MeshBase::prepare_for_use(), libMesh::DofObject::set_id(), libMesh::MeshBase::set_mesh_dimension(), libMesh::Elem::set_node(), and TestCommWorld.

CPPUNIT_TEST() [1/3]

SlitMeshRefinedSystemTest::CPPUNIT_TEST

(

testMesh

)

CPPUNIT_TEST() [2/3]

SlitMeshRefinedSystemTest::CPPUNIT_TEST

(

testRestart

)

CPPUNIT_TEST() [3/3]

SlitMeshRefinedSystemTest::CPPUNIT_TEST

(

testSystem

)

CPPUNIT_TEST_SUITE() [1/2]

SlitMeshRefinedSystemTest::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.

CPPUNIT_TEST_SUITE() [2/2]

SlitMeshTest::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.

CPPUNIT_TEST_SUITE_END()

SlitMeshRefinedSystemTest::CPPUNIT_TEST_SUITE_END

(

)

setUp()

void SlitMeshRefinedSystemTest::setUp ( )

inline

Definition at line 264 of file slit_mesh_test.C.

  {
#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 = new 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
  }

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::FIRST, libMesh::EquationSystems::init(), libMesh::System::project_solution(), libMesh::EquationSystems::reinit(), and libMesh::MeshRefinement::uniformly_refine().

tearDown()

void SlitMeshRefinedSystemTest::tearDown ( )

inline

Definition at line 290 of file slit_mesh_test.C.

  {
    delete _es;
    // _sys is owned by _es
    delete _mesh;
  }

testMesh()

void SlitMeshRefinedSystemTest::testMesh ( )

inline

Definition at line 297 of file slit_mesh_test.C.

  {
#ifdef LIBMESH_ENABLE_AMR
    // We should have 84 total and 64 active elements.
    CPPUNIT_ASSERT_EQUAL( (dof_id_type)(4+16+64), _mesh->n_elem() );
    CPPUNIT_ASSERT_EQUAL( (dof_id_type)64, _mesh->n_active_elem() );
 
    // We should have 88 nodes
    CPPUNIT_ASSERT_EQUAL( (dof_id_type)88, _mesh->n_nodes() );
#endif
  }

testRestart()

void SlitMeshRefinedSystemTest::testRestart ( )

inline

Definition at line 343 of file slit_mesh_test.C.

  {
    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->centroid());
        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);
          }
      }
  }

References libMesh::DistributedMesh::active_local_element_ptr_range(), 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(), libMesh::TypeVector< T >::size(), TestCommWorld, libMesh::TOLERANCE, libMesh::DofObject::unique_id(), libMesh::EquationSystems::write(), libMesh::EquationSystems::WRITE_DATA, and libMesh::EquationSystems::WRITE_SERIAL_FILES.

testSystem()

void SlitMeshRefinedSystemTest::testSystem ( )

inline

Definition at line 309 of file slit_mesh_test.C.

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

References dim, libMesh::FEGenericBase< OutputType >::get_phi(), libMesh::FEAbstract::get_xyz(), libMesh::libmesh_real(), libMesh::System::n_vars(), and libMesh::TOLERANCE.

Member Data Documentation

_es

EquationSystems* SlitMeshRefinedSystemTest::_es

protected

Definition at line 260 of file slit_mesh_test.C.

_mesh

Mesh* SlitMeshTest::_mesh

protectedinherited

Definition at line 77 of file slit_mesh_test.C.

_sys

System* SlitMeshRefinedSystemTest::_sys

protected

Definition at line 259 of file slit_mesh_test.C.

---

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

• tests/mesh/slit_mesh_test.C