WriteVecAndScalar Class Reference

Inheritance diagram for WriteVecAndScalar:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (WriteVecAndScalar)
	This test ensures you can write both vector and scalar variables. More...
	CPPUNIT_TEST (testWriteExodusDistributed)
	CPPUNIT_TEST (testWriteExodusReplicated)
	CPPUNIT_TEST (testWriteNemesisDistributed)
	CPPUNIT_TEST (testWriteNemesisReplicated)
	CPPUNIT_TEST_SUITE_END ()
void	setupTests (UnstructuredMesh &mesh, EquationSystems &equation_systems)
void	testSolution (const MeshBase &read_mesh, const System &sys2)
template<typename MeshType >
void	testWriteExodus (const std::string &filename)
void	testWriteExodusReplicated ()
void	testWriteExodusDistributed ()
template<typename MeshType >
void	testWriteNemesis (const std::string &filename)
void	testWriteNemesisReplicated ()
void	testWriteNemesisDistributed ()

Detailed Description

Definition at line 20 of file write_vec_and_scalar.C.

Member Function Documentation

CPPUNIT_TEST() [1/4]

WriteVecAndScalar::CPPUNIT_TEST

(

testWriteExodusDistributed

)

CPPUNIT_TEST() [2/4]

WriteVecAndScalar::CPPUNIT_TEST

(

testWriteExodusReplicated

)

CPPUNIT_TEST() [3/4]

WriteVecAndScalar::CPPUNIT_TEST

(

testWriteNemesisDistributed

)

CPPUNIT_TEST() [4/4]

WriteVecAndScalar::CPPUNIT_TEST

(

testWriteNemesisReplicated

)

CPPUNIT_TEST_SUITE_END()

WriteVecAndScalar::CPPUNIT_TEST_SUITE_END

(

)

LIBMESH_CPPUNIT_TEST_SUITE()

WriteVecAndScalar::LIBMESH_CPPUNIT_TEST_SUITE

(

WriteVecAndScalar

)

This test ensures you can write both vector and scalar variables.

setupTests()

void WriteVecAndScalar::setupTests ( UnstructuredMesh &  mesh, EquationSystems &  equation_systems  )

inline

Definition at line 39 of file write_vec_and_scalar.C.

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshBase::allow_renumbering(), libMesh::MeshTools::Generation::build_square(), libMesh::FIRST, libMesh::EquationSystems::init(), libMesh::LAGRANGE, mesh, libMesh::ParallelObject::n_processors(), libMesh::NEDELEC_ONE, libMesh::Real, libMesh::NumericVector< T >::set(), and libMesh::System::solution.

  {
    // We set our initial conditions based on build_square node ids
    mesh.allow_renumbering(false);

    MeshTools::Generation::build_square(mesh,
                                        1, 1,
                                        -1., 1.,
                                        -1., 1.,
                                        Utility::string_to_enum<ElemType>("TRI6"));

    ExplicitSystem & system = equation_systems.add_system<ExplicitSystem>("Tester");
    system.add_variable("u", FIRST, NEDELEC_ONE);
    system.add_variable("v", FIRST, LAGRANGE);

    // Initialize the system
    equation_systems.init();

    // Mimic the initial conditions of u(i)=2*i in the serial case,
    // but indexed by node id rather than dof id.
    std::vector<Real> initial_vector({10, 0, 12, 8, 4, 2, 16, 6, 14});

    NumericVector<Number> & sys_solution = *(system.solution);
    for (const auto & node : mesh.node_ptr_range())
      {
        dof_id_type dof_id;
        if (node->n_comp(0,0))
          {
            dof_id = node->dof_number(0,0,0);
          }
        else
          {
            CPPUNIT_ASSERT(node->n_comp(0,1));
            dof_id = node->dof_number(0,1,0);
          }
        if (dof_id >= sys_solution.first_local_index() &&
            dof_id < sys_solution.last_local_index())
          sys_solution.set(dof_id, initial_vector[node->id()]);
        if (mesh.n_processors() == 1)
          CPPUNIT_ASSERT_EQUAL(initial_vector[node->id()], dof_id*Real(2));
      }
    sys_solution.close();
  }

testSolution()

void WriteVecAndScalar::testSolution ( const MeshBase &  read_mesh, const System &  sys2  )

inline

Definition at line 84 of file write_vec_and_scalar.C.

References std::abs(), libMesh::libmesh_real(), libMesh::ParallelObject::processor_id(), libMesh::Real, and libMesh::System::solution.

  {
    // VariableGroup optimization means that DoFs iterate over each of
    // the 3 variables on each node before proceeding to the next
    // node.
    //                                     u_x, u_y, v
    const std::vector<Real> gold_vector = {-1,  3,   10,
                                           0,   1,   12,
                                           2,   0,   14,
                                           0,   1.5, 11,
                                           0.5, 1,   13,
                                           0.5, 1.5, 12,
                                           3,   4,   16,
                                           3,   1.5, 15,
                                           0.5, 4,   13};

    // Translation from node id to dof indexing order as gets done in
    // serial
    const std::vector<dof_id_type>
      node_reordering({0, 3, 1, 8, 5, 4, 6, 7, 2});

    Real tol = 1e-12;
    NumericVector<Number> & sys2_soln(*sys2.solution);
    for (const auto & node : read_mesh.node_ptr_range())
      {
        if (node->processor_id() != read_mesh.processor_id())
          continue;

        // We write out real, imaginary, and magnitude for complex
        // numbers
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
        const unsigned int v2 = 3;
#else
        const unsigned int v2 = 1;
#endif
        CPPUNIT_ASSERT_EQUAL(node->n_vars(0), 3*v2);

        CPPUNIT_ASSERT_LESS(node_reordering.size(), std::size_t(node->id()));
        const dof_id_type gold_i_ux = node_reordering[node->id()] * 3;
        const dof_id_type gold_i_uy = gold_i_ux + 1;
        const dof_id_type gold_i_v  = gold_i_uy + 1;
        CPPUNIT_ASSERT_LESS(gold_vector.size(), std::size_t(gold_i_v));

        LIBMESH_ASSERT_FP_EQUAL(libmesh_real(sys2_soln(node->dof_number(0,0,0))),
                                gold_vector[gold_i_ux], tol);
        LIBMESH_ASSERT_FP_EQUAL(libmesh_real(sys2_soln(node->dof_number(0,v2,0))),
                                gold_vector[gold_i_uy], tol);
        LIBMESH_ASSERT_FP_EQUAL(libmesh_real(sys2_soln(node->dof_number(0,2*v2,0))),
                                gold_vector[gold_i_v], tol);

        // Let's check imaginary parts and magnitude for good measure
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
        LIBMESH_ASSERT_FP_EQUAL(libmesh_real(sys2_soln(node->dof_number(0,1,0))),
                                0.0, tol);
        LIBMESH_ASSERT_FP_EQUAL(libmesh_real(sys2_soln(node->dof_number(0,2,0))),
                                std::abs(gold_vector[gold_i_ux]), tol);
        LIBMESH_ASSERT_FP_EQUAL(libmesh_real(sys2_soln(node->dof_number(0,4,0))),
                                0.0, tol);
        LIBMESH_ASSERT_FP_EQUAL(libmesh_real(sys2_soln(node->dof_number(0,5,0))),
                                std::abs(gold_vector[gold_i_uy]), tol);
        LIBMESH_ASSERT_FP_EQUAL(libmesh_real(sys2_soln(node->dof_number(0,7,0))),
                                0.0, tol);
        LIBMESH_ASSERT_FP_EQUAL(libmesh_real(sys2_soln(node->dof_number(0,8,0))),
                                std::abs(gold_vector[gold_i_v]), tol);
#endif
      }
  }

testWriteExodus()

template<typename MeshType >

void WriteVecAndScalar::testWriteExodus ( const std::string &  filename )

inline

Definition at line 154 of file write_vec_and_scalar.C.

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), TIMPI::Communicator::barrier(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::get_nodal_var_names(), libMesh::EquationSystems::init(), libMesh::LAGRANGE, mesh, libMesh::ExodusII_IO::read(), libMesh::SECOND, TestCommWorld, and libMesh::MeshOutput< MT >::write_equation_systems().

  {
    MeshType mesh(*TestCommWorld);
    EquationSystems equation_systems(mesh);

    setupTests(mesh, equation_systems);

#ifdef LIBMESH_HAVE_EXODUS_API
    // Make sure any previous reads are done before the writing starts
    TestCommWorld->barrier();

    // We write the file in the ExodusII format.
    ExodusII_IO(mesh).write_equation_systems(filename, equation_systems);

    // Make sure that the writing is done before the reading starts.
    TestCommWorld->barrier();

    // Now read it back in
    MeshType read_mesh(*TestCommWorld);
    ExodusII_IO exio(read_mesh);
    exio.read(filename);

    read_mesh.prepare_for_use();
    EquationSystems es2(read_mesh);
    ExplicitSystem & sys2 = es2.add_system<ExplicitSystem>("Test");

    const std::vector<std::string> & nodal_vars(exio.get_nodal_var_names());

    for (const auto & var_name : nodal_vars)
      sys2.add_variable(var_name, SECOND, LAGRANGE);

    es2.init();

    for (const auto & var_name : nodal_vars)
      exio.copy_nodal_solution(sys2, var_name, var_name, 1);

    testSolution(read_mesh, sys2);
#endif // #ifdef LIBMESH_HAVE_EXODUS_API
  }

testWriteExodusDistributed()

void WriteVecAndScalar::testWriteExodusDistributed ( )

inline

Definition at line 196 of file write_vec_and_scalar.C.

{ LOG_UNIT_TEST; testWriteExodus<DistributedMesh>("dist.e"); }

testWriteExodusReplicated()

void WriteVecAndScalar::testWriteExodusReplicated ( )

inline

Definition at line 195 of file write_vec_and_scalar.C.

{ LOG_UNIT_TEST; testWriteExodus<ReplicatedMesh>("rep.e"); }

testWriteNemesis()

template<typename MeshType >

void WriteVecAndScalar::testWriteNemesis ( const std::string &  filename )

inline

Definition at line 200 of file write_vec_and_scalar.C.

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), TIMPI::Communicator::barrier(), libMesh::Nemesis_IO::copy_nodal_solution(), libMesh::Nemesis_IO::get_nodal_var_names(), libMesh::EquationSystems::init(), libMesh::LAGRANGE, libMesh::libmesh_ignore(), mesh, libMesh::Nemesis_IO::read(), libMesh::SECOND, TestCommWorld, and libMesh::MeshOutput< MT >::write_equation_systems().

  {
    MeshType mesh(*TestCommWorld);
    EquationSystems equation_systems(mesh);

    setupTests(mesh, equation_systems);

#ifdef LIBMESH_HAVE_NEMESIS_API
    // Make sure any previous reads are done before the writing starts
    TestCommWorld->barrier();

    // We write the file in the Nemesis format.
    Nemesis_IO(mesh).write_equation_systems(filename, equation_systems);

    // Make sure that the writing is done before the reading starts.
    TestCommWorld->barrier();

    // Now read it back in
    MeshType read_mesh(*TestCommWorld);
    Nemesis_IO nemio(read_mesh);
    nemio.read(filename);

    read_mesh.prepare_for_use();
    EquationSystems es2(read_mesh);
    ExplicitSystem & sys2 = es2.add_system<ExplicitSystem>("Test");

    const std::vector<std::string> & nodal_vars(nemio.get_nodal_var_names());

    for (const auto & var_name : nodal_vars)
      sys2.add_variable(var_name, SECOND, LAGRANGE);

    es2.init();

    for (const auto & var_name : nodal_vars)
      nemio.copy_nodal_solution(sys2, var_name, var_name, 1);

    // FIXME - Nemesis still needs work for vector-valued variables
    // testSolution(read_mesh, sys2);
#else
    libmesh_ignore(filename);
#endif // #ifdef LIBMESH_HAVE_NEMESIS_API
  }

testWriteNemesisDistributed()

void WriteVecAndScalar::testWriteNemesisDistributed ( )

inline

Definition at line 244 of file write_vec_and_scalar.C.

{ LOG_UNIT_TEST; testWriteNemesis<DistributedMesh>("dist.nem"); }

testWriteNemesisReplicated()

void WriteVecAndScalar::testWriteNemesisReplicated ( )

inline

Definition at line 243 of file write_vec_and_scalar.C.

{ LOG_UNIT_TEST; testWriteNemesis<ReplicatedMesh>("rep.nem"); }

---

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

• tests/mesh/write_vec_and_scalar.C