MeshInputTest Class Reference

Inheritance diagram for MeshInputTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (MeshInputTest)
	CPPUNIT_TEST (testVTKPreserveElemIds)
	CPPUNIT_TEST (testVTKPreserveSubdomainIds)
	CPPUNIT_TEST (testVTKReadPolyhedra)
	CPPUNIT_TEST (testVTKReadPolyhedraSerial)
	CPPUNIT_TEST (testVTKReadNotAnXMLFile)
	CPPUNIT_TEST (testExodusCopyNodalSolutionDistributed)
	CPPUNIT_TEST (testExodusCopyElementSolutionDistributed)
	CPPUNIT_TEST (testExodusCopyNodalSolutionReplicated)
	CPPUNIT_TEST (testExodusCopyElementSolutionReplicated)
	CPPUNIT_TEST (testExodusCopyHighOrderElementSolution)
	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	checkHexPrismPolyhedron (MeshBase &mesh)
void	testVTKReadPolyhedra ()
void	testVTKReadPolyhedraSerial ()
void	testVTKReadNotAnXMLFile ()
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	testExodusCopyHighOrderElementSolution ()
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 100 of file mesh_input.C.

Member Function Documentation

checkHexPrismPolyhedron()

void MeshInputTest::checkHexPrismPolyhedron ( MeshBase &  mesh )

inline

Definition at line 343 of file mesh_input.C.

  {
    CPPUNIT_ASSERT_EQUAL(dof_id_type(1), mesh.n_elem());
 
    // The element may live on a single processor when the mesh is
    // distributed, so guard the checks accordingly.
    const Elem * elem = mesh.query_elem_ptr(0);
    bool found_elem = elem;
    mesh.comm().max(found_elem);
    CPPUNIT_ASSERT(found_elem);
 
    if (!elem)
      return;
 
    CPPUNIT_ASSERT_EQUAL(C0POLYHEDRON, elem->type());
    CPPUNIT_ASSERT_EQUAL(12u, elem->n_vertices());
    CPPUNIT_ASSERT_EQUAL(8u, elem->n_sides());
 
    // The file has no libmesh_node_id array, so libMesh node ids match
    // the VTK point ordering, i.e. the coordinates we wrote out.
    LIBMESH_ASSERT_FP_EQUAL(6.0, elem->volume(), TOLERANCE);
 
    // Collect the faces (as node-id sets) and compare against the faces
    // that were written to the file, independent of any reordering the
    // C0Polyhedron may do to its sides.
    std::set<std::set<dof_id_type>> faces;
    for (auto s : elem->side_index_range())
      {
        std::set<dof_id_type> face;
        for (const auto n : elem->nodes_on_side(s))
          face.insert(elem->node_id(n));
        faces.insert(std::move(face));
      }
 
    const std::set<std::set<dof_id_type>> expected_faces =
      { {0, 1, 2, 3, 4, 5},
        {0, 1, 7, 6},
        {1, 2, 8, 7},
        {2, 3, 9, 8},
        {3, 4, 10, 9},
        {4, 5, 11, 10},
        {5, 0, 6, 11},
        {6, 7, 8, 9, 10, 11} };
 
    CPPUNIT_ASSERT(faces == expected_faces);
  }

References libMesh::C0POLYHEDRON, libMesh::ParallelObject::comm(), libMesh::Parallel::Communicator::max(), mesh, libMesh::MeshBase::n_elem(), libMesh::Elem::n_sides(), libMesh::Elem::n_vertices(), libMesh::Elem::node_id(), libMesh::Elem::nodes_on_side(), libMesh::MeshBase::query_elem_ptr(), libMesh::Elem::side_index_range(), libMesh::TOLERANCE, libMesh::Elem::type(), and libMesh::Elem::volume().

Referenced by testVTKReadPolyhedra(), and testVTKReadPolyhedraSerial().

CPPUNIT_TEST() [1/69]

MeshInputTest::CPPUNIT_TEST

(

testAbaqusReadFirst

)

CPPUNIT_TEST() [2/69]

MeshInputTest::CPPUNIT_TEST

(

testAbaqusReadSecond

)

CPPUNIT_TEST() [3/69]

MeshInputTest::CPPUNIT_TEST

(

testBadGmsh

)

CPPUNIT_TEST() [4/69]

MeshInputTest::CPPUNIT_TEST

(

testDynaFileMappingsBlockWithHole

)

CPPUNIT_TEST() [5/69]

MeshInputTest::CPPUNIT_TEST

(

testDynaFileMappingsCyl3d

)

CPPUNIT_TEST() [6/69]

MeshInputTest::CPPUNIT_TEST

(

testDynaFileMappingsFEMEx5

)

CPPUNIT_TEST() [7/69]

MeshInputTest::CPPUNIT_TEST

(

testDynaFileMappingsPlateWithHole

)

CPPUNIT_TEST() [8/69]

MeshInputTest::CPPUNIT_TEST

(

testDynaNoSplines

)

CPPUNIT_TEST() [9/69]

MeshInputTest::CPPUNIT_TEST

(

testDynaReadElem

)

CPPUNIT_TEST() [10/69]

MeshInputTest::CPPUNIT_TEST

(

testDynaReadPatch

)

CPPUNIT_TEST() [11/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusCopyElementSolutionDistributed

)

CPPUNIT_TEST() [12/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusCopyElementSolutionReplicated

)

CPPUNIT_TEST() [13/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusCopyElementVectorDistributed

)

CPPUNIT_TEST() [14/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusCopyElementVectorReplicated

)

CPPUNIT_TEST() [15/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusCopyHighOrderElementSolution

)

CPPUNIT_TEST() [16/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusCopyNodalSolutionDistributed

)

CPPUNIT_TEST() [17/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusCopyNodalSolutionReplicated

)

CPPUNIT_TEST() [18/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscCyl3d

)

CPPUNIT_TEST() [19/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscPlateWithHole

)

CPPUNIT_TEST() [20/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscTwoBlocks

)

CPPUNIT_TEST() [21/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscTwoElemIGA

)

CPPUNIT_TEST() [22/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscWriteAddedSidesEdgeC0

)

CPPUNIT_TEST() [23/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscWriteAddedSidesHexC0

)

CPPUNIT_TEST() [24/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscWriteAddedSidesHexDisc

)

CPPUNIT_TEST() [25/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscWriteAddedSidesMixedEdgeC0

)

CPPUNIT_TEST() [26/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscWriteAddedSidesMixedHexC0

)

CPPUNIT_TEST() [27/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscWriteAddedSidesMixedQuadC0

)

CPPUNIT_TEST() [28/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscWriteAddedSidesMixedTriC0

)

CPPUNIT_TEST() [29/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscWriteAddedSidesQuadC0

)

CPPUNIT_TEST() [30/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusDiscWriteAddedSidesTriC0

)

CPPUNIT_TEST() [31/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusFileMappingsCyl3d

)

CPPUNIT_TEST() [32/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusFileMappingsPlateWithHole

)

CPPUNIT_TEST() [33/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusFileMappingsTwoBlocks

)

CPPUNIT_TEST() [34/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusFileMappingsTwoElemIGA

)

CPPUNIT_TEST() [35/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusIGASidesets

)

CPPUNIT_TEST() [36/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusReadHeader

)

CPPUNIT_TEST() [37/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusSetElemUniqueIdsFromMaps

)

CPPUNIT_TEST() [38/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusSetNodeUniqueIdsFromMaps

)

CPPUNIT_TEST() [39/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusWriteAddedSidesEdgeC0

)

CPPUNIT_TEST() [40/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusWriteAddedSidesHexC0

)

CPPUNIT_TEST() [41/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusWriteAddedSidesHexDisc

)

CPPUNIT_TEST() [42/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusWriteAddedSidesMixedEdgeC0

)

CPPUNIT_TEST() [43/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusWriteAddedSidesMixedHexC0

)

CPPUNIT_TEST() [44/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusWriteAddedSidesMixedQuadC0

)

CPPUNIT_TEST() [45/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusWriteAddedSidesMixedTriC0

)

CPPUNIT_TEST() [46/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusWriteAddedSidesQuadC0

)

CPPUNIT_TEST() [47/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusWriteAddedSidesTriC0

)

CPPUNIT_TEST() [48/69]

MeshInputTest::CPPUNIT_TEST

(

testExodusWriteElementDataFromDiscontinuousNodalData

)

CPPUNIT_TEST() [49/69]

MeshInputTest::CPPUNIT_TEST

(

testGmshBCIDOverlap

)

CPPUNIT_TEST() [50/69]

MeshInputTest::CPPUNIT_TEST

(

testGoodGmsh

)

CPPUNIT_TEST() [51/69]

MeshInputTest::CPPUNIT_TEST

(

testGoodSTL

)

CPPUNIT_TEST() [52/69]

MeshInputTest::CPPUNIT_TEST

(

testGoodSTLBinary

)

CPPUNIT_TEST() [53/69]

MeshInputTest::CPPUNIT_TEST

(

testLowOrderEdgeBlocks

)

CPPUNIT_TEST() [54/69]

MeshInputTest::CPPUNIT_TEST

(

testNemesisCopyElementSolutionDistributed

)

CPPUNIT_TEST() [55/69]

MeshInputTest::CPPUNIT_TEST

(

testNemesisCopyElementSolutionReplicated

)

CPPUNIT_TEST() [56/69]

MeshInputTest::CPPUNIT_TEST

(

testNemesisCopyElementVectorDistributed

)

CPPUNIT_TEST() [57/69]

MeshInputTest::CPPUNIT_TEST

(

testNemesisCopyElementVectorReplicated

)

CPPUNIT_TEST() [58/69]

MeshInputTest::CPPUNIT_TEST

(

testNemesisCopyNodalSolutionDistributed

)

CPPUNIT_TEST() [59/69]

MeshInputTest::CPPUNIT_TEST

(

testNemesisCopyNodalSolutionReplicated

)

CPPUNIT_TEST() [60/69]

MeshInputTest::CPPUNIT_TEST

(

testNemesisReadDistributed

)

CPPUNIT_TEST() [61/69]

MeshInputTest::CPPUNIT_TEST

(

testNemesisReadReplicated

)

CPPUNIT_TEST() [62/69]

MeshInputTest::CPPUNIT_TEST

(

testNemesisSingleElementDistributed

)

CPPUNIT_TEST() [63/69]

MeshInputTest::CPPUNIT_TEST

(

testNemesisSingleElementReplicated

)

CPPUNIT_TEST() [64/69]

MeshInputTest::CPPUNIT_TEST

(

testTetgenIO

)

CPPUNIT_TEST() [65/69]

MeshInputTest::CPPUNIT_TEST

(

testVTKPreserveElemIds

)

CPPUNIT_TEST() [66/69]

MeshInputTest::CPPUNIT_TEST

(

testVTKPreserveSubdomainIds

)

CPPUNIT_TEST() [67/69]

MeshInputTest::CPPUNIT_TEST

(

testVTKReadNotAnXMLFile

)

CPPUNIT_TEST() [68/69]

MeshInputTest::CPPUNIT_TEST

(

testVTKReadPolyhedra

)

CPPUNIT_TEST() [69/69]

MeshInputTest::CPPUNIT_TEST

(

testVTKReadPolyhedraSerial

)

CPPUNIT_TEST_SUITE_END()

MeshInputTest::CPPUNIT_TEST_SUITE_END

(

)

helperTestingDynaQuad()

void MeshInputTest::helperTestingDynaQuad ( const MeshBase &  mesh )

inline

Definition at line 1802 of file mesh_input.C.

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

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

Referenced by testDynaNoSplines(), and testDynaReadElem().

LIBMESH_CPPUNIT_TEST_SUITE()

MeshInputTest::LIBMESH_CPPUNIT_TEST_SUITE

(

MeshInputTest

)

setUp()

void MeshInputTest::setUp ( )

inline

Definition at line 225 of file mesh_input.C.

  {}

tearDown()

void MeshInputTest::tearDown ( )

inline

Definition at line 228 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 1846 of file mesh_input.C.

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

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

Referenced by testAbaqusReadFirst(), and testAbaqusReadSecond().

testAbaqusReadFirst()

void MeshInputTest::testAbaqusReadFirst ( )

inline

Definition at line 1865 of file mesh_input.C.

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

References testAbaqusRead().

testAbaqusReadSecond()

void MeshInputTest::testAbaqusReadSecond ( )

inline

Definition at line 1872 of file mesh_input.C.

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

References testAbaqusRead().

testBadGmsh()

void MeshInputTest::testBadGmsh ( )

inline

Definition at line 1901 of file mesh_input.C.

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

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

testCopyElementSolutionImpl()

template<typename MeshType , typename IOType >

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

inline

Definition at line 841 of file mesh_input.C.

  {
    {
      MeshType mesh(*TestCommWorld);
 
      EquationSystems es(mesh);
      System &sys = es.add_system<System> ("SimpleSystem");
      sys.add_variable("e", CONSTANT, MONOMIAL);
      sys.add_variable("e_no_p", FEType(CONSTANT, MONOMIAL).set_p_refinement(false));
      sys.add_variable("e_xyz", FEType(CONSTANT, XYZ));
 
      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);
      sys.add_variable("teste_no_p", FEType(CONSTANT, MONOMIAL).set_p_refinement(false));
      sys.add_variable("teste_xyz", FEType(CONSTANT, XYZ));
 
      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");
      meshinput.copy_elemental_solution(sys, "teste_no_p", "r_e_no_p");
      meshinput.copy_elemental_solution(sys, "teste_xyz", "r_e_xyz");
#else
      meshinput.copy_elemental_solution(sys, "teste", "e");
      meshinput.copy_elemental_solution(sys, "teste_no_p", "e_no_p");
      meshinput.copy_elemental_solution(sys, "teste_xyz", "e_xyz");
#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);
            LIBMESH_ASSERT_NUMBERS_EQUAL
              (sys.point_value(1,p), 6*x+60*y, exotol);
            LIBMESH_ASSERT_NUMBERS_EQUAL
              (sys.point_value(2,p), 6*x+60*y, exotol);
          }
    }
  }

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, libMesh::FEType::set_p_refinement(), six_x_plus_sixty_y(), libMesh::MeshBase::skip_noncritical_partitioning(), TestCommWorld, libMesh::TOLERANCE, and libMesh::XYZ.

testCopyElementVectorImpl()

template<typename MeshType , typename IOType >

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

inline

Definition at line 1082 of file mesh_input.C.

  {
    {
      MeshType mesh(*TestCommWorld);
 
      EquationSystems es(mesh);
 
      // We need a mesh.spatial_dimension() *before* adding a
      // vector-valued variable, so add_variable() can figure out how
      // many components it needs.
      MeshTools::Generation::build_square (mesh,
                                           3, 3,
                                           0., 1., 0., 1.);
 
      System & sys = es.add_system<System> ("SimpleSystem");
      auto e_var = sys.add_variable("e", CONSTANT, MONOMIAL_VEC);
      auto e_no_p_var = sys.add_variable("e_no_p",
                                         FEType(CONSTANT, MONOMIAL_VEC).set_p_refinement(false));
 
      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, "", ""));
        sys.current_local_solution->set(
          elem->dof_number(sys.number(), e_no_p_var, 0), six_x_plus_sixty_y(p, params, "", ""));
        sys.current_local_solution->set(
          elem->dof_number(sys.number(), e_no_p_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", FEType(CONSTANT, MONOMIAL).set_p_refinement(false));
      sys.add_variable("teste_y", FEType(CONSTANT, MONOMIAL).set_p_refinement(false));
      sys.add_variable("teste_no_p_x", FEType(CONSTANT, MONOMIAL).set_p_refinement(false));
      sys.add_variable("teste_no_p_y", FEType(CONSTANT, MONOMIAL).set_p_refinement(false));
 
      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");
      meshinput.copy_elemental_solution(sys, "teste_no_p_x", "e_no_p_x");
      meshinput.copy_elemental_solution(sys, "teste_no_p_y", "e_no_p_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);
            LIBMESH_ASSERT_NUMBERS_EQUAL
              (sys.point_value(2,p), 6*x+60*y, exotol);
            LIBMESH_ASSERT_NUMBERS_EQUAL
              (sys.point_value(3,p), sin(x)+cos(y), exotol);
          }
    }
  }

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, libMesh::FEType::set_p_refinement(), sin_x_plus_cos_y(), six_x_plus_sixty_y(), libMesh::MeshBase::skip_noncritical_partitioning(), TestCommWorld, and libMesh::TOLERANCE.

testCopyNodalSolutionImpl()

template<typename MeshType , typename IOType >

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

inline

Definition at line 757 of file mesh_input.C.

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

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.

testDynaFileMappings()

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

inline

Definition at line 2172 of file mesh_input.C.

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

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(), TestCommWorld, testMasterCenters(), and testProjectionRegression().

Referenced by testDynaFileMappingsBlockWithHole(), testDynaFileMappingsCyl3d(), testDynaFileMappingsFEMEx5(), and testDynaFileMappingsPlateWithHole().

testDynaFileMappingsBlockWithHole()

void MeshInputTest::testDynaFileMappingsBlockWithHole ( )

inline

Definition at line 2204 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}});
  }

References testDynaFileMappings().

testDynaFileMappingsCyl3d()

void MeshInputTest::testDynaFileMappingsCyl3d ( )

inline

Definition at line 2224 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}});
  }

References testDynaFileMappings().

testDynaFileMappingsFEMEx5()

void MeshInputTest::testDynaFileMappingsFEMEx5 ( )

inline

Definition at line 2194 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}});
  }

References testDynaFileMappings().

testDynaFileMappingsPlateWithHole()

void MeshInputTest::testDynaFileMappingsPlateWithHole ( )

inline

Definition at line 2214 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}});
  }

References testDynaFileMappings().

testDynaNoSplines()

void MeshInputTest::testDynaNoSplines ( )

inline

Definition at line 2039 of file mesh_input.C.

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

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

testDynaReadElem()

void MeshInputTest::testDynaReadElem ( )

inline

Definition at line 1879 of file mesh_input.C.

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

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

testDynaReadPatch()

void MeshInputTest::testDynaReadPatch ( )

inline

Definition at line 2061 of file mesh_input.C.

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

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, testMasterCenters(), and libMesh::TOLERANCE.

testExodusCopyElementSolutionDistributed()

void MeshInputTest::testExodusCopyElementSolutionDistributed ( )

inline

Definition at line 929 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 926 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 1200 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 1197 of file mesh_input.C.

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

testExodusCopyHighOrderElementSolution()

void MeshInputTest::testExodusCopyHighOrderElementSolution ( )

inline

Definition at line 941 of file mesh_input.C.

  {
    LOG_UNIT_TEST;
 
    const std::string filename("repl_with_high_order_elem_soln.e");
 
    {
      ReplicatedMesh mesh(*TestCommWorld);
 
      EquationSystems es(mesh);
      System &sys = es.add_system<System> ("SimpleSystem");
      sys.add_variable("e", FIRST, 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);
 
      ExodusII_IO meshinput(mesh);
      meshinput.write_discontinuous_elemental_data(true);
 
      std::set<std::string> sys_list;
      meshinput.write_equation_systems(filename, es, &sys_list);
      meshinput.write_element_data(es);
    }
 
    {
      ReplicatedMesh mesh(*TestCommWorld);
      mesh.allow_renumbering(false);
      ExodusII_IO meshinput(mesh);
 
      EquationSystems es(mesh);
      System &sys = es.add_system<System> ("SimpleSystem");
      sys.add_variable("teste", CONSTANT, MONOMIAL);
 
      if (mesh.processor_id() == 0)
        meshinput.read(filename);
      MeshCommunication().broadcast(mesh);
      mesh.prepare_for_use();
 
      es.init();
 
#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);
          }
    }
  }

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshBase::allow_renumbering(), libMesh::MeshCommunication::broadcast(), libMesh::MeshTools::Generation::build_square(), libMesh::CONSTANT, libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::FIRST, 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::ExodusII_IO::read(), libMesh::Real, six_x_plus_sixty_y(), TestCommWorld, libMesh::TOLERANCE, libMesh::ExodusII_IO::write_discontinuous_elemental_data(), libMesh::ExodusII_IO::write_element_data(), and libMesh::ExodusII_IO::write_equation_systems().

testExodusCopyNodalSolutionDistributed()

void MeshInputTest::testExodusCopyNodalSolutionDistributed ( )

inline

Definition at line 828 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 825 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 2356 of file mesh_input.C.

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

References testExodusFileMappings().

testExodusDiscPlateWithHole()

void MeshInputTest::testExodusDiscPlateWithHole ( )

inline

Definition at line 2317 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);
  }

References testExodusFileMappings().

testExodusDiscTwoBlocks()

void MeshInputTest::testExodusDiscTwoBlocks ( )

inline

Definition at line 2335 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);
  }

References testExodusFileMappings().

testExodusDiscTwoElemIGA()

void MeshInputTest::testExodusDiscTwoElemIGA ( )

inline

Definition at line 2345 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);
  }

References testExodusFileMappings().

testExodusDiscWriteAddedSidesEdgeC0()

void MeshInputTest::testExodusDiscWriteAddedSidesEdgeC0 ( )

inline

Definition at line 1572 of file mesh_input.C.

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

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

testExodusDiscWriteAddedSidesEdgeDisc()

void MeshInputTest::testExodusDiscWriteAddedSidesEdgeDisc ( )

inline

Definition at line 1595 of file mesh_input.C.

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

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

testExodusDiscWriteAddedSidesHexC0()

void MeshInputTest::testExodusDiscWriteAddedSidesHexC0 ( )

inline

Definition at line 1696 of file mesh_input.C.

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

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

testExodusDiscWriteAddedSidesHexDisc()

void MeshInputTest::testExodusDiscWriteAddedSidesHexDisc ( )

inline

Definition at line 1719 of file mesh_input.C.

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

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

testExodusDiscWriteAddedSidesMixedEdgeC0()

void MeshInputTest::testExodusDiscWriteAddedSidesMixedEdgeC0 ( )

inline

Definition at line 1584 of file mesh_input.C.

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

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

testExodusDiscWriteAddedSidesMixedHexC0()

void MeshInputTest::testExodusDiscWriteAddedSidesMixedHexC0 ( )

inline

Definition at line 1708 of file mesh_input.C.

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

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

testExodusDiscWriteAddedSidesMixedQuadC0()

void MeshInputTest::testExodusDiscWriteAddedSidesMixedQuadC0 ( )

inline

Definition at line 1652 of file mesh_input.C.

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

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

testExodusDiscWriteAddedSidesMixedTriC0()

void MeshInputTest::testExodusDiscWriteAddedSidesMixedTriC0 ( )

inline

Definition at line 1618 of file mesh_input.C.

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

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

testExodusDiscWriteAddedSidesQuadC0()

void MeshInputTest::testExodusDiscWriteAddedSidesQuadC0 ( )

inline

Definition at line 1640 of file mesh_input.C.

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

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

testExodusDiscWriteAddedSidesQuadDisc()

void MeshInputTest::testExodusDiscWriteAddedSidesQuadDisc ( )

inline

Definition at line 1663 of file mesh_input.C.

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

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

testExodusDiscWriteAddedSidesTetC0()

void MeshInputTest::testExodusDiscWriteAddedSidesTetC0 ( )

inline

Definition at line 1674 of file mesh_input.C.

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

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

testExodusDiscWriteAddedSidesTetDisc()

void MeshInputTest::testExodusDiscWriteAddedSidesTetDisc ( )

inline

Definition at line 1685 of file mesh_input.C.

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

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

testExodusDiscWriteAddedSidesTriC0()

void MeshInputTest::testExodusDiscWriteAddedSidesTriC0 ( )

inline

Definition at line 1606 of file mesh_input.C.

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

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

testExodusDiscWriteAddedSidesTriDisc()

void MeshInputTest::testExodusDiscWriteAddedSidesTriDisc ( )

inline

Definition at line 1629 of file mesh_input.C.

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

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

testExodusFileMappings()

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

inline

Definition at line 2234 of file mesh_input.C.

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

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, testMasterCenters(), testProjectionRegression(), libMesh::VTKIO::write(), and libMesh::ExodusII_IO::write().

Referenced by testExodusDiscCyl3d(), testExodusDiscPlateWithHole(), testExodusDiscTwoBlocks(), testExodusDiscTwoElemIGA(), testExodusFileMappingsCyl3d(), testExodusFileMappingsPlateWithHole(), testExodusFileMappingsTwoBlocks(), and testExodusFileMappingsTwoElemIGA().

testExodusFileMappingsCyl3d()

void MeshInputTest::testExodusFileMappingsCyl3d ( )

inline

Definition at line 2308 of file mesh_input.C.

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

References testExodusFileMappings().

testExodusFileMappingsPlateWithHole()

void MeshInputTest::testExodusFileMappingsPlateWithHole ( )

inline

Definition at line 2279 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}});
  }

References testExodusFileMappings().

testExodusFileMappingsTwoBlocks()

void MeshInputTest::testExodusFileMappingsTwoBlocks ( )

inline

Definition at line 2289 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}});
  }

References testExodusFileMappings().

testExodusFileMappingsTwoElemIGA()

void MeshInputTest::testExodusFileMappingsTwoElemIGA ( )

inline

Definition at line 2298 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}});
  }

References testExodusFileMappings().

testExodusIGASidesets()

void MeshInputTest::testExodusIGASidesets ( )

inline

Definition at line 666 of file mesh_input.C.

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

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(), libMesh::Parallel::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(), libMesh::Parallel::Communicator::sum(), TestCommWorld, and libMesh::ExodusII_IO::write().

testExodusReadHeader()

void MeshInputTest::testExodusReadHeader ( )

inline

Definition at line 586 of file mesh_input.C.

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

References 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().

testExodusSetElemUniqueIdsFromMaps()

void MeshInputTest::testExodusSetElemUniqueIdsFromMaps ( )

inline

Definition at line 555 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);
    }
  }

References testExodusSetElemUniqueIdsFromMaps_implementation().

testExodusSetElemUniqueIdsFromMaps_implementation()

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

inline

Definition at line 520 of file mesh_input.C.

  {
    // 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
  }

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

Referenced by testExodusSetElemUniqueIdsFromMaps().

testExodusSetNodeUniqueIdsFromMaps()

void MeshInputTest::testExodusSetNodeUniqueIdsFromMaps ( )

inline

Definition at line 499 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});
  }

References testExodusSetNodeUniqueIdsFromMaps_implementation().

testExodusSetNodeUniqueIdsFromMaps_implementation()

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

inline

Definition at line 463 of file mesh_input.C.

  {
    // 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()

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

Referenced by testExodusSetNodeUniqueIdsFromMaps().

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 1324 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

Referenced by testExodusDiscWriteAddedSidesEdgeC0(), testExodusDiscWriteAddedSidesEdgeDisc(), testExodusDiscWriteAddedSidesHexC0(), testExodusDiscWriteAddedSidesHexDisc(), testExodusDiscWriteAddedSidesMixedEdgeC0(), testExodusDiscWriteAddedSidesMixedHexC0(), testExodusDiscWriteAddedSidesMixedQuadC0(), testExodusDiscWriteAddedSidesMixedTriC0(), testExodusDiscWriteAddedSidesQuadC0(), testExodusDiscWriteAddedSidesQuadDisc(), testExodusDiscWriteAddedSidesTetC0(), testExodusDiscWriteAddedSidesTetDisc(), testExodusDiscWriteAddedSidesTriC0(), testExodusDiscWriteAddedSidesTriDisc(), testExodusWriteAddedSidesEdgeC0(), testExodusWriteAddedSidesEdgeDisc(), testExodusWriteAddedSidesHexC0(), testExodusWriteAddedSidesHexDisc(), testExodusWriteAddedSidesMixedEdgeC0(), testExodusWriteAddedSidesMixedHexC0(), testExodusWriteAddedSidesMixedQuadC0(), testExodusWriteAddedSidesMixedTriC0(), testExodusWriteAddedSidesQuadC0(), testExodusWriteAddedSidesQuadDisc(), testExodusWriteAddedSidesTetC0(), testExodusWriteAddedSidesTetDisc(), testExodusWriteAddedSidesTriC0(), and testExodusWriteAddedSidesTriDisc().

testExodusWriteAddedSidesEdgeC0()

void MeshInputTest::testExodusWriteAddedSidesEdgeC0 ( )

inline

Definition at line 1566 of file mesh_input.C.

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

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

testExodusWriteAddedSidesEdgeDisc()

void MeshInputTest::testExodusWriteAddedSidesEdgeDisc ( )

inline

Definition at line 1590 of file mesh_input.C.

  {
    testExodusWriteAddedSides(designed_for_side_elems, EDGE3, SECOND);
  }

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

testExodusWriteAddedSidesHexC0()

void MeshInputTest::testExodusWriteAddedSidesHexC0 ( )

inline

Definition at line 1690 of file mesh_input.C.

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

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

testExodusWriteAddedSidesHexDisc()

void MeshInputTest::testExodusWriteAddedSidesHexDisc ( )

inline

Definition at line 1714 of file mesh_input.C.

  {
    testExodusWriteAddedSides(designed_for_side_elems, HEX27, SECOND);
  }

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

testExodusWriteAddedSidesMixedEdgeC0()

void MeshInputTest::testExodusWriteAddedSidesMixedEdgeC0 ( )

inline

Definition at line 1578 of file mesh_input.C.

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

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

testExodusWriteAddedSidesMixedHexC0()

void MeshInputTest::testExodusWriteAddedSidesMixedHexC0 ( )

inline

Definition at line 1702 of file mesh_input.C.

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

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

testExodusWriteAddedSidesMixedQuadC0()

void MeshInputTest::testExodusWriteAddedSidesMixedQuadC0 ( )

inline

Definition at line 1646 of file mesh_input.C.

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

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

testExodusWriteAddedSidesMixedTriC0()

void MeshInputTest::testExodusWriteAddedSidesMixedTriC0 ( )

inline

Definition at line 1612 of file mesh_input.C.

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

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

testExodusWriteAddedSidesQuadC0()

void MeshInputTest::testExodusWriteAddedSidesQuadC0 ( )

inline

Definition at line 1634 of file mesh_input.C.

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

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

testExodusWriteAddedSidesQuadDisc()

void MeshInputTest::testExodusWriteAddedSidesQuadDisc ( )

inline

Definition at line 1658 of file mesh_input.C.

  {
    testExodusWriteAddedSides(designed_for_side_elems, QUAD9, SECOND);
  }

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

testExodusWriteAddedSidesTetC0()

void MeshInputTest::testExodusWriteAddedSidesTetC0 ( )

inline

Definition at line 1668 of file mesh_input.C.

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

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

testExodusWriteAddedSidesTetDisc()

void MeshInputTest::testExodusWriteAddedSidesTetDisc ( )

inline

Definition at line 1680 of file mesh_input.C.

  {
    testExodusWriteAddedSides(designed_for_side_elems, TET14, SECOND);
  }

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

testExodusWriteAddedSidesTriC0()

void MeshInputTest::testExodusWriteAddedSidesTriC0 ( )

inline

Definition at line 1600 of file mesh_input.C.

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

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

testExodusWriteAddedSidesTriDisc()

void MeshInputTest::testExodusWriteAddedSidesTriDisc ( )

inline

Definition at line 1624 of file mesh_input.C.

  {
    testExodusWriteAddedSides(designed_for_side_elems, TRI6, SECOND);
  }

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

testExodusWriteElementDataFromDiscontinuousNodalData()

void MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData ( )

inline

Definition at line 1212 of file mesh_input.C.

  {
    LOG_UNIT_TEST;
 
    const Real scalar_value = 42.;
    const Real xyz_value = 84.;
    const std::vector<Real> vector_values = {10., 20., 30.};
 
    // first scope: write file
    {
      Mesh mesh(*TestCommWorld);
 
      EquationSystems es(mesh);
      System & sys = es.add_system<System> ("SimpleSystem");
      sys.add_variable("u", FIRST, L2_LAGRANGE);
      const auto c_var =
        sys.add_variable("c", FEType(CONSTANT, MONOMIAL).set_p_refinement(false));
      const auto xyz_var =
        sys.add_variable("xyz", FEType(CONSTANT, XYZ));
      const auto vec_var =
        sys.add_variable("vec", FEType(CONSTANT, MONOMIAL_VEC).set_p_refinement(false));
 
      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->set(elem->dof_number(sys.number(), c_var, 0), scalar_value);
          sys.solution->set(elem->dof_number(sys.number(), xyz_var, 0), xyz_value);
          for (auto comp : index_range(vector_values))
            sys.solution->set(elem->dof_number(sys.number(),
                                               vec_var,
                                               cast_int<unsigned int>(comp)),
                              vector_values[comp]);
        }
      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",
         "c",
         "xyz",
         "vec_x",
         "vec_y",
         "vec_z"};
      std::vector<Real> expected_values =
        {0., 1., 2., 3.,
         scalar_value, xyz_value, vector_values[0], vector_values[1], vector_values[2]};
 
      // 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], FEType(CONSTANT, MONOMIAL).set_p_refinement(false));
 
      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

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::MONOMIAL_VEC, libMesh::System::number(), libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::ParallelObject::processor_id(), libMesh::ExodusII_IO::read(), libMesh::Real, libMesh::FEType::set_p_refinement(), libMesh::System::solution, TestCommWorld, libMesh::TOLERANCE, libMesh::System::variable_name(), libMesh::ExodusII_IO::write_element_data_from_discontinuous_nodal_data(), libMesh::ExodusII_IO::write_equation_systems(), and libMesh::XYZ.

testGmshBCIDOverlap()

void MeshInputTest::testGmshBCIDOverlap ( )

inline

Definition at line 1942 of file mesh_input.C.

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

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.

testGoodGmsh()

void MeshInputTest::testGoodGmsh ( )

inline

Definition at line 1927 of file mesh_input.C.

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

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

testGoodSTL()

void MeshInputTest::testGoodSTL ( )

inline

Definition at line 1968 of file mesh_input.C.

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

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

testGoodSTLBinary()

void MeshInputTest::testGoodSTLBinary ( )

inline

Definition at line 1983 of file mesh_input.C.

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

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

testLowOrderEdgeBlocks()

void MeshInputTest::testLowOrderEdgeBlocks ( )

inline

Definition at line 623 of file mesh_input.C.

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

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.

testMasterCenters()

void MeshInputTest::testMasterCenters ( const MeshBase &  mesh )

inline

Definition at line 1761 of file mesh_input.C.

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

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

Referenced by helperTestingDynaQuad(), testDynaFileMappings(), testDynaReadPatch(), and testExodusFileMappings().

testNemesisCopyElementSolutionDistributed()

void MeshInputTest::testNemesisCopyElementSolutionDistributed ( )

inline

Definition at line 1009 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 1006 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 1207 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 1204 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 835 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 832 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 1756 of file mesh_input.C.

  { LOG_UNIT_TEST; testNemesisReadImpl<DistributedMesh>(); }

testNemesisReadImpl()

template<typename MeshType >

void MeshInputTest::testNemesisReadImpl ( )

inline

Definition at line 1729 of file mesh_input.C.

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

References 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().

testNemesisReadReplicated()

void MeshInputTest::testNemesisReadReplicated ( )

inline

Definition at line 1753 of file mesh_input.C.

  { LOG_UNIT_TEST; testNemesisReadImpl<ReplicatedMesh>(); }

testNemesisSingleElementDistributed()

void MeshInputTest::testNemesisSingleElementDistributed ( )

inline

Definition at line 1071 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 1068 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 2125 of file mesh_input.C.

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

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, 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.

Referenced by testDynaFileMappings(), and testExodusFileMappings().

testSingleElementImpl()

template<typename MeshType , typename IOType >

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

inline

Definition at line 1017 of file mesh_input.C.

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

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

testTetgenIO()

void MeshInputTest::testTetgenIO ( )

inline

Definition at line 1999 of file mesh_input.C.

  {
#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
  }

References libMesh::MeshCommunication::broadcast(), libMesh::ParallelObject::comm(), libMesh::MeshBase::is_serial(), libMesh::Parallel::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().

testVTKPreserveElemIds()

void MeshInputTest::testVTKPreserveElemIds ( )

inline

Definition at line 232 of file mesh_input.C.

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

References libMesh::MeshBase::allow_renumbering(), 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().

testVTKPreserveSubdomainIds()

void MeshInputTest::testVTKPreserveSubdomainIds ( )

inline

Definition at line 291 of file mesh_input.C.

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

References libMesh::MeshBase::allow_renumbering(), 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().

testVTKReadNotAnXMLFile()

void MeshInputTest::testVTKReadNotAnXMLFile ( )

inline

Definition at line 445 of file mesh_input.C.

  {
    LOG_UNIT_TEST;
 
#ifdef LIBMESH_ENABLE_EXCEPTIONS
    Mesh mesh(*TestCommWorld);
    VTKIO vtk(mesh);
    CPPUNIT_ASSERT_THROW_MESSAGE
      ("Non-VTK-XML file not detected",
       vtk.read("meshes/circle.msh"),
       libMesh::LogicError);
#endif
  }

References mesh, libMesh::VTKIO::read(), and TestCommWorld.

testVTKReadPolyhedra()

void MeshInputTest::testVTKReadPolyhedra ( )

inline

Definition at line 390 of file mesh_input.C.

  {
    LOG_UNIT_TEST;
 
    // This .pvtu (+ piece) file contains a single VTK_POLYHEDRON cell.
    // VTKIO::read() sniffs the file's actual root element to tell a
    // parallel PUnstructuredGrid (.pvtu) descriptor from a plain serial
    // UnstructuredGrid (.vtu) file and uses the matching reader class --
    // see testVTKReadPolyhedraSerial below for the latter.
    Mesh mesh(*TestCommWorld);
    // Without this, prepare_for_use()'s default renumbering can reassign
    // node ids (by local element-traversal order rather than preserving
    // the ids we read), which would invalidate the "ids match VTK point
    // ordering" assumption checkHexPrismPolyhedron() relies on.
    mesh.allow_renumbering(false);
    mesh.read("meshes/hex_prism_polyhedron.pvtu");
    mesh.prepare_for_use();
 
    checkHexPrismPolyhedron(mesh);
  }

References libMesh::MeshBase::allow_renumbering(), checkHexPrismPolyhedron(), mesh, libMesh::MeshBase::prepare_for_use(), libMesh::MeshBase::read(), and TestCommWorld.

testVTKReadPolyhedraSerial()

void MeshInputTest::testVTKReadPolyhedraSerial ( )

inline

Definition at line 420 of file mesh_input.C.

  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
    mesh.allow_renumbering(false);
    mesh.read("meshes/hex_prism_polyhedron_0.vtu");
    mesh.prepare_for_use();
 
    checkHexPrismPolyhedron(mesh);
  }

References libMesh::MeshBase::allow_renumbering(), checkHexPrismPolyhedron(), mesh, libMesh::MeshBase::prepare_for_use(), libMesh::MeshBase::read(), and TestCommWorld.

---

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

• tests/mesh/mesh_input.C