EquationSystemsTest Class Reference

Inheritance diagram for EquationSystemsTest:

Public Member Functions
	CPPUNIT_TEST_SUITE (EquationSystemsTest)
	CPPUNIT_TEST (testConstruction)
	CPPUNIT_TEST (testAddSystem)
	CPPUNIT_TEST (testInit)
	CPPUNIT_TEST (testPostInitAddSystem)
	CPPUNIT_TEST (testPostInitAddElem)
	CPPUNIT_TEST (testReinitWithNodeElem)
	CPPUNIT_TEST (testRefineThenReinitPreserveFlags)
	CPPUNIT_TEST (testRepartitionThenReinit)
	CPPUNIT_TEST (testDisableDefaultGhosting)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
void	testConstruction ()
void	testAddSystem ()
void	testInit ()
void	testPostInitAddSystem ()
void	testPostInitAddRealSystem ()
void	testPostInitAddElem ()
void	testReinitWithNodeElem ()
void	testRefineThenReinitPreserveFlags ()
void	testRepartitionThenReinit ()
void	testDisableDefaultGhosting ()

Detailed Description

Definition at line 34 of file equation_systems_test.C.

Member Function Documentation

CPPUNIT_TEST() [1/9]

EquationSystemsTest::CPPUNIT_TEST

(

testAddSystem

)

CPPUNIT_TEST() [2/9]

EquationSystemsTest::CPPUNIT_TEST

(

testConstruction

)

CPPUNIT_TEST() [3/9]

EquationSystemsTest::CPPUNIT_TEST

(

testDisableDefaultGhosting

)

CPPUNIT_TEST() [4/9]

EquationSystemsTest::CPPUNIT_TEST

(

testInit

)

CPPUNIT_TEST() [5/9]

EquationSystemsTest::CPPUNIT_TEST

(

testPostInitAddElem

)

CPPUNIT_TEST() [6/9]

EquationSystemsTest::CPPUNIT_TEST

(

testPostInitAddSystem

)

CPPUNIT_TEST() [7/9]

EquationSystemsTest::CPPUNIT_TEST

(

testRefineThenReinitPreserveFlags

)

CPPUNIT_TEST() [8/9]

EquationSystemsTest::CPPUNIT_TEST

(

testReinitWithNodeElem

)

CPPUNIT_TEST() [9/9]

EquationSystemsTest::CPPUNIT_TEST

(

testRepartitionThenReinit

)

CPPUNIT_TEST_SUITE()

EquationSystemsTest::CPPUNIT_TEST_SUITE

(

EquationSystemsTest

)

CPPUNIT_TEST_SUITE_END()

EquationSystemsTest::CPPUNIT_TEST_SUITE_END

(

)

setUp()

void EquationSystemsTest::setUp ( )

inline

Definition at line 57 of file equation_systems_test.C.

  {}

tearDown()

void EquationSystemsTest::tearDown ( )

inline

Definition at line 60 of file equation_systems_test.C.

  {}

testAddSystem()

void EquationSystemsTest::testAddSystem ( )

inline

Definition at line 71 of file equation_systems_test.C.

  {
    Mesh mesh(*TestCommWorld);
    EquationSystems es(mesh);
    /*System &sys = */es.add_system<System> ("SimpleSystem");
  }

References libMesh::EquationSystems::add_system(), mesh, and TestCommWorld.

testConstruction()

void EquationSystemsTest::testConstruction ( )

inline

Definition at line 65 of file equation_systems_test.C.

  {
    Mesh mesh(*TestCommWorld);
    EquationSystems es(mesh);
  }

References mesh, and TestCommWorld.

testDisableDefaultGhosting()

void EquationSystemsTest::testDisableDefaultGhosting ( )

inline

Definition at line 217 of file equation_systems_test.C.

  {
    Mesh mesh(*TestCommWorld);
    EquationSystems es(mesh);
 
    auto n_ghosts = [&mesh]() {
      return int(std::distance(mesh.ghosting_functors_begin(),
                               mesh.ghosting_functors_end()));
    };
 
    auto n_evaluables = [](System &sys) {
      return int(std::distance(sys.get_dof_map().algebraic_ghosting_functors_begin(),
                               sys.get_dof_map().algebraic_ghosting_functors_end()));
    };
 
    auto n_couplings = [](System &sys) {
      return int(std::distance(sys.get_dof_map().coupling_functors_begin(),
                               sys.get_dof_map().coupling_functors_end()));
    };
 
    // One default ghosting functor on the mesh
    CPPUNIT_ASSERT_EQUAL(n_ghosts(), 1);
 
    // Add another functor, making two
    auto gpn = std::make_shared<GhostPointNeighbors>(mesh);
    mesh.add_ghosting_functor(gpn);
    CPPUNIT_ASSERT_EQUAL(n_ghosts(), 2);
 
    // Remove the default, leaving just the user functor
    es.enable_default_ghosting(false);
    CPPUNIT_ASSERT_EQUAL(n_ghosts(), 1);
 
    // Which can be removed too
    mesh.remove_ghosting_functor(*gpn);
    CPPUNIT_ASSERT_EQUAL(n_ghosts(), 0);
 
    // Adding a new system shouldn't add any default ghosting if the
    // EquationSystems disabled it
    System & sys1 = es.add_system<System>("System1");
    CPPUNIT_ASSERT_EQUAL(n_ghosts(), 0);
    CPPUNIT_ASSERT_EQUAL(n_evaluables(sys1), 0);
    CPPUNIT_ASSERT_EQUAL(n_couplings(sys1), 0);
 
    // But if we reenable it then now we should have three functors,
    // with the default algebraic and coupling functors from sys1.
    //
    // We currently iterate over coupling functors manually even when
    // using them for evaluability... this test will need to change
    // eventually, when that does.
    es.enable_default_ghosting(true);
    CPPUNIT_ASSERT_EQUAL(n_ghosts(), 3);
    CPPUNIT_ASSERT_EQUAL(n_evaluables(sys1), 1);
    CPPUNIT_ASSERT_EQUAL(n_couplings(sys1), 1);
 
    // Adding a second system with default ghosting reenabled should
    // give us 2 more functors.
    System & sys2 = es.add_system<System>("System2");
    CPPUNIT_ASSERT_EQUAL(n_ghosts(), 5);
    CPPUNIT_ASSERT_EQUAL(n_evaluables(sys2), 1);
    CPPUNIT_ASSERT_EQUAL(n_couplings(sys2), 1);
 
    // Adding a user functor to evaluables and couplings should add it
    // to the mesh
    GhostPointNeighbors gpn2(mesh);
    sys1.get_dof_map().add_algebraic_ghosting_functor(gpn2);
    CPPUNIT_ASSERT_EQUAL(n_ghosts(), 6);
    CPPUNIT_ASSERT_EQUAL(n_evaluables(sys1), 2);
    CPPUNIT_ASSERT_EQUAL(n_couplings(sys1), 1);
 
    // Unless we say not to.
    auto gpn3 = std::make_shared<GhostPointNeighbors>(mesh);
    sys1.get_dof_map().add_coupling_functor(gpn3, /*to_mesh=*/false);
    CPPUNIT_ASSERT_EQUAL(n_ghosts(), 6);
    CPPUNIT_ASSERT_EQUAL(n_evaluables(sys1), 2);
    CPPUNIT_ASSERT_EQUAL(n_couplings(sys1), 2);
 
    // Turning off default coupling again should get rid of everything
    // except the user functors.
    es.enable_default_ghosting(false);
    CPPUNIT_ASSERT_EQUAL(n_ghosts(), 1);
    CPPUNIT_ASSERT_EQUAL(n_evaluables(sys1), 1);
    CPPUNIT_ASSERT_EQUAL(n_couplings(sys1), 1);
    CPPUNIT_ASSERT_EQUAL(n_evaluables(sys2), 0);
    CPPUNIT_ASSERT_EQUAL(n_couplings(sys2), 0);
  }

References libMesh::DofMap::add_algebraic_ghosting_functor(), libMesh::DofMap::add_coupling_functor(), libMesh::MeshBase::add_ghosting_functor(), libMesh::EquationSystems::add_system(), distance(), libMesh::EquationSystems::enable_default_ghosting(), libMesh::System::get_dof_map(), libMesh::MeshBase::ghosting_functors_begin(), libMesh::MeshBase::ghosting_functors_end(), int, mesh, libMesh::MeshBase::remove_ghosting_functor(), and TestCommWorld.

testInit()

void EquationSystemsTest::testInit ( )

inline

Definition at line 78 of file equation_systems_test.C.

  {
    Mesh mesh(*TestCommWorld);
    EquationSystems es(mesh);
    /*System &sys = */es.add_system<System> ("SimpleSystem");
    MeshTools::Generation::build_point(mesh);
    es.init();
  }

References libMesh::EquationSystems::add_system(), libMesh::MeshTools::Generation::build_point(), libMesh::EquationSystems::init(), mesh, and TestCommWorld.

testPostInitAddElem()

void EquationSystemsTest::testPostInitAddElem ( )

inline

Definition at line 111 of file equation_systems_test.C.

  {
    ReplicatedMesh mesh(*TestCommWorld);
 
    EquationSystems es(mesh);
    System &sys = es.add_system<System> ("SimpleSystem");
    sys.add_variable("u", FIRST);
 
    MeshTools::Generation::build_line (mesh, 10, 0., 1., EDGE2);
    es.init();
 
    Elem* e = Elem::build(EDGE2).release();
    e->set_id(mesh.max_elem_id());
    e->processor_id() = 0;
    e->set_node(0) = mesh.node_ptr(2);
    e->set_node(1) = mesh.node_ptr(8);
    mesh.add_elem(e);
    mesh.prepare_for_use();
 
    es.reinit();
  }

References libMesh::MeshBase::add_elem(), libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::Elem::build(), libMesh::MeshTools::Generation::build_line(), libMesh::EDGE2, libMesh::FIRST, libMesh::EquationSystems::init(), libMesh::MeshBase::max_elem_id(), mesh, libMesh::MeshBase::node_ptr(), libMesh::MeshBase::prepare_for_use(), libMesh::DofObject::processor_id(), libMesh::EquationSystems::reinit(), libMesh::DofObject::set_id(), libMesh::Elem::set_node(), and TestCommWorld.

testPostInitAddRealSystem()

void EquationSystemsTest::testPostInitAddRealSystem ( )

inline

Definition at line 98 of file equation_systems_test.C.

  {
    Mesh mesh(*TestCommWorld);
    MeshTools::Generation::build_point(mesh);
    EquationSystems es(mesh);
    System &sys1 = es.add_system<System> ("SimpleSystem");
    sys1.add_variable("u1", FIRST);
    es.init();
    System &sys2 = es.add_system<System> ("SecondSystem");
    sys2.add_variable("u2", FIRST);
    es.reinit();
  }

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshTools::Generation::build_point(), libMesh::FIRST, libMesh::EquationSystems::init(), mesh, libMesh::EquationSystems::reinit(), and TestCommWorld.

testPostInitAddSystem()

void EquationSystemsTest::testPostInitAddSystem ( )

inline

Definition at line 87 of file equation_systems_test.C.

  {
    Mesh mesh(*TestCommWorld);
    MeshTools::Generation::build_point(mesh);
    EquationSystems es(mesh);
    /*System &sys1 = */es.add_system<System> ("SimpleSystem");
    es.init();
    /*System &sys2 = */es.add_system<System> ("SecondSystem");
    es.reinit();
  }

References libMesh::EquationSystems::add_system(), libMesh::MeshTools::Generation::build_point(), libMesh::EquationSystems::init(), mesh, libMesh::EquationSystems::reinit(), and TestCommWorld.

testRefineThenReinitPreserveFlags()

void EquationSystemsTest::testRefineThenReinitPreserveFlags ( )

inline

Definition at line 149 of file equation_systems_test.C.

  {
    // This test requires AMR support since it sets refinement flags.
#ifdef LIBMESH_ENABLE_AMR
    Mesh mesh(*TestCommWorld);
    mesh.allow_renumbering(false);
    EquationSystems es(mesh);
    System & sys = es.add_system<System> ("SimpleSystem");
    sys.add_variable("u", FIRST);
    MeshTools::Generation::build_square(mesh,2,1);
    es.init();
 
    Elem * to_refine = mesh.query_elem_ptr(0);
    if (to_refine)
      to_refine->set_refinement_flag(Elem::REFINE);
 
    MeshRefinement mr(mesh);
    mr.refine_elements();
    es.disable_refine_in_reinit();
    es.reinit();
 
    if (mesh.query_elem_ptr(1))
      CPPUNIT_ASSERT( mesh.elem_ptr(1)->active() );
 
    const Elem * elem = mesh.query_elem_ptr(0);
    if (elem)
      {
        CPPUNIT_ASSERT_EQUAL( Elem::INACTIVE,elem->refinement_flag() );
 
        for (unsigned int c=0; c<elem->n_children(); c++)
          if (elem->child_ptr(c) != remote_elem)
            CPPUNIT_ASSERT_EQUAL(Elem::JUST_REFINED,
                                 elem->child_ptr(c)->refinement_flag());
      }
#endif
  }

References libMesh::Elem::active(), libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshBase::allow_renumbering(), libMesh::MeshTools::Generation::build_square(), libMesh::Elem::child_ptr(), libMesh::EquationSystems::disable_refine_in_reinit(), libMesh::MeshBase::elem_ptr(), libMesh::FIRST, libMesh::Elem::INACTIVE, libMesh::EquationSystems::init(), libMesh::Elem::JUST_REFINED, mesh, libMesh::Elem::n_children(), libMesh::MeshBase::query_elem_ptr(), libMesh::Elem::REFINE, libMesh::MeshRefinement::refine_elements(), libMesh::Elem::refinement_flag(), libMesh::EquationSystems::reinit(), libMesh::remote_elem, libMesh::Elem::set_refinement_flag(), and TestCommWorld.

testReinitWithNodeElem()

void EquationSystemsTest::testReinitWithNodeElem ( )

inline

Definition at line 133 of file equation_systems_test.C.

  {
    ReplicatedMesh mesh(*TestCommWorld);
 
    MeshTools::Generation::build_line (mesh, 10, 0., 1., EDGE2);
    Elem* node_elem = mesh.add_elem (new NodeElem);
    node_elem->set_node(0) = mesh.node_ptr(0);
    mesh.prepare_for_use();
 
    EquationSystems es(mesh);
    System &sys = es.add_system<System> ("SimpleSystem");
    sys.add_variable("u", CONSTANT, MONOMIAL);
    es.init();
    es.reinit();
  }

References libMesh::MeshBase::add_elem(), libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshTools::Generation::build_line(), libMesh::CONSTANT, libMesh::EDGE2, libMesh::EquationSystems::init(), mesh, libMesh::MONOMIAL, libMesh::MeshBase::node_ptr(), libMesh::MeshBase::prepare_for_use(), libMesh::EquationSystems::reinit(), libMesh::Elem::set_node(), and TestCommWorld.

testRepartitionThenReinit()

void EquationSystemsTest::testRepartitionThenReinit ( )

inline

Definition at line 188 of file equation_systems_test.C.

  {
    Mesh mesh(*TestCommWorld);
    mesh.allow_renumbering(false);
    EquationSystems es(mesh);
    System & sys = es.add_system<System> ("SimpleSystem");
    sys.add_variable("u", FIRST);
    MeshTools::Generation::build_square(mesh,5,5);
    es.init();
    sys.project_solution(bilinear_test, NULL, es.parameters);
 
    // Force (in parallel) a different partitioning - we'll simply put
    // everything on rank 0, which hopefully is not what our default
    // partitioner did!
    mesh.partition(1);
 
    // Make sure the solution is still intact after reinit
    es.reinit();
 
    for (Real x = 0.1; x < 1; x += 0.2)
      for (Real y = 0.1; y < 1; y += 0.2)
        {
          Point p(x,y);
          LIBMESH_ASSERT_FP_EQUAL(libmesh_real(sys.point_value(0,p)),
                                  libmesh_real(bilinear_test(p,es.parameters,"","")),
                                  TOLERANCE*TOLERANCE);
        }
  }

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshBase::allow_renumbering(), libMesh::MeshTools::Generation::build_square(), libMesh::FIRST, libMesh::EquationSystems::init(), libMesh::libmesh_real(), mesh, libMesh::EquationSystems::parameters, libMesh::MeshBase::partition(), libMesh::System::point_value(), libMesh::System::project_solution(), libMesh::Real, libMesh::EquationSystems::reinit(), TestCommWorld, and libMesh::TOLERANCE.

---

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

• tests/systems/equation_systems_test.C