ExodusTest< elem_type > Class Template Reference

Inheritance diagram for ExodusTest< elem_type >:

Public Member Functions
void	test_read_gold ()
void	test_write ()
void	setUp ()

Protected Member Functions
bool	meshes_equal_enough (Mesh &other_mesh, bool double_precision)

Protected Attributes
std::unique_ptr< Mesh >	_mesh
std::string	libmesh_suite_name

Detailed Description

template<ElemType elem_type>
class ExodusTest< elem_type >

Definition at line 21 of file exodus_test.C.

Member Function Documentation

meshes_equal_enough()

template<ElemType elem_type>

bool MeshPerElemTest< elem_type >::meshes_equal_enough ( Mesh &  other_mesh, bool  double_precision  )

inlineprotectedinherited

Definition at line 15 of file mesh_elem_test.h.

  {
    // We'll need to fix up processor_id() and unique_id() values
    // before we can operator== these meshes.  But worse: our gold
    // meshes might have been numbered differently to our generated
    // meshes.  Some of our generated mesh options practically
    // *require* renumbering (e.g. after interior HEX20 nodes are
    // deleted, ExodusII still wants to see a contiguous numbering),
    // but ReplicatedMesh and DistributedMesh renumber differently.
    //
    // So, let's renumber too.
 
    MeshSerializer serialthis(*this->_mesh);
    MeshSerializer serialother(other_mesh);
 
    const dof_id_type max_elem_id = this->_mesh->max_elem_id();
    const dof_id_type max_node_id = this->_mesh->max_node_id();
 
    CPPUNIT_ASSERT_EQUAL(max_elem_id, other_mesh.max_elem_id());
    CPPUNIT_ASSERT_EQUAL(max_node_id, other_mesh.max_node_id());
 
    auto locator = other_mesh.sub_point_locator();
 
    for (Elem * e1 : this->_mesh->element_ptr_range())
    {
      const Elem * e2c = (*locator)(e1->vertex_average());
      CPPUNIT_ASSERT(e2c);
      Elem & e2 = other_mesh.elem_ref(e2c->id());
      e1->processor_id() = 0;
      e2.processor_id() = 0;
 
      const dof_id_type e1_id = e1->id();
      const dof_id_type e2_id = e2.id();
      // Do a swap if necessary, using a free temporary id
      if (e1_id != e2_id)
        {
          other_mesh.renumber_elem(e1_id, max_elem_id);
          other_mesh.renumber_elem(e2_id, e1_id);
          other_mesh.renumber_elem(max_elem_id, e2_id);
        }
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
      e2.set_unique_id(e1->unique_id());
#endif
    }
 
    for (Node * n1 : this->_mesh->node_ptr_range())
    {
      const Elem * e1c = (*locator)(*n1);
      Node * n2 = nullptr;
      for (const Node & n : e1c->node_ref_range())
        {
#if defined(LIBMESH_DEFAULT_QUADRUPLE_PRECISION) || defined(LIBMESH_DEFAULT_TRIPLE_PRECISION)
          if (double_precision)
            {
              const Point diff = Point(*n1)-Point(n);
 
              // We may be testing against ExodusII input, and if
              // we're in triple or quadruple precision that means our
              // lovely higher-precision node coordinates got
              // truncated to double to be written.  We need to adjust
              // ours or they won't satisfy operator== later.
 
              // We're *also* testing against gold files that were
              // calculated at double precision, so just casting a
              // higher precision calculation to double won't give the
              // exact same result, we have to account for error.
              if (diff.norm() < 1e-15)
                for (auto d : make_range(LIBMESH_DIM))
                  (*n1)(d) = double(n(d));
            }
#else
          libmesh_ignore(double_precision);
#endif
          if (Point(*n1) == Point(n))
            n2 = other_mesh.node_ptr(n.id());
        }
      CPPUNIT_ASSERT(n2);
      n1->processor_id() = 0;
      n2->processor_id() = 0;
 
      const dof_id_type n1_id = n1->id();
      const dof_id_type n2_id = n2->id();
      // Do a swap if necessary, using a free temporary id
      if (n1_id != n2_id)
        {
          other_mesh.renumber_node(n1_id,max_node_id);
          other_mesh.renumber_node(n2_id,n1_id);
          other_mesh.renumber_node(max_node_id, n2_id);
        }
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
      n2->set_unique_id(n1->unique_id());
#endif
    }
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
    other_mesh.set_next_unique_id(this->_mesh->parallel_max_unique_id());
    this->_mesh->set_next_unique_id(this->_mesh->parallel_max_unique_id());
#endif
 
    return *this->_mesh == other_mesh;
  }

References PerElemTest< elem_type >::_mesh, libMesh::MeshBase::elem_ref(), libMesh::DofObject::id(), libMesh::libmesh_ignore(), libMesh::make_range(), libMesh::DistributedMesh::max_elem_id(), libMesh::DistributedMesh::max_node_id(), libMesh::DistributedMesh::node_ptr(), libMesh::Elem::node_ref_range(), libMesh::TypeVector< T >::norm(), libMesh::DofObject::processor_id(), libMesh::DistributedMesh::renumber_elem(), libMesh::DistributedMesh::renumber_node(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofObject::set_unique_id(), and libMesh::MeshBase::sub_point_locator().

Referenced by ExodusTest< elem_type >::test_read_gold(), XdrIOTest< elem_type >::test_read_gold(), ExodusTest< elem_type >::test_write(), and XdrIOTest< elem_type >::test_write().

setUp()

template<ElemType elem_type>

void PerElemTest< elem_type >::setUp ( )

inlineinherited

Definition at line 30 of file elem_test.h.

  {
    const Real minpos = 1.5, maxpos = 5.5;
    const unsigned int N = 2;
 
    _mesh = std::make_unique<Mesh>(*TestCommWorld);
 
    std::unique_ptr<Elem> test_elem;
 
    if (elem_type != C0POLYHEDRON)
      test_elem = Elem::build(elem_type);
 
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
#if LIBMESH_DIM > 1
    if (test_elem.get() && test_elem->infinite())
      {
        Elem * elem = _mesh->add_elem(std::move(test_elem));
 
        const auto add_point =
          [this, elem](const unsigned int i,
                       const Real x,
                       const Real y,
                       const Real
#if LIBMESH_DIM == 3
                                  z
#endif
                      )
          {
#if LIBMESH_DIM == 2
            auto node = _mesh->add_point(Point(x, y), i);
#else
            auto node = _mesh->add_point(Point(x, y, z), i);
#endif
            elem->set_node(i, node);
          };
 
        const Real halfpos = (minpos + maxpos) / 2.;
 
        if (elem_type == INFQUAD4 || elem_type == INFQUAD6 ||
            elem_type == INFHEX8 || elem_type == INFHEX16 || elem_type == INFHEX18)
          {
            const bool is_quad = (elem_type == INFQUAD4 || elem_type == INFQUAD6);
 
            add_point(0, minpos, minpos, minpos);
            add_point(1, maxpos, minpos, minpos);
            add_point(2+is_quad, maxpos, maxpos, minpos);
            add_point(3-is_quad, minpos, maxpos, minpos);
 
            if (elem_type == INFQUAD6)
              {
                add_point(4, halfpos, minpos, minpos);
                add_point(5, halfpos, maxpos, minpos);
              }
          }
        if (elem_type == INFHEX8 || elem_type == INFHEX16 || elem_type == INFHEX18)
          {
            add_point(4, minpos, minpos, maxpos);
            add_point(5, maxpos, minpos, maxpos);
            add_point(6, maxpos, maxpos, maxpos);
            add_point(7, minpos, maxpos, maxpos);
 
            if (elem_type == INFHEX16 || elem_type == INFHEX18)
              {
                add_point(8, halfpos, minpos, minpos);
                add_point(9, maxpos, halfpos, minpos);
                add_point(10, halfpos, maxpos, minpos);
                add_point(11, minpos, halfpos, minpos);
                add_point(12, halfpos, minpos, maxpos);
                add_point(13, maxpos, halfpos, maxpos);
                add_point(14, halfpos, maxpos, maxpos);
                add_point(15, minpos, halfpos, maxpos);
              }
            if (elem_type == INFHEX18)
              {
                add_point(16, halfpos, halfpos, minpos);
                add_point(17, halfpos, halfpos, maxpos);
              }
          }
        if (elem_type == INFPRISM6 || elem_type == INFPRISM12)
          {
            add_point(0, minpos, minpos, minpos);
            add_point(1, maxpos, minpos, minpos);
            add_point(2, halfpos, maxpos, minpos);
            add_point(3, minpos, minpos, maxpos);
            add_point(4, maxpos, minpos, maxpos);
            add_point(5, halfpos, maxpos, maxpos);
 
            if (elem_type == INFPRISM12)
              {
                add_point(6, halfpos, minpos, minpos);
                add_point(7, (halfpos + maxpos) / 2., halfpos, minpos);
                add_point(8, (halfpos + minpos) / 2., halfpos, minpos);
                add_point(9, halfpos, minpos, maxpos);
                add_point(10, (halfpos + maxpos) / 2., halfpos, maxpos);
                add_point(11, (halfpos + minpos) / 2., halfpos, maxpos);
              }
          }
 
        _mesh->prepare_for_use();
      }
    else
#endif // LIBMESH_DIM > 1
#endif // LIBMESH_ENABLE_INFINITE_ELEMENTS
    if (elem_type == C0POLYGON)
      {
        // We're not going to implement build_square for e.g.
        // pentagons any time soon.
        //
        // We should probably implement build_dual_mesh, though, and
        // run it on a perturbed or triangle input so we don't just
        // get quads in the output...
 
        _mesh->add_point(Point(0, 0), 0);
        _mesh->add_point(Point(1, 0), 1);
        _mesh->add_point(Point(1.5, 0.5), 2);
        _mesh->add_point(Point(1, 1), 3);
        _mesh->add_point(Point(0, 1), 4);
 
        std::unique_ptr<Elem> polygon = std::make_unique<C0Polygon>(5);
        for (auto i : make_range(5))
          polygon->set_node(i, _mesh->node_ptr(i));
        polygon->set_id() = 0;
 
        _mesh->add_elem(std::move(polygon));
        _mesh->prepare_for_use();
      }
    else if (elem_type == C0POLYHEDRON)
      {
        // There's even less point in having a build_cube for general
        // polyhedra, so again we'll hand-make one for testing and
        // we'll plan on making a build_dual_mesh for the future.
 
#if 0
        // Try a truncated cube for relatively simple verification.
 
        // We have some differing orientations on the top sides, to
        // test handling of that.
        // Lower octagon points, counterclockwise
        _mesh->add_point(Point(1/Real(3), 0, 0), 0);
        _mesh->add_point(Point(2/Real(3), 0, 0), 1);
        _mesh->add_point(Point(1, 1/Real(3), 0), 2);
        _mesh->add_point(Point(1, 2/Real(3), 0), 3);
        _mesh->add_point(Point(2/Real(3), 1, 0), 4);
        _mesh->add_point(Point(1/Real(3), 1, 0), 5);
        _mesh->add_point(Point(0, 2/Real(3), 0), 6);
        _mesh->add_point(Point(0, 1/Real(3), 0), 7);
 
        // Lower-middle points, counterclockwise
        _mesh->add_point(Point(0, 0, 1/Real(3)), 8);
        _mesh->add_point(Point(1, 0, 1/Real(3)), 9);
        _mesh->add_point(Point(1, 1, 1/Real(3)), 10);
        _mesh->add_point(Point(0, 1, 1/Real(3)), 11);
 
        // Upper-middle points, counterclockwise
        _mesh->add_point(Point(0, 0, 2/Real(3)), 12);
        _mesh->add_point(Point(1, 0, 2/Real(3)), 13);
        _mesh->add_point(Point(1, 1, 2/Real(3)), 14);
        _mesh->add_point(Point(0, 1, 2/Real(3)), 15);
 
        // Upper octagon points, counterclockwise
        _mesh->add_point(Point(1/Real(3), 0, 1), 16);
        _mesh->add_point(Point(2/Real(3), 0, 1), 17);
        _mesh->add_point(Point(1, 1/Real(3), 1), 18);
        _mesh->add_point(Point(1, 2/Real(3), 1), 19);
        _mesh->add_point(Point(2/Real(3), 1, 1), 20);
        _mesh->add_point(Point(1/Real(3), 1, 1), 21);
        _mesh->add_point(Point(0, 2/Real(3), 1), 22);
        _mesh->add_point(Point(0, 1/Real(3), 1), 23);
 
        const std::vector<std::vector<unsigned int>> nodes_on_side =
          { {0, 1, 2, 3, 4, 5, 6, 7},         // min z
            {0, 1, 9, 13, 17, 16, 12, 8},     // min y
            {2, 3, 10, 14, 19, 18, 13, 9},    // max x
            {4, 5, 11, 15, 21, 20, 14, 10},   // max y
            {6, 7, 8, 12, 23, 22, 15, 11},    // min x
            {16, 17, 18, 19, 20, 21, 22, 23}, // max z
            {7, 0, 8},                        // max nothing
            {1, 2, 9},                        // max x
            {3, 4, 10},                       // max xy
            {5, 6, 11},                       // max y
            {23, 16, 12},                     // max z
            {17, 18, 13},                     // max xz
            {19, 20, 14},                     // max xyz
            {21, 22, 15} };                   // max yz
#endif
 
#if 1
        // Or try an affine-skewed box.  Unlike a unit cube, its
        // non-unit quality values cannot be confused with the generic
        // fallback value of 1.
        _mesh->add_point(Point(0, 0, 0), 0);
        _mesh->add_point(Point(2, 0, 0), 1);
        _mesh->add_point(Point(2.25, 1, 0), 2);
        _mesh->add_point(Point(0.25, 1, 0), 3);
        _mesh->add_point(Point(0, 0, 1), 4);
        _mesh->add_point(Point(2, 0, 1), 5);
        _mesh->add_point(Point(2.25, 1, 1), 6);
        _mesh->add_point(Point(0.25, 1, 1), 7);
 
        // With some combinations of face triangulations, even a
        // simple box has no tetrahedralization that doesn't have
        // either interior discontinuities or a 0-volume pancake tet!
        //
        // The initial "natural" way to orient our sides is commented
        // out here; permutations that fix diagonals for us are used
        // instead.
        // Listing both z sides first also tests nonconsecutive local
        // side edges in the polyhedron edge lookup.
        const std::vector<std::vector<unsigned int>> nodes_on_side =
          { {0, 1, 2, 3},   // min z
            {5, 6, 7, 4},   // max z
            {0, 1, 5, 4},   // min y
        //     {1, 2, 6, 5},   // max x - bad
            {2, 6, 5, 1},   // max x
            {2, 3, 7, 6},   // max y
        //     {3, 0, 4, 7},   // min x - bad
            {0, 4, 7, 3} }; // min x
#endif
 
        // Build all the sides.
        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<libMesh::Node> mid_elem_node;
        std::unique_ptr<Elem> polyhedron = std::make_unique<C0Polyhedron>(sides, mid_elem_node);
        _mesh->add_elem(std::move(polyhedron));
        if (mid_elem_node)
          _mesh->add_node(std::move(mid_elem_node));
        _mesh->prepare_for_use();
      }
    else
      {
        const unsigned int dim = test_elem->dim();
        const unsigned int use_x = dim > 0;
        const unsigned int use_y = dim > 1;
        const unsigned int use_z = dim > 2;
 
        MeshTools::Generation::build_cube (*_mesh,
                                           N*use_x, N*use_y, N*use_z,
                                           minpos, maxpos,
                                           minpos, use_y*maxpos,
                                           minpos, use_z*maxpos,
                                           elem_type);
      }
 
    // Use non-default subdomain ids so we can properly test their
    // preservation.
    //
    // Use long subdomain names so we can test that we're not
    // truncating as badly as we used to in ExodusII.
    for (const auto & elem :
         this->_mesh->element_ptr_range())
    {
      const subdomain_id_type sbdid = 10 + (elem->id() % 10);
      elem->subdomain_id() = sbdid;
      std::ostringstream sbdname;
      sbdname <<
        "a_very_long_subdomain_name_for_the_subdomain_with_number_" << sbdid;
      this->_mesh->set_subdomain_name(sbdid, sbdname.str());
    }
 
    // Make sure our mesh's cache knows about them all for later
    // test comparisons
    this->_mesh->cache_elem_data();
 
    // We may have updated only a portion of subdomain names if we're
    // on a distributed mesh, but every processor should know about
    // every name.
    this->_mesh->sync_subdomain_name_map();
  }

References PerElemTest< elem_type >::_mesh, libMesh::Elem::build(), libMesh::MeshTools::Generation::build_cube(), libMesh::C0POLYGON, libMesh::C0POLYHEDRON, dim, libMesh::index_range(), libMesh::INFHEX16, libMesh::INFHEX18, libMesh::INFHEX8, libMesh::INFPRISM12, libMesh::INFPRISM6, libMesh::INFQUAD4, libMesh::INFQUAD6, libMesh::make_range(), libMesh::Real, libMesh::Elem::set_node(), and TestCommWorld.

test_read_gold()

template<ElemType elem_type>

void ExodusTest< elem_type >::test_read_gold ( )

inline

Definition at line 24 of file exodus_test.C.

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

References libMesh::MeshCommunication::broadcast(), libMesh::Utility::enum_to_string(), MeshPerElemTest< elem_type >::meshes_equal_enough(), libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::ExodusII_IO::read(), and TestCommWorld.

test_write()

template<ElemType elem_type>

void ExodusTest< elem_type >::test_write ( )

inline

Definition at line 41 of file exodus_test.C.

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

References PerElemTest< elem_type >::_mesh, libMesh::MeshCommunication::broadcast(), libMesh::Utility::enum_to_string(), MeshPerElemTest< elem_type >::meshes_equal_enough(), libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::ExodusII_IO::read(), libMesh::ExodusII_IO::set_max_name_length(), TestCommWorld, and libMesh::ExodusII_IO::write().

Member Data Documentation

_mesh

template<ElemType elem_type>

std::unique_ptr<Mesh> PerElemTest< elem_type >::_mesh

protectedinherited

Definition at line 26 of file elem_test.h.

Referenced by MeshPerElemTest< elem_type >::meshes_equal_enough(), PerElemTest< elem_type >::setUp(), ElemTest< elem_type >::test_bounding_box(), ElemTest< elem_type >::test_center_node_on_side(), ElemTest< elem_type >::test_contains_point_node(), ElemTest< elem_type >::test_elem_side_builder(), ElemTest< elem_type >::test_flip(), ElemTest< elem_type >::test_is_internal(), ElemTest< elem_type >::test_maps(), ElemTest< elem_type >::test_n_refinements(), ElemTest< elem_type >::test_node_edge_map_consistency(), ElemTest< elem_type >::test_orient(), ElemTest< elem_type >::test_orient_elements(), ElemTest< elem_type >::test_permute(), ElemTest< elem_type >::test_quality(), ElemTest< elem_type >::test_side_subdomain(), ElemTest< elem_type >::test_side_type(), ElemTest< elem_type >::test_static_data(), ExodusTest< elem_type >::test_write(), and XdrIOTest< elem_type >::test_write().

libmesh_suite_name

template<ElemType elem_type>

std::string PerElemTest< elem_type >::libmesh_suite_name

protectedinherited

Definition at line 27 of file elem_test.h.

---

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

• tests/mesh/exodus_test.C