WriteVecAndScalar Class Reference

Inheritance diagram for WriteVecAndScalar:

Public Member Functions
	CPPUNIT_TEST_SUITE (WriteVecAndScalar)
	This test ensures you can write both vector and scalar variables. More...
	CPPUNIT_TEST (testWrite)
	CPPUNIT_TEST_SUITE_END ()
void	testWrite ()

Detailed Description

Definition at line 19 of file write_vec_and_scalar.C.

Member Function Documentation

CPPUNIT_TEST()

WriteVecAndScalar::CPPUNIT_TEST

(

testWrite

)

CPPUNIT_TEST_SUITE()

WriteVecAndScalar::CPPUNIT_TEST_SUITE

(

WriteVecAndScalar

)

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

CPPUNIT_TEST_SUITE_END()

WriteVecAndScalar::CPPUNIT_TEST_SUITE_END

(

)

testWrite()

void WriteVecAndScalar::testWrite ( )

inline

Definition at line 33 of file write_vec_and_scalar.C.

  {
    Mesh mesh(*TestCommWorld);
 
    // 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"));
 
    // Create an equation systems object.
    EquationSystems equation_systems(mesh);
 
    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();
 
#ifdef LIBMESH_HAVE_EXODUS_API
 
    // We write the file in the ExodusII format.
    ExodusII_IO(mesh).write_equation_systems("out.e", equation_systems);
 
    // Make sure that the writing is done before the reading starts.
    TestCommWorld->barrier();
 
    // Now read it back in
    Mesh read_mesh(*TestCommWorld);
    ExodusII_IO exio(read_mesh);
    exio.read("out.e");
 
    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);
 
    // 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() != 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);
 
        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;
 
        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
      }
#endif // #ifdef LIBMESH_HAVE_EXODUS_API
  }

References std::abs(), libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshBase::allow_renumbering(), libMesh::MeshTools::Generation::build_square(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::FIRST, libMesh::ExodusII_IO::get_nodal_var_names(), libMesh::EquationSystems::init(), libMesh::LAGRANGE, libMesh::libmesh_real(), mesh, libMesh::ParallelObject::n_processors(), libMesh::NEDELEC_ONE, libMesh::DistributedMesh::node_ptr_range(), libMesh::MeshBase::node_ptr_range(), libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::ExodusII_IO::read(), libMesh::Real, libMesh::SECOND, libMesh::NumericVector< T >::set(), libMesh::System::solution, TestCommWorld, and libMesh::MeshOutput< MT >::write_equation_systems().

---

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

• tests/mesh/write_vec_and_scalar.C