ExodusC0PolyhedronTest Class Reference

Inheritance diagram for ExodusC0PolyhedronTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (ExodusC0PolyhedronTest)
	CPPUNIT_TEST (test_write_cube_header)
	CPPUNIT_TEST (test_write_hexagonal_prism_header)
	CPPUNIT_TEST (test_write_and_read_hexagonal_prism)
	CPPUNIT_TEST_SUITE_END ()
ExodusHeaderInfo	write_and_read_header (Mesh &mesh, const std::string &filename)
void	build_c0polyhedron (Mesh &mesh, const std::vector< Point > &points, const std::vector< std::vector< unsigned int > > &nodes_on_side)
void	test_write_cube_header ()
void	test_write_hexagonal_prism_header ()
void	test_write_and_read_hexagonal_prism ()

Detailed Description

Definition at line 183 of file exodus_test.C.

Member Function Documentation

build_c0polyhedron()

void ExodusC0PolyhedronTest::build_c0polyhedron ( Mesh &  mesh, const std::vector< Point > &  points, const std::vector< std::vector< unsigned int > > &  nodes_on_side  )

inline

Definition at line 209 of file exodus_test.C.

  {
    for (auto p : index_range(points))
      mesh.add_point(points[p], /*id=*/p);
 
    std::vector<std::shared_ptr<Polygon>> sides(nodes_on_side.size());
    for (auto s : index_range(nodes_on_side))
      {
        const auto &nodes_on_s = nodes_on_side[s];
        sides[s] = std::make_shared<C0Polygon>(nodes_on_s.size());
        for (auto i : index_range(nodes_on_s))
          sides[s]->set_node(i, mesh.node_ptr(nodes_on_s[i]));
      }
 
    std::unique_ptr<Node> mid_elem_node;
    std::unique_ptr<Elem> polyhedron =
        std::make_unique<C0Polyhedron>(sides, mid_elem_node);
    if (mid_elem_node)
      mesh.add_node(std::move(mid_elem_node));
 
    polyhedron->set_id() = 0;
    Elem *elem = mesh.add_elem(std::move(polyhedron));
    elem->subdomain_id() = 1;
    mesh.cache_elem_data();
    mesh.prepare_for_use();
  }

References libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_node(), libMesh::MeshBase::add_point(), libMesh::MeshBase::cache_elem_data(), libMesh::index_range(), mesh, libMesh::MeshBase::node_ptr(), libMesh::MeshBase::prepare_for_use(), libMesh::DofObject::set_id(), and libMesh::Elem::subdomain_id().

Referenced by test_write_and_read_hexagonal_prism(), and test_write_hexagonal_prism_header().

CPPUNIT_TEST() [1/3]

ExodusC0PolyhedronTest::CPPUNIT_TEST

(

test_write_and_read_hexagonal_prism

)

CPPUNIT_TEST() [2/3]

ExodusC0PolyhedronTest::CPPUNIT_TEST

(

test_write_cube_header

)

CPPUNIT_TEST() [3/3]

ExodusC0PolyhedronTest::CPPUNIT_TEST

(

test_write_hexagonal_prism_header

)

CPPUNIT_TEST_SUITE_END()

ExodusC0PolyhedronTest::CPPUNIT_TEST_SUITE_END

(

)

LIBMESH_CPPUNIT_TEST_SUITE()

ExodusC0PolyhedronTest::LIBMESH_CPPUNIT_TEST_SUITE

(

ExodusC0PolyhedronTest

)

test_write_and_read_hexagonal_prism()

void ExodusC0PolyhedronTest::test_write_and_read_hexagonal_prism ( )

inline

Definition at line 301 of file exodus_test.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    const std::vector<Point> points =
      { { 0, -2, 0}, {-1, -1, 0}, {-1, 1, 0},
        { 0,  2, 0}, { 1,  1, 0}, { 1, -1, 0},
        { 0, -2, 1}, {-1, -1, 1}, {-1, 1, 1},
        { 0,  2, 1}, { 1,  1, 1}, { 1, -1, 1} };
 
    const std::vector<std::vector<unsigned int>> nodes_on_side =
      { {0, 1, 2, 3, 4, 5},
        {0, 1,  7,  6},
        {1, 2,  8,  7},
        {2, 3,  9,  8},
        {3, 4, 10,  9},
        {4, 5, 11, 10},
        {5, 0,  6, 11},
        {6, 7,  8,  9, 10, 11} };
 
    this->build_c0polyhedron(mesh, points, nodes_on_side);
 
    std::vector<std::vector<dof_id_type>> expected_nodes_on_side;
    const Elem *output_elem = mesh.query_elem_ptr(0);
    const bool have_output_elem = output_elem;
    bool found_output_elem = have_output_elem;
    mesh.comm().max(found_output_elem);
    CPPUNIT_ASSERT(found_output_elem);
 
    if (output_elem)
      {
        expected_nodes_on_side.reserve(output_elem->n_sides());
        for (auto s : output_elem->side_index_range())
          {
            expected_nodes_on_side.emplace_back();
            for (const auto n : output_elem->nodes_on_side(s))
              expected_nodes_on_side.back().push_back(output_elem->node_id(n));
          }
      }
 
    {
      ExodusII_IO exii(mesh);
      exii.write("write_exodus_C0POLYHEDRON_HEXPRISM_READ.e");
    }
 
    Mesh input_mesh(*TestCommWorld);
    ExodusII_IO exii_input(input_mesh);
    if (input_mesh.processor_id() == 0)
      exii_input.read("write_exodus_C0POLYHEDRON_HEXPRISM_READ.e");
 
    MeshCommunication().broadcast(input_mesh);
    input_mesh.prepare_for_use();
 
    CPPUNIT_ASSERT_EQUAL(cast_int<dof_id_type>(1), input_mesh.n_elem());
 
    const Elem *elem = input_mesh.query_elem_ptr(0);
    bool found_elem = elem;
    input_mesh.comm().max(found_elem);
    CPPUNIT_ASSERT(found_elem);
 
    const bool can_compare = have_output_elem && elem;
    bool found_comparable_elem = can_compare;
    input_mesh.comm().max(found_comparable_elem);
    CPPUNIT_ASSERT(found_comparable_elem);
 
    if (!can_compare)
      return;
 
    CPPUNIT_ASSERT_EQUAL(C0POLYHEDRON, elem->type());
    CPPUNIT_ASSERT_EQUAL(12u, elem->n_vertices());
    CPPUNIT_ASSERT_EQUAL(8u, elem->n_sides());
 
    for (auto s : index_range(expected_nodes_on_side))
      {
        const auto side_nodes = elem->nodes_on_side(s);
        CPPUNIT_ASSERT_EQUAL(expected_nodes_on_side[s].size(), side_nodes.size());
        for (auto n : index_range(expected_nodes_on_side[s]))
          CPPUNIT_ASSERT_EQUAL(expected_nodes_on_side[s][n],
                               elem->node_id(side_nodes[n]));
      }
  }

References libMesh::MeshCommunication::broadcast(), build_c0polyhedron(), libMesh::C0POLYHEDRON, libMesh::ParallelObject::comm(), libMesh::index_range(), libMesh::Parallel::Communicator::max(), mesh, libMesh::DistributedMesh::n_elem(), libMesh::Elem::n_sides(), libMesh::Elem::n_vertices(), libMesh::Elem::node_id(), libMesh::Elem::nodes_on_side(), libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::MeshBase::query_elem_ptr(), libMesh::DistributedMesh::query_elem_ptr(), libMesh::ExodusII_IO::read(), libMesh::Elem::side_index_range(), TestCommWorld, libMesh::Elem::type(), and libMesh::ExodusII_IO::write().

test_write_cube_header()

void ExodusC0PolyhedronTest::test_write_cube_header ( )

inline

Definition at line 238 of file exodus_test.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    MeshTools::Generation::build_cube(mesh, 2, 2, 2,
                                      -1., 1.,
                                      -1., 1.,
                                      -1., 1.,
                                      C0POLYHEDRON);
    mesh.get_boundary_info().clear();
 
    for (auto &elem : mesh.element_ptr_range())
      elem->subdomain_id() = 1;
    mesh.cache_elem_data();
 
    ExodusHeaderInfo header_info =
        this->write_and_read_header(mesh, "write_exodus_C0POLYHEDRON.e");
 
    CPPUNIT_ASSERT_EQUAL(header_info.num_dim, 3);
    CPPUNIT_ASSERT_EQUAL(header_info.num_elem, 8);
    CPPUNIT_ASSERT_EQUAL(header_info.num_elem_blk, 1);
    CPPUNIT_ASSERT_EQUAL(header_info.num_face, 48);
    CPPUNIT_ASSERT_EQUAL(header_info.num_face_blk, 1);
    CPPUNIT_ASSERT_EQUAL(header_info.num_node_sets, 0);
    CPPUNIT_ASSERT_EQUAL(header_info.num_side_sets, 0);
  }

References libMesh::MeshTools::Generation::build_cube(), libMesh::C0POLYHEDRON, libMesh::MeshBase::cache_elem_data(), libMesh::BoundaryInfo::clear(), libMesh::MeshBase::get_boundary_info(), mesh, libMesh::ExodusHeaderInfo::num_dim, libMesh::ExodusHeaderInfo::num_elem, libMesh::ExodusHeaderInfo::num_elem_blk, libMesh::ExodusHeaderInfo::num_face, libMesh::ExodusHeaderInfo::num_face_blk, libMesh::ExodusHeaderInfo::num_node_sets, libMesh::ExodusHeaderInfo::num_side_sets, TestCommWorld, and write_and_read_header().

test_write_hexagonal_prism_header()

void ExodusC0PolyhedronTest::test_write_hexagonal_prism_header ( )

inline

Definition at line 266 of file exodus_test.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    const std::vector<Point> points =
      { { 0, -2, 0}, {-1, -1, 0}, {-1, 1, 0},
        { 0,  2, 0}, { 1,  1, 0}, { 1, -1, 0},
        { 0, -2, 1}, {-1, -1, 1}, {-1, 1, 1},
        { 0,  2, 1}, { 1,  1, 1}, { 1, -1, 1} };
 
    const std::vector<std::vector<unsigned int>> nodes_on_side =
      { {0, 1, 2, 3, 4, 5},
        {0, 1,  7,  6},
        {1, 2,  8,  7},
        {2, 3,  9,  8},
        {3, 4, 10,  9},
        {4, 5, 11, 10},
        {5, 0,  6, 11},
        {6, 7,  8,  9, 10, 11} };
 
    this->build_c0polyhedron(mesh, points, nodes_on_side);
 
    ExodusHeaderInfo header_info =
        this->write_and_read_header(mesh, "write_exodus_C0POLYHEDRON_HEXPRISM.e");
 
    CPPUNIT_ASSERT_EQUAL(header_info.num_dim, 3);
    CPPUNIT_ASSERT_EQUAL(header_info.num_elem, 1);
    CPPUNIT_ASSERT_EQUAL(header_info.num_elem_blk, 1);
    CPPUNIT_ASSERT_EQUAL(header_info.num_face, 8);
    CPPUNIT_ASSERT_EQUAL(header_info.num_face_blk, 1);
    CPPUNIT_ASSERT_EQUAL(header_info.num_node_sets, 0);
    CPPUNIT_ASSERT_EQUAL(header_info.num_side_sets, 0);
  }

References build_c0polyhedron(), mesh, libMesh::ExodusHeaderInfo::num_dim, libMesh::ExodusHeaderInfo::num_elem, libMesh::ExodusHeaderInfo::num_elem_blk, libMesh::ExodusHeaderInfo::num_face, libMesh::ExodusHeaderInfo::num_face_blk, libMesh::ExodusHeaderInfo::num_node_sets, libMesh::ExodusHeaderInfo::num_side_sets, TestCommWorld, and write_and_read_header().

write_and_read_header()

ExodusHeaderInfo ExodusC0PolyhedronTest::write_and_read_header ( Mesh &  mesh, const std::string &  filename  )

inline

Definition at line 194 of file exodus_test.C.

  {
    {
      ExodusII_IO exii(mesh);
      exii.write(filename);
    }
 
    TestCommWorld->barrier();
 
    Mesh header_mesh(*TestCommWorld);
    ExodusII_IO exii(header_mesh);
    return exii.read_header(filename);
  }

References mesh, libMesh::ExodusII_IO::read_header(), TestCommWorld, and libMesh::ExodusII_IO::write().

Referenced by test_write_cube_header(), and test_write_hexagonal_prism_header().

---

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

• tests/mesh/exodus_test.C