Inheritance diagram for MeshInputTest:

[legend]

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (MeshInputTest)

	CPPUNIT_TEST (testVTKPreserveElemIds)

	CPPUNIT_TEST (testVTKPreserveSubdomainIds)

	CPPUNIT_TEST (testExodusCopyNodalSolutionDistributed)

	CPPUNIT_TEST (testExodusCopyElementSolutionDistributed)

	CPPUNIT_TEST (testExodusCopyNodalSolutionReplicated)

	CPPUNIT_TEST (testExodusCopyElementSolutionReplicated)

	CPPUNIT_TEST (testExodusReadHeader)

	CPPUNIT_TEST (testExodusSetNodeUniqueIdsFromMaps)

	CPPUNIT_TEST (testExodusSetElemUniqueIdsFromMaps)

	CPPUNIT_TEST (testExodusIGASidesets)

	CPPUNIT_TEST (testLowOrderEdgeBlocks)

	CPPUNIT_TEST (testExodusCopyElementVectorDistributed)

	CPPUNIT_TEST (testExodusCopyElementVectorReplicated)

	CPPUNIT_TEST (testExodusWriteElementDataFromDiscontinuousNodalData)

	CPPUNIT_TEST (testExodusWriteAddedSidesEdgeC0)

	CPPUNIT_TEST (testExodusDiscWriteAddedSidesEdgeC0)

	CPPUNIT_TEST (testExodusWriteAddedSidesMixedEdgeC0)

	CPPUNIT_TEST (testExodusDiscWriteAddedSidesMixedEdgeC0)

	CPPUNIT_TEST (testExodusWriteAddedSidesTriC0)

	CPPUNIT_TEST (testExodusDiscWriteAddedSidesTriC0)

	CPPUNIT_TEST (testExodusWriteAddedSidesMixedTriC0)

	CPPUNIT_TEST (testExodusDiscWriteAddedSidesMixedTriC0)

	CPPUNIT_TEST (testExodusWriteAddedSidesQuadC0)

	CPPUNIT_TEST (testExodusDiscWriteAddedSidesQuadC0)

	CPPUNIT_TEST (testExodusWriteAddedSidesMixedQuadC0)

	CPPUNIT_TEST (testExodusDiscWriteAddedSidesMixedQuadC0)

	CPPUNIT_TEST (testExodusWriteAddedSidesHexC0)

	CPPUNIT_TEST (testExodusDiscWriteAddedSidesHexC0)

	CPPUNIT_TEST (testExodusWriteAddedSidesMixedHexC0)

	CPPUNIT_TEST (testExodusDiscWriteAddedSidesMixedHexC0)

	CPPUNIT_TEST (testExodusWriteAddedSidesHexDisc)

	CPPUNIT_TEST (testExodusDiscWriteAddedSidesHexDisc)

	CPPUNIT_TEST (testExodusFileMappingsPlateWithHole)

	CPPUNIT_TEST (testExodusFileMappingsTwoBlocks)

	CPPUNIT_TEST (testExodusFileMappingsTwoElemIGA)

	CPPUNIT_TEST (testExodusFileMappingsCyl3d)

	CPPUNIT_TEST (testExodusDiscPlateWithHole)

	CPPUNIT_TEST (testExodusDiscTwoBlocks)

	CPPUNIT_TEST (testExodusDiscTwoElemIGA)

	CPPUNIT_TEST (testExodusDiscCyl3d)

	CPPUNIT_TEST (testNemesisReadReplicated)

	CPPUNIT_TEST (testNemesisReadDistributed)

	CPPUNIT_TEST (testNemesisCopyNodalSolutionDistributed)

	CPPUNIT_TEST (testNemesisCopyNodalSolutionReplicated)

	CPPUNIT_TEST (testNemesisCopyElementSolutionDistributed)

	CPPUNIT_TEST (testNemesisCopyElementSolutionReplicated)

	CPPUNIT_TEST (testNemesisSingleElementDistributed)

	CPPUNIT_TEST (testNemesisSingleElementReplicated)

	CPPUNIT_TEST (testNemesisCopyElementVectorDistributed)

	CPPUNIT_TEST (testNemesisCopyElementVectorReplicated)

	CPPUNIT_TEST (testAbaqusReadFirst)

	CPPUNIT_TEST (testAbaqusReadSecond)

	CPPUNIT_TEST (testDynaReadElem)

	CPPUNIT_TEST (testDynaNoSplines)

	CPPUNIT_TEST (testDynaReadPatch)

	CPPUNIT_TEST (testDynaFileMappingsFEMEx5)

	CPPUNIT_TEST (testDynaFileMappingsBlockWithHole)

	CPPUNIT_TEST (testDynaFileMappingsPlateWithHole)

	CPPUNIT_TEST (testDynaFileMappingsCyl3d)

	CPPUNIT_TEST (testBadGmsh)

	CPPUNIT_TEST (testGoodGmsh)

	CPPUNIT_TEST (testGoodSTL)

	CPPUNIT_TEST (testGoodSTLBinary)

	CPPUNIT_TEST (testGmshBCIDOverlap)

	CPPUNIT_TEST (testTetgenIO)

	CPPUNIT_TEST_SUITE_END ()

void	setUp ()

void	tearDown ()

void	testVTKPreserveElemIds ()

void	testVTKPreserveSubdomainIds ()

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

void	testExodusSetNodeUniqueIdsFromMaps ()

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

void	testExodusSetElemUniqueIdsFromMaps ()

void	testExodusReadHeader ()

void	testLowOrderEdgeBlocks ()

void	testExodusIGASidesets ()

template<typename MeshType , typename IOType >
void	testCopyNodalSolutionImpl (const std::string &filename)

void	testExodusCopyNodalSolutionReplicated ()

void	testExodusCopyNodalSolutionDistributed ()

void	testNemesisCopyNodalSolutionReplicated ()

void	testNemesisCopyNodalSolutionDistributed ()

template<typename MeshType , typename IOType >
void	testCopyElementSolutionImpl (const std::string &filename)

void	testExodusCopyElementSolutionReplicated ()

void	testExodusCopyElementSolutionDistributed ()

void	testNemesisCopyElementSolutionReplicated ()

void	testNemesisCopyElementSolutionDistributed ()

template<typename MeshType , typename IOType >
void	testSingleElementImpl (const std::string &filename)

void	testNemesisSingleElementReplicated ()

void	testNemesisSingleElementDistributed ()

template<typename MeshType , typename IOType >
void	testCopyElementVectorImpl (const std::string &filename)

void	testExodusCopyElementVectorReplicated ()

void	testExodusCopyElementVectorDistributed ()

void	testNemesisCopyElementVectorReplicated ()

void	testNemesisCopyElementVectorDistributed ()

void	testExodusWriteElementDataFromDiscontinuousNodalData ()

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

void	testExodusWriteAddedSidesEdgeC0 ()

void	testExodusDiscWriteAddedSidesEdgeC0 ()

void	testExodusWriteAddedSidesMixedEdgeC0 ()

void	testExodusDiscWriteAddedSidesMixedEdgeC0 ()

void	testExodusWriteAddedSidesEdgeDisc ()

void	testExodusDiscWriteAddedSidesEdgeDisc ()

void	testExodusWriteAddedSidesTriC0 ()

void	testExodusDiscWriteAddedSidesTriC0 ()

void	testExodusWriteAddedSidesMixedTriC0 ()

void	testExodusDiscWriteAddedSidesMixedTriC0 ()

void	testExodusWriteAddedSidesTriDisc ()

void	testExodusDiscWriteAddedSidesTriDisc ()

void	testExodusWriteAddedSidesQuadC0 ()

void	testExodusDiscWriteAddedSidesQuadC0 ()

void	testExodusWriteAddedSidesMixedQuadC0 ()

void	testExodusDiscWriteAddedSidesMixedQuadC0 ()

void	testExodusWriteAddedSidesQuadDisc ()

void	testExodusDiscWriteAddedSidesQuadDisc ()

void	testExodusWriteAddedSidesTetC0 ()

void	testExodusDiscWriteAddedSidesTetC0 ()

void	testExodusWriteAddedSidesTetDisc ()

void	testExodusDiscWriteAddedSidesTetDisc ()

void	testExodusWriteAddedSidesHexC0 ()

void	testExodusDiscWriteAddedSidesHexC0 ()

void	testExodusWriteAddedSidesMixedHexC0 ()

void	testExodusDiscWriteAddedSidesMixedHexC0 ()

void	testExodusWriteAddedSidesHexDisc ()

void	testExodusDiscWriteAddedSidesHexDisc ()

template<typename MeshType >
void	testNemesisReadImpl ()

void	testNemesisReadReplicated ()

void	testNemesisReadDistributed ()

void	testMasterCenters (const MeshBase &mesh)

void	helperTestingDynaQuad (const MeshBase &mesh)

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

void	testAbaqusReadFirst ()

void	testAbaqusReadSecond ()

void	testDynaReadElem ()

void	testBadGmsh ()

void	testGoodGmsh ()

void	testGmshBCIDOverlap ()

void	testGoodSTL ()

void	testGoodSTLBinary ()

void	testTetgenIO ()

void	testDynaNoSplines ()

void	testDynaReadPatch ()

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

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

void	testDynaFileMappingsFEMEx5 ()

void	testDynaFileMappingsBlockWithHole ()

void	testDynaFileMappingsPlateWithHole ()

void	testDynaFileMappingsCyl3d ()

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

void	testExodusFileMappingsPlateWithHole ()

void	testExodusFileMappingsTwoBlocks ()

void	testExodusFileMappingsTwoElemIGA ()

void	testExodusFileMappingsCyl3d ()

void	testExodusDiscPlateWithHole ()

void	testExodusDiscTwoBlocks ()

void	testExodusDiscTwoElemIGA ()

void	testExodusDiscCyl3d ()

Detailed Description

Definition at line 99 of file mesh_input.C.

Member Function Documentation

◆ CPPUNIT_TEST() [1/65]

MeshInputTest::CPPUNIT_TEST ( testAbaqusReadFirst )

◆ CPPUNIT_TEST() [2/65]

MeshInputTest::CPPUNIT_TEST ( testAbaqusReadSecond )

◆ CPPUNIT_TEST() [3/65]

MeshInputTest::CPPUNIT_TEST ( testBadGmsh )

◆ CPPUNIT_TEST() [4/65]

MeshInputTest::CPPUNIT_TEST ( testDynaFileMappingsBlockWithHole )

◆ CPPUNIT_TEST() [5/65]

MeshInputTest::CPPUNIT_TEST ( testDynaFileMappingsCyl3d )

◆ CPPUNIT_TEST() [6/65]

MeshInputTest::CPPUNIT_TEST ( testDynaFileMappingsFEMEx5 )

◆ CPPUNIT_TEST() [7/65]

MeshInputTest::CPPUNIT_TEST ( testDynaFileMappingsPlateWithHole )

◆ CPPUNIT_TEST() [8/65]

MeshInputTest::CPPUNIT_TEST ( testDynaNoSplines )

◆ CPPUNIT_TEST() [9/65]

MeshInputTest::CPPUNIT_TEST ( testDynaReadElem )

◆ CPPUNIT_TEST() [10/65]

MeshInputTest::CPPUNIT_TEST ( testDynaReadPatch )

◆ CPPUNIT_TEST() [11/65]

MeshInputTest::CPPUNIT_TEST ( testExodusCopyElementSolutionDistributed )

◆ CPPUNIT_TEST() [12/65]

MeshInputTest::CPPUNIT_TEST ( testExodusCopyElementSolutionReplicated )

◆ CPPUNIT_TEST() [13/65]

MeshInputTest::CPPUNIT_TEST ( testExodusCopyElementVectorDistributed )

◆ CPPUNIT_TEST() [14/65]

MeshInputTest::CPPUNIT_TEST ( testExodusCopyElementVectorReplicated )

◆ CPPUNIT_TEST() [15/65]

MeshInputTest::CPPUNIT_TEST ( testExodusCopyNodalSolutionDistributed )

◆ CPPUNIT_TEST() [16/65]

MeshInputTest::CPPUNIT_TEST ( testExodusCopyNodalSolutionReplicated )

◆ CPPUNIT_TEST() [17/65]

MeshInputTest::CPPUNIT_TEST ( testExodusDiscCyl3d )

◆ CPPUNIT_TEST() [18/65]

MeshInputTest::CPPUNIT_TEST ( testExodusDiscPlateWithHole )

◆ CPPUNIT_TEST() [19/65]

MeshInputTest::CPPUNIT_TEST ( testExodusDiscTwoBlocks )

◆ CPPUNIT_TEST() [20/65]

MeshInputTest::CPPUNIT_TEST ( testExodusDiscTwoElemIGA )

◆ CPPUNIT_TEST() [21/65]

MeshInputTest::CPPUNIT_TEST ( testExodusDiscWriteAddedSidesEdgeC0 )

◆ CPPUNIT_TEST() [22/65]

MeshInputTest::CPPUNIT_TEST ( testExodusDiscWriteAddedSidesHexC0 )

◆ CPPUNIT_TEST() [23/65]

MeshInputTest::CPPUNIT_TEST ( testExodusDiscWriteAddedSidesHexDisc )

◆ CPPUNIT_TEST() [24/65]

MeshInputTest::CPPUNIT_TEST ( testExodusDiscWriteAddedSidesMixedEdgeC0 )

◆ CPPUNIT_TEST() [25/65]

MeshInputTest::CPPUNIT_TEST ( testExodusDiscWriteAddedSidesMixedHexC0 )

◆ CPPUNIT_TEST() [26/65]

MeshInputTest::CPPUNIT_TEST ( testExodusDiscWriteAddedSidesMixedQuadC0 )

◆ CPPUNIT_TEST() [27/65]

MeshInputTest::CPPUNIT_TEST ( testExodusDiscWriteAddedSidesMixedTriC0 )

◆ CPPUNIT_TEST() [28/65]

MeshInputTest::CPPUNIT_TEST ( testExodusDiscWriteAddedSidesQuadC0 )

◆ CPPUNIT_TEST() [29/65]

MeshInputTest::CPPUNIT_TEST ( testExodusDiscWriteAddedSidesTriC0 )

◆ CPPUNIT_TEST() [30/65]

MeshInputTest::CPPUNIT_TEST ( testExodusFileMappingsCyl3d )

◆ CPPUNIT_TEST() [31/65]

MeshInputTest::CPPUNIT_TEST ( testExodusFileMappingsPlateWithHole )

◆ CPPUNIT_TEST() [32/65]

MeshInputTest::CPPUNIT_TEST ( testExodusFileMappingsTwoBlocks )

◆ CPPUNIT_TEST() [33/65]

MeshInputTest::CPPUNIT_TEST ( testExodusFileMappingsTwoElemIGA )

◆ CPPUNIT_TEST() [34/65]

MeshInputTest::CPPUNIT_TEST ( testExodusIGASidesets )

◆ CPPUNIT_TEST() [35/65]

MeshInputTest::CPPUNIT_TEST ( testExodusReadHeader )

◆ CPPUNIT_TEST() [36/65]

MeshInputTest::CPPUNIT_TEST ( testExodusSetElemUniqueIdsFromMaps )

◆ CPPUNIT_TEST() [37/65]

MeshInputTest::CPPUNIT_TEST ( testExodusSetNodeUniqueIdsFromMaps )

◆ CPPUNIT_TEST() [38/65]

MeshInputTest::CPPUNIT_TEST ( testExodusWriteAddedSidesEdgeC0 )

◆ CPPUNIT_TEST() [39/65]

MeshInputTest::CPPUNIT_TEST ( testExodusWriteAddedSidesHexC0 )

◆ CPPUNIT_TEST() [40/65]

MeshInputTest::CPPUNIT_TEST ( testExodusWriteAddedSidesHexDisc )

◆ CPPUNIT_TEST() [41/65]

MeshInputTest::CPPUNIT_TEST ( testExodusWriteAddedSidesMixedEdgeC0 )

◆ CPPUNIT_TEST() [42/65]

MeshInputTest::CPPUNIT_TEST ( testExodusWriteAddedSidesMixedHexC0 )

◆ CPPUNIT_TEST() [43/65]

MeshInputTest::CPPUNIT_TEST ( testExodusWriteAddedSidesMixedQuadC0 )

◆ CPPUNIT_TEST() [44/65]

MeshInputTest::CPPUNIT_TEST ( testExodusWriteAddedSidesMixedTriC0 )

◆ CPPUNIT_TEST() [45/65]

MeshInputTest::CPPUNIT_TEST ( testExodusWriteAddedSidesQuadC0 )

◆ CPPUNIT_TEST() [46/65]

MeshInputTest::CPPUNIT_TEST ( testExodusWriteAddedSidesTriC0 )

◆ CPPUNIT_TEST() [47/65]

MeshInputTest::CPPUNIT_TEST ( testExodusWriteElementDataFromDiscontinuousNodalData )

◆ CPPUNIT_TEST() [48/65]

MeshInputTest::CPPUNIT_TEST ( testGmshBCIDOverlap )

◆ CPPUNIT_TEST() [49/65]

MeshInputTest::CPPUNIT_TEST ( testGoodGmsh )

◆ CPPUNIT_TEST() [50/65]

MeshInputTest::CPPUNIT_TEST ( testGoodSTL )

◆ CPPUNIT_TEST() [51/65]

MeshInputTest::CPPUNIT_TEST ( testGoodSTLBinary )

◆ CPPUNIT_TEST() [52/65]

MeshInputTest::CPPUNIT_TEST ( testLowOrderEdgeBlocks )

◆ CPPUNIT_TEST() [53/65]

MeshInputTest::CPPUNIT_TEST ( testNemesisCopyElementSolutionDistributed )

◆ CPPUNIT_TEST() [54/65]

MeshInputTest::CPPUNIT_TEST ( testNemesisCopyElementSolutionReplicated )

◆ CPPUNIT_TEST() [55/65]

MeshInputTest::CPPUNIT_TEST ( testNemesisCopyElementVectorDistributed )

◆ CPPUNIT_TEST() [56/65]

MeshInputTest::CPPUNIT_TEST ( testNemesisCopyElementVectorReplicated )

◆ CPPUNIT_TEST() [57/65]

MeshInputTest::CPPUNIT_TEST ( testNemesisCopyNodalSolutionDistributed )

◆ CPPUNIT_TEST() [58/65]

MeshInputTest::CPPUNIT_TEST ( testNemesisCopyNodalSolutionReplicated )

◆ CPPUNIT_TEST() [59/65]

MeshInputTest::CPPUNIT_TEST ( testNemesisReadDistributed )

◆ CPPUNIT_TEST() [60/65]

MeshInputTest::CPPUNIT_TEST ( testNemesisReadReplicated )

◆ CPPUNIT_TEST() [61/65]

MeshInputTest::CPPUNIT_TEST ( testNemesisSingleElementDistributed )

◆ CPPUNIT_TEST() [62/65]

MeshInputTest::CPPUNIT_TEST ( testNemesisSingleElementReplicated )

◆ CPPUNIT_TEST() [63/65]

MeshInputTest::CPPUNIT_TEST ( testTetgenIO )

◆ CPPUNIT_TEST() [64/65]

MeshInputTest::CPPUNIT_TEST ( testVTKPreserveElemIds )

◆ CPPUNIT_TEST() [65/65]

MeshInputTest::CPPUNIT_TEST ( testVTKPreserveSubdomainIds )

◆ CPPUNIT_TEST_SUITE_END()

MeshInputTest::CPPUNIT_TEST_SUITE_END ( )

◆ helperTestingDynaQuad()

void MeshInputTest::helperTestingDynaQuad ( const MeshBase & mesh )

inline

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

221 {}

◆ tearDown()

void MeshInputTest::tearDown ( )

inline

Definition at line 223 of file mesh_input.C.

224 {}

◆ testAbaqusRead()

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

inline

Definition at line 1645 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 1664 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 1671 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 1700 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 717 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 885 of file mesh_input.C.

  {
    {
      MeshType mesh(*TestCommWorld);
 
      EquationSystems es(mesh);
      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));
 
      MeshTools::Generation::build_square (mesh,
                                           3, 3,
                                           0., 1., 0., 1.);
 
      es.init();
 
      // Here, we're going to manually set up the solution because the 'project_solution()' and
      // 'project_vector()' methods don't work so well with CONSTANT MONOMIAL_VEC variables. They
      // each lead to an error downstream asserting positive-definiteness when Cholesky decomposing.
      // Interestingly, the error is only invoked for CONSTANT MONOMIAL_VEC, and not, e.g.,
      // CONSTANT MONOMIAL nor FIRST LAGRANGE_VEC.
      //
      // Anyways, the important thing here is that we test the ExodusII and Nemesis writers, how
      // the solution is set is hardly important, and we're pretty much following the same
      // philosophy as the 'test2DProjectVectorFE()' unit tester in 'systems_test.C'
      Parameters params;
      for (const auto & elem : mesh.active_local_element_ptr_range())
      {
        const Point & p = elem->vertex_average();
 
        // Set the x-component with the value from 'six_x_plus_sixty_y()' and the y-component
        // with that from 'sin_x_plus_cos_y()' at the element centroid (vertex average)
        sys.current_local_solution->set(
          elem->dof_number(sys.number(), e_var, 0), six_x_plus_sixty_y(p, params, "", ""));
        sys.current_local_solution->set(
          elem->dof_number(sys.number(), e_var, 1), sin_x_plus_cos_y(p, params, "", ""));
        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 633 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 1971 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 2003 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 2023 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 1993 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 2013 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 1838 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 1678 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 1860 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 805 of file mesh_input.C.

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

◆ testExodusCopyElementSolutionReplicated()

void MeshInputTest::testExodusCopyElementSolutionReplicated ( )

inline

Definition at line 802 of file mesh_input.C.

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

◆ testExodusCopyElementVectorDistributed()

void MeshInputTest::testExodusCopyElementVectorDistributed ( )

inline

Definition at line 999 of file mesh_input.C.

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

◆ testExodusCopyElementVectorReplicated()

void MeshInputTest::testExodusCopyElementVectorReplicated ( )

inline

Definition at line 996 of file mesh_input.C.

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

◆ testExodusCopyNodalSolutionDistributed()

void MeshInputTest::testExodusCopyNodalSolutionDistributed ( )

inline

Definition at line 704 of file mesh_input.C.

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

◆ testExodusCopyNodalSolutionReplicated()

void MeshInputTest::testExodusCopyNodalSolutionReplicated ( )

inline

Definition at line 701 of file mesh_input.C.

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

◆ testExodusDiscCyl3d()

void MeshInputTest::testExodusDiscCyl3d ( )

inline

Definition at line 2155 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 2116 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 2134 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 2144 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 1371 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 1394 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 1495 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 1518 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 1383 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 1507 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 1451 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 1417 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 1439 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 1462 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 1473 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 1484 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 1405 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 1428 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 2033 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 2107 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 2078 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 2088 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 2097 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 542 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 462 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 431 of file mesh_input.C.

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

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 396 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 375 of file mesh_input.C.

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

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 339 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 1123 of file mesh_input.C.

                                            {},
     const std::vector<FEType> later_vars = {})
  {
    constexpr unsigned int nx = added_sides_nxyz[0],
                           ny = added_sides_nxyz[1],
                           nz = added_sides_nxyz[2];
 
    const unsigned int dim = Elem::type_to_dim_map[elem_type];
    const bool is_tensor = (Elem::build(elem_type)->n_sides() == dim * 2);
 
    // Figure out how many fake and true elements to expect
    dof_id_type n_fake_elem = 0;
    dof_id_type n_true_elem = 0;
 
    dof_id_type n_fake_nodes = 0;
    dof_id_type n_true_nodes = 0;
 
    const std::string filename =
      "side_discontinuous_"+Utility::enum_to_string<ElemType>(elem_type)+(write_discontinuous?"_disc":"")+".e";
 
    // first scope: write file
    {
      Mesh mesh(*TestCommWorld);
 
      EquationSystems es(mesh);
      System & sys = es.add_system<System> ("SimpleSystem");
      int varnum = 1;
      for (auto vartype : earlier_vars)
        sys.add_variable("earlier_"+std::to_string(varnum++), vartype);
 
      sys.add_variable("u", order, SIDE_HIERARCHIC);
 
      varnum = 1;
      for (auto vartype : later_vars)
        sys.add_variable("later_"+std::to_string(varnum++), vartype);
 
      if (dim == 3)
        MeshTools::Generation::build_cube
          (mesh, nx, ny, nz, 0., 1., 0., 1., 0., 1., elem_type);
      else if (dim == 2)
        MeshTools::Generation::build_square
          (mesh, nx, ny, 0., 1., 0., 1., elem_type);
      else
        MeshTools::Generation::build_line
          (mesh, nx, 0., 1., elem_type);
 
      n_true_elem = mesh.n_elem();
      n_true_nodes = mesh.n_nodes();
      CPPUNIT_ASSERT_LESS(n_true_nodes, n_true_elem); // Ne < Nn
 
      const unsigned int our_ny = dim>1 ? ny : 1;
      const unsigned int our_nz = dim>2 ? nz : 1;
 
      dof_id_type min_n_elem = nx * our_ny * our_nz;
      CPPUNIT_ASSERT_LESSEQUAL(n_true_elem, min_n_elem); // "backwards" API...
 
      for (const auto & elem : mesh.active_local_element_ptr_range())
        {
          for (auto s : make_range(elem->n_sides()))
          if (!elem->neighbor_ptr(s) || elem->neighbor_ptr(s)->id() < elem->id())
            {
              ++n_fake_elem;
              auto side = elem->build_side_ptr(s);
              n_fake_nodes += side->n_nodes();
            }
        }
      mesh.comm().sum(n_fake_elem);
      mesh.comm().sum(n_fake_nodes);
 
      const dof_id_type expected_fakes = [elem_type]() {
        switch (elem_type)
        {
          case EDGE3:
            return nx+1;
          case TRI6:
            return 3*nx*ny + nx + ny;
          case QUAD8:
          case QUAD9:
            return 2*nx*ny + nx + ny;
          case TET14:
            return 48*nx*ny*nz + 4*(nx*ny+nx*nz+ny*nz);
          case HEX27:
            return 3*nx*ny*nz + nx*ny + nx*nz + ny*nz;
          default:
            libmesh_error();
        }
      } (); // Invoke anonymous lambda
 
      CPPUNIT_ASSERT_EQUAL(n_fake_elem, expected_fakes); // "backwards" API...
 
      es.init();
      sys.project_solution(exact_sol, nullptr,
                           es.parameters);
 
      // Set solution u^e_i = i, for the ith vertex of a given element e.
 
      // Now write to file.
      ExodusII_IO exii(mesh);
      exii.write_added_sides(true);
 
      if (write_discontinuous)
        exii.write_discontinuous_equation_systems(filename, es);
      else
        exii.write_equation_systems(filename, es);
    } // end first scope
 
    // second scope: read file, verify extra elements exist
    {
      Mesh mesh(*TestCommWorld);
      mesh.allow_renumbering(false);
      ExodusII_IO exii(mesh);
 
      if (mesh.processor_id() == 0)
        exii.read(filename);
      MeshCommunication().broadcast(mesh);
      mesh.prepare_for_use();
 
      CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), n_true_elem + n_fake_elem);
      if (write_discontinuous)
        {
          const dof_id_type nodes_per_elem = Elem::build(elem_type)->n_nodes();
          CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(),
                               n_true_elem*nodes_per_elem + n_fake_nodes);
        }
      else
        CPPUNIT_ASSERT_EQUAL(mesh.n_nodes(), n_true_nodes + n_fake_nodes);
 
      EquationSystems es(mesh);
      System & sys = es.add_system<System> ("SimpleSystem");
      // Read back into a LAGRANGE variable for testing; we still
      // can't use Exodus for a proper restart.
      sys.add_variable("ul", SECOND);
      es.init();
 
      const DofMap & dof_map = sys.get_dof_map();
 
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
      exii.copy_nodal_solution(sys, "ul", "r_u");
#else
      exii.copy_nodal_solution(sys, "ul", "u");
#endif
 
      dof_id_type n_side_nodes = 0;
      const std::string nullstr;
      const std::string facestr = "face";
 
      // Debugging this in parallel is tricky.  Let's make sure that
      // if we have a failure on one rank we see it on all the others
      // and we can go on to other tests.
#ifdef LIBMESH_ENABLE_EXCEPTIONS
      bool threw_exception = false;
      try
#endif // LIBMESH_ENABLE_EXCEPTIONS
      {
      for (const auto & elem : mesh.active_local_element_ptr_range())
        {
          // Just look at side elements, not interiors
          if (elem->dim() == dim)
            continue;
 
          std::vector<dof_id_type> dof_indices;
          dof_map.dof_indices(elem, dof_indices, 0);
 
          // Find what face direction we're looking at, to
          // disambiguate when testing against a discontinuous
          // function, since we're evaluating on nodes that overlap
          // multiple faces
          const Point normal = [elem](){
            if (elem->dim() == 2)
              return Point((elem->point(1) - elem->point(0)).cross
                           (elem->point(2) - elem->point(0)));
            else if (elem->dim() == 1)
              return Point
                (elem->point(1)(1)-elem->point(0)(1),
                 elem->point(0)(0)-elem->point(1)(0));
            else
              return Point(1);
          } (); // Invoke anonymous lambda
 
          short faceval = -1;
          if (is_tensor)
            {
              if (std::abs(normal(0)) > TOLERANCE)
                {
                  faceval = 0;
                  libmesh_assert_less(std::abs(normal(1)), TOLERANCE);
                  libmesh_assert_less(std::abs(normal(2)), TOLERANCE);
                }
              else if (std::abs(normal(1)) > TOLERANCE)
                {
                  faceval = 1;
                  libmesh_assert_less(std::abs(normal(2)), TOLERANCE);
                }
              else
                {
                  faceval = 2;
                  libmesh_assert_greater(std::abs(normal(2)), TOLERANCE);
                }
              libmesh_assert_greater_equal(faceval, 0);
              es.parameters.set<short>(facestr) = faceval;
            }
 
          for (auto i : index_range(dof_indices))
            {
              const Point node_pt = elem->point(i);
              const Real nodal_coef =
                libmesh_real((*sys.current_local_solution)(dof_indices[i]));
              const Real exact_val =
                libmesh_real(exact_sol
                             (node_pt, es.parameters, nullstr,
                              nullstr));
              LIBMESH_ASSERT_FP_EQUAL
                (nodal_coef, exact_val,
                 std::max(Real(2),nodal_coef+exact_val)*
                 TOLERANCE*std::sqrt(TOLERANCE));
              ++n_side_nodes;
            }
        }
      }
#ifdef LIBMESH_ENABLE_EXCEPTIONS
      catch (...)
      {
        threw_exception = true;
        TestCommWorld->max(threw_exception);
        throw;
      }
      if (!threw_exception)
        TestCommWorld->max(threw_exception);
      CPPUNIT_ASSERT(!threw_exception);
#endif // LIBMESH_ENABLE_EXCEPTIONS
 
      TestCommWorld->sum(n_side_nodes);
      CPPUNIT_ASSERT_EQUAL(n_side_nodes, n_fake_nodes);
    } // end second scope
  } // end testExodusWriteAddedSides

◆ testExodusWriteAddedSidesEdgeC0()

void MeshInputTest::testExodusWriteAddedSidesEdgeC0 ( )

inline

Definition at line 1365 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 1389 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 1489 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 1513 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 1377 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 1501 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 1445 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 1411 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 1433 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 1457 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 1467 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 1479 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 1399 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 1423 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 1011 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 1741 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 1726 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 1767 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 1782 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 499 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 1560 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 812 of file mesh_input.C.

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

◆ testNemesisCopyElementSolutionReplicated()

void MeshInputTest::testNemesisCopyElementSolutionReplicated ( )

inline

Definition at line 809 of file mesh_input.C.

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

◆ testNemesisCopyElementVectorDistributed()

void MeshInputTest::testNemesisCopyElementVectorDistributed ( )

inline

Definition at line 1006 of file mesh_input.C.

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

◆ testNemesisCopyElementVectorReplicated()

void MeshInputTest::testNemesisCopyElementVectorReplicated ( )

inline

Definition at line 1003 of file mesh_input.C.

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

◆ testNemesisCopyNodalSolutionDistributed()

void MeshInputTest::testNemesisCopyNodalSolutionDistributed ( )

inline

Definition at line 711 of file mesh_input.C.

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

◆ testNemesisCopyNodalSolutionReplicated()

void MeshInputTest::testNemesisCopyNodalSolutionReplicated ( )

inline

Definition at line 708 of file mesh_input.C.

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

◆ testNemesisReadDistributed()

void MeshInputTest::testNemesisReadDistributed ( )

inline

Definition at line 1555 of file mesh_input.C.

1556 { LOG_UNIT_TEST; testNemesisReadImpl<DistributedMesh>(); }

◆ testNemesisReadImpl()

template<typename MeshType >

void MeshInputTest::testNemesisReadImpl ( )

inline

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

1553 { LOG_UNIT_TEST; testNemesisReadImpl<ReplicatedMesh>(); }

◆ testNemesisSingleElementDistributed()

void MeshInputTest::testNemesisSingleElementDistributed ( )

inline

Definition at line 874 of file mesh_input.C.

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

◆ testNemesisSingleElementReplicated()

void MeshInputTest::testNemesisSingleElementReplicated ( )

inline

Definition at line 871 of file mesh_input.C.

872 { 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 1924 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 820 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 1798 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 227 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 286 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().

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

tests/mesh/mesh_input.C

Public Member Functions

Detailed Description

Member Function Documentation

◆ CPPUNIT_TEST() [1/65]

◆ CPPUNIT_TEST() [2/65]

◆ CPPUNIT_TEST() [3/65]

◆ CPPUNIT_TEST() [4/65]

◆ CPPUNIT_TEST() [5/65]

◆ CPPUNIT_TEST() [6/65]

◆ CPPUNIT_TEST() [7/65]

◆ CPPUNIT_TEST() [8/65]

◆ CPPUNIT_TEST() [9/65]

◆ CPPUNIT_TEST() [10/65]

◆ CPPUNIT_TEST() [11/65]

◆ CPPUNIT_TEST() [12/65]

◆ CPPUNIT_TEST() [13/65]

◆ CPPUNIT_TEST() [14/65]

◆ CPPUNIT_TEST() [15/65]

◆ CPPUNIT_TEST() [16/65]

◆ CPPUNIT_TEST() [17/65]

◆ CPPUNIT_TEST() [18/65]

◆ CPPUNIT_TEST() [19/65]

◆ CPPUNIT_TEST() [20/65]

◆ CPPUNIT_TEST() [21/65]

◆ CPPUNIT_TEST() [22/65]

◆ CPPUNIT_TEST() [23/65]

◆ CPPUNIT_TEST() [24/65]

◆ CPPUNIT_TEST() [25/65]

◆ CPPUNIT_TEST() [26/65]

◆ CPPUNIT_TEST() [27/65]

◆ CPPUNIT_TEST() [28/65]

◆ CPPUNIT_TEST() [29/65]

◆ CPPUNIT_TEST() [30/65]

◆ CPPUNIT_TEST() [31/65]

◆ CPPUNIT_TEST() [32/65]

◆ CPPUNIT_TEST() [33/65]

◆ CPPUNIT_TEST() [34/65]

◆ CPPUNIT_TEST() [35/65]

◆ CPPUNIT_TEST() [36/65]

◆ CPPUNIT_TEST() [37/65]

◆ CPPUNIT_TEST() [38/65]

◆ CPPUNIT_TEST() [39/65]

◆ CPPUNIT_TEST() [40/65]

◆ CPPUNIT_TEST() [41/65]

◆ CPPUNIT_TEST() [42/65]

◆ CPPUNIT_TEST() [43/65]

◆ CPPUNIT_TEST() [44/65]

◆ CPPUNIT_TEST() [45/65]

◆ CPPUNIT_TEST() [46/65]

◆ CPPUNIT_TEST() [47/65]

◆ CPPUNIT_TEST() [48/65]

◆ CPPUNIT_TEST() [49/65]

◆ CPPUNIT_TEST() [50/65]

◆ CPPUNIT_TEST() [51/65]

◆ CPPUNIT_TEST() [52/65]

◆ CPPUNIT_TEST() [53/65]

◆ CPPUNIT_TEST() [54/65]

◆ CPPUNIT_TEST() [55/65]

◆ CPPUNIT_TEST() [56/65]

◆ CPPUNIT_TEST() [57/65]

◆ CPPUNIT_TEST() [58/65]

◆ CPPUNIT_TEST() [59/65]

◆ CPPUNIT_TEST() [60/65]

◆ CPPUNIT_TEST() [61/65]

◆ CPPUNIT_TEST() [62/65]

◆ CPPUNIT_TEST() [63/65]

◆ CPPUNIT_TEST() [64/65]

◆ CPPUNIT_TEST() [65/65]

◆ CPPUNIT_TEST_SUITE_END()

◆ helperTestingDynaQuad()

◆ LIBMESH_CPPUNIT_TEST_SUITE()

◆ setUp()

◆ tearDown()

◆ testAbaqusRead()

◆ testAbaqusReadFirst()

◆ testAbaqusReadSecond()

◆ testBadGmsh()

◆ testCopyElementSolutionImpl()

◆ testCopyElementVectorImpl()

◆ testCopyNodalSolutionImpl()