MeshInputTest Class Reference

Inheritance diagram for MeshInputTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (MeshInputTest)
	CPPUNIT_TEST (testVTKPreserveElemIds)
	CPPUNIT_TEST (testVTKPreserveSubdomainIds)
	CPPUNIT_TEST (testExodusCopyNodalSolutionDistributed)
	CPPUNIT_TEST (testExodusCopyElementSolutionDistributed)
	CPPUNIT_TEST (testExodusCopyNodalSolutionReplicated)
	CPPUNIT_TEST (testExodusCopyElementSolutionReplicated)
	CPPUNIT_TEST (testExodusReadHeader)
	CPPUNIT_TEST (testExodusSetNodeUniqueIdsFromMaps)
	CPPUNIT_TEST (testExodusSetElemUniqueIdsFromMaps)
	CPPUNIT_TEST (testExodusIGASidesets)
	CPPUNIT_TEST (testLowOrderEdgeBlocks)
	CPPUNIT_TEST (testExodusCopyElementVectorDistributed)
	CPPUNIT_TEST (testExodusCopyElementVectorReplicated)
	CPPUNIT_TEST (testExodusWriteElementDataFromDiscontinuousNodalData)
	CPPUNIT_TEST (testExodusWriteAddedSidesEdgeC0)
	CPPUNIT_TEST (testExodusDiscWriteAddedSidesEdgeC0)
	CPPUNIT_TEST (testExodusWriteAddedSidesMixedEdgeC0)
	CPPUNIT_TEST (testExodusDiscWriteAddedSidesMixedEdgeC0)
	CPPUNIT_TEST (testExodusWriteAddedSidesTriC0)
	CPPUNIT_TEST (testExodusDiscWriteAddedSidesTriC0)
	CPPUNIT_TEST (testExodusWriteAddedSidesMixedTriC0)
	CPPUNIT_TEST (testExodusDiscWriteAddedSidesMixedTriC0)
	CPPUNIT_TEST (testExodusWriteAddedSidesQuadC0)
	CPPUNIT_TEST (testExodusDiscWriteAddedSidesQuadC0)
	CPPUNIT_TEST (testExodusWriteAddedSidesMixedQuadC0)
	CPPUNIT_TEST (testExodusDiscWriteAddedSidesMixedQuadC0)
	CPPUNIT_TEST (testExodusWriteAddedSidesHexC0)
	CPPUNIT_TEST (testExodusDiscWriteAddedSidesHexC0)
	CPPUNIT_TEST (testExodusWriteAddedSidesMixedHexC0)
	CPPUNIT_TEST (testExodusDiscWriteAddedSidesMixedHexC0)
	CPPUNIT_TEST (testExodusWriteAddedSidesHexDisc)
	CPPUNIT_TEST (testExodusDiscWriteAddedSidesHexDisc)
	CPPUNIT_TEST (testExodusFileMappingsPlateWithHole)
	CPPUNIT_TEST (testExodusFileMappingsTwoBlocks)
	CPPUNIT_TEST (testExodusFileMappingsTwoElemIGA)
	CPPUNIT_TEST (testExodusFileMappingsCyl3d)
	CPPUNIT_TEST (testExodusDiscPlateWithHole)
	CPPUNIT_TEST (testExodusDiscTwoBlocks)
	CPPUNIT_TEST (testExodusDiscTwoElemIGA)
	CPPUNIT_TEST (testExodusDiscCyl3d)
	CPPUNIT_TEST (testNemesisReadReplicated)
	CPPUNIT_TEST (testNemesisReadDistributed)
	CPPUNIT_TEST (testNemesisCopyNodalSolutionDistributed)
	CPPUNIT_TEST (testNemesisCopyNodalSolutionReplicated)
	CPPUNIT_TEST (testNemesisCopyElementSolutionDistributed)
	CPPUNIT_TEST (testNemesisCopyElementSolutionReplicated)
	CPPUNIT_TEST (testNemesisSingleElementDistributed)
	CPPUNIT_TEST (testNemesisSingleElementReplicated)
	CPPUNIT_TEST (testNemesisCopyElementVectorDistributed)
	CPPUNIT_TEST (testNemesisCopyElementVectorReplicated)
	CPPUNIT_TEST (testAbaqusReadFirst)
	CPPUNIT_TEST (testAbaqusReadSecond)
	CPPUNIT_TEST (testDynaReadElem)
	CPPUNIT_TEST (testDynaNoSplines)
	CPPUNIT_TEST (testDynaReadPatch)
	CPPUNIT_TEST (testDynaFileMappingsFEMEx5)
	CPPUNIT_TEST (testDynaFileMappingsBlockWithHole)
	CPPUNIT_TEST (testDynaFileMappingsPlateWithHole)
	CPPUNIT_TEST (testDynaFileMappingsCyl3d)
	CPPUNIT_TEST (testBadGmsh)
	CPPUNIT_TEST (testGoodGmsh)
	CPPUNIT_TEST (testGoodSTL)
	CPPUNIT_TEST (testGoodSTLBinary)
	CPPUNIT_TEST (testGmshBCIDOverlap)
	CPPUNIT_TEST (testTetgenIO)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
void	testVTKPreserveElemIds ()
void	testVTKPreserveSubdomainIds ()
void	testExodusSetNodeUniqueIdsFromMaps_implementation (bool set_unique_ids, const std::vector< unique_id_type > &expected_unique_ids)
void	testExodusSetNodeUniqueIdsFromMaps ()
void	testExodusSetElemUniqueIdsFromMaps_implementation (bool set_unique_ids, const std::vector< unique_id_type > &expected_unique_ids)
void	testExodusSetElemUniqueIdsFromMaps ()
void	testExodusReadHeader ()
void	testLowOrderEdgeBlocks ()
void	testExodusIGASidesets ()
template<typename MeshType , typename IOType >
void	testCopyNodalSolutionImpl (const std::string &filename)
void	testExodusCopyNodalSolutionReplicated ()
void	testExodusCopyNodalSolutionDistributed ()
void	testNemesisCopyNodalSolutionReplicated ()
void	testNemesisCopyNodalSolutionDistributed ()
template<typename MeshType , typename IOType >
void	testCopyElementSolutionImpl (const std::string &filename)
void	testExodusCopyElementSolutionReplicated ()
void	testExodusCopyElementSolutionDistributed ()
void	testNemesisCopyElementSolutionReplicated ()
void	testNemesisCopyElementSolutionDistributed ()
template<typename MeshType , typename IOType >
void	testSingleElementImpl (const std::string &filename)
void	testNemesisSingleElementReplicated ()
void	testNemesisSingleElementDistributed ()
template<typename MeshType , typename IOType >
void	testCopyElementVectorImpl (const std::string &filename)
void	testExodusCopyElementVectorReplicated ()
void	testExodusCopyElementVectorDistributed ()
void	testNemesisCopyElementVectorReplicated ()
void	testNemesisCopyElementVectorDistributed ()
void	testExodusWriteElementDataFromDiscontinuousNodalData ()
void	testExodusWriteAddedSides (Number(*exact_sol)(const Point &, const Parameters &, const std::string &, const std::string &), const ElemType elem_type, const Order order, const bool write_discontinuous=false, const std::vector< FEType > earlier_vars={}, const std::vector< FEType > later_vars={})
void	testExodusWriteAddedSidesEdgeC0 ()
void	testExodusDiscWriteAddedSidesEdgeC0 ()
void	testExodusWriteAddedSidesMixedEdgeC0 ()
void	testExodusDiscWriteAddedSidesMixedEdgeC0 ()
void	testExodusWriteAddedSidesEdgeDisc ()
void	testExodusDiscWriteAddedSidesEdgeDisc ()
void	testExodusWriteAddedSidesTriC0 ()
void	testExodusDiscWriteAddedSidesTriC0 ()
void	testExodusWriteAddedSidesMixedTriC0 ()
void	testExodusDiscWriteAddedSidesMixedTriC0 ()
void	testExodusWriteAddedSidesTriDisc ()
void	testExodusDiscWriteAddedSidesTriDisc ()
void	testExodusWriteAddedSidesQuadC0 ()
void	testExodusDiscWriteAddedSidesQuadC0 ()
void	testExodusWriteAddedSidesMixedQuadC0 ()
void	testExodusDiscWriteAddedSidesMixedQuadC0 ()
void	testExodusWriteAddedSidesQuadDisc ()
void	testExodusDiscWriteAddedSidesQuadDisc ()
void	testExodusWriteAddedSidesTetC0 ()
void	testExodusDiscWriteAddedSidesTetC0 ()
void	testExodusWriteAddedSidesTetDisc ()
void	testExodusDiscWriteAddedSidesTetDisc ()
void	testExodusWriteAddedSidesHexC0 ()
void	testExodusDiscWriteAddedSidesHexC0 ()
void	testExodusWriteAddedSidesMixedHexC0 ()
void	testExodusDiscWriteAddedSidesMixedHexC0 ()
void	testExodusWriteAddedSidesHexDisc ()
void	testExodusDiscWriteAddedSidesHexDisc ()
template<typename MeshType >
void	testNemesisReadImpl ()
void	testNemesisReadReplicated ()
void	testNemesisReadDistributed ()
void	testMasterCenters (const MeshBase &mesh)
void	helperTestingDynaQuad (const MeshBase &mesh)
void	testAbaqusRead (const std::string &fname, dof_id_type n_elem, dof_id_type n_nodes)
void	testAbaqusReadFirst ()
void	testAbaqusReadSecond ()
void	testDynaReadElem ()
void	testBadGmsh ()
void	testGoodGmsh ()
void	testGmshBCIDOverlap ()
void	testGoodSTL ()
void	testGoodSTLBinary ()
void	testTetgenIO ()
void	testDynaNoSplines ()
void	testDynaReadPatch ()
void	testProjectionRegression (MeshBase &mesh, std::array< Real, 4 > expected_norms)
void	testDynaFileMappings (const std::string &filename, std::array< Real, 4 > expected_norms)
void	testDynaFileMappingsFEMEx5 ()
void	testDynaFileMappingsBlockWithHole ()
void	testDynaFileMappingsPlateWithHole ()
void	testDynaFileMappingsCyl3d ()
void	testExodusFileMappings (const std::string &filename, std::array< Real, 4 > expected_norms, bool use_disc_bex=false)
void	testExodusFileMappingsPlateWithHole ()
void	testExodusFileMappingsTwoBlocks ()
void	testExodusFileMappingsTwoElemIGA ()
void	testExodusFileMappingsCyl3d ()
void	testExodusDiscPlateWithHole ()
void	testExodusDiscTwoBlocks ()
void	testExodusDiscTwoElemIGA ()
void	testExodusDiscCyl3d ()

Detailed Description

Definition at line 99 of file mesh_input.C.

Member Function Documentation

CPPUNIT_TEST() [1/65]

MeshInputTest::CPPUNIT_TEST

(

testVTKPreserveElemIds

)

CPPUNIT_TEST() [2/65]

MeshInputTest::CPPUNIT_TEST

(

testVTKPreserveSubdomainIds

)

CPPUNIT_TEST() [3/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusCopyNodalSolutionDistributed

)

CPPUNIT_TEST() [4/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusCopyElementSolutionDistributed

)

CPPUNIT_TEST() [5/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusCopyNodalSolutionReplicated

)

CPPUNIT_TEST() [6/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusCopyElementSolutionReplicated

)

CPPUNIT_TEST() [7/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusReadHeader

)

CPPUNIT_TEST() [8/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusSetNodeUniqueIdsFromMaps

)

CPPUNIT_TEST() [9/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusSetElemUniqueIdsFromMaps

)

CPPUNIT_TEST() [10/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusIGASidesets

)

CPPUNIT_TEST() [11/65]

MeshInputTest::CPPUNIT_TEST

(

testLowOrderEdgeBlocks

)

CPPUNIT_TEST() [12/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusCopyElementVectorDistributed

)

CPPUNIT_TEST() [13/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusCopyElementVectorReplicated

)

CPPUNIT_TEST() [14/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusWriteElementDataFromDiscontinuousNodalData

)

CPPUNIT_TEST() [15/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusWriteAddedSidesEdgeC0

)

CPPUNIT_TEST() [16/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscWriteAddedSidesEdgeC0

)

CPPUNIT_TEST() [17/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusWriteAddedSidesMixedEdgeC0

)

CPPUNIT_TEST() [18/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscWriteAddedSidesMixedEdgeC0

)

CPPUNIT_TEST() [19/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusWriteAddedSidesTriC0

)

CPPUNIT_TEST() [20/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscWriteAddedSidesTriC0

)

CPPUNIT_TEST() [21/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusWriteAddedSidesMixedTriC0

)

CPPUNIT_TEST() [22/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscWriteAddedSidesMixedTriC0

)

CPPUNIT_TEST() [23/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusWriteAddedSidesQuadC0

)

CPPUNIT_TEST() [24/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscWriteAddedSidesQuadC0

)

CPPUNIT_TEST() [25/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusWriteAddedSidesMixedQuadC0

)

CPPUNIT_TEST() [26/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscWriteAddedSidesMixedQuadC0

)

CPPUNIT_TEST() [27/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusWriteAddedSidesHexC0

)

CPPUNIT_TEST() [28/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscWriteAddedSidesHexC0

)

CPPUNIT_TEST() [29/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusWriteAddedSidesMixedHexC0

)

CPPUNIT_TEST() [30/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscWriteAddedSidesMixedHexC0

)

CPPUNIT_TEST() [31/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusWriteAddedSidesHexDisc

)

CPPUNIT_TEST() [32/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscWriteAddedSidesHexDisc

)

CPPUNIT_TEST() [33/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusFileMappingsPlateWithHole

)

CPPUNIT_TEST() [34/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusFileMappingsTwoBlocks

)

CPPUNIT_TEST() [35/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusFileMappingsTwoElemIGA

)

CPPUNIT_TEST() [36/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusFileMappingsCyl3d

)

CPPUNIT_TEST() [37/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscPlateWithHole

)

CPPUNIT_TEST() [38/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscTwoBlocks

)

CPPUNIT_TEST() [39/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscTwoElemIGA

)

CPPUNIT_TEST() [40/65]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscCyl3d

)

CPPUNIT_TEST() [41/65]

MeshInputTest::CPPUNIT_TEST

(

testNemesisReadReplicated

)

CPPUNIT_TEST() [42/65]

MeshInputTest::CPPUNIT_TEST

(

testNemesisReadDistributed

)

CPPUNIT_TEST() [43/65]

MeshInputTest::CPPUNIT_TEST

(

testNemesisCopyNodalSolutionDistributed

)

CPPUNIT_TEST() [44/65]

MeshInputTest::CPPUNIT_TEST

(

testNemesisCopyNodalSolutionReplicated

)

CPPUNIT_TEST() [45/65]

MeshInputTest::CPPUNIT_TEST

(

testNemesisCopyElementSolutionDistributed

)

CPPUNIT_TEST() [46/65]

MeshInputTest::CPPUNIT_TEST

(

testNemesisCopyElementSolutionReplicated

)

CPPUNIT_TEST() [47/65]

MeshInputTest::CPPUNIT_TEST

(

testNemesisSingleElementDistributed

)

CPPUNIT_TEST() [48/65]

MeshInputTest::CPPUNIT_TEST

(

testNemesisSingleElementReplicated

)

CPPUNIT_TEST() [49/65]

MeshInputTest::CPPUNIT_TEST

(

testNemesisCopyElementVectorDistributed

)

CPPUNIT_TEST() [50/65]

MeshInputTest::CPPUNIT_TEST

(

testNemesisCopyElementVectorReplicated

)

CPPUNIT_TEST() [51/65]

MeshInputTest::CPPUNIT_TEST

(

testAbaqusReadFirst

)

CPPUNIT_TEST() [52/65]

MeshInputTest::CPPUNIT_TEST

(

testAbaqusReadSecond

)

CPPUNIT_TEST() [53/65]

MeshInputTest::CPPUNIT_TEST

(

testDynaReadElem

)

CPPUNIT_TEST() [54/65]

MeshInputTest::CPPUNIT_TEST

(

testDynaNoSplines

)

CPPUNIT_TEST() [55/65]

MeshInputTest::CPPUNIT_TEST

(

testDynaReadPatch

)

CPPUNIT_TEST() [56/65]

MeshInputTest::CPPUNIT_TEST

(

testDynaFileMappingsFEMEx5

)

CPPUNIT_TEST() [57/65]

MeshInputTest::CPPUNIT_TEST

(

testDynaFileMappingsBlockWithHole

)

CPPUNIT_TEST() [58/65]

MeshInputTest::CPPUNIT_TEST

(

testDynaFileMappingsPlateWithHole

)

CPPUNIT_TEST() [59/65]

MeshInputTest::CPPUNIT_TEST

(

testDynaFileMappingsCyl3d

)

CPPUNIT_TEST() [60/65]

MeshInputTest::CPPUNIT_TEST

(

testBadGmsh

)

CPPUNIT_TEST() [61/65]

MeshInputTest::CPPUNIT_TEST

(

testGoodGmsh

)

CPPUNIT_TEST() [62/65]

MeshInputTest::CPPUNIT_TEST

(

testGoodSTL

)

CPPUNIT_TEST() [63/65]

MeshInputTest::CPPUNIT_TEST

(

testGoodSTLBinary

)

CPPUNIT_TEST() [64/65]

MeshInputTest::CPPUNIT_TEST

(

testGmshBCIDOverlap

)

CPPUNIT_TEST() [65/65]

MeshInputTest::CPPUNIT_TEST

(

testTetgenIO

)

CPPUNIT_TEST_SUITE_END()

MeshInputTest::CPPUNIT_TEST_SUITE_END

(

)

helperTestingDynaQuad()

void MeshInputTest::helperTestingDynaQuad ( const MeshBase &  mesh )

inline

Definition at line 1550 of file mesh_input.C.

References libMesh::MeshBase::default_mapping_data(), libMesh::MeshBase::default_mapping_type(), TIMPI::Communicator::max(), mesh, libMesh::NODEELEM, libMesh::QUAD9, libMesh::RATIONAL_BERNSTEIN_MAP, libMesh::Real, and TestCommWorld.

  {
    CPPUNIT_ASSERT_EQUAL(mesh.default_mapping_type(),
                         RATIONAL_BERNSTEIN_MAP);

    unsigned char weight_index = mesh.default_mapping_data();

    bool found_the_quad = false;

    for (auto & elem : mesh.element_ptr_range())
      {
        if (elem->type() == NODEELEM)
          continue;

        CPPUNIT_ASSERT_EQUAL(elem->type(), QUAD9);
        found_the_quad = true;

        for (unsigned int n=0; n != 9; ++n)
          CPPUNIT_ASSERT_EQUAL
            (elem->node_ref(n).get_extra_datum<Real>(weight_index),
             Real(0.75));

        CPPUNIT_ASSERT_EQUAL(elem->point(0)(0), Real(0.5));
        CPPUNIT_ASSERT_EQUAL(elem->point(0)(1), Real(0.5));
        CPPUNIT_ASSERT_EQUAL(elem->point(1)(0), Real(1.5));
        CPPUNIT_ASSERT_EQUAL(elem->point(1)(1), Real(0.5));
        CPPUNIT_ASSERT_EQUAL(elem->point(2)(0), Real(1.5));
        CPPUNIT_ASSERT_EQUAL(elem->point(2)(1), Real(1.5));
        CPPUNIT_ASSERT_EQUAL(elem->point(3)(0), Real(0.5));
        CPPUNIT_ASSERT_EQUAL(elem->point(3)(1), Real(1.5));
        CPPUNIT_ASSERT(elem->has_affine_map());
#if LIBMESH_DIM > 2
        for (unsigned int v=0; v != 4; ++v)
          CPPUNIT_ASSERT_EQUAL(elem->point(v)(2), Real(0));
#endif
      }

    TestCommWorld->max(found_the_quad);
    CPPUNIT_ASSERT(found_the_quad);

    testMasterCenters(mesh);
  }

LIBMESH_CPPUNIT_TEST_SUITE()

MeshInputTest::LIBMESH_CPPUNIT_TEST_SUITE

(

MeshInputTest

)

setUp()

void MeshInputTest::setUp ( )

inline

Definition at line 220 of file mesh_input.C.

  {}

tearDown()

void MeshInputTest::tearDown ( )

inline

Definition at line 223 of file mesh_input.C.

  {}

testAbaqusRead()

void MeshInputTest::testAbaqusRead ( const std::string &  fname, dof_id_type  n_elem, dof_id_type  n_nodes  )

inline

Definition at line 1594 of file mesh_input.C.

References libMesh::MeshCommunication::broadcast(), mesh, libMesh::MeshTools::n_elem(), libMesh::MeshBase::n_elem(), n_nodes, libMesh::MeshBase::n_nodes(), libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::AbaqusIO::read(), and TestCommWorld.

  {
    Mesh mesh(*TestCommWorld);

    AbaqusIO abaqus(mesh);

    if (mesh.processor_id() == 0)
      abaqus.read(fname);
    MeshCommunication().broadcast (mesh);

    mesh.prepare_for_use();

    CPPUNIT_ASSERT_EQUAL(mesh.n_elem(),  n_elem);
    CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(), n_nodes);
  }

testAbaqusReadFirst()

void MeshInputTest::testAbaqusReadFirst ( )

inline

Definition at line 1613 of file mesh_input.C.

  {
    LOG_UNIT_TEST;
    testAbaqusRead("meshes/tensile_sample_test1.inp.gz", 728, 1166);
  }

testAbaqusReadSecond()

void MeshInputTest::testAbaqusReadSecond ( )

inline

Definition at line 1620 of file mesh_input.C.

  {
    LOG_UNIT_TEST;
    testAbaqusRead("meshes/poly_sample_test2.inp.gz", 1280, 1625);
  }

testBadGmsh()

void MeshInputTest::testBadGmsh ( )

inline

Definition at line 1649 of file mesh_input.C.

References TIMPI::Communicator::broadcast(), mesh, libMesh::ParallelObject::processor_id(), libMesh::GmshIO::read(), and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);

    GmshIO gmsh_io(mesh);

#ifdef LIBMESH_ENABLE_EXCEPTIONS
    std::string what = "";
    try
    {
      if (mesh.processor_id() == 0)
        gmsh_io.read("meshes/block.msh");
    }
    catch (libMesh::LogicError & e)
    {
      what = e.what();
    }

    TestCommWorld->broadcast(what);
    std::regex msg_regex("outside entity physical bounding box");
    CPPUNIT_ASSERT(std::regex_search(what, msg_regex));
#endif
  }

testCopyElementSolutionImpl()

template<typename MeshType , typename IOType >

void MeshInputTest::testCopyElementSolutionImpl ( const std::string &  filename )

inline

Definition at line 717 of file mesh_input.C.

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshBase::allow_renumbering(), libMesh::MeshCommunication::broadcast(), libMesh::MeshTools::Generation::build_square(), libMesh::CONSTANT, libMesh::EquationSystems::init(), mesh, libMesh::MONOMIAL, libMesh::EquationSystems::parameters, libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::System::project_solution(), libMesh::Real, six_x_plus_sixty_y(), libMesh::MeshBase::skip_noncritical_partitioning(), TestCommWorld, and libMesh::TOLERANCE.

  {
    {
      MeshType mesh(*TestCommWorld);

      EquationSystems es(mesh);
      System &sys = es.add_system<System> ("SimpleSystem");
      sys.add_variable("e", CONSTANT, MONOMIAL);

      MeshTools::Generation::build_square (mesh,
                                           3, 3,
                                           0., 1., 0., 1.);

      es.init();
      sys.project_solution(six_x_plus_sixty_y, nullptr, es.parameters);

      IOType meshinput(mesh);

      // Don't try to write element data as nodal data
      std::set<std::string> sys_list;
      meshinput.write_equation_systems(filename, es, &sys_list);

      // Just write it as element data
      meshinput.write_element_data(es);
    }

    {
      MeshType mesh(*TestCommWorld);
      mesh.allow_renumbering(false);
      IOType meshinput(mesh);

      // Avoid getting Nemesis solution values mixed up
      if (meshinput.is_parallel_format())
        {
          mesh.skip_noncritical_partitioning(true);
        }

      EquationSystems es(mesh);
      System &sys = es.add_system<System> ("SimpleSystem");
      sys.add_variable("teste", CONSTANT, MONOMIAL);

      if (mesh.processor_id() == 0 || meshinput.is_parallel_format())
        meshinput.read(filename);
      if (!meshinput.is_parallel_format())
        MeshCommunication().broadcast(mesh);
      mesh.prepare_for_use();

      es.init();

      // Read the solution e into variable teste.
      //
      // With complex numbers, we'll only bother reading the real
      // part.
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
      meshinput.copy_elemental_solution(sys, "teste", "r_e");
#else
      meshinput.copy_elemental_solution(sys, "teste", "e");
#endif

      // Exodus only handles double precision
      Real exotol = std::max(TOLERANCE*TOLERANCE, Real(1e-12));

      for (Real x = Real(1.L/6.L); x < 1; x += Real(1.L/3.L))
        for (Real y = Real(1.L/6.L); y < 1; y += Real(1.L/3.L))
          {
            Point p(x,y);
            LIBMESH_ASSERT_NUMBERS_EQUAL
              (sys.point_value(0,p), 6*x+60*y, exotol);
          }
    }
  }

testCopyElementVectorImpl()

template<typename MeshType , typename IOType >

void MeshInputTest::testCopyElementVectorImpl ( const std::string &  filename )

inline

Definition at line 873 of file mesh_input.C.

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshBase::allow_renumbering(), libMesh::MeshCommunication::broadcast(), libMesh::MeshTools::Generation::build_square(), libMesh::CONSTANT, libMesh::System::current_local_solution, libMesh::EquationSystems::init(), mesh, libMesh::MONOMIAL, libMesh::MONOMIAL_VEC, libMesh::System::number(), libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::Real, sin_x_plus_cos_y(), six_x_plus_sixty_y(), libMesh::MeshBase::skip_noncritical_partitioning(), TestCommWorld, and libMesh::TOLERANCE.

  {
    {
      MeshType mesh(*TestCommWorld);

      EquationSystems es(mesh);
      System & sys = es.add_system<System> ("SimpleSystem");
      auto e_var = sys.add_variable("e", CONSTANT, MONOMIAL_VEC);

      MeshTools::Generation::build_square (mesh,
                                           3, 3,
                                           0., 1., 0., 1.);

      es.init();

      // Here, we're going to manually set up the solution because the 'project_solution()' and
      // 'project_vector()' methods don't work so well with CONSTANT MONOMIAL_VEC variables. They
      // each lead to an error downstream asserting positive-definiteness when Cholesky decomposing.
      // Interestingly, the error is only invoked for CONSTANT MONOMIAL_VEC, and not, e.g.,
      // CONSTANT MONOMIAL nor FIRST LAGRANGE_VEC.
      //
      // Anyways, the important thing here is that we test the ExodusII and Nemesis writers, how
      // the solution is set is hardly important, and we're pretty much following the same
      // philosophy as the 'test2DProjectVectorFE()' unit tester in 'systems_test.C'
      Parameters params;
      for (const auto & elem : mesh.active_local_element_ptr_range())
      {
        const Point & p = elem->vertex_average();

        // Set the x-component with the value from 'six_x_plus_sixty_y()' and the y-component
        // with that from 'sin_x_plus_cos_y()' at the element centroid (vertex average)
        sys.current_local_solution->set(
          elem->dof_number(sys.number(), e_var, 0), six_x_plus_sixty_y(p, params, "", ""));
        sys.current_local_solution->set(
          elem->dof_number(sys.number(), e_var, 1), sin_x_plus_cos_y(p, params, "", ""));
      }

      // After setting values, we need to assemble
      sys.current_local_solution->close();

      IOType meshinput(mesh);

      // Don't try to write element data as nodal data
      std::set<std::string> sys_list;
      meshinput.write_equation_systems(filename, es, &sys_list);

      // Just write it as element data
      meshinput.write_element_data(es);
    }

    {
      MeshType mesh(*TestCommWorld);
      mesh.allow_renumbering(false);
      IOType meshinput(mesh);

      // Avoid getting Nemesis solution values mixed up
      if (meshinput.is_parallel_format())
        {
          mesh.skip_noncritical_partitioning(true);
        }

      EquationSystems es(mesh);
      System & sys = es.add_system<System> ("SimpleSystem");

      // We have to read the CONSTANT MONOMIAL_VEC var "e" into separate CONSTANT MONOMIAL vars
      // "e_x" and "e_y" because 'copy_elemental_solution()' currently doesn't support vectors.
      // Again, this isn't a test for reading/copying an elemental vector solution, only writing.
      sys.add_variable("teste_x", CONSTANT, MONOMIAL);
      sys.add_variable("teste_y", CONSTANT, MONOMIAL);

      if (mesh.processor_id() == 0 || meshinput.is_parallel_format())
        meshinput.read(filename);
      if (!meshinput.is_parallel_format())
        MeshCommunication().broadcast(mesh);
      mesh.prepare_for_use();

      es.init();

      // Read the solution e_x and e_y into variable teste_x and teste_y, respectively.
      meshinput.copy_elemental_solution(sys, "teste_x", "e_x");
      meshinput.copy_elemental_solution(sys, "teste_y", "e_y");

      // Exodus only handles double precision
      Real exotol = std::max(TOLERANCE*TOLERANCE, Real(1e-12));

      for (Real x = Real(1.L/6.L); x < 1; x += Real(1.L/3.L))
        for (Real y = Real(1.L/6.L); y < 1; y += Real(1.L/3.L))
          {
            Point p(x,y);
            LIBMESH_ASSERT_NUMBERS_EQUAL
              (sys.point_value(0,p), 6*x+60*y, exotol);
            LIBMESH_ASSERT_NUMBERS_EQUAL
              (sys.point_value(1,p), sin(x)+cos(y), exotol);
          }
    }
  }

testCopyNodalSolutionImpl()

template<typename MeshType , typename IOType >

void MeshInputTest::testCopyNodalSolutionImpl ( const std::string &  filename )

inline

Definition at line 633 of file mesh_input.C.

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshBase::allow_renumbering(), libMesh::MeshCommunication::broadcast(), libMesh::MeshTools::Generation::build_square(), libMesh::FIRST, libMesh::EquationSystems::init(), libMesh::LAGRANGE, mesh, libMesh::EquationSystems::parameters, libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::System::project_solution(), libMesh::Real, six_x_plus_sixty_y(), libMesh::MeshBase::skip_noncritical_partitioning(), TestCommWorld, and libMesh::TOLERANCE.

  {
    {
      MeshType mesh(*TestCommWorld);

      EquationSystems es(mesh);
      System &sys = es.add_system<System> ("SimpleSystem");
      sys.add_variable("n", FIRST, LAGRANGE);

      MeshTools::Generation::build_square (mesh,
                                           3, 3,
                                           0., 1., 0., 1.);

      es.init();
      sys.project_solution(six_x_plus_sixty_y, nullptr, es.parameters);

      IOType meshoutput(mesh);

      meshoutput.write_equation_systems(filename, es);
    }

    {
      MeshType mesh(*TestCommWorld);
      mesh.allow_renumbering(false);
      IOType meshinput(mesh);

      // Avoid getting Nemesis solution values mixed up
      if (meshinput.is_parallel_format())
        {
          mesh.skip_noncritical_partitioning(true);
        }

      EquationSystems es(mesh);
      System &sys = es.add_system<System> ("SimpleSystem");
      sys.add_variable("testn", FIRST, LAGRANGE);

      if (mesh.processor_id() == 0 || meshinput.is_parallel_format())
        meshinput.read(filename);
      if (!meshinput.is_parallel_format())
        MeshCommunication().broadcast(mesh);
      mesh.prepare_for_use();

      es.init();

      // Read the solution e into variable teste.
      //
      // With complex numbers, we'll only bother reading the real
      // part.
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
      meshinput.copy_nodal_solution(sys, "testn", "r_n");
#else
      meshinput.copy_nodal_solution(sys, "testn", "n");
#endif

      // Exodus only handles double precision
      Real exotol = std::max(TOLERANCE*TOLERANCE, Real(1e-12));

      for (Real x = 0; x < 1 + TOLERANCE; x += Real(1.L/3.L))
        for (Real y = 0; y < 1 + TOLERANCE; y += Real(1.L/3.L))
          {
            Point p(x,y);
            LIBMESH_ASSERT_NUMBERS_EQUAL
              (sys.point_value(0,p), 6*x+60*y, exotol);
          }
    }
  }

testDynaFileMappings()

void MeshInputTest::testDynaFileMappings ( const std::string &  filename, std::array< Real, 4 >  expected_norms  )

inline

Definition at line 1920 of file mesh_input.C.

References libMesh::MeshCommunication::broadcast(), libMesh::MeshBase::default_mapping_type(), mesh, libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::RATIONAL_BERNSTEIN_MAP, libMesh::DynaIO::read(), and TestCommWorld.

  {
    Mesh mesh(*TestCommWorld);

    DynaIO dyna(mesh);
    if (mesh.processor_id() == 0)
      dyna.read(filename);
    MeshCommunication().broadcast (mesh);

    mesh.prepare_for_use();

    CPPUNIT_ASSERT_EQUAL(mesh.default_mapping_type(),
                         RATIONAL_BERNSTEIN_MAP);

    // Useful when trying out different projection functions
    // std::cout << filename << ":" << std::endl;

    testMasterCenters(mesh);

    testProjectionRegression(mesh, expected_norms);
  }

testDynaFileMappingsBlockWithHole()

void MeshInputTest::testDynaFileMappingsBlockWithHole ( )

inline

Definition at line 1952 of file mesh_input.C.

  {
    LOG_UNIT_TEST;

    testDynaFileMappings("meshes/BlockWithHole_Patch9.bxt.gz",
    // Regression values for sin_x_plus_cos_y
                         {{3.22612556930183, 1.97405365384733,
                           2.53376235803176, 1.41374070517223}});
  }

testDynaFileMappingsCyl3d()

void MeshInputTest::testDynaFileMappingsCyl3d ( )

inline

Definition at line 1972 of file mesh_input.C.

  {
    LOG_UNIT_TEST;

    testDynaFileMappings("meshes/PressurizedCyl3d_Patch1_8Elem.bxt.gz",
    // Regression values for sin_x_plus_cos_y
                         {{0.963612880188165, 1.82329452603503,
                           0.707998701597943, 1.31399222566683}});
  }

testDynaFileMappingsFEMEx5()

void MeshInputTest::testDynaFileMappingsFEMEx5 ( )

inline

Definition at line 1942 of file mesh_input.C.

  {
    LOG_UNIT_TEST;

    testDynaFileMappings("meshes/PressurizedCyl_Patch6_256Elem.bxt.gz",
    // Regression values for sin_x_plus_cos_y
                         {{0.9639857809698268, 1.839870171669186,
                           0.7089812562241862, 1.306121188539059}});
  }

testDynaFileMappingsPlateWithHole()

void MeshInputTest::testDynaFileMappingsPlateWithHole ( )

inline

Definition at line 1962 of file mesh_input.C.

  {
    LOG_UNIT_TEST;

    testDynaFileMappings("meshes/PlateWithHole_Patch8.bxt.gz",
    // Regression values for sin_x_plus_cos_y
                         {{2.2812154374012, 1.974049990211937,
                           1.791640772215248, 1.413679237529376}});
  }

testDynaNoSplines()

void MeshInputTest::testDynaNoSplines ( )

inline

Definition at line 1787 of file mesh_input.C.

References libMesh::MeshCommunication::broadcast(), mesh, libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::DynaIO::read(), and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);

    DynaIO dyna(mesh, /* keep_spline_nodes = */ false);

    if (mesh.processor_id() == 0)
      dyna.read("meshes/1_quad.bxt.gz");
    MeshCommunication().broadcast (mesh);

    mesh.prepare_for_use();

    // We have 1 QUAD9 finite element
    CPPUNIT_ASSERT_EQUAL(mesh.n_elem(),  static_cast<dof_id_type>(1));
    CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(), static_cast<dof_id_type>(9));

    helperTestingDynaQuad(mesh);
  }

testDynaReadElem()

void MeshInputTest::testDynaReadElem ( )

inline

Definition at line 1627 of file mesh_input.C.

References libMesh::MeshCommunication::broadcast(), mesh, libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::DynaIO::read(), and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);

    DynaIO dyna(mesh);

    if (mesh.processor_id() == 0)
      dyna.read("meshes/1_quad.bxt.gz");
    MeshCommunication().broadcast (mesh);

    mesh.prepare_for_use();

    // We have 1 QUAD9 finite element, attached via a trivial map to 9
    // spline Node+NodeElem objects
    CPPUNIT_ASSERT_EQUAL(mesh.n_elem(),  static_cast<dof_id_type>(10));
    CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(), static_cast<dof_id_type>(18));

    helperTestingDynaQuad(mesh);
  }

testDynaReadPatch()

void MeshInputTest::testDynaReadPatch ( )

inline

Definition at line 1809 of file mesh_input.C.

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshCommunication::broadcast(), libMesh::MeshBase::default_mapping_data(), libMesh::MeshBase::default_mapping_type(), libMesh::System::get_dof_map(), libMesh::EquationSystems::init(), mesh, libMesh::DofMap::n_constrained_dofs(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::NODEELEM, libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::RATIONAL_BERNSTEIN_MAP, libMesh::DynaIO::read(), libMesh::Real, libMesh::SECOND, TestCommWorld, and libMesh::TOLERANCE.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);

    DynaIO dyna(mesh);
    if (mesh.processor_id() == 0)
      dyna.read("meshes/25_quad.bxt.gz");
    MeshCommunication().broadcast (mesh);

    mesh.prepare_for_use();

    // We have 5^2 QUAD9 elements, with 11^2 nodes,
    // tied to 49 Node/NodeElem spline nodes
    CPPUNIT_ASSERT_EQUAL(mesh.n_elem(),  static_cast<dof_id_type>(25+49));
    CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(), static_cast<dof_id_type>(121+49));

    CPPUNIT_ASSERT_EQUAL(mesh.default_mapping_type(),
                         RATIONAL_BERNSTEIN_MAP);

    unsigned char weight_index = mesh.default_mapping_data();

    for (const auto & elem : mesh.active_element_ptr_range())
      {
        if (elem->type() == NODEELEM)
          continue;
        LIBMESH_ASSERT_FP_EQUAL(Real(0.04), elem->volume(), TOLERANCE);

        for (unsigned int n=0; n != 9; ++n)
          CPPUNIT_ASSERT_EQUAL
            (elem->node_ref(n).get_extra_datum<Real>(weight_index),
             Real(1.0));

        unsigned int n_neighbors = 0, n_neighbors_expected = 2;
        for (unsigned int side=0; side != 4; ++side)
          if (elem->neighbor_ptr(side))
            n_neighbors++;
        Point c = elem->vertex_average();

        if (c(0) > 0.2 && c(0) < 0.8)
          n_neighbors_expected++;
        if (c(1) > 0.2 && c(1) < 0.8)
          n_neighbors_expected++;

        CPPUNIT_ASSERT_EQUAL(n_neighbors, n_neighbors_expected);
      }

    testMasterCenters(mesh);

#ifdef LIBMESH_HAVE_SOLVER
#ifdef LIBMESH_ENABLE_CONSTRAINTS
    // Now test whether we can assign the desired constraint equations
    EquationSystems es(mesh);
    System & sys = es.add_system<LinearImplicitSystem>("test");
    sys.add_variable("u", SECOND); // to match QUAD9
    es.init();

    // We should have a constraint on every FE dof
    CPPUNIT_ASSERT_EQUAL(sys.get_dof_map().n_constrained_dofs(), static_cast<dof_id_type>(121));
#endif // LIBMESH_ENABLE_CONSTRAINTS
#endif // LIBMESH_HAVE_SOLVER
  }

testExodusCopyElementSolutionDistributed()

void MeshInputTest::testExodusCopyElementSolutionDistributed ( )

inline

Definition at line 793 of file mesh_input.C.

  { LOG_UNIT_TEST; testCopyElementSolutionImpl<DistributedMesh,ExodusII_IO>("dist_with_elem_soln.e"); }

testExodusCopyElementSolutionReplicated()

void MeshInputTest::testExodusCopyElementSolutionReplicated ( )

inline

Definition at line 790 of file mesh_input.C.

  { LOG_UNIT_TEST; testCopyElementSolutionImpl<ReplicatedMesh,ExodusII_IO>("repl_with_elem_soln.e"); }

testExodusCopyElementVectorDistributed()

void MeshInputTest::testExodusCopyElementVectorDistributed ( )

inline

Definition at line 973 of file mesh_input.C.

  { LOG_UNIT_TEST; testCopyElementVectorImpl<DistributedMesh,ExodusII_IO>("dist_with_elem_vec.e"); }

testExodusCopyElementVectorReplicated()

void MeshInputTest::testExodusCopyElementVectorReplicated ( )

inline

Definition at line 970 of file mesh_input.C.

  { LOG_UNIT_TEST; testCopyElementVectorImpl<ReplicatedMesh, ExodusII_IO>("repl_with_elem_vec.e"); }

testExodusCopyNodalSolutionDistributed()

void MeshInputTest::testExodusCopyNodalSolutionDistributed ( )

inline

Definition at line 704 of file mesh_input.C.

  { LOG_UNIT_TEST; testCopyNodalSolutionImpl<DistributedMesh,ExodusII_IO>("dist_with_nodal_soln.e"); }

testExodusCopyNodalSolutionReplicated()

void MeshInputTest::testExodusCopyNodalSolutionReplicated ( )

inline

Definition at line 701 of file mesh_input.C.

  { LOG_UNIT_TEST; testCopyNodalSolutionImpl<ReplicatedMesh,ExodusII_IO>("repl_with_nodal_soln.e"); }

testExodusDiscCyl3d()

void MeshInputTest::testExodusDiscCyl3d ( )

inline

Definition at line 2104 of file mesh_input.C.

  {
    LOG_UNIT_TEST;

    testExodusFileMappings("meshes/PressurizedCyl3d_Patch1_8Elem.e",
                           {{0.963855209590556, 1.8234396424318,
                             0.708286572453382, 1.31468940958327}},
                             true);
  }

testExodusDiscPlateWithHole()

void MeshInputTest::testExodusDiscPlateWithHole ( )

inline

Definition at line 2065 of file mesh_input.C.

  {
    LOG_UNIT_TEST;

    testExodusFileMappings("meshes/PlateWithHole_Patch8.e",
    // Regression values for sin_x_plus_cos_y
    //
    // These are *not* the same as for the continuous plate, because
    // we do the C^TKCx=C^Tf trick to pull back projections to the
    // spline nodes, and the pseudoinverse here minimizes the error in
    // a discretization-dependent norm, not in a Sobolev norm.  For
    // these coarse meshes, our Sobolev norms can end up being ~0.1%
    // different.
                           {{2.28234312456534, 1.97439548757586,
                             1.79290449809266, 1.41075128955985}},
                             true);
  }

testExodusDiscTwoBlocks()

void MeshInputTest::testExodusDiscTwoBlocks ( )

inline

Definition at line 2083 of file mesh_input.C.

  {
    LOG_UNIT_TEST;

    testExodusFileMappings("meshes/two_quads_two_blocks.e",
    // Regression values for sin_x_plus_cos_y
                           {{2.03496953073072, 1.97996853164955,
                             1.18462134113435, 1.03085301158959}},
                             true);
  }

testExodusDiscTwoElemIGA()

void MeshInputTest::testExodusDiscTwoElemIGA ( )

inline

Definition at line 2093 of file mesh_input.C.

  {
    LOG_UNIT_TEST;

    testExodusFileMappings("meshes/two_element_iga_in.e",
    // Regression values for sin_x_plus_cos_y
                           {{1.26877626663365, 1.42553698909339,
                             1.54810114917177, 1.29792704408979}},
                             true);
  }

testExodusDiscWriteAddedSidesEdgeC0()

void MeshInputTest::testExodusDiscWriteAddedSidesEdgeC0 ( )

inline

Definition at line 1320 of file mesh_input.C.

References libMesh::EDGE3, libMesh::FIRST, libMesh::SECOND, and six_x_plus_sixty_y().

  {
    testExodusWriteAddedSides(six_x_plus_sixty_y, EDGE3, FIRST, true);
    testExodusWriteAddedSides(six_x_plus_sixty_y, EDGE3, SECOND, true);
  }

testExodusDiscWriteAddedSidesEdgeDisc()

void MeshInputTest::testExodusDiscWriteAddedSidesEdgeDisc ( )

inline

Definition at line 1343 of file mesh_input.C.

References designed_for_side_elems(), libMesh::EDGE3, and libMesh::SECOND.

  {
    testExodusWriteAddedSides(designed_for_side_elems, EDGE3, SECOND, true);
  }

testExodusDiscWriteAddedSidesHexC0()

void MeshInputTest::testExodusDiscWriteAddedSidesHexC0 ( )

inline

Definition at line 1444 of file mesh_input.C.

References libMesh::FIRST, libMesh::HEX27, libMesh::SECOND, and six_x_plus_sixty_y().

  {
    testExodusWriteAddedSides(six_x_plus_sixty_y, HEX27, FIRST, true);
    testExodusWriteAddedSides(six_x_plus_sixty_y, HEX27, SECOND, true);
  }

testExodusDiscWriteAddedSidesHexDisc()

void MeshInputTest::testExodusDiscWriteAddedSidesHexDisc ( )

inline

Definition at line 1467 of file mesh_input.C.

References designed_for_side_elems(), libMesh::HEX27, and libMesh::SECOND.

  {
    testExodusWriteAddedSides(designed_for_side_elems, HEX27, SECOND, true);
  }

testExodusDiscWriteAddedSidesMixedEdgeC0()

void MeshInputTest::testExodusDiscWriteAddedSidesMixedEdgeC0 ( )

inline

Definition at line 1332 of file mesh_input.C.

References libMesh::EDGE3, libMesh::FIRST, libMesh::LAGRANGE, libMesh::SECOND, and six_x_plus_sixty_y().

  {
    testExodusWriteAddedSides(six_x_plus_sixty_y, EDGE3, FIRST, true, {{FIRST, LAGRANGE}});
    testExodusWriteAddedSides(six_x_plus_sixty_y, EDGE3, SECOND, true, {}, {{FIRST, LAGRANGE}});
  }

testExodusDiscWriteAddedSidesMixedHexC0()

void MeshInputTest::testExodusDiscWriteAddedSidesMixedHexC0 ( )

inline

Definition at line 1456 of file mesh_input.C.

References libMesh::FIRST, libMesh::HEX27, libMesh::HIERARCHIC, libMesh::LAGRANGE, libMesh::SECOND, and six_x_plus_sixty_y().

  {
    testExodusWriteAddedSides(six_x_plus_sixty_y, HEX27, FIRST, true, {{FIRST, LAGRANGE}});
    testExodusWriteAddedSides(six_x_plus_sixty_y, HEX27, SECOND, true, {}, {{SECOND, HIERARCHIC}});
  }

testExodusDiscWriteAddedSidesMixedQuadC0()

void MeshInputTest::testExodusDiscWriteAddedSidesMixedQuadC0 ( )

inline

Definition at line 1400 of file mesh_input.C.

References libMesh::FIRST, libMesh::LAGRANGE, libMesh::QUAD9, libMesh::SECOND, and six_x_plus_sixty_y().

  {
    testExodusWriteAddedSides(six_x_plus_sixty_y, QUAD9, FIRST, true, {{SECOND, LAGRANGE}});
    testExodusWriteAddedSides(six_x_plus_sixty_y, QUAD9, SECOND, true, {}, {{FIRST, LAGRANGE}});
  }

testExodusDiscWriteAddedSidesMixedTriC0()

void MeshInputTest::testExodusDiscWriteAddedSidesMixedTriC0 ( )

inline

Definition at line 1366 of file mesh_input.C.

References libMesh::FIRST, libMesh::HIERARCHIC, libMesh::SECOND, six_x_plus_sixty_y(), libMesh::SZABAB, and libMesh::TRI6.

  {
    testExodusWriteAddedSides(six_x_plus_sixty_y, TRI6, FIRST, true, {{SECOND, HIERARCHIC}});
    testExodusWriteAddedSides(six_x_plus_sixty_y, TRI6, SECOND, true, {}, {{SECOND, SZABAB}});
  }

testExodusDiscWriteAddedSidesQuadC0()

void MeshInputTest::testExodusDiscWriteAddedSidesQuadC0 ( )

inline

Definition at line 1388 of file mesh_input.C.

References libMesh::FIRST, libMesh::QUAD9, libMesh::SECOND, and six_x_plus_sixty_y().

  {
    testExodusWriteAddedSides(six_x_plus_sixty_y, QUAD9, FIRST, true);
    testExodusWriteAddedSides(six_x_plus_sixty_y, QUAD9, SECOND, true);
  }

testExodusDiscWriteAddedSidesQuadDisc()

void MeshInputTest::testExodusDiscWriteAddedSidesQuadDisc ( )

inline

Definition at line 1411 of file mesh_input.C.

References designed_for_side_elems(), libMesh::QUAD9, and libMesh::SECOND.

  {
    testExodusWriteAddedSides(designed_for_side_elems, QUAD9, SECOND, true);
  }

testExodusDiscWriteAddedSidesTetC0()

void MeshInputTest::testExodusDiscWriteAddedSidesTetC0 ( )

inline

Definition at line 1422 of file mesh_input.C.

References libMesh::FIRST, libMesh::SECOND, six_x_plus_sixty_y(), and libMesh::TET14.

  {
    testExodusWriteAddedSides(six_x_plus_sixty_y, TET14, FIRST, true);
    testExodusWriteAddedSides(six_x_plus_sixty_y, TET14, SECOND, true);
  }

testExodusDiscWriteAddedSidesTetDisc()

void MeshInputTest::testExodusDiscWriteAddedSidesTetDisc ( )

inline

Definition at line 1433 of file mesh_input.C.

References designed_for_side_elems(), libMesh::SECOND, and libMesh::TET14.

  {
    testExodusWriteAddedSides(designed_for_side_elems, TET14, SECOND, true);
  }

testExodusDiscWriteAddedSidesTriC0()

void MeshInputTest::testExodusDiscWriteAddedSidesTriC0 ( )

inline

Definition at line 1354 of file mesh_input.C.

References libMesh::FIRST, libMesh::SECOND, six_x_plus_sixty_y(), and libMesh::TRI6.

  {
    testExodusWriteAddedSides(six_x_plus_sixty_y, TRI6, FIRST, true);
    testExodusWriteAddedSides(six_x_plus_sixty_y, TRI6, SECOND, true);
  }

testExodusDiscWriteAddedSidesTriDisc()

void MeshInputTest::testExodusDiscWriteAddedSidesTriDisc ( )

inline

Definition at line 1377 of file mesh_input.C.

References designed_for_side_elems(), libMesh::SECOND, and libMesh::TRI6.

  {
    testExodusWriteAddedSides(designed_for_side_elems, TRI6, SECOND, true);
  }

testExodusFileMappings()

void MeshInputTest::testExodusFileMappings ( const std::string &  filename, std::array< Real, 4 >  expected_norms, bool  use_disc_bex = false  )

inline

Definition at line 1982 of file mesh_input.C.

References libMesh::MeshCommunication::broadcast(), libMesh::MeshBase::default_mapping_type(), libMesh::ExodusII_IO::get_exodus_version(), mesh, libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::RATIONAL_BERNSTEIN_MAP, libMesh::ExodusII_IO::read(), libMesh::ExodusII_IO::set_discontinuous_bex(), TestCommWorld, libMesh::VTKIO::write(), and libMesh::ExodusII_IO::write().

  {
    Mesh mesh(*TestCommWorld);

    ExodusII_IO exii(mesh);
    // IGA Exodus meshes require ExodusII 8 or higher
    if (exii.get_exodus_version() < 800)
      return;

    // This should default to false
    if (use_disc_bex)
      exii.set_discontinuous_bex(true);

    if (mesh.processor_id() == 0)
      exii.read(filename);
    MeshCommunication().broadcast (mesh);

    mesh.prepare_for_use();

    CPPUNIT_ASSERT_EQUAL(mesh.default_mapping_type(),
                         RATIONAL_BERNSTEIN_MAP);

    testMasterCenters(mesh);

    testProjectionRegression(mesh, expected_norms);

    // Test a write when we're done reading; I was getting weirdness
    // from NetCDF at this point in a Moose output test.
    {
      ExodusII_IO exii(mesh);

      exii.write("exodus_file_mapping_out.e");
    }

#ifdef LIBMESH_HAVE_VTK
    {
      VTKIO vtkout(mesh);

      vtkout.write("vtk_file_mapping_out.pvtu");
    }
#endif
  }

testExodusFileMappingsCyl3d()

void MeshInputTest::testExodusFileMappingsCyl3d ( )

inline

Definition at line 2056 of file mesh_input.C.

  {
    LOG_UNIT_TEST;

    testExodusFileMappings("meshes/PressurizedCyl3d_Patch1_8Elem.e",
                           {{0.963612880188165, 1.82329452603503,
                             0.707998701597943, 1.31399222566683}});
  }

testExodusFileMappingsPlateWithHole()

void MeshInputTest::testExodusFileMappingsPlateWithHole ( )

inline

Definition at line 2027 of file mesh_input.C.

  {
    LOG_UNIT_TEST;

    testExodusFileMappings("meshes/PlateWithHole_Patch8.e",
    // Regression values for sin_x_plus_cos_y
                           {{2.2812154374012, 1.974049990211937,
                             1.791640772215248, 1.413679237529376}});
  }

testExodusFileMappingsTwoBlocks()

void MeshInputTest::testExodusFileMappingsTwoBlocks ( )

inline

Definition at line 2037 of file mesh_input.C.

  {
    LOG_UNIT_TEST;

    testExodusFileMappings("meshes/two_quads_two_blocks.e",
    // Regression values for sin_x_plus_cos_y
                           {{2.03496953073072, 1.97996853164955,
                             1.18462134113435, 1.03085301158959}});
  }

testExodusFileMappingsTwoElemIGA()

void MeshInputTest::testExodusFileMappingsTwoElemIGA ( )

inline

Definition at line 2046 of file mesh_input.C.

  {
    LOG_UNIT_TEST;

    testExodusFileMappings("meshes/two_element_iga_in.e",
    // Regression values for sin_x_plus_cos_y
                           {{1.26865962862531, 1.42562070158386,
                             1.54905363492342, 1.29782906548366}});
  }

testExodusIGASidesets()

void MeshInputTest::testExodusIGASidesets ( )

inline

Definition at line 542 of file mesh_input.C.

References libMesh::BoundaryInfo::boundary_ids(), libMesh::MeshCommunication::broadcast(), libMesh::ParallelObject::comm(), libMesh::BoundaryInfo::get_boundary_ids(), libMesh::MeshBase::get_boundary_info(), libMesh::ExodusII_IO::get_exodus_version(), libMesh::MeshBase::is_serial(), TIMPI::Communicator::max(), mesh, libMesh::BoundaryInfo::n_boundary_ids(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::NODEELEM, libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::ExodusII_IO::read(), TIMPI::Communicator::sum(), TestCommWorld, and libMesh::ExodusII_IO::write().

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);

    // Block here so we trigger exii destructor early; I thought I
    // might have had a bug in there at one point
    {
      ExodusII_IO exii(mesh);
      // IGA Exodus meshes require ExodusII 8 or higher
      if (exii.get_exodus_version() < 800)
        return;

      if (mesh.processor_id() == 0)
        exii.read("meshes/Cube_With_Sidesets.e");

    }

    MeshCommunication().broadcast(mesh);
    mesh.prepare_for_use();

    // 5^3 spline nodes + 7^3 Rational Bezier nodes
    CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(), static_cast<dof_id_type>(468));
    // 5^3 spline elements + 3^3 Rational Bezier elements
    CPPUNIT_ASSERT_EQUAL(mesh.n_elem(),  static_cast<dof_id_type>(152));

    // Check that we see the boundary ids we expect
    BoundaryInfo & bi = mesh.get_boundary_info();

    // On a ReplicatedMesh, we should see all 6 boundary ids on each processor
    if (mesh.is_serial())
      CPPUNIT_ASSERT_EQUAL(static_cast<std::size_t>(6), bi.n_boundary_ids());

    // On any mesh, we should see each id on *some* processor
    {
      const std::set<boundary_id_type> & bc_ids = bi.get_boundary_ids();
      // CoreForm gave me a file with 1-based numbering! (faints)
      for (boundary_id_type i = 1 ; i != 7; ++i)
        {
          bool has_bcid = bc_ids.count(i);
          mesh.comm().max(has_bcid);
          CPPUNIT_ASSERT(has_bcid);
        }
    }

    // Indexed by bcid-1, because we count from 0, like God and
    // Dijkstra intended!
    std::vector<int> side_counts(6, 0);

    // Map from our side numbers to the file's BCIDs
    const boundary_id_type libmesh_side_to_bcid[] = {1, 4, 6, 3, 5, 2};

    for (const auto & elem : mesh.active_local_element_ptr_range())
      {
        if (elem->type() == NODEELEM)
          continue;

        for (unsigned short side=0; side<elem->n_sides(); side++)
          {
            if (elem->neighbor_ptr(side))
              CPPUNIT_ASSERT_EQUAL(bi.n_boundary_ids(elem, side), 0u);
            else
              {
                CPPUNIT_ASSERT_EQUAL(bi.n_boundary_ids(elem, side), 1u);
                std::vector<boundary_id_type> bids;
                bi.boundary_ids(elem, side, bids);
                side_counts[bids[0]-1]++;
                CPPUNIT_ASSERT_EQUAL(libmesh_side_to_bcid[side], bids[0]);
              }
          }
      }

    for (auto bc_count : side_counts)
      {
        // We should have 3^2 sides with each id
        mesh.comm().sum(bc_count);
        CPPUNIT_ASSERT_EQUAL(bc_count, 9);
      }

    // Test a write when we're done reading; I was getting weirdness
    // from NetCDF at this point in a Moose output test.
    {
      ExodusII_IO exii(mesh);

      exii.write("Cube_With_Sidesets_out.e");
    }
  }

testExodusReadHeader()

void MeshInputTest::testExodusReadHeader ( )

inline

Definition at line 462 of file mesh_input.C.

References TIMPI::Communicator::barrier(), libMesh::MeshTools::Generation::build_square(), mesh, libMesh::ExodusHeaderInfo::num_dim, libMesh::ExodusHeaderInfo::num_edge, libMesh::ExodusHeaderInfo::num_edge_blk, libMesh::ExodusHeaderInfo::num_elem, libMesh::ExodusHeaderInfo::num_elem_blk, libMesh::ExodusHeaderInfo::num_node_sets, libMesh::ExodusHeaderInfo::num_side_sets, libMesh::ExodusII_IO::read_header(), TestCommWorld, libMesh::ExodusHeaderInfo::title, and libMesh::MeshBase::write().

  {
    LOG_UNIT_TEST;

    // first scope: write file
    {
      ReplicatedMesh mesh(*TestCommWorld);
      MeshTools::Generation::build_square (mesh, 3, 3, 0., 1., 0., 1.);
      ExodusII_IO exii(mesh);
      mesh.write("read_header_test.e");
    }

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

    // second scope: read header
    // Note: The header information is read from file on processor 0
    // and then broadcast to the other procs, so with this test we are
    // checking both that the header information is read correctly and
    // that it is correctly communicated to other procs.
    {
      ReplicatedMesh mesh(*TestCommWorld);
      ExodusII_IO exii(mesh);
      ExodusHeaderInfo header_info = exii.read_header("read_header_test.e");

      // Make sure the header information is as expected.
      CPPUNIT_ASSERT_EQUAL(std::string(header_info.title.data()), std::string("read_header_test.e"));
      CPPUNIT_ASSERT_EQUAL(header_info.num_dim, 2);
      CPPUNIT_ASSERT_EQUAL(header_info.num_elem, 9);
      CPPUNIT_ASSERT_EQUAL(header_info.num_elem_blk, 1);
      CPPUNIT_ASSERT_EQUAL(header_info.num_node_sets, 4);
      CPPUNIT_ASSERT_EQUAL(header_info.num_side_sets, 4);
      CPPUNIT_ASSERT_EQUAL(header_info.num_edge_blk, 0);
      CPPUNIT_ASSERT_EQUAL(header_info.num_edge, 0);
    }
  }

testExodusSetElemUniqueIdsFromMaps()

void MeshInputTest::testExodusSetElemUniqueIdsFromMaps ( )

inline

Definition at line 431 of file mesh_input.C.

  {
    LOG_UNIT_TEST;

    // The mesh used in this test has a non-trivial elem_num_map with
    // a non-contiguous numbering that has a "gap" at the beginning
    // and is also missing "16":
    // elem_num_map = 11, 12, 13, 14, 15, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
    //    27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
    //    45, 46 ;
    {
      // When we assign (zero-based) elem_num_map entries as unique_ids, the
      // unique_ids are just a zero-based version of the entries above.
      std::vector<unique_id_type> expected_unique_ids = {
        10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
        30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45};
      this->testExodusSetElemUniqueIdsFromMaps_implementation(
        /*set_unique_ids=*/true, expected_unique_ids);
    }

    {
      // When libmesh assigns unique_ids, all the Nodes (50) are
      // numbered first, so the first Elem is assigned a unique_id of
      // 50 and the rest are sequential from there.
      std::vector<unique_id_type> expected_unique_ids(/*size=*/35);
      std::iota(expected_unique_ids.begin(), expected_unique_ids.end(), /*start=*/50);
      this->testExodusSetElemUniqueIdsFromMaps_implementation(
        /*set_unique_ids=*/false, expected_unique_ids);
    }
  }

testExodusSetElemUniqueIdsFromMaps_implementation()

void MeshInputTest::testExodusSetElemUniqueIdsFromMaps_implementation ( bool  set_unique_ids, const std::vector< unique_id_type > &  expected_unique_ids  )

inline

Definition at line 396 of file mesh_input.C.

References libMesh::libmesh_ignore(), mesh, libMesh::ExodusII_IO::read(), libMesh::ExodusII_IO::set_unique_ids_from_maps(), and TestCommWorld.

  {
    // This test requires that libmesh is compiled with unique_ids enabled
#ifdef LIBMESH_ENABLE_UNIQUE_ID
    {
      ReplicatedMesh mesh(*TestCommWorld);
      ExodusII_IO exii(mesh);

      // Set Node/Elem unique ids based on the node/elem_num_map
      exii.set_unique_ids_from_maps(set_unique_ids);

      // Read the mesh
      exii.read("meshes/nontrivial_elem_num_map.exo");

      // Verify the results.
      auto expected_it = expected_unique_ids.begin();
      for (const auto & elem : mesh.element_ptr_range())
        {
          // Debugging:
          // libMesh::out << "unique_id for Elem " << elem->id()
          //              << " = " << elem->unique_id()
          //              << std::endl;

          CPPUNIT_ASSERT_EQUAL(elem->unique_id(), *expected_it++);
        }
    }
#else
    // Prevent compiler warnings about unused variables when
    // unique_ids are not enabled.
    libmesh_ignore(set_unique_ids, expected_unique_ids);
#endif // LIBMESH_ENABLE_UNIQUE_ID
  }

testExodusSetNodeUniqueIdsFromMaps()

void MeshInputTest::testExodusSetNodeUniqueIdsFromMaps ( )

inline

Definition at line 375 of file mesh_input.C.

  {
    LOG_UNIT_TEST;

    // node_num_map =    1,   3, 9,    8,   2,   5,    7,    6,    4
    // The input is a (zero-based) version of the node_num_map as it
    // exists in the file.
    this->testExodusSetNodeUniqueIdsFromMaps_implementation(
      /*set_unique_ids=*/true,
      /*expected_unique_ids=*/{0, 2, 8, 7, 1, 4, 6, 5, 3});

    // The input is the (zero-based) _position_ of the (one-based) id
    // "i" in the node_num_map, as it exists in the file. For example,
    // zero-based Node id 3 corresponds to one-based Node id 4, which
    // appears in (zero-based) position 8 in the node_num_map, hence:
    // 3 -> 8, etc.
    this->testExodusSetNodeUniqueIdsFromMaps_implementation(
      /*set_unique_ids=*/false,
      /*expected_unique_ids=*/{0, 4, 1, 8, 5, 7, 6, 3, 2});
  }

testExodusSetNodeUniqueIdsFromMaps_implementation()

void MeshInputTest::testExodusSetNodeUniqueIdsFromMaps_implementation ( bool  set_unique_ids, const std::vector< unique_id_type > &  expected_unique_ids  )

inline

Definition at line 339 of file mesh_input.C.

References libMesh::index_range(), libMesh::libmesh_ignore(), mesh, libMesh::MeshBase::node_ptr(), libMesh::ExodusII_IO::read(), libMesh::ExodusII_IO::set_unique_ids_from_maps(), TestCommWorld, and libMesh::DofObject::unique_id().

  {
    // This test requires that libmesh is compiled with unique_ids enabled
#ifdef LIBMESH_ENABLE_UNIQUE_ID
    {
      ReplicatedMesh mesh(*TestCommWorld);
      ExodusII_IO exii(mesh);

      // Set Node/Elem unique ids based on the node/elem_num_map
      exii.set_unique_ids_from_maps(set_unique_ids);

      // Read the mesh
      exii.read("meshes/nontrivial_node_num_map.exo");

      // Verify the results.
      for (auto i : index_range(expected_unique_ids))
        {
          // Debugging:
          // libMesh::out << "unique_id for node " << i
          //              << " = " << mesh.node_ptr(i)->unique_id()
          //              << std::endl;

          CPPUNIT_ASSERT_EQUAL(mesh.node_ptr(i)->unique_id(), expected_unique_ids[i]);
        }
    }
#else
    // Prevent compiler warnings about unused variables when
    // unique_ids are not enabled.
    libmesh_ignore(set_unique_ids, expected_unique_ids);
#endif // LIBMESH_ENABLE_UNIQUE_ID
  } // end testExodusSetNodeUniqueIdsFromMaps_implementation()

testExodusWriteAddedSides()

void MeshInputTest::testExodusWriteAddedSides ( Number(*)(const Point &, const Parameters &, const std::string &, const std::string &)  exact_sol, const ElemType  elem_type, const Order  order, const bool  write_discontinuous = false, const std::vector< FEType >  earlier_vars = {}, const std::vector< FEType >  later_vars = {}  )

inline

Definition at line 1073 of file mesh_input.C.

                                            {},
     const std::vector<FEType> later_vars = {})
  {
    constexpr unsigned int nx = added_sides_nxyz[0],
                           ny = added_sides_nxyz[1],
                           nz = added_sides_nxyz[2];

    const unsigned int dim = Elem::type_to_dim_map[elem_type];
    const bool is_tensor = (Elem::build(elem_type)->n_sides() == dim * 2);

    // Figure out how many fake and true elements to expect
    dof_id_type n_fake_elem = 0;
    dof_id_type n_true_elem = 0;

    dof_id_type n_fake_nodes = 0;
    dof_id_type n_true_nodes = 0;

    const std::string filename =
      "side_discontinuous_"+Utility::enum_to_string<ElemType>(elem_type)+(write_discontinuous?"_disc":"")+".e";

    // first scope: write file
    {
      Mesh mesh(*TestCommWorld);

      EquationSystems es(mesh);
      System & sys = es.add_system<System> ("SimpleSystem");
      int varnum = 1;
      for (auto vartype : earlier_vars)
        sys.add_variable("earlier_"+std::to_string(varnum++), vartype);

      sys.add_variable("u", order, SIDE_HIERARCHIC);

      varnum = 1;
      for (auto vartype : later_vars)
        sys.add_variable("later_"+std::to_string(varnum++), vartype);

      if (dim == 3)
        MeshTools::Generation::build_cube
          (mesh, nx, ny, nz, 0., 1., 0., 1., 0., 1., elem_type);
      else if (dim == 2)
        MeshTools::Generation::build_square
          (mesh, nx, ny, 0., 1., 0., 1., elem_type);
      else
        MeshTools::Generation::build_line
          (mesh, nx, 0., 1., elem_type);

      n_true_elem = mesh.n_elem();
      n_true_nodes = mesh.n_nodes();
      CPPUNIT_ASSERT_LESS(n_true_nodes, n_true_elem); // Ne < Nn

      const unsigned int our_ny = dim>1 ? ny : 1;
      const unsigned int our_nz = dim>2 ? nz : 1;

      dof_id_type min_n_elem = nx * our_ny * our_nz;
      CPPUNIT_ASSERT_LESSEQUAL(n_true_elem, min_n_elem); // "backwards" API...

      for (const auto & elem : mesh.active_local_element_ptr_range())
        {
          for (auto s : make_range(elem->n_sides()))
          if (!elem->neighbor_ptr(s) || elem->neighbor_ptr(s)->id() < elem->id())
            {
              ++n_fake_elem;
              auto side = elem->build_side_ptr(s);
              n_fake_nodes += side->n_nodes();
            }
        }
      mesh.comm().sum(n_fake_elem);
      mesh.comm().sum(n_fake_nodes);

      const dof_id_type expected_fakes = [elem_type]() {
        switch (elem_type)
        {
          case EDGE3:
            return nx+1;
          case TRI6:
            return 3*nx*ny + nx + ny;
          case QUAD8:
          case QUAD9:
            return 2*nx*ny + nx + ny;
          case TET14:
            return 48*nx*ny*nz + 4*(nx*ny+nx*nz+ny*nz);
          case HEX27:
            return 3*nx*ny*nz + nx*ny + nx*nz + ny*nz;
          default:
            libmesh_error();
        }
      } (); // Invoke anonymous lambda

      CPPUNIT_ASSERT_EQUAL(n_fake_elem, expected_fakes); // "backwards" API...

      es.init();
      sys.project_solution(exact_sol, nullptr,
                           es.parameters);

      // Set solution u^e_i = i, for the ith vertex of a given element e.

      // Now write to file.
      ExodusII_IO exii(mesh);
      exii.write_added_sides(true);

      if (write_discontinuous)
        exii.write_discontinuous_equation_systems(filename, es);
      else
        exii.write_equation_systems(filename, es);
    } // end first scope

    // second scope: read file, verify extra elements exist
    {
      Mesh mesh(*TestCommWorld);
      mesh.allow_renumbering(false);
      ExodusII_IO exii(mesh);

      if (mesh.processor_id() == 0)
        exii.read(filename);
      MeshCommunication().broadcast(mesh);
      mesh.prepare_for_use();

      CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), n_true_elem + n_fake_elem);
      if (write_discontinuous)
        {
          const dof_id_type nodes_per_elem = Elem::build(elem_type)->n_nodes();
          CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(),
                               n_true_elem*nodes_per_elem + n_fake_nodes);
        }
      else
        CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(), n_true_nodes + n_fake_nodes);

      EquationSystems es(mesh);
      System & sys = es.add_system<System> ("SimpleSystem");
      // Read back into a LAGRANGE variable for testing; we still
      // can't use Exodus for a proper restart.
      sys.add_variable("ul", SECOND);
      es.init();

      const DofMap & dof_map = sys.get_dof_map();

#ifdef LIBMESH_USE_COMPLEX_NUMBERS
      exii.copy_nodal_solution(sys, "ul", "r_u");
#else
      exii.copy_nodal_solution(sys, "ul", "u");
#endif

      dof_id_type n_side_nodes = 0;
      const std::string nullstr;
      const std::string facestr = "face";

      // Debugging this in parallel is tricky.  Let's make sure that
      // if we have a failure on one rank we see it on all the others
      // and we can go on to other tests.
#ifdef LIBMESH_ENABLE_EXCEPTIONS
      bool threw_exception = false;
      try
#endif // LIBMESH_ENABLE_EXCEPTIONS
      {
      for (const auto & elem : mesh.active_local_element_ptr_range())
        {
          // Just look at side elements, not interiors
          if (elem->dim() == dim)
            continue;

          std::vector<dof_id_type> dof_indices;
          dof_map.dof_indices(elem, dof_indices, 0);

          // Find what face direction we're looking at, to
          // disambiguate when testing against a discontinuous
          // function, since we're evaluating on nodes that overlap
          // multiple faces
          const Point normal = [elem](){
            if (elem->dim() == 2)
              return Point((elem->point(1) - elem->point(0)).cross
                           (elem->point(2) - elem->point(0)));
            else if (elem->dim() == 1)
              return Point
                (elem->point(1)(1)-elem->point(0)(1),
                 elem->point(0)(0)-elem->point(1)(0));
            else
              return Point(1);
          } (); // Invoke anonymous lambda

          short faceval = -1;
          if (is_tensor)
            {
              if (std::abs(normal(0)) > TOLERANCE)
                {
                  faceval = 0;
                  libmesh_assert_less(std::abs(normal(1)), TOLERANCE);
                  libmesh_assert_less(std::abs(normal(2)), TOLERANCE);
                }
              else if (std::abs(normal(1)) > TOLERANCE)
                {
                  faceval = 1;
                  libmesh_assert_less(std::abs(normal(2)), TOLERANCE);
                }
              else
                {
                  faceval = 2;
                  libmesh_assert_greater(std::abs(normal(2)), TOLERANCE);
                }
              libmesh_assert_greater_equal(faceval, 0);
              es.parameters.set<short>(facestr) = faceval;
            }

          for (auto i : index_range(dof_indices))
            {
              const Point node_pt = elem->point(i);
              const Real nodal_coef =
                libmesh_real((*sys.current_local_solution)(dof_indices[i]));
              const Real exact_val =
                libmesh_real(exact_sol
                             (node_pt, es.parameters, nullstr,
                              nullstr));
              LIBMESH_ASSERT_FP_EQUAL
                (nodal_coef, exact_val,
                 std::max(Real(2),nodal_coef+exact_val)*
                 TOLERANCE*std::sqrt(TOLERANCE));
              ++n_side_nodes;
            }
        }
      }
#ifdef LIBMESH_ENABLE_EXCEPTIONS
      catch (...)
      {
        threw_exception = true;
        TestCommWorld->max(threw_exception);
        throw;
      }
      if (!threw_exception)
        TestCommWorld->max(threw_exception);
      CPPUNIT_ASSERT(!threw_exception);
#endif // LIBMESH_ENABLE_EXCEPTIONS

      TestCommWorld->sum(n_side_nodes);
      CPPUNIT_ASSERT_EQUAL(n_side_nodes, n_fake_nodes);
    } // end second scope
  } // end testExodusWriteAddedSides

testExodusWriteAddedSidesEdgeC0()

void MeshInputTest::testExodusWriteAddedSidesEdgeC0 ( )

inline

Definition at line 1314 of file mesh_input.C.

References libMesh::EDGE3, libMesh::FIRST, libMesh::SECOND, and six_x_plus_sixty_y().

  {
    testExodusWriteAddedSides(six_x_plus_sixty_y, EDGE3, FIRST);
    testExodusWriteAddedSides(six_x_plus_sixty_y, EDGE3, SECOND);
  }

testExodusWriteAddedSidesEdgeDisc()

void MeshInputTest::testExodusWriteAddedSidesEdgeDisc ( )

inline

Definition at line 1338 of file mesh_input.C.

References designed_for_side_elems(), libMesh::EDGE3, and libMesh::SECOND.

  {
    testExodusWriteAddedSides(designed_for_side_elems, EDGE3, SECOND);
  }

testExodusWriteAddedSidesHexC0()

void MeshInputTest::testExodusWriteAddedSidesHexC0 ( )

inline

Definition at line 1438 of file mesh_input.C.

References libMesh::FIRST, libMesh::HEX27, libMesh::SECOND, and six_x_plus_sixty_y().

  {
    testExodusWriteAddedSides(six_x_plus_sixty_y, HEX27, FIRST);
    testExodusWriteAddedSides(six_x_plus_sixty_y, HEX27, SECOND);
  }

testExodusWriteAddedSidesHexDisc()

void MeshInputTest::testExodusWriteAddedSidesHexDisc ( )

inline

Definition at line 1462 of file mesh_input.C.

References designed_for_side_elems(), libMesh::HEX27, and libMesh::SECOND.

  {
    testExodusWriteAddedSides(designed_for_side_elems, HEX27, SECOND);
  }

testExodusWriteAddedSidesMixedEdgeC0()

void MeshInputTest::testExodusWriteAddedSidesMixedEdgeC0 ( )

inline

Definition at line 1326 of file mesh_input.C.

References libMesh::EDGE3, libMesh::FIRST, libMesh::LAGRANGE, libMesh::SECOND, and six_x_plus_sixty_y().

  {
    testExodusWriteAddedSides(six_x_plus_sixty_y, EDGE3, FIRST, false, {{FIRST, LAGRANGE}});
    testExodusWriteAddedSides(six_x_plus_sixty_y, EDGE3, SECOND, false, {}, {{FIRST, LAGRANGE}});
  }

testExodusWriteAddedSidesMixedHexC0()

void MeshInputTest::testExodusWriteAddedSidesMixedHexC0 ( )

inline

Definition at line 1450 of file mesh_input.C.

References libMesh::FIRST, libMesh::HEX27, libMesh::HIERARCHIC, libMesh::LAGRANGE, libMesh::SECOND, and six_x_plus_sixty_y().

  {
    testExodusWriteAddedSides(six_x_plus_sixty_y, HEX27, FIRST, false, {{FIRST, LAGRANGE}});
    testExodusWriteAddedSides(six_x_plus_sixty_y, HEX27, SECOND, false, {}, {{SECOND, HIERARCHIC}});
  }

testExodusWriteAddedSidesMixedQuadC0()

void MeshInputTest::testExodusWriteAddedSidesMixedQuadC0 ( )

inline

Definition at line 1394 of file mesh_input.C.

References libMesh::FIRST, libMesh::LAGRANGE, libMesh::QUAD9, libMesh::SECOND, and six_x_plus_sixty_y().

  {
    testExodusWriteAddedSides(six_x_plus_sixty_y, QUAD9, FIRST, false, {{SECOND, LAGRANGE}});
    testExodusWriteAddedSides(six_x_plus_sixty_y, QUAD9, SECOND, false, {}, {{FIRST, LAGRANGE}});
  }

testExodusWriteAddedSidesMixedTriC0()

void MeshInputTest::testExodusWriteAddedSidesMixedTriC0 ( )

inline

Definition at line 1360 of file mesh_input.C.

References libMesh::FIRST, libMesh::HIERARCHIC, libMesh::SECOND, six_x_plus_sixty_y(), libMesh::SZABAB, and libMesh::TRI6.

  {
    testExodusWriteAddedSides(six_x_plus_sixty_y, TRI6, FIRST, false, {{SECOND, HIERARCHIC}});
    testExodusWriteAddedSides(six_x_plus_sixty_y, TRI6, SECOND, false, {}, {{SECOND, SZABAB}});
  }

testExodusWriteAddedSidesQuadC0()

void MeshInputTest::testExodusWriteAddedSidesQuadC0 ( )

inline

Definition at line 1382 of file mesh_input.C.

References libMesh::FIRST, libMesh::QUAD9, libMesh::SECOND, and six_x_plus_sixty_y().

  {
    testExodusWriteAddedSides(six_x_plus_sixty_y, QUAD9, FIRST);
    testExodusWriteAddedSides(six_x_plus_sixty_y, QUAD9, SECOND);
  }

testExodusWriteAddedSidesQuadDisc()

void MeshInputTest::testExodusWriteAddedSidesQuadDisc ( )

inline

Definition at line 1406 of file mesh_input.C.

References designed_for_side_elems(), libMesh::QUAD9, and libMesh::SECOND.

  {
    testExodusWriteAddedSides(designed_for_side_elems, QUAD9, SECOND);
  }

testExodusWriteAddedSidesTetC0()

void MeshInputTest::testExodusWriteAddedSidesTetC0 ( )

inline

Definition at line 1416 of file mesh_input.C.

References libMesh::FIRST, libMesh::SECOND, six_x_plus_sixty_y(), and libMesh::TET14.

  {
    testExodusWriteAddedSides(six_x_plus_sixty_y, TET14, FIRST);
    testExodusWriteAddedSides(six_x_plus_sixty_y, TET14, SECOND);
  }

testExodusWriteAddedSidesTetDisc()

void MeshInputTest::testExodusWriteAddedSidesTetDisc ( )

inline

Definition at line 1428 of file mesh_input.C.

References designed_for_side_elems(), libMesh::SECOND, and libMesh::TET14.

  {
    testExodusWriteAddedSides(designed_for_side_elems, TET14, SECOND);
  }

testExodusWriteAddedSidesTriC0()

void MeshInputTest::testExodusWriteAddedSidesTriC0 ( )

inline

Definition at line 1348 of file mesh_input.C.

References libMesh::FIRST, libMesh::SECOND, six_x_plus_sixty_y(), and libMesh::TRI6.

  {
    testExodusWriteAddedSides(six_x_plus_sixty_y, TRI6, FIRST);
    testExodusWriteAddedSides(six_x_plus_sixty_y, TRI6, SECOND);
  }

testExodusWriteAddedSidesTriDisc()

void MeshInputTest::testExodusWriteAddedSidesTriDisc ( )

inline

Definition at line 1372 of file mesh_input.C.

References designed_for_side_elems(), libMesh::SECOND, and libMesh::TRI6.

  {
    testExodusWriteAddedSides(designed_for_side_elems, TRI6, SECOND);
  }

testExodusWriteElementDataFromDiscontinuousNodalData()

void MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData ( )

inline

Definition at line 985 of file mesh_input.C.

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshBase::allow_renumbering(), libMesh::MeshCommunication::broadcast(), libMesh::MeshTools::Generation::build_cube(), libMesh::CONSTANT, libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::DofMap::dof_indices(), libMesh::FIRST, libMesh::System::get_dof_map(), libMesh::HEX8, libMesh::index_range(), libMesh::EquationSystems::init(), libMesh::L2_LAGRANGE, mesh, libMesh::MONOMIAL, libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::ExodusII_IO::read(), libMesh::Real, libMesh::System::solution, TestCommWorld, libMesh::TOLERANCE, libMesh::System::variable_name(), libMesh::ExodusII_IO::write_element_data_from_discontinuous_nodal_data(), and libMesh::ExodusII_IO::write_equation_systems().

  {
    LOG_UNIT_TEST;

    // first scope: write file
    {
      Mesh mesh(*TestCommWorld);

      EquationSystems es(mesh);
      System & sys = es.add_system<System> ("SimpleSystem");
      sys.add_variable("u", FIRST, L2_LAGRANGE);

      MeshTools::Generation::build_cube
        (mesh, 2, 2, 2, 0., 1., 0., 1., 0., 1., HEX8);

      es.init();

      // Set solution u^e_i = i, for the ith vertex of a given element e.
      const DofMap & dof_map = sys.get_dof_map();
      std::vector<dof_id_type> dof_indices;
      for (const auto & elem : mesh.element_ptr_range())
        {
          dof_map.dof_indices(elem, dof_indices, /*var_id=*/0);
          for (unsigned int i=0; i<dof_indices.size(); ++i)
            sys.solution->set(dof_indices[i], i);
        }
      sys.solution->close();

      // Now write to file.
      ExodusII_IO exii(mesh);

      // Don't try to write element data as averaged nodal data.
      std::set<std::string> sys_list;
      exii.write_equation_systems("elemental_from_nodal.e", es, &sys_list);

      // Write one elemental data field per vertex value.
      sys_list = {"SimpleSystem"};

      exii.write_element_data_from_discontinuous_nodal_data
        (es, &sys_list, /*var_suffix=*/"_elem_corner_");
    } // end first scope

    // second scope: read values back in, verify they are correct.
    {
      std::vector<std::string> file_var_names =
        {"u_elem_corner_0",
         "u_elem_corner_1",
         "u_elem_corner_2",
         "u_elem_corner_3"};
      std::vector<Real> expected_values = {0., 1., 2., 3.};

      // copy_elemental_solution currently requires ReplicatedMesh
      ReplicatedMesh mesh(*TestCommWorld);
      mesh.allow_renumbering(false);

      EquationSystems es(mesh);
      System & sys = es.add_system<System> ("SimpleSystem");
      for (auto i : index_range(file_var_names))
        sys.add_variable(file_var_names[i], CONSTANT, MONOMIAL);

      ExodusII_IO exii(mesh);

      if (mesh.processor_id() == 0)
        exii.read("elemental_from_nodal.e");
      MeshCommunication().broadcast(mesh);
      mesh.prepare_for_use();

      es.init();

      for (auto i : index_range(file_var_names))
        exii.copy_elemental_solution
          (sys, sys.variable_name(i), file_var_names[i]);

      // Check that the values we read back in are as expected.
      for (const auto & elem : mesh.active_element_ptr_range())
        for (auto i : index_range(file_var_names))
          {
            Real read_val = sys.point_value(i, elem->vertex_average());
            LIBMESH_ASSERT_FP_EQUAL
              (expected_values[i], read_val, TOLERANCE*TOLERANCE);
          }
    } // end second scope
  } // end testExodusWriteElementDataFromDiscontinuousNodalData

testGmshBCIDOverlap()

void MeshInputTest::testGmshBCIDOverlap ( )

inline

Definition at line 1690 of file mesh_input.C.

References libMesh::MeshCommunication::broadcast(), libMesh::MeshBase::get_boundary_info(), libMesh::BoundaryInfo::get_sideset_name_map(), libMesh::MeshBase::get_subdomain_name_map(), mesh, libMesh::ParallelObject::processor_id(), libMesh::GmshIO::read(), libMesh::BoundaryInfo::sideset_name(), libMesh::MeshBase::subdomain_name(), and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);

    GmshIO gmsh_io(mesh);

    if (mesh.processor_id() == 0)
      gmsh_io.read("meshes/bcid_overlap.msh");
    MeshCommunication().broadcast(mesh);

    CPPUNIT_ASSERT_EQUAL(mesh.get_boundary_info().get_sideset_name_map().size(),
                         std::size_t(2));
    CPPUNIT_ASSERT_EQUAL(mesh.get_boundary_info().sideset_name(1),
                         std::string("srfBC4A"));
    CPPUNIT_ASSERT_EQUAL(mesh.get_boundary_info().sideset_name(2),
                         std::string("srfBC4B"));
    CPPUNIT_ASSERT_EQUAL(mesh.get_subdomain_name_map().size(),
                         std::size_t(2));
    CPPUNIT_ASSERT_EQUAL(mesh.subdomain_name(1),
                         std::string("volBC3A"));
    CPPUNIT_ASSERT_EQUAL(mesh.subdomain_name(2),
                         std::string("volBC3B"));
  }

testGoodGmsh()

void MeshInputTest::testGoodGmsh ( )

inline

Definition at line 1675 of file mesh_input.C.

References libMesh::MeshCommunication::broadcast(), mesh, libMesh::MeshBase::n_elem(), libMesh::ParallelObject::processor_id(), libMesh::GmshIO::read(), and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);

    GmshIO gmsh_io(mesh);

    if (mesh.processor_id() == 0)
      gmsh_io.read("meshes/circle.msh");
    MeshCommunication().broadcast(mesh);

    CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), dof_id_type(14));
  }

testGoodSTL()

void MeshInputTest::testGoodSTL ( )

inline

Definition at line 1716 of file mesh_input.C.

References libMesh::MeshCommunication::broadcast(), mesh, libMesh::MeshBase::n_elem(), libMesh::ParallelObject::processor_id(), libMesh::STLIO::read(), and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);

    STLIO stl_io(mesh);

    if (mesh.processor_id() == 0)
      stl_io.read("meshes/Cluster_34.stl");
    MeshCommunication().broadcast(mesh);

    CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), dof_id_type(40));
  }

testGoodSTLBinary()

void MeshInputTest::testGoodSTLBinary ( )

inline

Definition at line 1731 of file mesh_input.C.

References libMesh::MeshCommunication::broadcast(), mesh, libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::ParallelObject::processor_id(), libMesh::STLIO::read(), and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);

    STLIO stl_io(mesh);

    if (mesh.processor_id() == 0)
      stl_io.read("meshes/engraving.stl");
    MeshCommunication().broadcast(mesh);

    CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), dof_id_type(426));
    CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(), dof_id_type(215));
  }

testLowOrderEdgeBlocks()

void MeshInputTest::testLowOrderEdgeBlocks ( )

inline

Definition at line 499 of file mesh_input.C.

References libMesh::MeshCommunication::broadcast(), libMesh::BoundaryInfo::build_edge_list(), libMesh::MeshBase::get_boundary_info(), libMesh::MeshBase::is_serial(), mesh, libMesh::BoundaryInfo::n_boundary_ids(), libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::ExodusII_IO::read(), and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);
    ExodusII_IO exii(mesh);

    if (mesh.processor_id() == 0)
      exii.read("meshes/mesh_with_low_order_edge_blocks.e");

    MeshCommunication().broadcast(mesh);
    mesh.prepare_for_use();

    // Check that we see the boundary ids we expect
    BoundaryInfo & bi = mesh.get_boundary_info();

    // On a ReplicatedMesh, check that the number of edge boundary
    // conditions is as expected. The real test is that we can read
    // this file in at all. Prior to the changes in #3491, the Exodus
    // reader threw an exception while trying to read this mesh.
    if (mesh.is_serial())
    {
      // Mesh has 26 boundary ids total (including edge and side ids).
      // ss_prop1 = 200, 201 ;
      // ed_prop1 = 8000, 8001, 8002, 8003, 8004, 8005, 8006, 8007, 8008, 8009, 8010,
      //            8011, 9001, 9002, 9003, 9004, 9005, 9006, 9007, 9008, 9009, 9010,
      //            9011, 9012 ;
      CPPUNIT_ASSERT_EQUAL(static_cast<std::size_t>(26), bi.n_boundary_ids());

      // We can binary_search() the build_edge_list() which is sorted
      // in lexicographical order before it's returned.
      auto edge_list = bi.build_edge_list();

      // Search for some tuples we expect to be present
      CPPUNIT_ASSERT(std::binary_search(edge_list.begin(), edge_list.end(), std::make_tuple(4, 1, 8007)));
      CPPUNIT_ASSERT(std::binary_search(edge_list.begin(), edge_list.end(), std::make_tuple(10, 6, 8001)));

      // And make sure we don't have entries we shouldn't have
      CPPUNIT_ASSERT(!std::binary_search(edge_list.begin(), edge_list.end(), std::make_tuple(1, 8, 8009)));
      CPPUNIT_ASSERT(!std::binary_search(edge_list.begin(), edge_list.end(), std::make_tuple(2, 10, 9011)));
    }
  }

testMasterCenters()

void MeshInputTest::testMasterCenters ( const MeshBase &  mesh )

inline

Definition at line 1509 of file mesh_input.C.

References libMesh::FEMap::inverse_map(), libMesh::FEMap::map(), mesh, libMesh::TensorTools::norm(), libMesh::MeshBase::sub_point_locator(), and libMesh::TOLERANCE.

  {
    auto locator = mesh.sub_point_locator();

    for (auto & elem : mesh.element_ptr_range())
      {
        Point master_pt = {}; // center, for tensor product elements

        // But perturb it to try and trigger any mapping weirdness
        if (elem->dim() > 0)
          master_pt(0) = 0.25;

        if (elem->dim() > 1)
          master_pt(1) = -0.25;

        if (elem->dim() > 2)
          master_pt(2) = 0.75;

        Point physical_pt = FEMap::map(elem->dim(), elem, master_pt);

        Point inverse_pt = FEMap::inverse_map(elem->dim(), elem,
                                              physical_pt);

        CPPUNIT_ASSERT((inverse_pt-master_pt).norm() < TOLERANCE);

        CPPUNIT_ASSERT(elem->contains_point(physical_pt));

        // We only want to find elements in the same block
        std::set<subdomain_id_type> my_subdomain { elem->subdomain_id() };

        // We can *still* have overlapping NodeElem from a slit mesh
        // input file; better check them all
        std::set<const Elem * > located_elems;
        (*locator)(physical_pt, located_elems, &my_subdomain);

        CPPUNIT_ASSERT(located_elems.count(elem));
      }
  }

testNemesisCopyElementSolutionDistributed()

void MeshInputTest::testNemesisCopyElementSolutionDistributed ( )

inline

Definition at line 800 of file mesh_input.C.

  { LOG_UNIT_TEST; testCopyElementSolutionImpl<DistributedMesh,Nemesis_IO>("dist_with_elem_soln.nem"); }

testNemesisCopyElementSolutionReplicated()

void MeshInputTest::testNemesisCopyElementSolutionReplicated ( )

inline

Definition at line 797 of file mesh_input.C.

  { LOG_UNIT_TEST; testCopyElementSolutionImpl<ReplicatedMesh,Nemesis_IO>("repl_with_elem_soln.nem"); }

testNemesisCopyElementVectorDistributed()

void MeshInputTest::testNemesisCopyElementVectorDistributed ( )

inline

Definition at line 980 of file mesh_input.C.

  { LOG_UNIT_TEST; testCopyElementVectorImpl<DistributedMesh,Nemesis_IO>("dist_with_elem_vec.nem"); }

testNemesisCopyElementVectorReplicated()

void MeshInputTest::testNemesisCopyElementVectorReplicated ( )

inline

Definition at line 977 of file mesh_input.C.

  { LOG_UNIT_TEST; testCopyElementVectorImpl<ReplicatedMesh,Nemesis_IO>("repl_with_elem_vec.nem"); }

testNemesisCopyNodalSolutionDistributed()

void MeshInputTest::testNemesisCopyNodalSolutionDistributed ( )

inline

Definition at line 711 of file mesh_input.C.

  { LOG_UNIT_TEST; testCopyNodalSolutionImpl<DistributedMesh,Nemesis_IO>("dist_with_nodal_soln.nem"); }

testNemesisCopyNodalSolutionReplicated()

void MeshInputTest::testNemesisCopyNodalSolutionReplicated ( )

inline

Definition at line 708 of file mesh_input.C.

  { LOG_UNIT_TEST; testCopyNodalSolutionImpl<ReplicatedMesh,Nemesis_IO>("repl_with_nodal_soln.nem"); }

testNemesisReadDistributed()

void MeshInputTest::testNemesisReadDistributed ( )

inline

Definition at line 1504 of file mesh_input.C.

  { LOG_UNIT_TEST; testNemesisReadImpl<DistributedMesh>(); }

testNemesisReadImpl()

template<typename MeshType >

void MeshInputTest::testNemesisReadImpl ( )

inline

Definition at line 1477 of file mesh_input.C.

References TIMPI::Communicator::barrier(), libMesh::MeshTools::Generation::build_square(), mesh, libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::prepare_for_use(), libMesh::Nemesis_IO::read(), TestCommWorld, and libMesh::MeshBase::write().

  {
    // first scope: write file
    {
      MeshType mesh(*TestCommWorld);
      MeshTools::Generation::build_square (mesh, 3, 3, 0., 1., 0., 1.);
      mesh.write("test_nemesis_read.nem");
    }

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

    // second scope: read file
    {
      MeshType mesh(*TestCommWorld);
      Nemesis_IO nem(mesh);

      nem.read("test_nemesis_read.nem");
      mesh.prepare_for_use();
      CPPUNIT_ASSERT_EQUAL(mesh.n_elem(),  static_cast<dof_id_type>(9));
      CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(), static_cast<dof_id_type>(16));
    }
  }

testNemesisReadReplicated()

void MeshInputTest::testNemesisReadReplicated ( )

inline

Definition at line 1501 of file mesh_input.C.

  { LOG_UNIT_TEST; testNemesisReadImpl<ReplicatedMesh>(); }

testNemesisSingleElementDistributed()

void MeshInputTest::testNemesisSingleElementDistributed ( )

inline

Definition at line 862 of file mesh_input.C.

  { LOG_UNIT_TEST; testSingleElementImpl<DistributedMesh,Nemesis_IO>("dist_with_single_elem.nem"); }

testNemesisSingleElementReplicated()

void MeshInputTest::testNemesisSingleElementReplicated ( )

inline

Definition at line 859 of file mesh_input.C.

  { LOG_UNIT_TEST; testSingleElementImpl<ReplicatedMesh,Nemesis_IO>("repl_with_single_elem.nem"); }

testProjectionRegression()

void MeshInputTest::testProjectionRegression ( MeshBase &  mesh, std::array< Real, 4 >  expected_norms  )

inline

Definition at line 1873 of file mesh_input.C.

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::System::calculate_norm(), libMesh::MeshBase::clone(), libMesh::H1_SEMINORM, libMesh::EquationSystems::init(), libMesh::L2, libMesh::L_INF, TIMPI::Communicator::max(), mesh, libMesh::EquationSystems::parameters, libMesh::System::project_solution(), libMesh::RATIONAL_BERNSTEIN, libMesh::Real, sin_x_plus_cos_y(), libMesh::System::solution, TestCommWorld, libMesh::TOLERANCE, and libMesh::W1_INF_SEMINORM.

  {
    int order = 0;
    for (const auto elem : mesh.element_ptr_range())
      order = std::max(order, int(elem->default_order()));
    TestCommWorld->max(order);
    CPPUNIT_ASSERT (order > 0);

    // Let's test that IGA constraints are preserved (in a relative
    // sense) when we clone a mesh.
    std::unique_ptr<MeshBase> mesh_clone = mesh.clone();
    CPPUNIT_ASSERT(*mesh_clone == mesh);

    EquationSystems es(mesh);
    System &sys = es.add_system<System> ("SimpleSystem");
    sys.add_variable("n", Order(order), RATIONAL_BERNSTEIN);

    es.init();

    sys.project_solution(sin_x_plus_cos_y, nullptr, es.parameters);

    // Make this easy to tweak in the future
    const Real my_tolerance = TOLERANCE;

    // Calculate some norms, skipping the spline points, and compare
    // to regression standard values
    std::set<unsigned int> skip_dimensions {0};
    const Real L2_norm =
      sys.calculate_norm(*sys.solution, 0, L2, &skip_dimensions);
//    std::cout.precision(16);
//    std::cout << "L2_norm = " << L2_norm << std::endl;
    LIBMESH_ASSERT_FP_EQUAL(L2_norm, expected_norms[0], my_tolerance);
    const Real Linf_norm =
      sys.calculate_norm(*sys.solution, 0, L_INF, &skip_dimensions);
//    std::cout << "Linf_norm = " << Linf_norm << std::endl;
    LIBMESH_ASSERT_FP_EQUAL(Linf_norm, expected_norms[1], my_tolerance);
    const Real H1_norm =
      sys.calculate_norm(*sys.solution, 0, H1_SEMINORM, &skip_dimensions);
//    std::cout << "H1_norm = " << H1_norm << std::endl;
    LIBMESH_ASSERT_FP_EQUAL(H1_norm, expected_norms[2], my_tolerance);
    const Real W1inf_norm =
      sys.calculate_norm(*sys.solution, 0, W1_INF_SEMINORM, &skip_dimensions);
//    std::cout << "W1inf_norm = " << W1inf_norm << std::endl;
    // W1_inf seems more sensitive to FP error...
    LIBMESH_ASSERT_FP_EQUAL(W1inf_norm, expected_norms[3], 10*my_tolerance);
  }

testSingleElementImpl()

template<typename MeshType , typename IOType >

void MeshInputTest::testSingleElementImpl ( const std::string &  filename )

inline

Definition at line 808 of file mesh_input.C.

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshBase::allow_renumbering(), libMesh::MeshTools::Generation::build_square(), libMesh::CONSTANT, libMesh::Nemesis_IO::copy_elemental_solution(), libMesh::EquationSystems::init(), libMesh::MeshInput< MT >::is_parallel_format(), libMesh::libmesh_real(), mesh, libMesh::MONOMIAL, libMesh::EquationSystems::parameters, libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::Nemesis_IO::read(), libMesh::Real, six_x_plus_sixty_y(), TestCommWorld, libMesh::Nemesis_IO::write_element_data(), and libMesh::MeshOutput< MT >::write_equation_systems().

  {
    {
      // Generate a single 1x1 square element mesh
      MeshType mesh(*TestCommWorld);
      MeshTools::Generation::build_square(mesh, 1, 1);

      EquationSystems es(mesh);
      auto & sys = es.add_system<System>("SimpleSystem");
      sys.add_variable("e", CONSTANT, MONOMIAL);

      // Set an arbitrary solution for the single element DOF
      es.init();
      sys.project_solution(six_x_plus_sixty_y, nullptr, es.parameters);

      // Write the solution to Nemesis file(s) - only proc 0 should have anything to write!
      Nemesis_IO nem_io(mesh);
      std::set<std::string> sys_list;
      nem_io.write_equation_systems(filename, es, &sys_list);
      nem_io.write_element_data(es);
    }

    // If we can read and copy the correct element value back into the mesh, we know the Nemesis
    // file(s) were written properly.
    {
      MeshType mesh(*TestCommWorld);
      mesh.allow_renumbering(false);
      EquationSystems es(mesh);
      auto & sys = es.add_system<System>("SimpleSystem");
      sys.add_variable("teste", CONSTANT, MONOMIAL);

      Nemesis_IO nem_io(mesh);
      if (mesh.processor_id() == 0 || nem_io.is_parallel_format())
        nem_io.read(filename);

      mesh.prepare_for_use();
      es.init();

#ifdef LIBMESH_USE_COMPLEX_NUMBERS
      nem_io.copy_elemental_solution(sys, "teste", "r_e");
#else
      nem_io.copy_elemental_solution(sys, "teste", "e");
#endif

      // The result should be '\frac{6 + 60}{2} = 33' at all points in the element domain
      CPPUNIT_ASSERT_EQUAL(int(sys.solution->size()), 1);
      CPPUNIT_ASSERT_EQUAL(libmesh_real(sys.point_value(0, Point(0.5, 0.5))), Real(33));
    }
  }

testTetgenIO()

void MeshInputTest::testTetgenIO ( )

inline

Definition at line 1747 of file mesh_input.C.

References libMesh::MeshCommunication::broadcast(), libMesh::ParallelObject::comm(), libMesh::MeshBase::is_serial(), TIMPI::Communicator::max(), mesh, libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::MeshBase::query_elem_ptr(), libMesh::TetGenIO::read(), libMesh::Real, TestCommWorld, libMesh::TOLERANCE, and libMesh::Elem::volume().

  {
#ifdef LIBMESH_HAVE_TETGEN
    LOG_UNIT_TEST;

    Mesh mesh(*TestCommWorld);

    TetGenIO tetgen_io(mesh);

    if (mesh.processor_id() == 0)
      tetgen_io.read("meshes/tetgen_one_tet10.ele");
    MeshCommunication().broadcast(mesh);

    mesh.prepare_for_use();

    // Mesh should contain 1 TET10 finite element
    CPPUNIT_ASSERT_EQUAL(mesh.n_elem(),  static_cast<dof_id_type>(1));
    CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(), static_cast<dof_id_type>(10));

    // Element should have TET10 reference element volume
    const Elem * const elem = mesh.query_elem_ptr(0);

    // On a serial mesh we have every element everywhere
    if (mesh.is_serial())
      CPPUNIT_ASSERT(elem);
    else
      {
        bool have_elem = elem;
        mesh.comm().max(have_elem);
        CPPUNIT_ASSERT(have_elem);
      }

    if (elem)
      {
        const Real vol = elem->volume();
        LIBMESH_ASSERT_FP_EQUAL(vol, 1./6, TOLERANCE*TOLERANCE);
      }
#endif
  }

testVTKPreserveElemIds()

void MeshInputTest::testVTKPreserveElemIds ( )

inline

Definition at line 227 of file mesh_input.C.

References libMesh::MeshBase::allow_renumbering(), TIMPI::Communicator::barrier(), libMesh::MeshTools::Generation::build_square(), int, libMesh::MeshBase::max_elem_id(), mesh, libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::prepare_for_use(), libMesh::MeshBase::read(), libMesh::MeshBase::renumber_elem(), TestCommWorld, and libMesh::VTKIO::write().

  {
    LOG_UNIT_TEST;

    // Come up with some crazy numbering.  Make all the new ids higher
    // than the existing ids so we don't have to worry about conflicts
    // while renumbering.
    dof_id_type start_id;

    // first scope: write file
    {
      Mesh mesh(*TestCommWorld);
      mesh.allow_renumbering(false);
      MeshTools::Generation::build_square (mesh, 3, 3, 0., 1., 0., 1.);

      start_id = mesh.max_elem_id();

      // Use a separate container that won't invalidate iterators when
      // we renumber
      std::set<Elem *> elements {mesh.elements_begin(), mesh.elements_end()};
      for (Elem * elem : elements)
      {
        const Point center = elem->vertex_average();
        const int xn = int(center(0)*3);
        const int yn = int(center(1)*3);
        const dof_id_type new_id = start_id + yn*5 + xn;
        mesh.renumber_elem(elem->id(), new_id);
      }

      // Explicit writer object here to be absolutely sure we get VTK
      VTKIO vtk(mesh);
      vtk.write("read_elem_ids_test.pvtu");
    }

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

    // second scope: read file
    {
      Mesh mesh(*TestCommWorld);
      mesh.allow_renumbering(false);

      mesh.read("read_elem_ids_test.pvtu");
      mesh.prepare_for_use();

      CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(), dof_id_type(16));
      CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), dof_id_type(9));

      for (const auto & elem : mesh.element_ptr_range())
      {
        const Point center = elem->vertex_average();
        const int xn = int(center(0)*3);
        const int yn = int(center(1)*3);
        const dof_id_type expected_id = start_id + yn*5 + xn;
        CPPUNIT_ASSERT_EQUAL(elem->id(), expected_id);
      }
    }
  }

testVTKPreserveSubdomainIds()

void MeshInputTest::testVTKPreserveSubdomainIds ( )

inline

Definition at line 286 of file mesh_input.C.

References libMesh::MeshBase::allow_renumbering(), TIMPI::Communicator::barrier(), libMesh::MeshTools::Generation::build_square(), int, mesh, libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::prepare_for_use(), libMesh::MeshBase::read(), TestCommWorld, and libMesh::VTKIO::write().

  {
    LOG_UNIT_TEST;

    // first scope: write file
    {
      Mesh mesh(*TestCommWorld);
      mesh.allow_renumbering(false);
      MeshTools::Generation::build_square (mesh, 3, 3, 0., 1., 0., 1.);

      for (const auto & elem : mesh.element_ptr_range())
      {
        const Point center = elem->vertex_average();
        const int xn = int(center(0)*3);
        const int yn = int(center(1)*3);
        const subdomain_id_type new_id = yn*4 + xn;
        elem->subdomain_id() = new_id;
      }

      // Explicit writer object here to be absolutely sure we get VTK
      VTKIO vtk(mesh);
      vtk.write("read_sbd_ids_test.pvtu");
    }

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

    // second scope: read file
    {
      Mesh mesh(*TestCommWorld);
      mesh.allow_renumbering(false);

      mesh.read("read_sbd_ids_test.pvtu");
      mesh.prepare_for_use();

      CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(), dof_id_type(16));
      CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), dof_id_type(9));

      for (const auto & elem : mesh.element_ptr_range())
      {
        const Point center = elem->vertex_average();
        const int xn = int(center(0)*3);
        const int yn = int(center(1)*3);
        const subdomain_id_type expected_id = yn*4 + xn;
        CPPUNIT_ASSERT_EQUAL(elem->subdomain_id(), expected_id);
      }
    }
  }

---

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

• tests/mesh/mesh_input.C