doxygen/libmesh/exodus__test_8C_source.html

#include "mesh_elem_test.h"


#ifdef LIBMESH_HAVE_EXODUS_API


#include "libmesh/cell_c0polyhedron.h"

#include "libmesh/distributed_mesh.h"

#include "libmesh/enum_to_string.h"

#include "libmesh/exodusII_io.h"

#include "libmesh/exodusII_io_helper.h"

#include "libmesh/face_c0polygon.h"

#include "libmesh/int_range.h"

#include "libmesh/mesh_communication.h"

#include "libmesh/mesh_generation.h"

#include "libmesh/node.h"

#include "libmesh/replicated_mesh.h"


#include <memory>

#include <set>

#include <string>

#include <vector>


using namespace libMesh;


template <ElemType elem_type>


class ExodusTest : public MeshPerElemTest<elem_type>

{

public:


  void test_read_gold()

  {

    LOG_UNIT_TEST;


    Mesh input_mesh(*TestCommWorld);


    ExodusII_IO exii(input_mesh);

    if (input_mesh.processor_id() == 0)

      exii.read("meshes/exodus_elements/read_exodus_" +

                Utility::enum_to_string(elem_type) + ".e");


    MeshCommunication().broadcast(input_mesh);

    input_mesh.prepare_for_use();


    CPPUNIT_ASSERT(this->meshes_equal_enough(input_mesh, true));

  }


  void test_write()

  {

    LOG_UNIT_TEST;


    // This is a *buffered* write; we use scope to make sure the

    // ExodusII_IO object gets destructed (and thus is guaranteed to

    // finish writing and close the file) before we try to read what

    // was written.

    {

      ExodusII_IO exii(*this->_mesh);


      // We still default to 32-char names for backwards

      // compatibility, but we're writing a mesh with extra-long names

      // in it for testing, so we manually enable longer names.

      exii.set_max_name_length(80);


      exii.write("write_exodus_" +

                 Utility::enum_to_string(elem_type) + ".e");

    }


    Mesh input_mesh(*TestCommWorld);

    ExodusII_IO exii_input(input_mesh);

    if (input_mesh.processor_id() == 0)

      exii_input.read("write_exodus_" +

                      Utility::enum_to_string(elem_type) + ".e");


    MeshCommunication().broadcast(input_mesh);

    input_mesh.prepare_for_use();


    CPPUNIT_ASSERT(this->meshes_equal_enough(input_mesh, true));

  }


};


#define EXODUSTEST              \

  CPPUNIT_TEST(test_read_gold); \

  CPPUNIT_TEST(test_write);


#define INSTANTIATE_EXODUSTEST(elemtype)                    \

  class ExodusTest_##elemtype : public ExodusTest<elemtype> \

  {                                                         \

  public:                                                   \

    ExodusTest_##elemtype() : ExodusTest<elemtype>()        \

    {                                                       \

      if (unitlog->summarized_logs_enabled())               \

        this->libmesh_suite_name = "ExodusTest";            \

      else                                                  \

        this->libmesh_suite_name = "ExodusTest_" #elemtype; \

    }                                                       \

    CPPUNIT_TEST_SUITE(ExodusTest_##elemtype);              \

    EXODUSTEST;                                             \

    CPPUNIT_TEST_SUITE_END();                               \

  };                                                        \

                                                            \

  CPPUNIT_TEST_SUITE_REGISTRATION(ExodusTest_##elemtype)


INSTANTIATE_EXODUSTEST(EDGE2);

INSTANTIATE_EXODUSTEST(EDGE3);

INSTANTIATE_EXODUSTEST(EDGE4);


#if LIBMESH_DIM > 1

INSTANTIATE_EXODUSTEST(TRI3);

INSTANTIATE_EXODUSTEST(TRISHELL3);

INSTANTIATE_EXODUSTEST(TRI6);

INSTANTIATE_EXODUSTEST(TRI7);


INSTANTIATE_EXODUSTEST(QUAD4);

INSTANTIATE_EXODUSTEST(QUADSHELL4);

INSTANTIATE_EXODUSTEST(QUAD8);

INSTANTIATE_EXODUSTEST(QUADSHELL8);

INSTANTIATE_EXODUSTEST(QUAD9);

INSTANTIATE_EXODUSTEST(QUADSHELL9);


class ExodusC0PolygonTest : public CppUnit::TestCase

{

public:

  LIBMESH_CPPUNIT_TEST_SUITE(ExodusC0PolygonTest);


  CPPUNIT_TEST(test_write_and_read_pentagon);


  CPPUNIT_TEST_SUITE_END();


  void build_pentagon(Mesh &mesh)

  {

    const std::vector<Point> points =

      { {0, 0}, {1, 0}, {1.5, 0.5}, {1, 1}, {0, 1} };


    for (auto p : index_range(points))

      mesh.add_point(points[p], /*id=*/p);


    std::unique_ptr<Elem> polygon =

        std::make_unique<C0Polygon>(cast_int<unsigned int>(points.size()));

    for (auto i : index_range(points))

      polygon->set_node(i, mesh.node_ptr(i));


    polygon->set_id() = 0;

    Elem *elem = mesh.add_elem(std::move(polygon));

    elem->subdomain_id() = 1;

    mesh.prepare_for_use();

  }


  void test_write_and_read_pentagon()

  {

    LOG_UNIT_TEST;


    Mesh mesh(*TestCommWorld);

    this->build_pentagon(mesh);


    {

      ExodusII_IO exii(mesh);

      exii.write("write_exodus_C0POLYGON.e");

    }


    Mesh input_mesh(*TestCommWorld);

    ExodusII_IO exii_input(input_mesh);

    if (input_mesh.processor_id() == 0)

      exii_input.read("write_exodus_C0POLYGON.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);


    if (!elem)

      return;


    CPPUNIT_ASSERT_EQUAL(C0POLYGON, elem->type());

    CPPUNIT_ASSERT_EQUAL(5u, elem->n_nodes());


    for (auto i : make_range(5))

      CPPUNIT_ASSERT_EQUAL(cast_int<dof_id_type>(i), elem->node_id(i));

  }


};


CPPUNIT_TEST_SUITE_REGISTRATION(ExodusC0PolygonTest);

#endif // LIBMESH_DIM > 1


#if LIBMESH_DIM > 2


class ExodusC0PolyhedronTest : public CppUnit::TestCase

{

public:

  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(test_write_and_read_mixed_poly_hex_replicated);

  CPPUNIT_TEST(test_write_and_read_mixed_poly_hex_distributed);

  CPPUNIT_TEST(test_write_and_read_mixed_hex_tet_block_names_replicated);

  CPPUNIT_TEST(test_write_and_read_mixed_hex_tet_block_names_distributed);

  CPPUNIT_TEST(test_write_and_read_mixed_hex_tet_block_names_all_ranks);


  CPPUNIT_TEST_SUITE_END();


  ExodusHeaderInfo write_and_read_header(Mesh &mesh,

                                         const std::string &filename)

  {

    {

      ExodusII_IO exii(mesh);

      exii.write(filename);

    }


    TestCommWorld->barrier();


    Mesh header_mesh(*TestCommWorld);

    ExodusII_IO exii(header_mesh);

    return exii.read_header(filename);

  }


  // When run in parallel, check that a DistributedMesh really is

  // distributed before we write it, so the writer is exercised on a

  // mesh that has to be gathered to processor 0.


  static void assert_distributed_if_parallel(const MeshBase & mesh)

  {

    if (mesh.n_processors() > 1 &&

        dynamic_cast<const DistributedMesh *>(&mesh))

      CPPUNIT_ASSERT(!mesh.is_serial());

  }


  void build_c0polyhedron(Mesh &mesh,

                          const std::vector<Point> &points,

                          const std::vector<std::vector<unsigned int>> &nodes_on_side)

  {

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

  }


  void test_write_cube_header()

  {

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

  }


  void test_write_hexagonal_prism_header()

  {

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

  }


  void test_write_and_read_hexagonal_prism()

  {

    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]));

      }

  }


  // A mesh with a C0POLYHEDRON and a HEX8 in the *same* subdomain.  Exodus

  // requires a single element type per block, so the writer has to split

  // this subdomain into two blocks (one NFACED, one HEX8).  Before that

  // fix the whole subdomain was written as a single block of the first

  // element's type, which errored (or, when the first element was the

  // HEX8, crashed) instead of writing the polyhedra.

  template <typename MeshType>


  void test_write_and_read_mixed_poly_hex_impl(const std::string & filename)

  {

    MeshType mesh(*TestCommWorld);


    // A hexagonal-prism polyhedron, nodes 0..11, in subdomain 1.

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

    for (auto p : index_range(points))

      mesh.add_point(points[p], p);


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

    std::vector<std::shared_ptr<Polygon>> sides(nodes_on_side.size());

    for (auto s : index_range(nodes_on_side))

      {

        sides[s] = std::make_shared<C0Polygon>(nodes_on_side[s].size());

        for (auto i : index_range(nodes_on_side[s]))

          sides[s]->set_node(i, mesh.node_ptr(nodes_on_side[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;

    polyhedron->subdomain_id() = 1;

    mesh.add_elem(std::move(polyhedron));


    // A HEX8 in the *same* subdomain, nodes 12..19 (offset in x).

    const std::vector<Point> hex_points =

      { {5,0,0}, {6,0,0}, {6,1,0}, {5,1,0}, {5,0,1}, {6,0,1}, {6,1,1}, {5,1,1} };

    for (auto i : index_range(hex_points))

      mesh.add_point(hex_points[i], 12 + i);

    std::unique_ptr<Elem> hex = Elem::build(HEX8);

    for (unsigned int i = 0; i != 8; ++i)

      hex->set_node(i, mesh.node_ptr(12 + i));

    hex->set_id() = 1;

    hex->subdomain_id() = 1;

    mesh.add_elem(std::move(hex));


    mesh.cache_elem_data();

    mesh.prepare_for_use();

    assert_distributed_if_parallel(mesh);


    {

      ExodusII_IO exii(mesh);

      exii.write(filename);

    }


    TestCommWorld->barrier();


    MeshType input_mesh(*TestCommWorld);

    ExodusII_IO exii_input(input_mesh);

    if (input_mesh.processor_id() == 0)

      exii_input.read(filename);


    MeshCommunication().broadcast(input_mesh);

    input_mesh.prepare_for_use();


    CPPUNIT_ASSERT_EQUAL(cast_int<dof_id_type>(2), input_mesh.n_elem());


    // Both element types must survive the round trip, in their own blocks.

    unsigned int n_poly = 0, n_hex = 0;

    for (const auto & elem : input_mesh.active_local_element_ptr_range())

      {

        if (elem->type() == C0POLYHEDRON)

          ++n_poly;

        else if (elem->type() == HEX8)

          ++n_hex;

      }

    input_mesh.comm().sum(n_poly);

    input_mesh.comm().sum(n_hex);

    CPPUNIT_ASSERT_EQUAL(1u, n_poly);

    CPPUNIT_ASSERT_EQUAL(1u, n_hex);

  }


  void test_write_and_read_mixed_poly_hex_replicated()

  {

    LOG_UNIT_TEST;

    test_write_and_read_mixed_poly_hex_impl<ReplicatedMesh>("write_exodus_mixed_poly_hex_repl.e");

  }


  void test_write_and_read_mixed_poly_hex_distributed()

  {

    LOG_UNIT_TEST;

    test_write_and_read_mixed_poly_hex_impl<DistributedMesh>("write_exodus_mixed_poly_hex_dist.e");

  }


  // A subdomain that mixes element types (here HEX8 + TET4) must be split

  // into one Exodus block per type, since Exodus allows a single element

  // type per block.  Only the lower-valued ElemType keeps the subdomain

  // id; the other type is written to a synthesized block whose name is the

  // element type prefixed onto the original subdomain name, so it round

  // trips as an identifiable, separate subdomain.  This also checks the

  // add_sides path, where side blocks are numbered above the synthesized

  // element blocks and so must not collide with them.

  template <typename MeshType>


  void test_write_and_read_mixed_hex_tet_block_names_impl(const std::string & basename,

                                                          bool run_only_on_proc0 = true)

  {

    MeshType mesh(*TestCommWorld);


    // HEX8, nodes 0..7, subdomain 1.

    const std::vector<Point> hex_points =

      { {0,0,0}, {1,0,0}, {1,1,0}, {0,1,0}, {0,0,1}, {1,0,1}, {1,1,1}, {0,1,1} };

    for (auto i : index_range(hex_points))

      mesh.add_point(hex_points[i], i);

    std::unique_ptr<Elem> hex = Elem::build(HEX8);

    for (unsigned int i = 0; i != 8; ++i)

      hex->set_node(i, mesh.node_ptr(i));

    hex->set_id() = 0;

    hex->subdomain_id() = 1;

    mesh.add_elem(std::move(hex));


    // TET4 in the *same* subdomain 1, nodes 8..11 (offset in x).

    const std::vector<Point> tet_points =

      { {5,0,0}, {6,0,0}, {5,1,0}, {5,0,1} };

    for (auto i : index_range(tet_points))

      mesh.add_point(tet_points[i], 8 + i);

    std::unique_ptr<Elem> tet = Elem::build(TET4);

    for (unsigned int i = 0; i != 4; ++i)

      tet->set_node(i, mesh.node_ptr(8 + i));

    tet->set_id() = 1;

    tet->subdomain_id() = 1;

    mesh.add_elem(std::move(tet));


    mesh.set_subdomain_name(1, "solid", /*synchronous=*/true);


    mesh.prepare_for_use();

    assert_distributed_if_parallel(mesh);


    // ExodusII_IO only writes on processor 0.  A helper created with

    // run_only_on_proc0=false instead writes on every rank (as Nemesis

    // and MOOSE do), each to its own file, so build_subdomain_map() has

    // to reduce the local elements across ranks.  That needs the whole

    // mesh on every rank.

    libmesh_assert(run_only_on_proc0 || mesh.is_serial());

    const std::string suffix = run_only_on_proc0 ? ".e" :

      "." + std::to_string(mesh.n_processors()) + "." +

      std::to_string(mesh.processor_id()) + ".e";


    auto write_mesh = [&mesh, run_only_on_proc0](const std::string & filename,

                                                 bool add_sides)

      {

        if (run_only_on_proc0)

          {

            ExodusII_IO exii(mesh);

            exii.write_added_sides(add_sides);

            exii.write(filename);

          }

        else

          {

            ExodusII_IO_Helper helper(mesh, /*v=*/false, /*run_only_on_proc0=*/false);

            helper.set_add_sides(add_sides);

            helper.create(filename);

            helper.initialize(filename, mesh);

            helper.write_nodal_coordinates(mesh);

            helper.write_elements(mesh);

            helper.close();

          }

      };


    write_mesh(basename + suffix, /*add_sides=*/false);


    // The mixed subdomain must also survive an add_sides write: its side

    // blocks are numbered above the synthesized element block, so the two

    // id spaces must not collide (guarded in build_subdomain_map()).

    write_mesh(basename + "_sides" + suffix, /*add_sides=*/true);


    TestCommWorld->barrier();


    // Processor 0's file is read back either way.

    MeshType input_mesh(*TestCommWorld);

    ExodusII_IO exii_input(input_mesh);

    if (input_mesh.processor_id() == 0)

      exii_input.read(basename + suffix);


    MeshCommunication().broadcast(input_mesh);

    input_mesh.prepare_for_use();


    CPPUNIT_ASSERT_EQUAL(cast_int<dof_id_type>(2), input_mesh.n_elem());


    // Both element types survive the round trip.

    unsigned int n_hex = 0, n_tet = 0;

    for (const auto & elem : input_mesh.active_local_element_ptr_range())

      {

        if (elem->type() == HEX8)

          ++n_hex;

        else if (elem->type() == TET4)

          ++n_tet;

      }

    input_mesh.comm().sum(n_hex);

    input_mesh.comm().sum(n_tet);

    CPPUNIT_ASSERT_EQUAL(1u, n_hex);

    CPPUNIT_ASSERT_EQUAL(1u, n_tet);


    // The single input subdomain became two: the original "solid" (which

    // kept the TET4, the lower-valued ElemType) and a synthesized

    // "HEX8_solid" for the HEX8.

    std::set<subdomain_id_type> sbd_ids;

    input_mesh.subdomain_ids(sbd_ids);

    CPPUNIT_ASSERT_EQUAL(std::size_t(2), sbd_ids.size());


    std::set<std::string> names;

    for (auto sid : sbd_ids)

      names.insert(input_mesh.subdomain_name(sid));

    CPPUNIT_ASSERT_EQUAL(std::size_t(1), names.count("solid"));

    CPPUNIT_ASSERT_EQUAL(std::size_t(1), names.count("solid_HEX8"));

  }


  void test_write_and_read_mixed_hex_tet_block_names_replicated()

  {

    LOG_UNIT_TEST;

    test_write_and_read_mixed_hex_tet_block_names_impl<ReplicatedMesh>("write_exodus_mixed_hex_tet_repl");

  }


  void test_write_and_read_mixed_hex_tet_block_names_distributed()

  {

    LOG_UNIT_TEST;

    test_write_and_read_mixed_hex_tet_block_names_impl<DistributedMesh>("write_exodus_mixed_hex_tet_dist");

  }


  void test_write_and_read_mixed_hex_tet_block_names_all_ranks()

  {

    LOG_UNIT_TEST;

    test_write_and_read_mixed_hex_tet_block_names_impl<ReplicatedMesh>

      ("write_exodus_mixed_hex_tet_all_ranks", /*run_only_on_proc0=*/false);

  }


};


CPPUNIT_TEST_SUITE_REGISTRATION(ExodusC0PolyhedronTest);


INSTANTIATE_EXODUSTEST(TET4);

INSTANTIATE_EXODUSTEST(TET10);

INSTANTIATE_EXODUSTEST(TET14);


INSTANTIATE_EXODUSTEST(HEX8);

INSTANTIATE_EXODUSTEST(HEX20);

INSTANTIATE_EXODUSTEST(HEX27);


INSTANTIATE_EXODUSTEST(PRISM6);

INSTANTIATE_EXODUSTEST(PRISM15);

INSTANTIATE_EXODUSTEST(PRISM18);

INSTANTIATE_EXODUSTEST(PRISM20);

INSTANTIATE_EXODUSTEST(PRISM21);


// These tests use PointLocator, which uses contains_point(), which

// uses inverse_map(), which doesn't play nicely on Pyramids unless we

// have exceptions support

#ifdef LIBMESH_ENABLE_EXCEPTIONS

INSTANTIATE_EXODUSTEST(PYRAMID5);

INSTANTIATE_EXODUSTEST(PYRAMID13);

INSTANTIATE_EXODUSTEST(PYRAMID14);

INSTANTIATE_EXODUSTEST(PYRAMID18);

#endif

#endif // LIBMESH_DIM > 2


#endif // LIBMESH_HAVE_EXODUS_API

ExodusC0PolygonTest
Definition exodus_test.C:118

ExodusC0PolygonTest::LIBMESH_CPPUNIT_TEST_SUITE
LIBMESH_CPPUNIT_TEST_SUITE(ExodusC0PolygonTest)

ExodusC0PolygonTest::build_pentagon
void build_pentagon(Mesh &mesh)
Definition exodus_test.C:126

ExodusC0PolygonTest::CPPUNIT_TEST_SUITE_END
CPPUNIT_TEST_SUITE_END()

ExodusC0PolygonTest::CPPUNIT_TEST
CPPUNIT_TEST(test_write_and_read_pentagon)

ExodusC0PolygonTest::test_write_and_read_pentagon
void test_write_and_read_pentagon()
Definition exodus_test.C:145

ExodusC0PolyhedronTest
Definition exodus_test.C:188

ExodusC0PolyhedronTest::test_write_and_read_mixed_hex_tet_block_names_replicated
void test_write_and_read_mixed_hex_tet_block_names_replicated()
Definition exodus_test.C:622

ExodusC0PolyhedronTest::CPPUNIT_TEST
CPPUNIT_TEST(test_write_and_read_hexagonal_prism)

ExodusC0PolyhedronTest::CPPUNIT_TEST
CPPUNIT_TEST(test_write_and_read_mixed_hex_tet_block_names_replicated)

ExodusC0PolyhedronTest::test_write_and_read_mixed_poly_hex_replicated
void test_write_and_read_mixed_poly_hex_replicated()
Definition exodus_test.C:488

ExodusC0PolyhedronTest::CPPUNIT_TEST
CPPUNIT_TEST(test_write_hexagonal_prism_header)

ExodusC0PolyhedronTest::test_write_hexagonal_prism_header
void test_write_hexagonal_prism_header()
Definition exodus_test.C:285

ExodusC0PolyhedronTest::test_write_and_read_hexagonal_prism
void test_write_and_read_hexagonal_prism()
Definition exodus_test.C:320

ExodusC0PolyhedronTest::CPPUNIT_TEST
CPPUNIT_TEST(test_write_and_read_mixed_hex_tet_block_names_distributed)

ExodusC0PolyhedronTest::CPPUNIT_TEST
CPPUNIT_TEST(test_write_and_read_mixed_poly_hex_distributed)

ExodusC0PolyhedronTest::test_write_and_read_mixed_hex_tet_block_names_impl
void test_write_and_read_mixed_hex_tet_block_names_impl(const std::string &basename, bool run_only_on_proc0=true)
Definition exodus_test.C:509

ExodusC0PolyhedronTest::CPPUNIT_TEST
CPPUNIT_TEST(test_write_and_read_mixed_hex_tet_block_names_all_ranks)

ExodusC0PolyhedronTest::test_write_cube_header
void test_write_cube_header()
Definition exodus_test.C:257

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

ExodusC0PolyhedronTest::test_write_and_read_mixed_hex_tet_block_names_all_ranks
void test_write_and_read_mixed_hex_tet_block_names_all_ranks()
Definition exodus_test.C:634

ExodusC0PolyhedronTest::write_and_read_header
ExodusHeaderInfo write_and_read_header(Mesh &mesh, const std::string &filename)
Definition exodus_test.C:203

ExodusC0PolyhedronTest::assert_distributed_if_parallel
static void assert_distributed_if_parallel(const MeshBase &mesh)
Definition exodus_test.C:221

ExodusC0PolyhedronTest::CPPUNIT_TEST_SUITE_END
CPPUNIT_TEST_SUITE_END()

ExodusC0PolyhedronTest::test_write_and_read_mixed_poly_hex_impl
void test_write_and_read_mixed_poly_hex_impl(const std::string &filename)
Definition exodus_test.C:410

ExodusC0PolyhedronTest::CPPUNIT_TEST
CPPUNIT_TEST(test_write_cube_header)

ExodusC0PolyhedronTest::test_write_and_read_mixed_hex_tet_block_names_distributed
void test_write_and_read_mixed_hex_tet_block_names_distributed()
Definition exodus_test.C:628

ExodusC0PolyhedronTest::LIBMESH_CPPUNIT_TEST_SUITE
LIBMESH_CPPUNIT_TEST_SUITE(ExodusC0PolyhedronTest)

ExodusC0PolyhedronTest::test_write_and_read_mixed_poly_hex_distributed
void test_write_and_read_mixed_poly_hex_distributed()
Definition exodus_test.C:494

ExodusC0PolyhedronTest::CPPUNIT_TEST
CPPUNIT_TEST(test_write_and_read_mixed_poly_hex_replicated)

ExodusTest
Definition exodus_test.C:26

ExodusTest::test_write
void test_write()
Definition exodus_test.C:45

ExodusTest::test_read_gold
void test_read_gold()
Definition exodus_test.C:28

MeshPerElemTest
Definition mesh_elem_test.h:12

MeshPerElemTest::meshes_equal_enough
bool meshes_equal_enough(Mesh &other_mesh, bool double_precision)
Definition mesh_elem_test.h:15

PerElemTest::_mesh
std::unique_ptr< Mesh > _mesh
Definition elem_test.h:26

libMesh::Parallel::Communicator::max
void max(const T &r, T &o, Request &req) const

libMesh::BoundaryInfo::clear
void clear()
Clears the underlying data structures and restores the object to a pristine state with no data stored...
Definition boundary_info.C:346

libMesh::DistributedMesh
The DistributedMesh class is derived from the MeshBase class, and is intended to provide identical fu...
Definition distributed_mesh.h:58

libMesh::DistributedMesh::n_elem
virtual dof_id_type n_elem() const override final
Definition distributed_mesh.h:273

libMesh::DistributedMesh::query_elem_ptr
virtual const Elem * query_elem_ptr(const dof_id_type i) const override final
Definition distributed_mesh.C:562

libMesh::DofObject::set_id
dof_id_type & set_id()
Definition dof_object.h:841

libMesh::Elem
This is the base class from which all geometric element types are derived.
Definition elem.h:96

libMesh::Elem::n_vertices
virtual unsigned int n_vertices() const =0

libMesh::Elem::n_nodes
virtual unsigned int n_nodes() const =0

libMesh::Elem::build
static std::unique_ptr< Elem > build(const ElemType type, Elem *p=nullptr)
Definition elem.C:382

libMesh::Elem::nodes_on_side
virtual std::vector< unsigned int > nodes_on_side(const unsigned int) const =0

libMesh::Elem::subdomain_id
subdomain_id_type subdomain_id() const
Definition elem.h:2712

libMesh::Elem::type
virtual ElemType type() const =0

libMesh::Elem::n_sides
virtual unsigned int n_sides() const =0

libMesh::Elem::node_id
dof_id_type node_id(const unsigned int i) const
Definition elem.h:2605

libMesh::Elem::side_index_range
IntRange< unsigned short > side_index_range() const
Definition elem.h:2848

libMesh::ExodusHeaderInfo
This class is used as both an external data structure for passing around Exodus file header informati...
Definition exodus_header_info.h:38

libMesh::ExodusHeaderInfo::num_side_sets
int num_side_sets
Definition exodus_header_info.h:86

libMesh::ExodusHeaderInfo::num_dim
int num_dim
Definition exodus_header_info.h:81

libMesh::ExodusHeaderInfo::num_node_sets
int num_node_sets
Definition exodus_header_info.h:85

libMesh::ExodusHeaderInfo::num_face
int num_face
Definition exodus_header_info.h:91

libMesh::ExodusHeaderInfo::num_face_blk
int num_face_blk
Definition exodus_header_info.h:90

libMesh::ExodusHeaderInfo::num_elem
int num_elem
Definition exodus_header_info.h:83

libMesh::ExodusHeaderInfo::num_elem_blk
int num_elem_blk
Definition exodus_header_info.h:84

libMesh::ExodusII_IO_Helper
This is the ExodusII_IO_Helper class.
Definition exodusII_io_helper.h:75

libMesh::ExodusII_IO_Helper::write_nodal_coordinates
virtual void write_nodal_coordinates(const MeshBase &mesh, bool use_discontinuous=false)
Writes the nodal coordinates contained in "mesh".
Definition exodusII_io_helper.C:2889

libMesh::ExodusII_IO_Helper::close
void close() noexcept
Closes the ExodusII mesh file.
Definition exodusII_io_helper.C:2128

libMesh::ExodusII_IO_Helper::create
virtual void create(std::string filename)
Opens an ExodusII mesh file named filename for writing.
Definition exodusII_io_helper.C:2601

libMesh::ExodusII_IO_Helper::write_elements
virtual void write_elements(const MeshBase &mesh, bool use_discontinuous=false)
Writes the elements contained in "mesh".
Definition exodusII_io_helper.C:3046

libMesh::ExodusII_IO_Helper::initialize
virtual void initialize(std::string title, const MeshBase &mesh, bool use_discontinuous=false)
Initializes the Exodus file.
Definition exodusII_io_helper.C:2668

libMesh::ExodusII_IO_Helper::set_add_sides
void set_add_sides(bool add_sides)
Sets whether or not to write extra "side" elements.
Definition exodusII_io_helper.h:1362

libMesh::ExodusII_IO
The ExodusII_IO class implements reading meshes in the ExodusII file format from Sandia National Labs...
Definition exodusII_io.h:53

libMesh::ExodusII_IO::set_max_name_length
void set_max_name_length(unsigned int max_length)
For backwards compatibility, libMesh currently truncates names in ExodusII output to the old default ...
Definition exodusII_io.C:2516

libMesh::ExodusII_IO::write
virtual void write(const std::string &fname) override
This method implements writing a mesh to a specified file.
Definition exodusII_io.C:2283

libMesh::ExodusII_IO::read_header
ExodusHeaderInfo read_header(const std::string &name)
Read only the header information, instead of the entire mesh.
Definition exodusII_io.C:1044

libMesh::ExodusII_IO::read
virtual void read(const std::string &name) override
This method implements reading a mesh from a specified file.
Definition exodusII_io.C:276

libMesh::ExodusII_IO::write_added_sides
void write_added_sides(bool val)
By default, we only write out the elements physically stored in the mesh.
Definition exodusII_io.C:1134

libMesh::MeshBase
This is the MeshBase class.
Definition mesh_base.h:81

libMesh::MeshBase::set_subdomain_name
void set_subdomain_name(subdomain_id_type id, const std::string &name, bool synchronous=false)
Sets the name for the provided id.
Definition mesh_base.C:1929

libMesh::MeshBase::is_serial
virtual bool is_serial() const
Definition mesh_base.h:357

libMesh::MeshBase::get_boundary_info
const BoundaryInfo & get_boundary_info() const
The information about boundary ids on the mesh.
Definition mesh_base.h:170

libMesh::MeshBase::node_ptr
virtual const Node * node_ptr(const dof_id_type i) const =0

libMesh::MeshBase::cache_elem_data
void cache_elem_data()
Definition mesh_base.C:2000

libMesh::MeshBase::prepare_for_use
void prepare_for_use(const bool skip_renumber_nodes_and_elements, const bool skip_find_neighbors)
Prepare a newly created (or read) mesh for use.
Definition mesh_base.C:824

libMesh::MeshBase::add_point
virtual Node * add_point(const Point &p, const dof_id_type id=DofObject::invalid_id, const processor_id_type proc_id=DofObject::invalid_processor_id)=0
Add a new Node at Point p to the end of the vertex array, with processor_id procid.

libMesh::MeshBase::add_node
virtual Node * add_node(Node *n)=0
Add Node n to the end of the vertex array.

libMesh::MeshBase::query_elem_ptr
virtual const Elem * query_elem_ptr(const dof_id_type i) const =0

libMesh::MeshBase::add_elem
virtual Elem * add_elem(Elem *e)=0
Add elem e to the end of the element array.

libMesh::MeshCommunication
This is the MeshCommunication class.
Definition mesh_communication.h:54

libMesh::MeshCommunication::broadcast
void broadcast(MeshBase &) const
This method takes a mesh (which is assumed to reside on processor 0) and broadcasts it to all the oth...
Definition mesh_communication.C:1163

libMesh::Mesh
The Mesh class is a thin wrapper, around the ReplicatedMesh class by default.
Definition mesh.h:51

libMesh::ParallelObject::processor_id
processor_id_type processor_id() const
Definition parallel_object.h:114

libMesh::ParallelObject::comm
const Parallel::Communicator & comm() const
Definition parallel_object.h:97

libMesh::ParallelObject::n_processors
processor_id_type n_processors() const
Definition parallel_object.h:103

TestCommWorld
Communicator * TestCommWorld

CPPUNIT_TEST_SUITE_REGISTRATION
CPPUNIT_TEST_SUITE_REGISTRATION(ExodusC0PolygonTest)

INSTANTIATE_EXODUSTEST
INSTANTIATE_EXODUSTEST(EDGE2)

mesh
MeshBase & mesh
Definition mesh_communication.C:1473

mesh_elem_test.h

libMesh::MeshTools::Generation::build_cube
void build_cube(UnstructuredMesh &mesh, const unsigned int nx=0, const unsigned int ny=0, const unsigned int nz=0, const Real xmin=0., const Real xmax=1., const Real ymin=0., const Real ymax=1., const Real zmin=0., const Real zmax=1., const ElemType type=INVALID_ELEM, const bool gauss_lobatto_grid=false)
Builds a  (elements) cube.
Definition mesh_generation.C:317

libMesh::Utility::enum_to_string
std::string enum_to_string(const T e)

libMesh
The libMesh namespace provides an interface to certain functionality in the library.

libMesh::index_range
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition int_range.h:153

libMesh::PRISM15
@ PRISM15
Definition enum_elem_type.h:51

libMesh::TET14
@ TET14
Definition enum_elem_type.h:76

libMesh::QUADSHELL4
@ QUADSHELL4
Definition enum_elem_type.h:72

libMesh::PYRAMID18
@ PYRAMID18
Definition enum_elem_type.h:79

libMesh::HEX20
@ HEX20
Definition enum_elem_type.h:48

libMesh::PYRAMID14
@ PYRAMID14
Definition enum_elem_type.h:55

libMesh::QUAD9
@ QUAD9
Definition enum_elem_type.h:43

libMesh::TRI7
@ TRI7
Definition enum_elem_type.h:75

libMesh::EDGE3
@ EDGE3
Definition enum_elem_type.h:36

libMesh::QUADSHELL9
@ QUADSHELL9
Definition enum_elem_type.h:81

libMesh::PRISM18
@ PRISM18
Definition enum_elem_type.h:52

libMesh::QUAD8
@ QUAD8
Definition enum_elem_type.h:42

libMesh::TRISHELL3
@ TRISHELL3
Definition enum_elem_type.h:71

libMesh::PRISM20
@ PRISM20
Definition enum_elem_type.h:77

libMesh::HEX27
@ HEX27
Definition enum_elem_type.h:49

libMesh::EDGE4
@ EDGE4
Definition enum_elem_type.h:37

libMesh::C0POLYHEDRON
@ C0POLYHEDRON
Definition enum_elem_type.h:85

libMesh::TET4
@ TET4
Definition enum_elem_type.h:45

libMesh::PRISM6
@ PRISM6
Definition enum_elem_type.h:50

libMesh::EDGE2
@ EDGE2
Definition enum_elem_type.h:35

libMesh::TRI6
@ TRI6
Definition enum_elem_type.h:40

libMesh::HEX8
@ HEX8
Definition enum_elem_type.h:47

libMesh::C0POLYGON
@ C0POLYGON
Definition enum_elem_type.h:83

libMesh::QUADSHELL8
@ QUADSHELL8
Definition enum_elem_type.h:73

libMesh::PYRAMID13
@ PYRAMID13
Definition enum_elem_type.h:54

libMesh::TRI3
@ TRI3
Definition enum_elem_type.h:39

libMesh::TET10
@ TET10
Definition enum_elem_type.h:46

libMesh::PRISM21
@ PRISM21
Definition enum_elem_type.h:78

libMesh::PYRAMID5
@ PYRAMID5
Definition enum_elem_type.h:53

libMesh::QUAD4
@ QUAD4
Definition enum_elem_type.h:41

libMesh::libmesh_assert
libmesh_assert(ctx)

libMesh::make_range
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition int_range.h:176