ConstraintOperatorTest Class Reference

Inheritance diagram for ConstraintOperatorTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (ConstraintOperatorTest)
	CPPUNIT_TEST (test1DCoarseningOperator)
	CPPUNIT_TEST (test1DCoarseningNewNodes)
	CPPUNIT_TEST (testCoreformGeom2)
	CPPUNIT_TEST (testCoreformGeom4)
	CPPUNIT_TEST (testCoreformGeom8)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
void	test1DCoarseningOperator ()
void	testCoreform (const std::string &meshfile, const std::string &matrixfile, Real expected_norm, Order order=FIRST)
void	testCoreformGeom2 ()
void	testCoreformGeom4 ()
void	testCoreformGeom8 ()
void	test1DCoarseningNewNodes ()

Detailed Description

Definition at line 99 of file constraint_operator_test.C.

Member Function Documentation

CPPUNIT_TEST() [1/5]

ConstraintOperatorTest::CPPUNIT_TEST

(

test1DCoarseningOperator

)

CPPUNIT_TEST() [2/5]

ConstraintOperatorTest::CPPUNIT_TEST

(

test1DCoarseningNewNodes

)

CPPUNIT_TEST() [3/5]

ConstraintOperatorTest::CPPUNIT_TEST

(

testCoreformGeom2

)

CPPUNIT_TEST() [4/5]

ConstraintOperatorTest::CPPUNIT_TEST

(

testCoreformGeom4

)

CPPUNIT_TEST() [5/5]

ConstraintOperatorTest::CPPUNIT_TEST

(

testCoreformGeom8

)

CPPUNIT_TEST_SUITE_END()

ConstraintOperatorTest::CPPUNIT_TEST_SUITE_END

(

)

LIBMESH_CPPUNIT_TEST_SUITE()

ConstraintOperatorTest::LIBMESH_CPPUNIT_TEST_SUITE

(

ConstraintOperatorTest

)

setUp()

void ConstraintOperatorTest::setUp ( )

inline

Definition at line 129 of file constraint_operator_test.C.

  {}

tearDown()

void ConstraintOperatorTest::tearDown ( )

inline

Definition at line 132 of file constraint_operator_test.C.

  {}

test1DCoarseningNewNodes()

void ConstraintOperatorTest::test1DCoarseningNewNodes ( )

inline

Definition at line 316 of file constraint_operator_test.C.

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshBase::allow_renumbering(), assemble_matrix_and_rhs(), libMesh::System::attach_assemble_function(), libMesh::SparseMatrix< T >::build(), libMesh::MeshTools::Generation::build_line(), libMesh::ParallelObject::comm(), libMesh::MeshBase::copy_constraint_rows(), libMesh::EDGE2, libMesh::FIRST, libMesh::System::get_dof_map(), libMesh::EquationSystems::init(), libMesh::MeshBase::is_prepared(), mesh, libMesh::DofMap::n_constrained_dofs(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::prepare_for_use(), libMesh::SparseMatrix< T >::read_matlab(), libMesh::ExplicitSystem::solve(), TestCommWorld, and libMesh::MeshTools::valid_is_prepared().

  {
    LOG_UNIT_TEST;

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

    ExplicitSystem &sys =
      es.add_system<LinearImplicitSystem> ("test");

    sys.add_variable("u", FIRST);
    sys.attach_assemble_function (assemble_matrix_and_rhs);

    // Make sure numbering matches our constraint operator matrix
    mesh.allow_renumbering(false);

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

    // We should be prepared at this point
    CPPUNIT_ASSERT(mesh.is_prepared());
    CPPUNIT_ASSERT(MeshTools::valid_is_prepared(mesh));

    auto matrix = SparseMatrix<Number>::build (mesh.comm());

    // Create a projection matrix from 10 elements to 4.  We'll only
    // be leaving the end nodes and one central node unconstrained, so
    // we should see two new unconstrained NodeElem added.
    matrix->read_matlab("meshes/constrain10to4.m");

    mesh.copy_constraint_rows(*matrix);

    // We should still be prepared at this point
    CPPUNIT_ASSERT(mesh.is_prepared());
    CPPUNIT_ASSERT(MeshTools::valid_is_prepared(mesh));

    // Do a redundant prepare-for-use to catch any issues there
    mesh.prepare_for_use();

    es.init ();
    sys.solve();

    const DofMap & dof_map = sys.get_dof_map();

    CPPUNIT_ASSERT_EQUAL(dof_id_type(11+2), mesh.n_nodes());
    CPPUNIT_ASSERT_EQUAL(dof_id_type(10+2), mesh.n_elem());
    CPPUNIT_ASSERT_EQUAL(dof_id_type(8), dof_map.n_constrained_dofs());
  }

test1DCoarseningOperator()

void ConstraintOperatorTest::test1DCoarseningOperator ( )

inline

Definition at line 136 of file constraint_operator_test.C.

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshBase::allow_renumbering(), assemble_matrix_and_rhs(), libMesh::System::attach_assemble_function(), libMesh::ExactSolution::attach_exact_value(), libMesh::SparseMatrix< T >::build(), libMesh::NumericVector< T >::build(), libMesh::MeshTools::Generation::build_line(), libMesh::SparseMatrix< T >::close(), libMesh::ParallelObject::comm(), libMesh::ExactSolution::compute_error(), libMesh::MeshBase::copy_constraint_rows(), libMesh::EDGE2, libMesh::err, libMesh::FIRST, libMesh::System::get_dof_map(), libMesh::EquationSystems::init(), libMesh::SparseMatrix< T >::init(), libMesh::MeshBase::is_prepared(), libMesh::ExactSolution::l2_error(), libMesh::make_range(), mesh, libMesh::DofMap::n_constrained_dofs(), libMesh::MeshBase::prepare_for_use(), TIMPI::Communicator::rank(), libMesh::Real, libMesh::SERIAL, libMesh::SparseMatrix< T >::set(), libMesh::System::solution, libMesh::ExplicitSystem::solve(), TestCommWorld, libMesh::TOLERANCE, and libMesh::MeshTools::valid_is_prepared().

  {
    LOG_UNIT_TEST;

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

    ExplicitSystem &sys =
      es.add_system<LinearImplicitSystem> ("test");

    sys.add_variable("u", FIRST);
    sys.attach_assemble_function (assemble_matrix_and_rhs);

    // Make sure numbering matches our constraint operator matrix
    mesh.allow_renumbering(false);

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

    // We should be prepared at this point
    CPPUNIT_ASSERT(mesh.is_prepared());
    CPPUNIT_ASSERT(MeshTools::valid_is_prepared(mesh));

    auto matrix = SparseMatrix<Number>::build (mesh.comm());

    // Create a projection matrix from 10 elements to 5.  We might as
    // well just make it on processor 0.
    processor_id_type my_rank = mesh.comm().rank();
    matrix->init(11, 6,
                 (my_rank ? 0 : 11),
                 (my_rank ? 0 : 6),
                 (my_rank ? 0 : 6),
                 0);

    if (!my_rank)
      {
        for (auto i : make_range(5))
          {
            matrix->set(i*2, i, 1);
            matrix->set(i*2+1, i, 0.5);
            matrix->set(i*2+1, i+1, 0.5);
          }
        matrix->set(10, 5, 1);
      }
    matrix->close();

    mesh.copy_constraint_rows(*matrix);

    // We should still be prepared at this point
    CPPUNIT_ASSERT(mesh.is_prepared());
    CPPUNIT_ASSERT(MeshTools::valid_is_prepared(mesh));

    // Do a redundant prepare-for-use to catch any issues there
    mesh.prepare_for_use();

    es.init ();
    sys.solve();

    const DofMap & dof_map = sys.get_dof_map();

    CPPUNIT_ASSERT_EQUAL(dof_id_type(5), dof_map.n_constrained_dofs());

    // Now compare the results to just solving on 5 elements.

    // Matching up partitioning is hard, so just replicate+serialize
    ReplicatedMesh mesh2(*TestCommWorld);
    EquationSystems es2(mesh);

    ExplicitSystem &sys2 =
      es2.add_system<LinearImplicitSystem> ("test");

    sys2.add_variable("u", FIRST);
    sys2.attach_assemble_function (assemble_matrix_and_rhs);

    MeshTools::Generation::build_line (mesh2,
                                       5,
                                       0., 1.,
                                       EDGE2);

    es2.init ();
    sys2.solve();

    // Integrate any differences on the fine grid
    ExactSolution exact(es);

    // Serialize rather than figure out proper ghosting for an
    // arbitrary partitioning mix
    auto serialized_solution2 =
      NumericVector<Number>::build(*TestCommWorld);
    serialized_solution2->init(sys2.solution->size(), false, SERIAL);
    sys2.solution->localize(*serialized_solution2);

    MeshFunction coarse_solution
      (es2, *serialized_solution2, sys2.get_dof_map(), 0);

    exact.attach_exact_value(0, &coarse_solution);
    exact.compute_error("test", "u");
    Real err = exact.l2_error("test", "u");
    CPPUNIT_ASSERT_LESS(Real(TOLERANCE*TOLERANCE), err);
  }

testCoreform()

void ConstraintOperatorTest::testCoreform ( const std::string &  meshfile, const std::string &  matrixfile, Real  expected_norm, Order  order = FIRST  )

inline

Definition at line 240 of file constraint_operator_test.C.

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshBase::allow_renumbering(), assemble_matrix_and_rhs(), libMesh::System::attach_assemble_function(), libMesh::SparseMatrix< T >::build(), libMesh::System::calculate_norm(), libMesh::ParallelObject::comm(), libMesh::MeshBase::copy_constraint_rows(), libMesh::H1, libMesh::EquationSystems::init(), libMesh::MeshBase::is_prepared(), mesh, libMesh::MeshBase::prepare_for_use(), libMesh::MeshBase::read(), libMesh::Real, libMesh::System::solution, libMesh::ExplicitSystem::solve(), TestCommWorld, libMesh::TOLERANCE, and libMesh::MeshTools::valid_is_prepared().

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

    ExplicitSystem &sys =
      es.add_system<LinearImplicitSystem> ("test");

    sys.add_variable("u", order);
    sys.attach_assemble_function (assemble_matrix_and_rhs);

    // Make sure numbering matches our constraint operator matrix
    mesh.allow_renumbering(false);

    mesh.read(meshfile);

    CPPUNIT_ASSERT(mesh.is_prepared());

    // For these matrices Coreform has been experimenting with PETSc
    // solvers which take the transpose of what we expect, so we'll
    // un-transpose here.
    auto matrix = SparseMatrix<Number>::build (mesh.comm());
    matrix->read_matlab(matrixfile);
    matrix->get_transpose(*matrix);

    mesh.copy_constraint_rows(*matrix);

    // We should be prepared at this point
    CPPUNIT_ASSERT(mesh.is_prepared());
    CPPUNIT_ASSERT(MeshTools::valid_is_prepared(mesh));

    // Do a redundant prepare-for-use to catch any issues there
    mesh.prepare_for_use();

    es.init ();
    sys.solve();

    // Skip norm calculations on NodeElems
    std::set<unsigned int> skip_dimensions {0};
    Real h1_norm = sys.calculate_norm(*sys.solution, 0, H1,
                                      &skip_dimensions);

    LIBMESH_ASSERT_FP_EQUAL(h1_norm, expected_norm, TOLERANCE*std::sqrt(TOLERANCE));
  }

testCoreformGeom2()

void ConstraintOperatorTest::testCoreformGeom2 ( )

inline

Definition at line 289 of file constraint_operator_test.C.

  {
    LOG_UNIT_TEST;
    testCoreform("meshes/geom_2.exo",
                 "matrices/geom_2_extraction_op.m",
                 0.09598270393980124874069039295234223854_R);
  }

testCoreformGeom4()

void ConstraintOperatorTest::testCoreformGeom4 ( )

inline

Definition at line 298 of file constraint_operator_test.C.

  {
    LOG_UNIT_TEST;
    testCoreform("meshes/geom_4.exo",
                 "matrices/geom_4_extraction_op.m",
                 0.1040405127939275102143852084416339522_R);
  }

testCoreformGeom8()

void ConstraintOperatorTest::testCoreformGeom8 ( )

inline

Definition at line 307 of file constraint_operator_test.C.

  {
    LOG_UNIT_TEST;
    testCoreform("meshes/geom_8.exo",
                 "matrices/geom_8_extraction_op.m",
                 0.103252835327032837145271735988790535_R);
  }

---

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

• tests/systems/constraint_operator_test.C