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 (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	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/35]

SystemsTest::CPPUNIT_TEST

(

test100KVariables

)

CPPUNIT_TEST() [2/35]

SystemsTest::CPPUNIT_TEST

(

testUninitializedInfo

)

CPPUNIT_TEST() [3/35]

SystemsTest::CPPUNIT_TEST

(

testPostInitAddVector

)

CPPUNIT_TEST() [4/35]

SystemsTest::CPPUNIT_TEST

(

testAddVectorProjChange

)

CPPUNIT_TEST() [5/35]

SystemsTest::CPPUNIT_TEST

(

testAddVectorTypeChange

)

CPPUNIT_TEST() [6/35]

SystemsTest::CPPUNIT_TEST

(

testPostInitAddVectorTypeChange

)

CPPUNIT_TEST() [7/35]

SystemsTest::CPPUNIT_TEST

(

testProjectHierarchicEdge3

)

CPPUNIT_TEST() [8/35]

SystemsTest::CPPUNIT_TEST

(

testProjectHierarchicQuad9

)

CPPUNIT_TEST() [9/35]

SystemsTest::CPPUNIT_TEST

(

testProjectHierarchicTri6

)

CPPUNIT_TEST() [10/35]

SystemsTest::CPPUNIT_TEST

(

testProjectHierarchicTri7

)

CPPUNIT_TEST() [11/35]

SystemsTest::CPPUNIT_TEST

(

test2DProjectVectorFETri3

)

CPPUNIT_TEST() [12/35]

SystemsTest::CPPUNIT_TEST

(

test2DProjectVectorFEQuad4

)

CPPUNIT_TEST() [13/35]

SystemsTest::CPPUNIT_TEST

(

test2DProjectVectorFETri6

)

CPPUNIT_TEST() [14/35]

SystemsTest::CPPUNIT_TEST

(

test2DProjectVectorFETri7

)

CPPUNIT_TEST() [15/35]

SystemsTest::CPPUNIT_TEST

(

test2DProjectVectorFEQuad8

)

CPPUNIT_TEST() [16/35]

SystemsTest::CPPUNIT_TEST

(

test2DProjectVectorFEQuad9

)

CPPUNIT_TEST() [17/35]

SystemsTest::CPPUNIT_TEST

(

testBlockRestrictedVarNDofs

)

CPPUNIT_TEST() [18/35]

SystemsTest::CPPUNIT_TEST

(

testFirstScalarNumber

)

CPPUNIT_TEST() [19/35]

SystemsTest::CPPUNIT_TEST

(

testProjectHierarchicHex27

)

CPPUNIT_TEST() [20/35]

SystemsTest::CPPUNIT_TEST

(

testProjectMeshFunctionHex27

)

CPPUNIT_TEST() [21/35]

SystemsTest::CPPUNIT_TEST

(

testBoundaryProjectCube

)

CPPUNIT_TEST() [22/35]

SystemsTest::CPPUNIT_TEST

(

test3DProjectVectorFETet4

)

CPPUNIT_TEST() [23/35]

SystemsTest::CPPUNIT_TEST

(

test3DProjectVectorFEHex8

)

CPPUNIT_TEST() [24/35]

SystemsTest::CPPUNIT_TEST

(

test3DProjectVectorFETet10

)

CPPUNIT_TEST() [25/35]

SystemsTest::CPPUNIT_TEST

(

test3DProjectVectorFETet14

)

CPPUNIT_TEST() [26/35]

SystemsTest::CPPUNIT_TEST

(

test3DProjectVectorFEHex20

)

CPPUNIT_TEST() [27/35]

SystemsTest::CPPUNIT_TEST

(

test3DProjectVectorFEHex27

)

CPPUNIT_TEST() [28/35]

SystemsTest::CPPUNIT_TEST

(

testSetSystemParameterOverEquationSystem

)

CPPUNIT_TEST() [29/35]

SystemsTest::CPPUNIT_TEST

(

testAssemblyWithDgFemContext

)

CPPUNIT_TEST() [30/35]

SystemsTest::CPPUNIT_TEST

(

testDofCouplingWithVarGroups

)

CPPUNIT_TEST() [31/35]

SystemsTest::CPPUNIT_TEST

(

testProjectMatrixEdge2

)

CPPUNIT_TEST() [32/35]

SystemsTest::CPPUNIT_TEST

(

testProjectMatrixQuad4

)

CPPUNIT_TEST() [33/35]

SystemsTest::CPPUNIT_TEST

(

testProjectMatrixTri3

)

CPPUNIT_TEST() [34/35]

SystemsTest::CPPUNIT_TEST

(

testProjectMatrixHex8

)

CPPUNIT_TEST() [35/35]

SystemsTest::CPPUNIT_TEST

(

testProjectMatrixTet4

)

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 566 of file systems_test.C.

  {}

simpleSetup()

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

inline

Definition at line 573 of file systems_test.C.

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

  {
    ExplicitSystem &sys =
      es.add_system<ExplicitSystem> ("Simple");

    sys.add_variable("u", FIRST);

    MeshTools::Generation::build_line (mesh,
                                       10,
                                       0., 1.,
                                       EDGE3);

    return sys;
  }

tearDown()

void SystemsTest::tearDown ( )

inline

Definition at line 569 of file systems_test.C.

  {}

test100KVariables()

void SystemsTest::test100KVariables ( )

inline

Definition at line 629 of file systems_test.C.

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::DofMap::n_dofs(), libMesh::System::n_dofs(), libMesh::DofMap::n_dofs_per_processor(), and TestCommWorld.

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

test2DProjectVectorFE()

void SystemsTest::test2DProjectVectorFE ( const ElemType  elem_type )

inline

Definition at line 831 of file systems_test.C.

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.

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

test2DProjectVectorFEQuad4()

void SystemsTest::test2DProjectVectorFEQuad4 ( )

inline

Definition at line 1945 of file systems_test.C.

References libMesh::QUAD4.

{ LOG_UNIT_TEST; test2DProjectVectorFE(QUAD4); }

test2DProjectVectorFEQuad8()

void SystemsTest::test2DProjectVectorFEQuad8 ( )

inline

Definition at line 1948 of file systems_test.C.

References libMesh::QUAD8.

{ LOG_UNIT_TEST; test2DProjectVectorFE(QUAD8); }

test2DProjectVectorFEQuad9()

void SystemsTest::test2DProjectVectorFEQuad9 ( )

inline

Definition at line 1949 of file systems_test.C.

References libMesh::QUAD9.

{ LOG_UNIT_TEST; test2DProjectVectorFE(QUAD9); }

test2DProjectVectorFETri3()

void SystemsTest::test2DProjectVectorFETri3 ( )

inline

Definition at line 1944 of file systems_test.C.

References libMesh::TRI3.

{ LOG_UNIT_TEST; test2DProjectVectorFE(TRI3); }

test2DProjectVectorFETri6()

void SystemsTest::test2DProjectVectorFETri6 ( )

inline

Definition at line 1946 of file systems_test.C.

References libMesh::TRI6.

{ LOG_UNIT_TEST; test2DProjectVectorFE(TRI6); }

test2DProjectVectorFETri7()

void SystemsTest::test2DProjectVectorFETri7 ( )

inline

Definition at line 1947 of file systems_test.C.

References libMesh::TRI7.

{ LOG_UNIT_TEST; test2DProjectVectorFE(TRI7); }

test3DProjectVectorFE()

void SystemsTest::test3DProjectVectorFE ( const ElemType  elem_type )

inline

Definition at line 881 of file systems_test.C.

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.

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

test3DProjectVectorFEHex20()

void SystemsTest::test3DProjectVectorFEHex20 ( )

inline

Definition at line 1954 of file systems_test.C.

References libMesh::HEX20.

{ LOG_UNIT_TEST; test3DProjectVectorFE(HEX20); }

test3DProjectVectorFEHex27()

void SystemsTest::test3DProjectVectorFEHex27 ( )

inline

Definition at line 1955 of file systems_test.C.

References libMesh::HEX27.

{ LOG_UNIT_TEST; test3DProjectVectorFE(HEX27); }

test3DProjectVectorFEHex8()

void SystemsTest::test3DProjectVectorFEHex8 ( )

inline

Definition at line 1951 of file systems_test.C.

References libMesh::HEX8.

{ LOG_UNIT_TEST; test3DProjectVectorFE(HEX8); }

test3DProjectVectorFETet10()

void SystemsTest::test3DProjectVectorFETet10 ( )

inline

Definition at line 1952 of file systems_test.C.

References libMesh::TET10.

{ LOG_UNIT_TEST; test3DProjectVectorFE(TET10); }

test3DProjectVectorFETet14()

void SystemsTest::test3DProjectVectorFETet14 ( )

inline

Definition at line 1953 of file systems_test.C.

References libMesh::TET14.

{ LOG_UNIT_TEST; test3DProjectVectorFE(TET14); }

test3DProjectVectorFETet4()

void SystemsTest::test3DProjectVectorFETet4 ( )

inline

Definition at line 1950 of file systems_test.C.

References libMesh::TET4.

{ LOG_UNIT_TEST; test3DProjectVectorFE(TET4); }

testAddVectorProjChange()

void SystemsTest::testAddVectorProjChange ( )

inline

Definition at line 695 of file systems_test.C.

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

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

testAddVectorTypeChange()

void SystemsTest::testAddVectorTypeChange ( )

inline

Definition at line 709 of file systems_test.C.

References libMesh::System::add_vector(), libMesh::GHOSTED, mesh, libMesh::PARALLEL, TIMPI::Communicator::size(), TestCommWorld, and libMesh::System::vector_preservation().

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

testAssemblyWithDgFemContext()

void SystemsTest::testAssemblyWithDgFemContext ( )

inline

Definition at line 1388 of file systems_test.C.

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.

  {
    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.
  }

testBlockRestrictedVarNDofs()

void SystemsTest::testBlockRestrictedVarNDofs ( )

inline

Definition at line 1414 of file systems_test.C.

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), TIMPI::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, TIMPI::Communicator::set_union(), and TestCommWorld.

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

testBoundaryProjectCube()

void SystemsTest::testBoundaryProjectCube ( )

inline

Definition at line 1106 of file systems_test.C.

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, TIMPI::Communicator::set_union(), libMesh::System::solution, TestCommWorld, and libMesh::TOLERANCE.

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

testDofCouplingWithVarGroups()

void SystemsTest::testDofCouplingWithVarGroups ( )

inline

Definition at line 1251 of file systems_test.C.

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.

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

testFirstScalarNumber()

void SystemsTest::testFirstScalarNumber ( )

inline

Definition at line 590 of file systems_test.C.

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().

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

testPostInitAddVector()

void SystemsTest::testPostInitAddVector ( )

inline

Definition at line 678 of file systems_test.C.

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

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

testPostInitAddVectorTypeChange()

void SystemsTest::testPostInitAddVectorTypeChange ( )

inline

Definition at line 737 of file systems_test.C.

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, TIMPI::Communicator::size(), TestCommWorld, and libMesh::System::vector_preservation().

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

testProjectCube()

void SystemsTest::testProjectCube ( const ElemType  elem_type )

inline

Definition at line 987 of file systems_test.C.

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, and libMesh::THIRD.

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

testProjectCubeWithMeshFunction()

void SystemsTest::testProjectCubeWithMeshFunction ( const ElemType  elem_type )

inline

Definition at line 1045 of file systems_test.C.

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::MeshFunction::init(), libMesh::EquationSystems::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.

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

testProjectHierarchicEdge3()

void SystemsTest::testProjectHierarchicEdge3 ( )

inline

Definition at line 1938 of file systems_test.C.

References libMesh::EDGE3.

{ LOG_UNIT_TEST; testProjectLine(EDGE3); }

testProjectHierarchicHex27()

void SystemsTest::testProjectHierarchicHex27 ( )

inline

Definition at line 1942 of file systems_test.C.

References libMesh::HEX27.

{ LOG_UNIT_TEST; testProjectCube(HEX27); }

testProjectHierarchicQuad9()

void SystemsTest::testProjectHierarchicQuad9 ( )

inline

Definition at line 1939 of file systems_test.C.

References libMesh::QUAD9.

{ LOG_UNIT_TEST; testProjectSquare(QUAD9); }

testProjectHierarchicTri6()

void SystemsTest::testProjectHierarchicTri6 ( )

inline

Definition at line 1940 of file systems_test.C.

References libMesh::TRI6.

{ LOG_UNIT_TEST; testProjectSquare(TRI6); }

testProjectHierarchicTri7()

void SystemsTest::testProjectHierarchicTri7 ( )

inline

Definition at line 1941 of file systems_test.C.

References libMesh::TRI7.

{ LOG_UNIT_TEST; testProjectSquare(TRI7); }

testProjectLine()

void SystemsTest::testProjectLine ( const ElemType  elem_type )

inline

Definition at line 777 of file systems_test.C.

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, and libMesh::THIRD.

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

testProjectMatrix1D()

void SystemsTest::testProjectMatrix1D ( const ElemType  elem_type )

inline

Definition at line 1480 of file systems_test.C.

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::MeshTools::Subdivision::next, libMesh::MeshTools::Subdivision::prev, 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().

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

testProjectMatrix2D()

void SystemsTest::testProjectMatrix2D ( const ElemType  elem_type )

inline

Definition at line 1587 of file systems_test.C.

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().

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

testProjectMatrix3D()

void SystemsTest::testProjectMatrix3D ( const ElemType  elem_type )

inline

Definition at line 1746 of file systems_test.C.

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().

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

testProjectMatrixEdge2()

void SystemsTest::testProjectMatrixEdge2 ( )

inline

Definition at line 1961 of file systems_test.C.

References libMesh::EDGE2.

{ LOG_UNIT_TEST; testProjectMatrix1D(EDGE2); }

testProjectMatrixHex8()

void SystemsTest::testProjectMatrixHex8 ( )

inline

Definition at line 1964 of file systems_test.C.

References libMesh::HEX8.

{ LOG_UNIT_TEST; testProjectMatrix3D(HEX8); }

testProjectMatrixQuad4()

void SystemsTest::testProjectMatrixQuad4 ( )

inline

Definition at line 1962 of file systems_test.C.

References libMesh::QUAD4.

{ LOG_UNIT_TEST; testProjectMatrix2D(QUAD4); }

testProjectMatrixTet4()

void SystemsTest::testProjectMatrixTet4 ( )

inline

Definition at line 1965 of file systems_test.C.

References libMesh::TET4.

{ LOG_UNIT_TEST; testProjectMatrix3D(TET4); }

testProjectMatrixTri3()

void SystemsTest::testProjectMatrixTri3 ( )

inline

Definition at line 1963 of file systems_test.C.

References libMesh::TRI3.

{ LOG_UNIT_TEST; testProjectMatrix2D(TRI3); }

testProjectMeshFunctionHex27()

void SystemsTest::testProjectMeshFunctionHex27 ( )

inline

Definition at line 1943 of file systems_test.C.

References libMesh::HEX27.

{ LOG_UNIT_TEST; testProjectCubeWithMeshFunction(HEX27); }

testProjectSquare()

void SystemsTest::testProjectSquare ( const ElemType  elem_type )

inline

Definition at line 931 of file systems_test.C.

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, and libMesh::THIRD.

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

testSetSystemParameterOverEquationSystem()

void SystemsTest::testSetSystemParameterOverEquationSystem ( )

inline

Definition at line 1322 of file systems_test.C.

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.

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

testUninitializedInfo()

void SystemsTest::testUninitializedInfo ( )

inline

Definition at line 666 of file systems_test.C.

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

  {
    Mesh mesh(*TestCommWorld);
    EquationSystems es(mesh);
    ExplicitSystem & sys = simpleSetup(mesh, es);

    auto info = sys.get_info();

    CPPUNIT_ASSERT (info.find("uninitialized") != std::string::npos);
  }

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 509 of file systems_test.C.

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

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

---

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

• tests/systems/systems_test.C