SystemsTest Class Reference

Inheritance diagram for SystemsTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (SystemsTest)
	CPPUNIT_TEST (test100KVariables)
	CPPUNIT_TEST (testUninitializedInfo)
	CPPUNIT_TEST (testPostInitAddVector)
	CPPUNIT_TEST (testAddVectorProjChange)
	CPPUNIT_TEST (testAddVectorTypeChange)
	CPPUNIT_TEST (testPostInitAddVectorTypeChange)
	CPPUNIT_TEST (testProjectHierarchicEdge3)
	CPPUNIT_TEST (testProjectHierarchicQuad9)
	CPPUNIT_TEST (testProjectHierarchicTri6)
	CPPUNIT_TEST (testProjectHierarchicTri7)
	CPPUNIT_TEST (test2DProjectVectorFETri3)
	CPPUNIT_TEST (test2DProjectVectorFEQuad4)
	CPPUNIT_TEST (test2DProjectVectorFETri6)
	CPPUNIT_TEST (test2DProjectVectorFETri7)
	CPPUNIT_TEST (test2DProjectVectorFEQuad8)
	CPPUNIT_TEST (test2DProjectVectorFEQuad9)
	CPPUNIT_TEST (testBlockRestrictedVarNDofs)
	CPPUNIT_TEST (testFirstScalarNumber)
	CPPUNIT_TEST (testProjectHierarchicHex27)
	CPPUNIT_TEST (testProjectMeshFunctionHex27)
	CPPUNIT_TEST (testBoundaryProjectCube)
	CPPUNIT_TEST (test3DProjectVectorFETet4)
	CPPUNIT_TEST (test3DProjectVectorFEHex8)
	CPPUNIT_TEST (test3DProjectVectorFETet10)
	CPPUNIT_TEST (test3DProjectVectorFETet14)
	CPPUNIT_TEST (test3DProjectVectorFEHex20)
	CPPUNIT_TEST (test3DProjectVectorFEHex27)
	CPPUNIT_TEST (testSetSystemParameterOverEquationSystem)
	CPPUNIT_TEST (testAssemblyWithDgFemContext)
	CPPUNIT_TEST (testDofCouplingWithVarGroups)
	CPPUNIT_TEST (testProjectScalarCoarsening)
	CPPUNIT_TEST (testProjectMatrixEdge2)
	CPPUNIT_TEST (testProjectMatrixQuad4)
	CPPUNIT_TEST (testProjectMatrixTri3)
	CPPUNIT_TEST (testProjectMatrixHex8)
	CPPUNIT_TEST (testProjectMatrixTet4)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
ExplicitSystem &	simpleSetup (UnstructuredMesh &mesh, EquationSystems &es)
void	testFirstScalarNumber ()
void	test100KVariables ()
void	testUninitializedInfo ()
void	testPostInitAddVector ()
void	testAddVectorProjChange ()
void	testAddVectorTypeChange ()
void	testPostInitAddVectorTypeChange ()
void	testProjectLine (const ElemType elem_type)
void	testProjectScalarCoarsening ()
void	test2DProjectVectorFE (const ElemType elem_type)
void	test3DProjectVectorFE (const ElemType elem_type)
void	testProjectSquare (const ElemType elem_type)
void	testProjectCube (const ElemType elem_type)
void	testProjectCubeWithMeshFunction (const ElemType elem_type)
void	testBoundaryProjectCube ()
void	testDofCouplingWithVarGroups ()
void	testSetSystemParameterOverEquationSystem ()
void	testAssemblyWithDgFemContext ()
void	testBlockRestrictedVarNDofs ()
void	testProjectMatrix1D (const ElemType elem_type)
void	testProjectMatrix2D (const ElemType elem_type)
void	testProjectMatrix3D (const ElemType elem_type)
void	testProjectHierarchicEdge3 ()
void	testProjectHierarchicQuad9 ()
void	testProjectHierarchicTri6 ()
void	testProjectHierarchicTri7 ()
void	testProjectHierarchicHex27 ()
void	testProjectMeshFunctionHex27 ()
void	test2DProjectVectorFETri3 ()
void	test2DProjectVectorFEQuad4 ()
void	test2DProjectVectorFETri6 ()
void	test2DProjectVectorFETri7 ()
void	test2DProjectVectorFEQuad8 ()
void	test2DProjectVectorFEQuad9 ()
void	test3DProjectVectorFETet4 ()
void	test3DProjectVectorFEHex8 ()
void	test3DProjectVectorFETet10 ()
void	test3DProjectVectorFETet14 ()
void	test3DProjectVectorFEHex20 ()
void	test3DProjectVectorFEHex27 ()
void	testProjectMatrixEdge2 ()
void	testProjectMatrixQuad4 ()
void	testProjectMatrixTri3 ()
void	testProjectMatrixHex8 ()
void	testProjectMatrixTet4 ()

Private Member Functions
void	tripleValueTest (const Point &p, const TransientExplicitSystem &sys, const PointLocatorBase &locator, std::set< subdomain_id_type > &u_subdomains, std::set< subdomain_id_type > &v_subdomains, std::set< subdomain_id_type > &w_subdomains, const Parameters &param)

Detailed Description

Definition at line 442 of file systems_test.C.

Member Function Documentation

CPPUNIT_TEST() [1/36]

SystemsTest::CPPUNIT_TEST

(

test100KVariables

)

CPPUNIT_TEST() [2/36]

SystemsTest::CPPUNIT_TEST

(

test2DProjectVectorFEQuad4

)

CPPUNIT_TEST() [3/36]

SystemsTest::CPPUNIT_TEST

(

test2DProjectVectorFEQuad8

)

CPPUNIT_TEST() [4/36]

SystemsTest::CPPUNIT_TEST

(

test2DProjectVectorFEQuad9

)

CPPUNIT_TEST() [5/36]

SystemsTest::CPPUNIT_TEST

(

test2DProjectVectorFETri3

)

CPPUNIT_TEST() [6/36]

SystemsTest::CPPUNIT_TEST

(

test2DProjectVectorFETri6

)

CPPUNIT_TEST() [7/36]

SystemsTest::CPPUNIT_TEST

(

test2DProjectVectorFETri7

)

CPPUNIT_TEST() [8/36]

SystemsTest::CPPUNIT_TEST

(

test3DProjectVectorFEHex20

)

CPPUNIT_TEST() [9/36]

SystemsTest::CPPUNIT_TEST

(

test3DProjectVectorFEHex27

)

CPPUNIT_TEST() [10/36]

SystemsTest::CPPUNIT_TEST

(

test3DProjectVectorFEHex8

)

CPPUNIT_TEST() [11/36]

SystemsTest::CPPUNIT_TEST

(

test3DProjectVectorFETet10

)

CPPUNIT_TEST() [12/36]

SystemsTest::CPPUNIT_TEST

(

test3DProjectVectorFETet14

)

CPPUNIT_TEST() [13/36]

SystemsTest::CPPUNIT_TEST

(

test3DProjectVectorFETet4

)

CPPUNIT_TEST() [14/36]

SystemsTest::CPPUNIT_TEST

(

testAddVectorProjChange

)

CPPUNIT_TEST() [15/36]

SystemsTest::CPPUNIT_TEST

(

testAddVectorTypeChange

)

CPPUNIT_TEST() [16/36]

SystemsTest::CPPUNIT_TEST

(

testAssemblyWithDgFemContext

)

CPPUNIT_TEST() [17/36]

SystemsTest::CPPUNIT_TEST

(

testBlockRestrictedVarNDofs

)

CPPUNIT_TEST() [18/36]

SystemsTest::CPPUNIT_TEST

(

testBoundaryProjectCube

)

CPPUNIT_TEST() [19/36]

SystemsTest::CPPUNIT_TEST

(

testDofCouplingWithVarGroups

)

CPPUNIT_TEST() [20/36]

SystemsTest::CPPUNIT_TEST

(

testFirstScalarNumber

)

CPPUNIT_TEST() [21/36]

SystemsTest::CPPUNIT_TEST

(

testPostInitAddVector

)

CPPUNIT_TEST() [22/36]

SystemsTest::CPPUNIT_TEST

(

testPostInitAddVectorTypeChange

)

CPPUNIT_TEST() [23/36]

SystemsTest::CPPUNIT_TEST

(

testProjectHierarchicEdge3

)

CPPUNIT_TEST() [24/36]

SystemsTest::CPPUNIT_TEST

(

testProjectHierarchicHex27

)

CPPUNIT_TEST() [25/36]

SystemsTest::CPPUNIT_TEST

(

testProjectHierarchicQuad9

)

CPPUNIT_TEST() [26/36]

SystemsTest::CPPUNIT_TEST

(

testProjectHierarchicTri6

)

CPPUNIT_TEST() [27/36]

SystemsTest::CPPUNIT_TEST

(

testProjectHierarchicTri7

)

CPPUNIT_TEST() [28/36]

SystemsTest::CPPUNIT_TEST

(

testProjectMatrixEdge2

)

CPPUNIT_TEST() [29/36]

SystemsTest::CPPUNIT_TEST

(

testProjectMatrixHex8

)

CPPUNIT_TEST() [30/36]

SystemsTest::CPPUNIT_TEST

(

testProjectMatrixQuad4

)

CPPUNIT_TEST() [31/36]

SystemsTest::CPPUNIT_TEST

(

testProjectMatrixTet4

)

CPPUNIT_TEST() [32/36]

SystemsTest::CPPUNIT_TEST

(

testProjectMatrixTri3

)

CPPUNIT_TEST() [33/36]

SystemsTest::CPPUNIT_TEST

(

testProjectMeshFunctionHex27

)

CPPUNIT_TEST() [34/36]

SystemsTest::CPPUNIT_TEST

(

testProjectScalarCoarsening

)

CPPUNIT_TEST() [35/36]

SystemsTest::CPPUNIT_TEST

(

testSetSystemParameterOverEquationSystem

)

CPPUNIT_TEST() [36/36]

SystemsTest::CPPUNIT_TEST

(

testUninitializedInfo

)

CPPUNIT_TEST_SUITE_END()

SystemsTest::CPPUNIT_TEST_SUITE_END

(

)

LIBMESH_CPPUNIT_TEST_SUITE()

SystemsTest::LIBMESH_CPPUNIT_TEST_SUITE

(

SystemsTest

)

setUp()

void SystemsTest::setUp ( )

inline

Definition at line 568 of file systems_test.C.

  {}

simpleSetup()

ExplicitSystem & SystemsTest::simpleSetup ( UnstructuredMesh &  mesh, EquationSystems &  es  )

inline

Definition at line 575 of file systems_test.C.

  {
    ExplicitSystem &sys =
      es.add_system<ExplicitSystem> ("Simple");
 
    sys.add_variable("u", FIRST);
 
    MeshTools::Generation::build_line (mesh,
                                       10,
                                       0., 1.,
                                       EDGE3);
 
    return sys;
  }

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshTools::Generation::build_line(), libMesh::EDGE3, libMesh::FIRST, and mesh.

Referenced by testAddVectorProjChange(), testAddVectorTypeChange(), testPostInitAddVector(), testPostInitAddVectorTypeChange(), and testUninitializedInfo().

tearDown()

void SystemsTest::tearDown ( )

inline

Definition at line 571 of file systems_test.C.

  {}

test100KVariables()

void SystemsTest::test100KVariables ( )

inline

Definition at line 631 of file systems_test.C.

  {
    Mesh mesh(*TestCommWorld);
    EquationSystems es(mesh);
    ExplicitSystem &sys =
      es.add_system<ExplicitSystem> ("100KVars");
 
    dof_id_type n_dofs = 100000;
 
    // This takes 16 seconds in opt mode for me, 200 in dbg!?
    /*
    for (auto i : make_range(n_dofs))
      sys.add_variable(std::to_string(i), FIRST);
    */
 
    std::vector<std::string> var_names(n_dofs);
    for (auto i : make_range(n_dofs))
      var_names[i] = std::to_string(i);
 
    sys.add_variables(var_names, FIRST);
 
    MeshTools::Generation::build_line (mesh,
                                       4,
                                       0., 1.,
                                       EDGE3);
 
    es.init();
 
    CPPUNIT_ASSERT_EQUAL(sys.n_dofs(), n_dofs*5);
    for (const Node * node : mesh.node_ptr_range())
      CPPUNIT_ASSERT_EQUAL(dof_id_type(node->n_vars(0)), n_dofs);
 
    std::vector<dof_id_type> each = sys.get_dof_map().n_dofs_per_processor(888);
    CPPUNIT_ASSERT_EQUAL(std::accumulate(each.begin(), each.end(), dof_id_type(0)), dof_id_type(5));
    CPPUNIT_ASSERT_EQUAL(sys.get_dof_map().n_dofs(888), dof_id_type(5));
  }

References libMesh::EquationSystems::add_system(), libMesh::System::add_variables(), libMesh::MeshTools::Generation::build_line(), libMesh::EDGE3, libMesh::FIRST, libMesh::System::get_dof_map(), libMesh::EquationSystems::init(), libMesh::make_range(), mesh, libMesh::System::n_dofs(), libMesh::DofMap::n_dofs(), libMesh::DofMap::n_dofs_per_processor(), and TestCommWorld.

test2DProjectVectorFE()

void SystemsTest::test2DProjectVectorFE ( const ElemType  elem_type )

inline

Definition at line 893 of file systems_test.C.

  {
    Mesh mesh(*TestCommWorld);
 
    EquationSystems es(mesh);
    TransientExplicitSystem &sys =
      es.add_system<TransientExplicitSystem> ("SimpleSystem");
 
    auto u_var = sys.add_variable("u", Elem::type_to_default_order_map[elem_type], LAGRANGE_VEC);
 
    MeshTools::Generation::build_square (mesh,
                                         1, 1,
                                         0., 1., 0., 1.,
                                         elem_type);
 
    es.init();
 
    // Manually set-up the solution because I'm too lazy to set-up all the generic
    // function projection code right now
    for (const auto & node : mesh.local_node_ptr_range())
    {
      for (unsigned int i : make_range(Elem::type_to_dim_map[elem_type]))
      {
        auto dof_index = node->dof_number(sys.number(), u_var, i);
        sys.solution->set(dof_index, (*node)(i));
      }
    }
 
    // After setting values, we need to assemble
    sys.solution->close();
 
 
#ifdef LIBMESH_ENABLE_AMR
    for (auto & elem : mesh.element_ptr_range())
        elem->set_refinement_flag(Elem::REFINE);
    es.reinit();
#endif
 
    for (const auto & node : mesh.local_node_ptr_range())
    {
      // 2D element here
      for (unsigned int i : make_range(Elem::type_to_dim_map[elem_type]))
      {
        auto dof_index = node->dof_number(sys.number(), u_var, i);
        auto value = (*sys.solution)(dof_index);
        LIBMESH_ASSERT_NUMBERS_EQUAL(value, (*node)(i), TOLERANCE*TOLERANCE);
      }
    }
  }

References libMesh::EquationSystems::add_system(), libMesh::MeshTools::Generation::build_square(), libMesh::EquationSystems::init(), libMesh::LAGRANGE_VEC, libMesh::make_range(), mesh, libMesh::Elem::REFINE, libMesh::EquationSystems::reinit(), TestCommWorld, libMesh::TOLERANCE, libMesh::Elem::type_to_default_order_map, libMesh::Elem::type_to_dim_map, and value.

Referenced by test2DProjectVectorFEQuad4(), test2DProjectVectorFEQuad8(), test2DProjectVectorFEQuad9(), test2DProjectVectorFETri3(), test2DProjectVectorFETri6(), and test2DProjectVectorFETri7().

test2DProjectVectorFEQuad4()

void SystemsTest::test2DProjectVectorFEQuad4 ( )

inline

Definition at line 2007 of file systems_test.C.

{ LOG_UNIT_TEST; test2DProjectVectorFE(QUAD4); }

References libMesh::QUAD4, and test2DProjectVectorFE().

test2DProjectVectorFEQuad8()

void SystemsTest::test2DProjectVectorFEQuad8 ( )

inline

Definition at line 2010 of file systems_test.C.

{ LOG_UNIT_TEST; test2DProjectVectorFE(QUAD8); }

References libMesh::QUAD8, and test2DProjectVectorFE().

test2DProjectVectorFEQuad9()

void SystemsTest::test2DProjectVectorFEQuad9 ( )

inline

Definition at line 2011 of file systems_test.C.

{ LOG_UNIT_TEST; test2DProjectVectorFE(QUAD9); }

References libMesh::QUAD9, and test2DProjectVectorFE().

test2DProjectVectorFETri3()

void SystemsTest::test2DProjectVectorFETri3 ( )

inline

Definition at line 2006 of file systems_test.C.

{ LOG_UNIT_TEST; test2DProjectVectorFE(TRI3); }

References test2DProjectVectorFE(), and libMesh::TRI3.

test2DProjectVectorFETri6()

void SystemsTest::test2DProjectVectorFETri6 ( )

inline

Definition at line 2008 of file systems_test.C.

{ LOG_UNIT_TEST; test2DProjectVectorFE(TRI6); }

References test2DProjectVectorFE(), and libMesh::TRI6.

test2DProjectVectorFETri7()

void SystemsTest::test2DProjectVectorFETri7 ( )

inline

Definition at line 2009 of file systems_test.C.

{ LOG_UNIT_TEST; test2DProjectVectorFE(TRI7); }

References test2DProjectVectorFE(), and libMesh::TRI7.

test3DProjectVectorFE()

void SystemsTest::test3DProjectVectorFE ( const ElemType  elem_type )

inline

Definition at line 943 of file systems_test.C.

  {
    Mesh mesh(*TestCommWorld);
 
    EquationSystems es(mesh);
    TransientExplicitSystem &sys =
      es.add_system<TransientExplicitSystem> ("SimpleSystem");
 
    auto u_var = sys.add_variable
      ("u", Elem::type_to_default_order_map[elem_type], LAGRANGE_VEC);
 
    MeshTools::Generation::build_cube (mesh,
                                       1, 1, 1,
                                       0., 1., 0., 1., 0., 1.,
                                       elem_type);
 
    es.init();
 
    // Manually set-up the solution because I'm too lazy to set-up all the generic
    // function projection code right now
    for (const auto & node : mesh.local_node_ptr_range())
    {
      for (unsigned int i : make_range(Elem::type_to_dim_map[elem_type]))
      {
        auto dof_index = node->dof_number(sys.number(), u_var, i);
        sys.solution->set(dof_index, (*node)(i));
      }
    }
 
    // After setting values, we need to assemble
    sys.solution->close();
 
 
#ifdef LIBMESH_ENABLE_AMR
    for (auto & elem : mesh.element_ptr_range())
        elem->set_refinement_flag(Elem::REFINE);
    es.reinit();
#endif
 
    for (const auto & node : mesh.local_node_ptr_range())
    {
      for (unsigned int i : make_range(Elem::type_to_dim_map[elem_type]))
      {
        auto dof_index = node->dof_number(sys.number(), u_var, i);
        auto value = (*sys.solution)(dof_index);
        LIBMESH_ASSERT_NUMBERS_EQUAL(value, (*node)(i), TOLERANCE*TOLERANCE);
      }
    }
  }

References libMesh::EquationSystems::add_system(), libMesh::MeshTools::Generation::build_cube(), libMesh::EquationSystems::init(), libMesh::LAGRANGE_VEC, libMesh::make_range(), mesh, libMesh::Elem::REFINE, libMesh::EquationSystems::reinit(), TestCommWorld, libMesh::TOLERANCE, libMesh::Elem::type_to_default_order_map, libMesh::Elem::type_to_dim_map, and value.

Referenced by test3DProjectVectorFEHex20(), test3DProjectVectorFEHex27(), test3DProjectVectorFEHex8(), test3DProjectVectorFETet10(), test3DProjectVectorFETet14(), and test3DProjectVectorFETet4().

test3DProjectVectorFEHex20()

void SystemsTest::test3DProjectVectorFEHex20 ( )

inline

Definition at line 2016 of file systems_test.C.

{ LOG_UNIT_TEST; test3DProjectVectorFE(HEX20); }

References libMesh::HEX20, and test3DProjectVectorFE().

test3DProjectVectorFEHex27()

void SystemsTest::test3DProjectVectorFEHex27 ( )

inline

Definition at line 2017 of file systems_test.C.

{ LOG_UNIT_TEST; test3DProjectVectorFE(HEX27); }

References libMesh::HEX27, and test3DProjectVectorFE().

test3DProjectVectorFEHex8()

void SystemsTest::test3DProjectVectorFEHex8 ( )

inline

Definition at line 2013 of file systems_test.C.

{ LOG_UNIT_TEST; test3DProjectVectorFE(HEX8); }

References libMesh::HEX8, and test3DProjectVectorFE().

test3DProjectVectorFETet10()

void SystemsTest::test3DProjectVectorFETet10 ( )

inline

Definition at line 2014 of file systems_test.C.

{ LOG_UNIT_TEST; test3DProjectVectorFE(TET10); }

References test3DProjectVectorFE(), and libMesh::TET10.

test3DProjectVectorFETet14()

void SystemsTest::test3DProjectVectorFETet14 ( )

inline

Definition at line 2015 of file systems_test.C.

{ LOG_UNIT_TEST; test3DProjectVectorFE(TET14); }

References test3DProjectVectorFE(), and libMesh::TET14.

test3DProjectVectorFETet4()

void SystemsTest::test3DProjectVectorFETet4 ( )

inline

Definition at line 2012 of file systems_test.C.

{ LOG_UNIT_TEST; test3DProjectVectorFE(TET4); }

References test3DProjectVectorFE(), and libMesh::TET4.

testAddVectorProjChange()

void SystemsTest::testAddVectorProjChange ( )

inline

Definition at line 697 of file systems_test.C.

  {
    Mesh mesh(*TestCommWorld);
    EquationSystems es(mesh);
    ExplicitSystem & sys = simpleSetup(mesh, es);
 
    sys.add_vector("late", /* projections = */ false);
    CPPUNIT_ASSERT_EQUAL(sys.vector_preservation("late"), false);
 
    sys.add_vector("late");
    CPPUNIT_ASSERT_EQUAL(sys.vector_preservation("late"), true);
  }

References libMesh::System::add_vector(), mesh, simpleSetup(), TestCommWorld, and libMesh::System::vector_preservation().

testAddVectorTypeChange()

void SystemsTest::testAddVectorTypeChange ( )

inline

Definition at line 711 of file systems_test.C.

  {
    // Vector types are all pretty much equivalent in serial.
    if (TestCommWorld->size() == 1)
      return;
 
    Mesh mesh(*TestCommWorld);
    EquationSystems es(mesh);
    ExplicitSystem & sys = simpleSetup(mesh, es);
 
    auto & late_vec = sys.add_vector("late");
    CPPUNIT_ASSERT_EQUAL(late_vec.type(), PARALLEL);
    CPPUNIT_ASSERT_EQUAL(sys.vector_preservation("late"), true);
 
    // We should never downgrade projection settings, so "false"
    // should be safely ignored here
    sys.add_vector("late", false, GHOSTED);
    CPPUNIT_ASSERT_EQUAL(late_vec.type(), GHOSTED);
    CPPUNIT_ASSERT_EQUAL(sys.vector_preservation("late"), true);
 
    // We should never downgrade storage settings, so this should be a
    // no-op.
    sys.add_vector("late", true, PARALLEL);
    CPPUNIT_ASSERT_EQUAL(late_vec.type(), GHOSTED);
    CPPUNIT_ASSERT_EQUAL(sys.vector_preservation("late"), true);
  }

References libMesh::System::add_vector(), libMesh::GHOSTED, mesh, libMesh::PARALLEL, simpleSetup(), TestCommWorld, and libMesh::System::vector_preservation().

testAssemblyWithDgFemContext()

void SystemsTest::testAssemblyWithDgFemContext ( )

inline

Definition at line 1450 of file systems_test.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
 
    EquationSystems es(mesh);
    System &sys = es.add_system<LinearImplicitSystem> ("test");
 
    // We must use a discontinuous variable type in this test or
    // else the sparsity pattern will not be correct
    sys.add_variable("u", FIRST, L2_LAGRANGE);
 
    MeshTools::Generation::build_cube (mesh,
                                       5, 5, 5,
                                       0., 1., 0., 1., 0., 1.,
                                       HEX8);
 
    es.init();
    sys.attach_assemble_function (assembly_with_dg_fem_context);
    sys.solve();
 
    // We don't actually assert anything in this test. We just want to check that
    // the assembly and solve do not encounter any errors.
  }

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), assembly_with_dg_fem_context(), libMesh::System::attach_assemble_function(), libMesh::MeshTools::Generation::build_cube(), libMesh::FIRST, libMesh::HEX8, libMesh::EquationSystems::init(), libMesh::L2_LAGRANGE, mesh, libMesh::System::solve(), and TestCommWorld.

testBlockRestrictedVarNDofs()

void SystemsTest::testBlockRestrictedVarNDofs ( )

inline

Definition at line 1476 of file systems_test.C.

  {
    LOG_UNIT_TEST;
 
    ReplicatedMesh mesh(*TestCommWorld);
 
    MeshTools::Generation::build_cube (mesh,
                                      4,
                                      4,
                                      0,
                                      0., 1.,
                                      0., 1.,
                                      0., 0.,
                                      QUAD4);
 
    for (const auto & elem : mesh.element_ptr_range())
      {
        Point c = elem->vertex_average();
        if (c(0) <= 0.5 && c(1) <= 0.5)
          elem->subdomain_id() = 0;
        else
          elem->subdomain_id() = 1;
      }
 
    mesh.prepare_for_use();
 
    // Create an equation systems object.
    EquationSystems equation_systems (mesh);
    ExplicitSystem& system =
      equation_systems.add_system<LinearImplicitSystem> ("test");
 
    std::set<subdomain_id_type> block0;
    std::set<subdomain_id_type> block1;
    block0.insert(0);
    block1.insert(1);
    auto u0 = system.add_variable ("u0", libMesh::FIRST, &block0);
    auto u1 = system.add_variable ("u1", libMesh::FIRST, &block1);
    equation_systems.init();
 
    std::vector<dof_id_type> u0_dofs;
    system.get_dof_map().local_variable_indices(u0_dofs, mesh, u0);
    std::vector<dof_id_type> u1_dofs;
    system.get_dof_map().local_variable_indices(u1_dofs, mesh, u1);
 
    std::set<dof_id_type> sys_u0_dofs;
    system.local_dof_indices(u0, sys_u0_dofs);
    std::set<dof_id_type> sys_u1_dofs;
    system.local_dof_indices(u1, sys_u1_dofs);
 
    // Get local indices from other processors too
    mesh.comm().allgather(u0_dofs);
    mesh.comm().allgather(u1_dofs);
    mesh.comm().set_union(sys_u0_dofs);
    mesh.comm().set_union(sys_u1_dofs);
 
    const std::size_t c9 = 9;
    const std::size_t c21 = 21;
    CPPUNIT_ASSERT_EQUAL(c9, u0_dofs.size());
    CPPUNIT_ASSERT_EQUAL(c21, u1_dofs.size());
    CPPUNIT_ASSERT_EQUAL(c9, sys_u0_dofs.size());
    CPPUNIT_ASSERT_EQUAL(c21, sys_u1_dofs.size());
  }

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::Parallel::Communicator::allgather(), libMesh::MeshTools::Generation::build_cube(), libMesh::ParallelObject::comm(), libMesh::FIRST, libMesh::System::get_dof_map(), libMesh::EquationSystems::init(), libMesh::System::local_dof_indices(), libMesh::DofMap::local_variable_indices(), mesh, libMesh::MeshBase::prepare_for_use(), libMesh::QUAD4, libMesh::Parallel::Communicator::set_union(), and TestCommWorld.

testBoundaryProjectCube()

void SystemsTest::testBoundaryProjectCube ( )

inline

Definition at line 1168 of file systems_test.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
 
    // const boundary_id_type BOUNDARY_ID_MIN_Z  = 0;
    const boundary_id_type BOUNDARY_ID_MIN_Y  = 1;
    const boundary_id_type BOUNDARY_ID_MAX_X  = 2;
    const boundary_id_type BOUNDARY_ID_MAX_Y  = 3;
    const boundary_id_type BOUNDARY_ID_MIN_X  = 4;
    const boundary_id_type BOUNDARY_ID_MAX_Z  = 5;
    const boundary_id_type NODE_BOUNDARY_ID  = 10;
    const boundary_id_type EDGE_BOUNDARY_ID  = 20;
    const boundary_id_type SIDE_BOUNDARY_ID  = BOUNDARY_ID_MIN_X;
 
    EquationSystems es(mesh);
    System &sys = es.add_system<System> ("SimpleSystem");
    unsigned int u_var = sys.add_variable("u", FIRST, LAGRANGE);
 
    MeshTools::Generation::build_cube (mesh,
                                       3, 3, 3,
                                       0., 1., 0., 1., 0., 1.,
                                       HEX8);
 
    // Count the number of nodes on SIDE_BOUNDARY_ID
    std::set<dof_id_type> projected_nodes_set;
 
    for (const auto & elem : mesh.element_ptr_range())
      {
        for (auto side : elem->side_index_range())
          {
            std::vector<boundary_id_type> vec_to_fill;
            mesh.get_boundary_info().boundary_ids(elem, side, vec_to_fill);
 
            auto vec_it = std::find(vec_to_fill.begin(), vec_to_fill.end(), SIDE_BOUNDARY_ID);
            if (vec_it != vec_to_fill.end())
              {
                for (unsigned int node_index=0; node_index<elem->n_nodes(); node_index++)
                  {
                    if( elem->is_node_on_side(node_index, side))
                      {
                        projected_nodes_set.insert(elem->node_id(node_index));
                      }
                  }
              }
          }
      }
 
  // Also add some edge and node boundary IDs
  for (const auto & elem : mesh.element_ptr_range())
    {
      unsigned int
        side_max_x = 0, side_min_y = 0,
        side_max_y = 0, side_max_z = 0;
 
      bool
        found_side_max_x = false, found_side_max_y = false,
        found_side_min_y = false, found_side_max_z = false;
 
      for (auto side : elem->side_index_range())
        {
          if (mesh.get_boundary_info().has_boundary_id(elem, side, BOUNDARY_ID_MAX_X))
            {
              side_max_x = side;
              found_side_max_x = true;
            }
 
          if (mesh.get_boundary_info().has_boundary_id(elem, side, BOUNDARY_ID_MIN_Y))
            {
              side_min_y = side;
              found_side_min_y = true;
            }
 
          if (mesh.get_boundary_info().has_boundary_id(elem, side, BOUNDARY_ID_MAX_Y))
            {
              side_max_y = side;
              found_side_max_y = true;
            }
 
          if (mesh.get_boundary_info().has_boundary_id(elem, side, BOUNDARY_ID_MAX_Z))
            {
              side_max_z = side;
              found_side_max_z = true;
            }
        }
 
      // If elem has sides on boundaries
      // BOUNDARY_ID_MAX_X, BOUNDARY_ID_MAX_Y, BOUNDARY_ID_MAX_Z
      // then let's set a node boundary condition
      if (found_side_max_x && found_side_max_y && found_side_max_z)
        for (auto n : elem->node_index_range())
          if (elem->is_node_on_side(n, side_max_x) &&
              elem->is_node_on_side(n, side_max_y) &&
              elem->is_node_on_side(n, side_max_z))
            {
              projected_nodes_set.insert(elem->node_id(n));
              mesh.get_boundary_info().add_node(elem->node_ptr(n), NODE_BOUNDARY_ID);
            }
 
      // If elem has sides on boundaries
      // BOUNDARY_ID_MAX_X and BOUNDARY_ID_MIN_Y
      // then let's set an edge boundary condition
      if (found_side_max_x && found_side_min_y)
        for (auto e : elem->edge_index_range())
          if (elem->is_edge_on_side(e, side_max_x) &&
              elem->is_edge_on_side(e, side_min_y))
            {
              mesh.get_boundary_info().add_edge(elem, e, EDGE_BOUNDARY_ID);
 
              for (unsigned int node_index=0; node_index<elem->n_nodes(); node_index++)
                {
                  if (elem->is_node_on_edge(node_index, e))
                    {
                      projected_nodes_set.insert(elem->node_id(node_index));
                    }
                }
            }
    }
 
    es.init();
 
    sys.solution->add(1.0);
 
    std::set<boundary_id_type> boundary_ids;
    boundary_ids.insert(NODE_BOUNDARY_ID);
    boundary_ids.insert(EDGE_BOUNDARY_ID);
    boundary_ids.insert(SIDE_BOUNDARY_ID);
    std::vector<unsigned int> variables;
    variables.push_back(u_var);
    ZeroFunction<> zf;
    sys.boundary_project_solution(boundary_ids, variables, &zf);
 
    // On a distributed mesh we may not have every node on every
    // processor
    TestCommWorld->set_union(projected_nodes_set);
 
    // We set the solution to be 1 everywhere and then zero on specific boundary
    // nodes, so the final l1 norm of the solution is the difference between the
    // number of nodes in the mesh and the number of nodes we zero on.
    Real ref_l1_norm = static_cast<Real>(mesh.n_nodes()) - static_cast<Real>(projected_nodes_set.size());
 
    LIBMESH_ASSERT_FP_EQUAL(sys.solution->l1_norm(), ref_l1_norm, TOLERANCE*TOLERANCE);
  }

References libMesh::BoundaryInfo::add_edge(), libMesh::BoundaryInfo::add_node(), libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::BoundaryInfo::boundary_ids(), libMesh::System::boundary_project_solution(), libMesh::MeshTools::Generation::build_cube(), libMesh::FIRST, libMesh::MeshBase::get_boundary_info(), libMesh::BoundaryInfo::has_boundary_id(), libMesh::HEX8, libMesh::EquationSystems::init(), libMesh::LAGRANGE, mesh, libMesh::MeshBase::n_nodes(), libMesh::Real, libMesh::System::solution, TestCommWorld, and libMesh::TOLERANCE.

testDofCouplingWithVarGroups()

void SystemsTest::testDofCouplingWithVarGroups ( )

inline

Definition at line 1313 of file systems_test.C.

  {
    LOG_UNIT_TEST;
 
    ReplicatedMesh mesh(*TestCommWorld);
 
    MeshTools::Generation::build_cube (mesh,
                                      1,
                                      0,
                                      0,
                                      0., 1.,
                                      0., 0.,
                                      0., 0.,
                                      EDGE2);
 
    Point new_point_a(2.);
    Point new_point_b(3.);
    Node* new_node_a = mesh.add_point( new_point_a );
    Node* new_node_b = mesh.add_point( new_point_b );
    auto new_edge_elem = mesh.add_elem(Elem::build(EDGE2));
    new_edge_elem->set_node(0, new_node_a);
    new_edge_elem->set_node(1, new_node_b);
 
    mesh.elem_ref(0).subdomain_id() = 10;
    mesh.elem_ref(1).subdomain_id() = 10;
 
    // Add NodeElems for coupling purposes
    auto node_elem_1 = mesh.add_elem(Elem::build(NODEELEM));
    node_elem_1->set_node(0, mesh.elem_ref(0).node_ptr(1));
    auto node_elem_2 = mesh.add_elem(Elem::build(NODEELEM));
    node_elem_2->set_node(0, new_node_a);
 
    mesh.prepare_for_use();
 
    // Create an equation systems object.
    EquationSystems equation_systems (mesh);
    LinearImplicitSystem & system =
      equation_systems.add_system<LinearImplicitSystem> ("test");
 
    system.add_variable ("u", libMesh::FIRST);
    system.add_variable ("v", libMesh::FIRST);
    system.add_variable ("w", libMesh::FIRST);
 
    std::set<subdomain_id_type> theta_subdomains;
    theta_subdomains.insert(10);
    system.add_variable ("theta_x", libMesh::FIRST, &theta_subdomains);
    system.add_variable ("theta_y", libMesh::FIRST, &theta_subdomains);
    system.add_variable ("theta_z", libMesh::FIRST, &theta_subdomains);
 
    system.attach_assemble_function (assemble_matrix_and_rhs);
 
    AugmentSparsityOnNodes augment_sparsity(mesh);
    system.get_dof_map().add_coupling_functor(augment_sparsity);
 
    // LASPACK GMRES + ILU defaults don't like this problem, but it's
    // small enough to just use a simpler iteration.
    system.get_linear_solver()->set_solver_type(JACOBI);
    system.get_linear_solver()->set_preconditioner_type(IDENTITY_PRECOND);
 
    equation_systems.init ();
 
    system.solve();
 
    // We set the solution to be 1 everywhere, so the final l1 norm of the
    // solution is the product of the number of variables and number of nodes.
    Real ref_l1_norm = static_cast<Real>(mesh.n_nodes() * system.n_vars());
 
    LIBMESH_ASSERT_FP_EQUAL(system.solution->l1_norm(), ref_l1_norm, TOLERANCE*TOLERANCE);
  }

References libMesh::DofMap::add_coupling_functor(), libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), assemble_matrix_and_rhs(), libMesh::System::attach_assemble_function(), libMesh::Elem::build(), libMesh::MeshTools::Generation::build_cube(), libMesh::EDGE2, libMesh::MeshBase::elem_ref(), libMesh::FIRST, libMesh::System::get_dof_map(), libMesh::LinearImplicitSystem::get_linear_solver(), libMesh::IDENTITY_PRECOND, libMesh::EquationSystems::init(), libMesh::JACOBI, mesh, libMesh::MeshBase::n_nodes(), libMesh::System::n_vars(), libMesh::Elem::node_ptr(), libMesh::NODEELEM, libMesh::MeshBase::prepare_for_use(), libMesh::Real, libMesh::Elem::set_node(), libMesh::LinearSolver< T >::set_preconditioner_type(), libMesh::LinearSolver< T >::set_solver_type(), libMesh::System::solution, libMesh::LinearImplicitSystem::solve(), libMesh::Elem::subdomain_id(), TestCommWorld, and libMesh::TOLERANCE.

testFirstScalarNumber()

void SystemsTest::testFirstScalarNumber ( )

inline

Definition at line 592 of file systems_test.C.

  {
    Mesh mesh(*TestCommWorld);
 
    MeshTools::Generation::build_cube (mesh,
                                       1, 1, 1,
                                       0., 1., 0., 1., 0., 1.,
                                       HEX8);
 
    EquationSystems es(mesh);
    System &sys = es.add_system<System> ("SimpleSystem");
 
    const FEFamily types[3] = {MONOMIAL_VEC, LAGRANGE_VEC, NEDELEC_ONE};
    const Order orders[3] = {CONSTANT, SECOND, FIRST};
    const std::string names[3] = {"u", "v", "w"};
    const unsigned int var_nums[3] =
      {
        sys.add_variable("u", CONSTANT, MONOMIAL_VEC),
        sys.add_variable("v", SECOND, LAGRANGE_VEC),
        sys.add_variable("w", FIRST, NEDELEC_ONE)
      };
 
    for (unsigned int i : {0, 1, 2})
      {
        // We did just add these in order
        CPPUNIT_ASSERT_EQUAL(i, var_nums[i]);
 
        auto & var = sys.variable(i);
        CPPUNIT_ASSERT_EQUAL(var.system(), &sys);
        CPPUNIT_ASSERT_EQUAL(var.name(), names[i]);
        CPPUNIT_ASSERT_EQUAL(var.number(), i);
        CPPUNIT_ASSERT_EQUAL(var.first_scalar_number(), i*3);
        CPPUNIT_ASSERT_EQUAL(var.type().family, types[i]);
        CPPUNIT_ASSERT_EQUAL(Order(var.type().order), orders[i]);
        CPPUNIT_ASSERT_EQUAL(var.n_components(mesh), 3u);
      }
  }

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshTools::Generation::build_cube(), libMesh::CONSTANT, libMesh::FIRST, libMesh::HEX8, libMesh::LAGRANGE_VEC, mesh, libMesh::MONOMIAL_VEC, libMesh::NEDELEC_ONE, libMesh::SECOND, TestCommWorld, and libMesh::System::variable().

testPostInitAddVector()

void SystemsTest::testPostInitAddVector ( )

inline

Definition at line 680 of file systems_test.C.

  {
    Mesh mesh(*TestCommWorld);
    EquationSystems es(mesh);
    ExplicitSystem & sys = simpleSetup(mesh, es);
    es.init();
 
    auto & late_vec = sys.add_vector("late");
 
    CPPUNIT_ASSERT_EQUAL(sys.n_dofs(), dof_id_type(11));
 
    // late_vec should be initialized
    CPPUNIT_ASSERT_EQUAL(late_vec.size(), dof_id_type(11));
    CPPUNIT_ASSERT_EQUAL(late_vec.local_size(), sys.solution->local_size());
  }

References libMesh::System::add_vector(), libMesh::EquationSystems::init(), mesh, libMesh::System::n_dofs(), simpleSetup(), libMesh::System::solution, and TestCommWorld.

testPostInitAddVectorTypeChange()

void SystemsTest::testPostInitAddVectorTypeChange ( )

inline

Definition at line 739 of file systems_test.C.

  {
    // Vector types are all pretty much equivalent in serial.
    if (TestCommWorld->size() == 1)
      return;
 
    Mesh mesh(*TestCommWorld);
    EquationSystems es(mesh);
    ExplicitSystem & sys = simpleSetup(mesh, es);
 
    auto & late_vec = sys.add_vector("late");
    CPPUNIT_ASSERT_EQUAL(late_vec.type(), PARALLEL);
    CPPUNIT_ASSERT_EQUAL(sys.vector_preservation("late"), true);
 
    es.init();
 
    auto & dof_map = sys.get_dof_map();
 
    // Set some data to make sure it's preserved
    CPPUNIT_ASSERT_EQUAL(sys.n_dofs(), dof_id_type(11));
    for (auto i : make_range(dof_map.first_dof(),
                             dof_map.end_dof()))
      late_vec.set(i, 2.0*i);
    late_vec.close();
 
    sys.add_vector("late", false, GHOSTED);
    CPPUNIT_ASSERT_EQUAL(late_vec.type(), GHOSTED);
 
    std::vector<dof_id_type> dof_indices;
    for (auto & elem : mesh.active_local_element_ptr_range())
      {
        dof_map.dof_indices (elem, dof_indices);
 
        for (auto d : dof_indices)
          CPPUNIT_ASSERT_EQUAL(late_vec(d), Number(2.0*d));
      }
  }

References libMesh::System::add_vector(), libMesh::System::get_dof_map(), libMesh::GHOSTED, libMesh::EquationSystems::init(), libMesh::make_range(), mesh, libMesh::System::n_dofs(), libMesh::PARALLEL, simpleSetup(), TestCommWorld, and libMesh::System::vector_preservation().

testProjectCube()

void SystemsTest::testProjectCube ( const ElemType  elem_type )

inline

Definition at line 1049 of file systems_test.C.

  {
    Mesh mesh(*TestCommWorld);
 
    EquationSystems es(mesh);
    TransientExplicitSystem &sys =
      es.add_system<TransientExplicitSystem> ("SimpleSystem");
 
    std::set<subdomain_id_type> u_subdomains {0, 1, 4, 5},
                                v_subdomains {1, 2, 3, 4},
                                w_subdomains {0, 1, 2, 3, 4};
 
    sys.add_variable("u", THIRD,    HIERARCHIC, &u_subdomains);
    sys.add_variable("v", FIRST,    LAGRANGE,   &v_subdomains);
    sys.add_variable("w", CONSTANT, MONOMIAL,   &w_subdomains);
 
    MeshTools::Generation::build_cube (mesh,
                                       3, 3, 3,
                                       0., 1., 0., 1., 0., 1.,
                                       elem_type);
 
    for (auto & elem : mesh.element_ptr_range())
      elem->subdomain_id() = elem->id()/6;
 
    es.init();
    TripleFunction tfunc;
    sys.project_solution(&tfunc);
    tfunc.offset = 10;
    sys.project_vector(*sys.old_local_solution, &tfunc);
    tfunc.offset = 20;
    sys.project_vector(*sys.older_local_solution, &tfunc);
 
    std::unique_ptr<PointLocatorBase> locator = mesh.sub_point_locator();
    locator->enable_out_of_mesh_mode();
    for (Real x = 0.1; x < 1; x += 0.2)
      for (Real y = 0.1; y < 1; y += 0.2)
        for (Real z = 0.1; z < 1; z += 0.2)
          tripleValueTest(Point(x,y,z), sys, *locator,
                          u_subdomains, v_subdomains, w_subdomains,
                          es.parameters);
 
  #ifdef LIBMESH_ENABLE_AMR
    for (auto & elem : mesh.element_ptr_range())
      if ((elem->id()/2)%2)
        elem->set_refinement_flag(Elem::REFINE);
    es.reinit();
 
    locator = mesh.sub_point_locator();
    locator->enable_out_of_mesh_mode();
    for (Real x = 0.1; x < 1; x += 0.2)
      for (Real y = 0.1; y < 1; y += 0.2)
        for (Real z = 0.1; z < 1; z += 0.2)
          tripleValueTest(Point(x,y,z), sys, *locator,
                          u_subdomains, v_subdomains, w_subdomains,
                          es.parameters);
  #endif
  }

References libMesh::EquationSystems::add_system(), libMesh::MeshTools::Generation::build_cube(), libMesh::CONSTANT, libMesh::FIRST, libMesh::HIERARCHIC, libMesh::EquationSystems::init(), libMesh::LAGRANGE, mesh, libMesh::MONOMIAL, TripleFunction::offset, libMesh::TransientSystem< Base >::old_local_solution, libMesh::TransientSystem< Base >::older_local_solution, libMesh::EquationSystems::parameters, libMesh::Real, libMesh::Elem::REFINE, libMesh::EquationSystems::reinit(), libMesh::MeshBase::sub_point_locator(), TestCommWorld, libMesh::THIRD, and tripleValueTest().

Referenced by testProjectHierarchicHex27().

testProjectCubeWithMeshFunction()

void SystemsTest::testProjectCubeWithMeshFunction ( const ElemType  elem_type )

inline

Definition at line 1107 of file systems_test.C.

  {
    // The source mesh needs to exist everywhere it's queried, so we
    // use a ReplicatedMesh
    ReplicatedMesh mesh(*TestCommWorld);
 
    EquationSystems es(mesh);
    System &sys = es.add_system<System> ("SimpleSystem");
    sys.add_variable("u", THIRD, MONOMIAL);
 
    MeshTools::Generation::build_cube (mesh,
                                       3, 3, 3,
                                       0., 1., 0., 1., 0., 1.,
                                       elem_type);
 
    es.init();
    sys.project_solution(cubic_test, nullptr, es.parameters);
 
    std::vector<unsigned int> variables;
    sys.get_all_variable_numbers(variables);
    std::sort(variables.begin(),variables.end());
 
    std::unique_ptr< NumericVector<Number> > mesh_function_vector =
      NumericVector<Number>::build(es.comm());
    mesh_function_vector->init(sys.n_dofs(), false, SERIAL);
    sys.solution->localize( *mesh_function_vector );
 
    MeshFunction mesh_function(es,
                               *mesh_function_vector,
                               sys.get_dof_map(),
                               variables);
    mesh_function.init();
 
    // Make a second system and project onto it using a MeshFunction
    Mesh proj_mesh(*TestCommWorld);
    EquationSystems proj_es(proj_mesh);
 
    System &proj_sys = proj_es.add_system<System> ("ProjectionSystem");
 
    // use 3rd order again so we can expect exact results
    proj_sys.add_variable("u", THIRD, HIERARCHIC);
 
    MeshTools::Generation::build_cube (proj_mesh,
                                       5, 5, 5,
                                       0., 1., 0., 1., 0., 1.,
                                       elem_type);
 
    proj_es.init();
    proj_sys.project_solution(&mesh_function);
 
    for (Real x = 0.1; x < 1; x += 0.2)
      for (Real y = 0.1; y < 1; y += 0.2)
        for (Real z = 0.1; z < 1; z += 0.2)
          {
            Point p(x,y,z);
            LIBMESH_ASSERT_NUMBERS_EQUAL
              (cubic_test(p,es.parameters,"",""),
               proj_sys.point_value(0,p), TOLERANCE*TOLERANCE);
          }
  }

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::NumericVector< T >::build(), libMesh::MeshTools::Generation::build_cube(), libMesh::ParallelObject::comm(), cubic_test(), libMesh::System::get_all_variable_numbers(), libMesh::System::get_dof_map(), libMesh::HIERARCHIC, libMesh::EquationSystems::init(), libMesh::MeshFunction::init(), mesh, libMesh::MONOMIAL, libMesh::System::n_dofs(), libMesh::EquationSystems::parameters, libMesh::System::point_value(), libMesh::System::project_solution(), libMesh::Real, libMesh::SERIAL, libMesh::System::solution, TestCommWorld, libMesh::THIRD, and libMesh::TOLERANCE.

Referenced by testProjectMeshFunctionHex27().

testProjectHierarchicEdge3()

void SystemsTest::testProjectHierarchicEdge3 ( )

inline

Definition at line 2000 of file systems_test.C.

{ LOG_UNIT_TEST; testProjectLine(EDGE3); }

References libMesh::EDGE3, and testProjectLine().

testProjectHierarchicHex27()

void SystemsTest::testProjectHierarchicHex27 ( )

inline

Definition at line 2004 of file systems_test.C.

{ LOG_UNIT_TEST; testProjectCube(HEX27); }

References libMesh::HEX27, and testProjectCube().

testProjectHierarchicQuad9()

void SystemsTest::testProjectHierarchicQuad9 ( )

inline

Definition at line 2001 of file systems_test.C.

{ LOG_UNIT_TEST; testProjectSquare(QUAD9); }

References libMesh::QUAD9, and testProjectSquare().

testProjectHierarchicTri6()

void SystemsTest::testProjectHierarchicTri6 ( )

inline

Definition at line 2002 of file systems_test.C.

{ LOG_UNIT_TEST; testProjectSquare(TRI6); }

References testProjectSquare(), and libMesh::TRI6.

testProjectHierarchicTri7()

void SystemsTest::testProjectHierarchicTri7 ( )

inline

Definition at line 2003 of file systems_test.C.

{ LOG_UNIT_TEST; testProjectSquare(TRI7); }

References testProjectSquare(), and libMesh::TRI7.

testProjectLine()

void SystemsTest::testProjectLine ( const ElemType  elem_type )

inline

Definition at line 779 of file systems_test.C.

  {
    Mesh mesh(*TestCommWorld);
 
    EquationSystems es(mesh);
    TransientExplicitSystem &sys =
      es.add_system<TransientExplicitSystem> ("SimpleSystem");
 
    std::set<subdomain_id_type> u_subdomains {0, 1, 4, 5},
                                v_subdomains {1, 2, 3, 4},
                                w_subdomains {0, 1, 2, 3, 4};
 
    sys.add_variable("u", THIRD,    HIERARCHIC, &u_subdomains);
    sys.add_variable("v", FIRST,    LAGRANGE,   &v_subdomains);
    sys.add_variable("w", CONSTANT, MONOMIAL,   &w_subdomains);
 
    MeshTools::Generation::build_line (mesh,
                                       6,
                                       0., 1.,
                                       elem_type);
 
    for (auto & elem : mesh.element_ptr_range())
      elem->subdomain_id() = elem->id();
 
    es.init();
    TripleFunction tfunc;
    sys.project_solution(&tfunc);
    tfunc.offset = 10;
    sys.project_vector(*sys.old_local_solution, &tfunc);
    tfunc.offset = 20;
    sys.project_vector(*sys.older_local_solution, &tfunc);
 
    std::unique_ptr<PointLocatorBase> locator = mesh.sub_point_locator();
    locator->enable_out_of_mesh_mode();
    for (Real x = 0.1; x < 1; x += 0.2)
      tripleValueTest(Point(x), sys, *locator,
                      u_subdomains, v_subdomains, w_subdomains,
                      es.parameters);
 
#ifdef LIBMESH_ENABLE_AMR
    for (auto & elem : mesh.element_ptr_range())
      if ((elem->id()/2)%2)
        elem->set_refinement_flag(Elem::REFINE);
    es.reinit();
 
    locator = mesh.sub_point_locator();
    locator->enable_out_of_mesh_mode();
    for (Real x = 0.1; x < 1; x += 0.2)
      tripleValueTest(Point(x), sys, *locator,
                      u_subdomains, v_subdomains, w_subdomains,
                      es.parameters);
#endif
  }

References libMesh::EquationSystems::add_system(), libMesh::MeshTools::Generation::build_line(), libMesh::CONSTANT, libMesh::FIRST, libMesh::HIERARCHIC, libMesh::EquationSystems::init(), libMesh::LAGRANGE, mesh, libMesh::MONOMIAL, TripleFunction::offset, libMesh::TransientSystem< Base >::old_local_solution, libMesh::TransientSystem< Base >::older_local_solution, libMesh::EquationSystems::parameters, libMesh::Real, libMesh::Elem::REFINE, libMesh::EquationSystems::reinit(), libMesh::MeshBase::sub_point_locator(), TestCommWorld, libMesh::THIRD, and tripleValueTest().

Referenced by testProjectHierarchicEdge3().

testProjectMatrix1D()

void SystemsTest::testProjectMatrix1D ( const ElemType  elem_type )

inline

Definition at line 1542 of file systems_test.C.

  {
    // Use ReplicatedMesh to get consistent child element node
    // numbering during refinement
    ReplicatedMesh mesh(*TestCommWorld);
 
    // fix the node numbering to resolve dof_id numbering issues in parallel tests
    mesh.allow_renumbering(false);
 
    // init a simple 1d system
    EquationSystems es(mesh);
    System &sys = es.add_system<System> ("SimpleSystem");
    sys.add_variable("u", FIRST, LAGRANGE);
 
    MeshTools::Generation::build_line (mesh,
                                       4, 0., 1.,
                                       elem_type);
 
    es.init();
 
    // static set of coarse nodes / order of fine grid nodes from x=0 to x=1 going left to right
    std::set<dof_id_type> coarse_nodes({0,1,2,3,4});
    std::vector<dof_id_type> node_order_f({0,5,1,6,2,7,3,8,4});
 
    // stash number of dofs on coarse grid for projection sizing
    int n_old_dofs = sys.n_dofs();
 
    // save old coarse dof_ids in order of coarse nodes
    std::map <dof_id_type, dof_id_type> node2dof_c;
    for ( const auto & node : mesh.node_ptr_range() )
      {
        dof_id_type cdof_id = node->dof_number(0,0,0);
        node2dof_c.insert( std::pair<dof_id_type,dof_id_type>( node->id() , cdof_id) );
      }
 
    // refine the mesh so we can utilize old_dof_indices for projection_matrix
    MeshRefinement mr(mesh);
    mr.uniformly_refine(1);
    sys.get_dof_map().distribute_dofs(mesh);
 
    // fine node to dof map
    std::map <dof_id_type, dof_id_type> node2dof_f;
    for ( const auto & node : mesh.local_node_ptr_range() )
      {
        dof_id_type fdof_id = node->dof_number(0,0,0);
        node2dof_f.insert( std::pair<dof_id_type,dof_id_type>(node->id() , fdof_id) );
      }
 
    // local and global projection_matrix sizes infos
    int n_new_dofs = sys.n_dofs();
    int n_new_dofs_local = sys.get_dof_map().n_local_dofs();
    int ndofs_old_first = sys.get_dof_map().first_old_dof();
    int ndofs_old_end   = sys.get_dof_map().end_old_dof();
    int n_old_dofs_local = ndofs_old_end - ndofs_old_first;
 
    // init and compute the projection matrix using GenericProjector
    std::unique_ptr<SparseMatrix<Number> > proj_mat_ptr =
      SparseMatrix<Number>::build(*TestCommWorld);
    SparseMatrix<Number> & proj_mat = *proj_mat_ptr;
    proj_mat.init(n_new_dofs, n_old_dofs, n_new_dofs_local, n_old_dofs_local);
    sys.projection_matrix(proj_mat);
    proj_mat.close();
 
    // init the gold standard projection matrix
    std::unique_ptr<SparseMatrix<Number> > gold_mat_ptr =
      SparseMatrix<Number>::build(*TestCommWorld);
    SparseMatrix<Number> & gold_mat = *gold_mat_ptr;
    gold_mat.init(n_new_dofs, n_old_dofs, n_new_dofs_local, n_old_dofs_local);
 
    // construct the gold projection matrix using static node numbering as reference info
    for ( const auto & node : mesh.local_node_ptr_range() )
      {
        dof_id_type node_id = node->id();
        dof_id_type fdof_id = (node2dof_f.find(node_id))->second;
 
        if (coarse_nodes.find(node_id) != coarse_nodes.end() )
          { //direct inject coarse nodes
            if (fdof_id >= gold_mat.row_start() && fdof_id < gold_mat.row_stop())
              {
                auto cdof_id = node2dof_c.find(node_id);
                gold_mat.set(fdof_id, cdof_id->second, 1.0);
              }
          }
        else
          { // new nodes with old_dof neighbor contributions
            if (fdof_id >= gold_mat.row_start() && fdof_id < gold_mat.row_stop())
              {
                auto node_loc = std::find(node_order_f.begin(), node_order_f.end(), node_id);
                auto node_n = *std::next(node_loc, 1);
                auto node_p = *std::prev(node_loc, 1);
                auto dof_p = node2dof_c.find(node_p);
                auto dof_n = node2dof_c.find(node_n);
 
                gold_mat.set(fdof_id, dof_p->second, 0.5);
                gold_mat.set(fdof_id, dof_n->second, 0.5);
              }
          }
      } // end gold mat build
    gold_mat.close();
 
    // calculate relative difference norm between the two projection matrices
    Real gold_norm = gold_mat.linfty_norm();
    gold_mat.add(-1.0, proj_mat);
    Real diff_norm = gold_mat.linfty_norm();
    CPPUNIT_ASSERT(diff_norm/gold_norm < TOLERANCE*TOLERANCE);
  }

References libMesh::SparseMatrix< T >::add(), libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshBase::allow_renumbering(), libMesh::SparseMatrix< T >::build(), libMesh::MeshTools::Generation::build_line(), libMesh::SparseMatrix< T >::close(), libMesh::DofMap::distribute_dofs(), libMesh::DofMapBase::end_old_dof(), libMesh::FIRST, libMesh::DofMapBase::first_old_dof(), libMesh::System::get_dof_map(), libMesh::EquationSystems::init(), libMesh::SparseMatrix< T >::init(), libMesh::LAGRANGE, libMesh::SparseMatrix< T >::linfty_norm(), mesh, libMesh::System::n_dofs(), libMesh::DofMap::n_local_dofs(), libMesh::System::projection_matrix(), libMesh::Real, libMesh::SparseMatrix< T >::row_start(), libMesh::SparseMatrix< T >::row_stop(), libMesh::SparseMatrix< T >::set(), TestCommWorld, libMesh::TOLERANCE, and libMesh::MeshRefinement::uniformly_refine().

Referenced by testProjectMatrixEdge2().

testProjectMatrix2D()

void SystemsTest::testProjectMatrix2D ( const ElemType  elem_type )

inline

Definition at line 1649 of file systems_test.C.

  {
    // Use ReplicatedMesh to get consistent child element node
    // numbering during refinement
    ReplicatedMesh mesh(*TestCommWorld);
 
    // fix the node numbering to resolve dof_id numbering issues in parallel tests
    mesh.allow_renumbering(false);
 
    // init a simple 1d system
    EquationSystems es(mesh);
    System &sys = es.add_system<System> ("SimpleSystem");
    sys.add_variable("u", FIRST, LAGRANGE);
 
    if (elem_type == Utility::string_to_enum<ElemType>("QUAD4"))
      MeshTools::Generation::build_square (mesh,
                                           2, 2,
                                           0., 1., 0., 1.,
                                           elem_type);
    else if (elem_type == Utility::string_to_enum<ElemType>("TRI3"))
      MeshTools::Generation::build_square (mesh,
                                           1, 1,
                                           0., 1., 0., 1.,
                                           elem_type);
 
    es.init();
 
    // static sets of nodes and their neighbors
    std::set<dof_id_type> coarse_nodes;
    std::map<dof_id_type, std::vector<dof_id_type>> side_nbr_nodes;
    std::map<dof_id_type, std::vector<dof_id_type>> int_nbr_nodes;
 
    // fill neighbor maps based on static node numbering
    if (elem_type == Utility::string_to_enum<ElemType>("QUAD4"))
      {
        coarse_nodes.insert({0,1,2,3,4,5,6,7,8});
 
        side_nbr_nodes.insert({9, {0,1}});
        side_nbr_nodes.insert({14, {1,2}});
        side_nbr_nodes.insert({11, {0,3}});
        side_nbr_nodes.insert({12, {1,4}});
        side_nbr_nodes.insert({16, {2,5}});
        side_nbr_nodes.insert({13, {3,4}});
        side_nbr_nodes.insert({17, {4,5}});
        side_nbr_nodes.insert({19, {3,6}});
        side_nbr_nodes.insert({20, {4,7}});
        side_nbr_nodes.insert({23, {5,8}});
        side_nbr_nodes.insert({21, {6,7}});
        side_nbr_nodes.insert({24, {7,8}});
 
        int_nbr_nodes.insert({10, {0,1,3,4}});
        int_nbr_nodes.insert({15, {1,2,4,5}});
        int_nbr_nodes.insert({18, {3,4,6,7}});
        int_nbr_nodes.insert({22, {4,5,7,8}});
      }
    else if (elem_type == Utility::string_to_enum<ElemType>("TRI3"))
      {
        coarse_nodes.insert({0,1,2,3});
 
        side_nbr_nodes.insert({4, {0,1}});
        side_nbr_nodes.insert({5, {0,3}});
        side_nbr_nodes.insert({6, {1,3}});
        side_nbr_nodes.insert({7, {0,2}});
        side_nbr_nodes.insert({8, {2,3}});
      }
 
    // stash number of dofs on coarse grid for projection sizing
    int n_old_dofs = sys.n_dofs();
 
    // save old coarse dof_ids in order of coarse nodes
    std::map <dof_id_type, dof_id_type> node2dof_c;
    for ( const auto & node : mesh.node_ptr_range() )
      {
        dof_id_type cdof_id = node->dof_number(0,0,0);
        node2dof_c.insert( std::pair<dof_id_type,dof_id_type>( node->id() , cdof_id) );
      }
 
    // refine the mesh so we can utilize old_dof_indices for projection_matrix
    MeshRefinement mr(mesh);
    mr.uniformly_refine(1);
    sys.get_dof_map().distribute_dofs(mesh);
 
    // fine node to dof map
    std::map <dof_id_type, dof_id_type> node2dof_f;
    for ( const auto & node : mesh.local_node_ptr_range() )
      {
        dof_id_type fdof_id = node->dof_number(0,0,0);
        node2dof_f.insert( std::pair<dof_id_type,dof_id_type>(node->id() , fdof_id) );
      }
 
    // local and global projection_matrix sizes infos
    int n_new_dofs = sys.n_dofs();
    int n_new_dofs_local = sys.get_dof_map().n_local_dofs();
    int ndofs_old_first = sys.get_dof_map().first_old_dof();
    int ndofs_old_end   = sys.get_dof_map().end_old_dof();
    int n_old_dofs_local = ndofs_old_end - ndofs_old_first;
 
    // init and compute the projection matrix using GenericProjector
    std::unique_ptr<SparseMatrix<Number> > proj_mat_ptr =
      SparseMatrix<Number>::build(*TestCommWorld);
    SparseMatrix<Number> & proj_mat = *proj_mat_ptr;
    proj_mat.init(n_new_dofs, n_old_dofs, n_new_dofs_local, n_old_dofs_local);
    sys.projection_matrix(proj_mat);
    proj_mat.close();
 
    // init the gold standard projection matrix
    std::unique_ptr<SparseMatrix<Number> > gold_mat_ptr =
      SparseMatrix<Number>::build(*TestCommWorld);
    SparseMatrix<Number> & gold_mat = *gold_mat_ptr;
    gold_mat.init(n_new_dofs, n_old_dofs, n_new_dofs_local, n_old_dofs_local);
 
    // construct the gold projection matrix using static node numbering as reference info
    for ( const auto & node : mesh.local_node_ptr_range() )
      {
        dof_id_type node_id = node->id();
        dof_id_type fdof_id = (node2dof_f.find(node_id))->second;
 
        if (coarse_nodes.find(node_id) != coarse_nodes.end() )
          { // direct inject coarse nodes
            if (fdof_id >= gold_mat.row_start() && fdof_id < gold_mat.row_stop())
              {
                auto cdof_id = node2dof_c.find(node_id);
                gold_mat.set(fdof_id, cdof_id->second, 1.0);
              }
          }
        else if ( side_nbr_nodes.find(node_id) != side_nbr_nodes.end() )
          { // new side nodes with old_dof neighbor contributions
            if (fdof_id >= gold_mat.row_start() && fdof_id < gold_mat.row_stop())
              {
                auto node_nbrs = side_nbr_nodes.find(node_id);
                for (auto nbr : node_nbrs->second)
                  {
                    auto nbr_dof = node2dof_c.find(nbr);
                    gold_mat.set(fdof_id, nbr_dof->second, 0.5);
                  }
              }
          }
        else
          { // new interior nodes with old_dof neighbor contributions
            if (fdof_id >= gold_mat.row_start() && fdof_id < gold_mat.row_stop())
              {
                auto node_nbrs = int_nbr_nodes.find(node_id);
                for (auto nbr : node_nbrs->second)
                  {
                    auto nbr_dof = node2dof_c.find(nbr);
                    gold_mat.set(fdof_id, nbr_dof->second, 0.25);
                  }
              }
          }
      } // end gold mat build
    gold_mat.close();
 
    // calculate relative difference norm between the two projection matrices
    Real gold_norm = gold_mat.linfty_norm();
    proj_mat.add(-1.0, gold_mat);
    Real diff_norm = proj_mat.linfty_norm();
    CPPUNIT_ASSERT(diff_norm/gold_norm < TOLERANCE*TOLERANCE);
  }

References libMesh::SparseMatrix< T >::add(), libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshBase::allow_renumbering(), libMesh::SparseMatrix< T >::build(), libMesh::MeshTools::Generation::build_square(), libMesh::SparseMatrix< T >::close(), libMesh::DofMap::distribute_dofs(), libMesh::DofMapBase::end_old_dof(), libMesh::FIRST, libMesh::DofMapBase::first_old_dof(), libMesh::System::get_dof_map(), libMesh::EquationSystems::init(), libMesh::SparseMatrix< T >::init(), libMesh::LAGRANGE, libMesh::SparseMatrix< T >::linfty_norm(), mesh, libMesh::System::n_dofs(), libMesh::DofMap::n_local_dofs(), libMesh::System::projection_matrix(), libMesh::Real, libMesh::SparseMatrix< T >::row_start(), libMesh::SparseMatrix< T >::row_stop(), libMesh::SparseMatrix< T >::set(), TestCommWorld, libMesh::TOLERANCE, and libMesh::MeshRefinement::uniformly_refine().

Referenced by testProjectMatrixQuad4(), and testProjectMatrixTri3().

testProjectMatrix3D()

void SystemsTest::testProjectMatrix3D ( const ElemType  elem_type )

inline

Definition at line 1808 of file systems_test.C.

  {
    // Use ReplicatedMesh to get consistent child element node
    // numbering during refinement
    ReplicatedMesh mesh(*TestCommWorld);
 
    // fix the node numbering to resolve dof_id numbering issues in parallel tests
    mesh.allow_renumbering(false);
 
    // init a simple 1d system
    EquationSystems es(mesh);
    System &sys = es.add_system<System> ("SimpleSystem");
    sys.add_variable("u", FIRST, LAGRANGE);
 
    if (elem_type == Utility::string_to_enum<ElemType>("HEX8"))
      MeshTools::Generation::build_cube (mesh,
                                         1, 1, 1,
                                         0., 1., 0., 1., 0., 1.,
                                         elem_type);
    else if (elem_type == Utility::string_to_enum<ElemType>("TET4"))
      {
        // manually build a Tet4 element
        mesh.add_point( Point(0,0,0), 0 );
        mesh.add_point( Point(1,0,0), 1 );
        mesh.add_point( Point(0,1,0), 2 );
        mesh.add_point( Point(1./3.,1./3.,1), 3 );
 
        Elem * elem = mesh.add_elem(Elem::build_with_id(TET4, 0));
        elem->set_node(0, mesh.node_ptr(0));
        elem->set_node(1, mesh.node_ptr(1));
        elem->set_node(2, mesh.node_ptr(2));
        elem->set_node(3, mesh.node_ptr(3));
 
        mesh.prepare_for_use();
      }
    es.init();
 
    // static sets of nodes and their neighbors
    std::set<dof_id_type> coarse_nodes;
    std::map<dof_id_type, std::vector<dof_id_type>> side_nbr_nodes;
    std::map<dof_id_type, std::vector<dof_id_type>> face_nbr_nodes;
    std::map<dof_id_type, std::vector<dof_id_type>> int_nbr_nodes;
 
    if (elem_type == Utility::string_to_enum<ElemType>("HEX8"))
      {
        coarse_nodes.insert({0,1,2,3,4,5,6,7});
 
        // fill neighbor maps based on static node numbering
        side_nbr_nodes.insert({8, {0,1}});
        side_nbr_nodes.insert({10, {0,2}});
        side_nbr_nodes.insert({15, {1,3}});
        side_nbr_nodes.insert({18, {2,3}});
        side_nbr_nodes.insert({11, {0,4}});
        side_nbr_nodes.insert({16, {1,5}});
        side_nbr_nodes.insert({21, {3,7}});
        side_nbr_nodes.insert({20, {2,6}});
        side_nbr_nodes.insert({22, {4,5}});
        side_nbr_nodes.insert({24, {4,6}});
        side_nbr_nodes.insert({25, {5,7}});
        side_nbr_nodes.insert({26, {6,7}});
 
        face_nbr_nodes.insert({12, {0,1,4,5}});
        face_nbr_nodes.insert({9 , {0,1,2,3}});
        face_nbr_nodes.insert({14, {0,2,4,6}});
        face_nbr_nodes.insert({17, {1,3,5,7}});
        face_nbr_nodes.insert({19, {2,3,6,7}});
        face_nbr_nodes.insert({23, {4,5,6,7}});
 
        int_nbr_nodes.insert({13, {0,1,2,3,4,5,6,7}});
      }
    else if (elem_type == Utility::string_to_enum<ElemType>("TET4"))
      {
        coarse_nodes.insert({0,1,2,3});
 
        // fill neighbor maps based on static node numbering
        side_nbr_nodes.insert({4, {0,1}});
        side_nbr_nodes.insert({5, {0,2}});
        side_nbr_nodes.insert({6, {0,3}});
        side_nbr_nodes.insert({7, {1,2}});
        side_nbr_nodes.insert({8, {1,3}});
        side_nbr_nodes.insert({9, {2,3}});
      }
 
    // stash number of dofs on coarse grid for projection sizing
    int n_old_dofs = sys.n_dofs();
 
    // save old coarse dof_ids in order of coarse nodes
    std::map <dof_id_type, dof_id_type> node2dof_c;
    for ( const auto & node : mesh.node_ptr_range() )
      {
        dof_id_type cdof_id = node->dof_number(0,0,0);
        node2dof_c.insert( std::pair<dof_id_type,dof_id_type>( node->id() , cdof_id) );
      }
 
    // refine the mesh so we can utilize old_dof_indices for projection_matrix
    MeshRefinement mr(mesh);
    mr.uniformly_refine(1);
    sys.get_dof_map().distribute_dofs(mesh);
 
    // fine node to dof map
    std::map <dof_id_type, dof_id_type> node2dof_f;
    for ( const auto & node : mesh.local_node_ptr_range() )
      {
        dof_id_type fdof_id = node->dof_number(0,0,0);
        node2dof_f.insert( std::pair<dof_id_type,dof_id_type>(node->id() , fdof_id) );
      }
 
    // local and global projection_matrix sizes infos
    int n_new_dofs = sys.n_dofs();
    int n_new_dofs_local = sys.get_dof_map().n_dofs_on_processor(sys.processor_id());
    int ndofs_old_first = sys.get_dof_map().first_old_dof(sys.processor_id());
    int ndofs_old_end   = sys.get_dof_map().end_old_dof(sys.processor_id());
    int n_old_dofs_local = ndofs_old_end - ndofs_old_first;
 
    // init and compute the projection matrix using GenericProjector
    std::unique_ptr<SparseMatrix<Number> > proj_mat_ptr =
      SparseMatrix<Number>::build(*TestCommWorld);
    SparseMatrix<Number> & proj_mat = *proj_mat_ptr;
    proj_mat.init(n_new_dofs, n_old_dofs, n_new_dofs_local, n_old_dofs_local);
    sys.projection_matrix(proj_mat);
    proj_mat.close();
 
    // init the gold standard projection matrix
    std::unique_ptr<SparseMatrix<Number> > gold_mat_ptr =
      SparseMatrix<Number>::build(*TestCommWorld);
    SparseMatrix<Number> & gold_mat = *gold_mat_ptr;
    gold_mat.init(n_new_dofs, n_old_dofs, n_new_dofs_local, n_old_dofs_local);
 
    // construct the gold projection matrix using static node numbering as reference info
    for ( const auto & node : mesh.local_node_ptr_range() )
      {
        dof_id_type node_id = node->id();
        dof_id_type fdof_id = (node2dof_f.find(node_id))->second;
 
        if (coarse_nodes.find(node_id) != coarse_nodes.end() )
          { // direct inject coarse nodes
            if (fdof_id >= gold_mat.row_start() && fdof_id < gold_mat.row_stop())
              {
                auto cdof_id = node2dof_c.find(node_id);
                gold_mat.set(fdof_id, cdof_id->second, 1.0);
              }
          }
        else if ( side_nbr_nodes.find(node_id) != side_nbr_nodes.end() )
          { // new side nodes with old_dof neighbor contributions
            if (fdof_id >= gold_mat.row_start() && fdof_id < gold_mat.row_stop())
              {
                auto node_nbrs = side_nbr_nodes.find(node_id);
                for (auto nbr : node_nbrs->second)
                  {
                    auto nbr_dof = node2dof_c.find(nbr);
                    gold_mat.set(fdof_id, nbr_dof->second, 0.5);
                  }
              }
          }
        else if ( face_nbr_nodes.find(node_id) != face_nbr_nodes.end() )
          { // new face nodes with old_dof neighbor contributions
            if (fdof_id >= gold_mat.row_start() && fdof_id < gold_mat.row_stop())
              {
                auto node_nbrs = face_nbr_nodes.find(node_id);
                for (auto nbr : node_nbrs->second)
                  {
                    auto nbr_dof = node2dof_c.find(nbr);
                    gold_mat.set(fdof_id, nbr_dof->second, 0.25);
                  }
              }
          }
        else
          { // new interior nodes with old_dof neighbor contributions
            if (fdof_id >= gold_mat.row_start() && fdof_id < gold_mat.row_stop())
              {
                auto node_nbrs = int_nbr_nodes.find(node_id);
                for (auto nbr : node_nbrs->second)
                  {
                    auto nbr_dof = node2dof_c.find(nbr);
                    gold_mat.set(fdof_id, nbr_dof->second, 0.125);
                  }
              }
          }
      } // end gold mat build
    gold_mat.close();
 
    // calculate relative difference norm between the two projection matrices
    Real gold_norm = gold_mat.linfty_norm();
    proj_mat.add(-1.0, gold_mat);
    Real diff_norm = proj_mat.linfty_norm();
    CPPUNIT_ASSERT(diff_norm/gold_norm < TOLERANCE*TOLERANCE);
  }

References libMesh::SparseMatrix< T >::add(), libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshBase::allow_renumbering(), libMesh::SparseMatrix< T >::build(), libMesh::MeshTools::Generation::build_cube(), libMesh::Elem::build_with_id(), libMesh::SparseMatrix< T >::close(), libMesh::DofMap::distribute_dofs(), libMesh::DofMapBase::end_old_dof(), libMesh::FIRST, libMesh::DofMapBase::first_old_dof(), libMesh::System::get_dof_map(), libMesh::EquationSystems::init(), libMesh::SparseMatrix< T >::init(), libMesh::LAGRANGE, libMesh::SparseMatrix< T >::linfty_norm(), mesh, libMesh::System::n_dofs(), libMesh::DofMapBase::n_dofs_on_processor(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::System::projection_matrix(), libMesh::Real, libMesh::SparseMatrix< T >::row_start(), libMesh::SparseMatrix< T >::row_stop(), libMesh::SparseMatrix< T >::set(), libMesh::Elem::set_node(), TestCommWorld, libMesh::TET4, libMesh::TOLERANCE, and libMesh::MeshRefinement::uniformly_refine().

Referenced by testProjectMatrixHex8(), and testProjectMatrixTet4().

testProjectMatrixEdge2()

void SystemsTest::testProjectMatrixEdge2 ( )

inline

Definition at line 2023 of file systems_test.C.

{ LOG_UNIT_TEST; testProjectMatrix1D(EDGE2); }

References libMesh::EDGE2, and testProjectMatrix1D().

testProjectMatrixHex8()

void SystemsTest::testProjectMatrixHex8 ( )

inline

Definition at line 2026 of file systems_test.C.

{ LOG_UNIT_TEST; testProjectMatrix3D(HEX8); }

References libMesh::HEX8, and testProjectMatrix3D().

testProjectMatrixQuad4()

void SystemsTest::testProjectMatrixQuad4 ( )

inline

Definition at line 2024 of file systems_test.C.

{ LOG_UNIT_TEST; testProjectMatrix2D(QUAD4); }

References libMesh::QUAD4, and testProjectMatrix2D().

testProjectMatrixTet4()

void SystemsTest::testProjectMatrixTet4 ( )

inline

Definition at line 2027 of file systems_test.C.

{ LOG_UNIT_TEST; testProjectMatrix3D(TET4); }

References testProjectMatrix3D(), and libMesh::TET4.

testProjectMatrixTri3()

void SystemsTest::testProjectMatrixTri3 ( )

inline

Definition at line 2025 of file systems_test.C.

{ LOG_UNIT_TEST; testProjectMatrix2D(TRI3); }

References testProjectMatrix2D(), and libMesh::TRI3.

testProjectMeshFunctionHex27()

void SystemsTest::testProjectMeshFunctionHex27 ( )

inline

Definition at line 2005 of file systems_test.C.

{ LOG_UNIT_TEST; testProjectCubeWithMeshFunction(HEX27); }

References libMesh::HEX27, and testProjectCubeWithMeshFunction().

testProjectScalarCoarsening()

void SystemsTest::testProjectScalarCoarsening ( )

inline

Definition at line 834 of file systems_test.C.

  {
    Mesh mesh(*TestCommWorld);
 
    MeshTools::Generation::build_square(mesh,
                                        2, 2,
                                        0., 1.,
                                        0., 1.,
                                        QUAD4);
 
    // Initialize the EquationSystems on a refined mesh so that the
    // subsequent reinit performs a fine-to-coarse projection.
    MeshRefinement mesh_refinement(mesh);
    for (auto & elem : mesh.active_element_ptr_range())
      elem->set_refinement_flag(Elem::REFINE);
    mesh_refinement.refine_elements();
    mesh.prepare_for_use();
 
    EquationSystems es(mesh);
    ExplicitSystem & sys =
      es.add_system<ExplicitSystem>("SimpleSystem");
 
    sys.add_variable("u", CONSTANT, MONOMIAL);
    const unsigned int scalar_var =
      sys.add_variable("scalar", FIRST, SCALAR);
 
    es.init();
 
    std::vector<dof_id_type> scalar_dofs;
    sys.get_dof_map().SCALAR_dof_indices(scalar_dofs, scalar_var);
    CPPUNIT_ASSERT_EQUAL(std::size_t(1), scalar_dofs.size());
 
    NumericVector<Number> & solution = *sys.solution;
    const dof_id_type scalar_dof = scalar_dofs[0];
    if (scalar_dof >= solution.first_local_index() &&
        scalar_dof < solution.last_local_index())
      solution.set(scalar_dof, 7.25);
    solution.close();
 
    for (auto & elem : mesh.active_element_ptr_range())
      elem->set_refinement_flag(Elem::COARSEN);
 
    es.reinit();
 
    scalar_dofs.clear();
    sys.get_dof_map().SCALAR_dof_indices(scalar_dofs, scalar_var);
    CPPUNIT_ASSERT_EQUAL(std::size_t(1), scalar_dofs.size());
 
    std::unique_ptr<NumericVector<Number>> localized_solution =
      NumericVector<Number>::build(es.comm());
    localized_solution->init(sys.n_dofs(), false, SERIAL);
    sys.solution->localize(*localized_solution);
 
    LIBMESH_ASSERT_NUMBERS_EQUAL((*localized_solution)(scalar_dofs[0]),
                                 Number(7.25),
                                 TOLERANCE);
  }

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::NumericVector< T >::build(), libMesh::MeshTools::Generation::build_square(), libMesh::NumericVector< T >::close(), libMesh::Elem::COARSEN, libMesh::ParallelObject::comm(), libMesh::CONSTANT, libMesh::FIRST, libMesh::NumericVector< T >::first_local_index(), libMesh::System::get_dof_map(), libMesh::EquationSystems::init(), libMesh::NumericVector< T >::last_local_index(), mesh, libMesh::MONOMIAL, libMesh::System::n_dofs(), libMesh::MeshBase::prepare_for_use(), libMesh::QUAD4, libMesh::Elem::REFINE, libMesh::MeshRefinement::refine_elements(), libMesh::EquationSystems::reinit(), libMesh::SCALAR, libMesh::DofMap::SCALAR_dof_indices(), libMesh::SERIAL, libMesh::NumericVector< T >::set(), libMesh::System::solution, TestCommWorld, and libMesh::TOLERANCE.

testProjectSquare()

void SystemsTest::testProjectSquare ( const ElemType  elem_type )

inline

Definition at line 993 of file systems_test.C.

  {
    Mesh mesh(*TestCommWorld);
 
    EquationSystems es(mesh);
    TransientExplicitSystem &sys =
      es.add_system<TransientExplicitSystem> ("SimpleSystem");
 
    std::set<subdomain_id_type> u_subdomains {0, 1, 4, 5},
                                v_subdomains {1, 2, 3, 4},
                                w_subdomains {0, 1, 2, 3, 4};
 
    sys.add_variable("u", THIRD,    HIERARCHIC, &u_subdomains);
    sys.add_variable("v", FIRST,    LAGRANGE,   &v_subdomains);
    sys.add_variable("w", CONSTANT, MONOMIAL,   &w_subdomains);
 
    MeshTools::Generation::build_square (mesh,
                                         3, 3,
                                         0., 1., 0., 1.,
                                         elem_type);
 
    for (auto & elem : mesh.element_ptr_range())
      elem->subdomain_id() = elem->id()/2;
 
    es.init();
    TripleFunction tfunc;
    sys.project_solution(&tfunc);
    tfunc.offset = 10;
    sys.project_vector(*sys.old_local_solution, &tfunc);
    tfunc.offset = 20;
    sys.project_vector(*sys.older_local_solution, &tfunc);
 
    std::unique_ptr<PointLocatorBase> locator = mesh.sub_point_locator();
    locator->enable_out_of_mesh_mode();
    for (Real x = 0.1; x < 1; x += 0.2)
      for (Real y = 0.1; y < 1; y += 0.2)
        tripleValueTest(Point(x,y), sys, *locator,
                        u_subdomains, v_subdomains, w_subdomains,
                        es.parameters);
 
#ifdef LIBMESH_ENABLE_AMR
    for (auto & elem : mesh.element_ptr_range())
      if ((elem->id()/2)%2)
        elem->set_refinement_flag(Elem::REFINE);
    es.reinit();
 
    locator = mesh.sub_point_locator();
    locator->enable_out_of_mesh_mode();
    for (Real x = 0.1; x < 1; x += 0.2)
      for (Real y = 0.1; y < 1; y += 0.2)
        tripleValueTest(Point(x,y), sys, *locator,
                        u_subdomains, v_subdomains, w_subdomains,
                        es.parameters);
#endif
  }

References libMesh::EquationSystems::add_system(), libMesh::MeshTools::Generation::build_square(), libMesh::CONSTANT, libMesh::FIRST, libMesh::HIERARCHIC, libMesh::EquationSystems::init(), libMesh::LAGRANGE, mesh, libMesh::MONOMIAL, TripleFunction::offset, libMesh::TransientSystem< Base >::old_local_solution, libMesh::TransientSystem< Base >::older_local_solution, libMesh::EquationSystems::parameters, libMesh::Real, libMesh::Elem::REFINE, libMesh::EquationSystems::reinit(), libMesh::MeshBase::sub_point_locator(), TestCommWorld, libMesh::THIRD, and tripleValueTest().

Referenced by testProjectHierarchicQuad9(), testProjectHierarchicTri6(), and testProjectHierarchicTri7().

testSetSystemParameterOverEquationSystem()

void SystemsTest::testSetSystemParameterOverEquationSystem ( )

inline

Definition at line 1384 of file systems_test.C.

  {
    LOG_UNIT_TEST;
 
    ReplicatedMesh mesh(*TestCommWorld);
 
    MeshTools::Generation::build_cube (mesh,
                                      1,
                                      0,
                                      0,
                                      0., 1.,
                                      0., 0.,
                                      0., 0.,
                                      EDGE2);
 
    Point new_point_a(2.);
    Point new_point_b(3.);
    Node* new_node_a = mesh.add_point( new_point_a );
    Node* new_node_b = mesh.add_point( new_point_b );
    auto new_edge_elem = mesh.add_elem(Elem::build(EDGE2));
    new_edge_elem->set_node(0, new_node_a);
    new_edge_elem->set_node(1, new_node_b);
 
    mesh.elem_ref(0).subdomain_id() = 10;
    mesh.elem_ref(1).subdomain_id() = 10;
 
    mesh.prepare_for_use();
 
    // Create an equation systems object.
    EquationSystems equation_systems (mesh);
 
    // Set some parameters to the equation system that would cause a failed test
    equation_systems.parameters.set<unsigned int>("linear solver maximum iterations") = 0;
 
    // Setup Linear Implicit system
    LinearImplicitSystem & li_system =
      equation_systems.add_system<LinearImplicitSystem> ("test");
 
    // We must use a discontinuous variable type in this test or
    // else the sparsity pattern will not be correct
    li_system.add_variable("u", FIRST, L2_LAGRANGE);
 
    MeshTools::Generation::build_cube (mesh,
                                       5, 5, 5,
                                       0., 1., 0., 1., 0., 1.,
                                       HEX8);
 
    li_system.attach_assemble_function (assembly_with_dg_fem_context);
    li_system.get_linear_solver()->set_solver_type(GMRES);
    // Need 5 iterations, dont overdo the preconditioning
    li_system.get_linear_solver()->set_preconditioner_type(IDENTITY_PRECOND);
 
    // Set some parameters to the system that work for the solve
    li_system.parameters.set<unsigned int>("linear solver maximum iterations") = 5;
    li_system.parameters.set<Real>("linear solver tolerance") = 1e-100;
 
    // Need to init before we can access the system matrix
    equation_systems.init ();
 
    // See the solve pass, indicating system parameters are used over equation system parameters
    li_system.solve();
 
    // Check that the number of iterations from the systems got obeyed
    CPPUNIT_ASSERT_EQUAL(li_system.n_linear_iterations(), 5u);
}

References libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), assembly_with_dg_fem_context(), libMesh::Elem::build(), libMesh::MeshTools::Generation::build_cube(), libMesh::EDGE2, libMesh::MeshBase::elem_ref(), libMesh::FIRST, libMesh::GMRES, libMesh::HEX8, libMesh::IDENTITY_PRECOND, libMesh::EquationSystems::init(), libMesh::L2_LAGRANGE, mesh, libMesh::EquationSystems::parameters, libMesh::MeshBase::prepare_for_use(), libMesh::Real, libMesh::Parameters::set(), libMesh::Elem::set_node(), libMesh::Elem::subdomain_id(), and TestCommWorld.

testUninitializedInfo()

void SystemsTest::testUninitializedInfo ( )

inline

Definition at line 668 of file systems_test.C.

  {
    Mesh mesh(*TestCommWorld);
    EquationSystems es(mesh);
    ExplicitSystem & sys = simpleSetup(mesh, es);
 
    auto info = sys.get_info();
 
    CPPUNIT_ASSERT (info.find("uninitialized") != std::string::npos);
  }

References libMesh::System::get_info(), mesh, simpleSetup(), and TestCommWorld.

tripleValueTest()

void SystemsTest::tripleValueTest ( const Point &  p, const TransientExplicitSystem &  sys, const PointLocatorBase &  locator, std::set< subdomain_id_type > &  u_subdomains, std::set< subdomain_id_type > &  v_subdomains, std::set< subdomain_id_type > &  w_subdomains, const Parameters &  param  )

inlineprivate

Definition at line 511 of file systems_test.C.

  {
    const Elem * elem = locator(p);
    subdomain_id_type sbd_id = elem ? elem->subdomain_id() : 0;
    TestCommWorld->max(sbd_id);
 
    if (u_subdomains.count(sbd_id))
      {
        LIBMESH_ASSERT_NUMBERS_EQUAL(cubic_test(p,param,"",""),
                                sys.point_value(0,p),
                                TOLERANCE*TOLERANCE*10);
        LIBMESH_ASSERT_NUMBERS_EQUAL
          (cubic_test(p,param,"","") + Number(10),
           sys.point_value(0,p,sys.old_local_solution),
           TOLERANCE*TOLERANCE*100);
        LIBMESH_ASSERT_NUMBERS_EQUAL
          (cubic_test(p,param,"","") + Number(20),
           sys.point_value(0,p,sys.older_local_solution),
           TOLERANCE*TOLERANCE*100);
      }
    if (v_subdomains.count(sbd_id))
      {
        LIBMESH_ASSERT_NUMBERS_EQUAL
          (new_linear_test(p,param,"",""), sys.point_value(1,p),
           TOLERANCE*TOLERANCE*10);
        LIBMESH_ASSERT_NUMBERS_EQUAL
          (new_linear_test(p,param,"","") + Number(10),
           sys.point_value(1,p,sys.old_local_solution),
           TOLERANCE*TOLERANCE*100);
        LIBMESH_ASSERT_NUMBERS_EQUAL
          (new_linear_test(p,param,"","") + Number(20),
           sys.point_value(1,p,sys.older_local_solution),
           TOLERANCE*TOLERANCE*100);
      }
    if (w_subdomains.count(sbd_id))
      {
        LIBMESH_ASSERT_NUMBERS_EQUAL
          (disc_thirds_test(p,param,"",""), sys.point_value(2,p),
           TOLERANCE*TOLERANCE*10);
        LIBMESH_ASSERT_NUMBERS_EQUAL
          (disc_thirds_test(p,param,"","") + Number(10),
           sys.point_value(2,p,sys.old_local_solution),
           TOLERANCE*TOLERANCE*100);
        LIBMESH_ASSERT_NUMBERS_EQUAL
          (disc_thirds_test(p,param,"","") + Number(20),
           sys.point_value(2,p,sys.older_local_solution),
           TOLERANCE*TOLERANCE*100);
      }
  }

References cubic_test(), disc_thirds_test(), new_linear_test(), libMesh::TransientSystem< Base >::old_local_solution, libMesh::TransientSystem< Base >::older_local_solution, libMesh::Elem::subdomain_id(), TestCommWorld, and libMesh::TOLERANCE.

Referenced by testProjectCube(), testProjectLine(), and testProjectSquare().

---

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

• tests/systems/systems_test.C