MeshAssignTest Class Reference

Inheritance diagram for MeshAssignTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (MeshAssignTest)
	This test verifies the operations of the move assignment operator for MeshBase and derived classes. More...
	CPPUNIT_TEST (testMeshMoveAssignFromMemory)
	CPPUNIT_TEST (testReplicatedMeshMoveAssignFromMemory)
	CPPUNIT_TEST (testDistributedMeshMoveAssignFromMemory)
	CPPUNIT_TEST (testMeshMoveAssignFromFile)
	CPPUNIT_TEST (testReplicatedMeshMoveAssignFromFile)
	CPPUNIT_TEST (testDistributedMeshMoveAssignFromFile)
	CPPUNIT_TEST (testReplicatedMeshConstructFromReplicated)
	CPPUNIT_TEST (testReplicatedMeshConstructFromDistributed)
	CPPUNIT_TEST (testDistributedMeshConstructFromReplicated)
	CPPUNIT_TEST (testDistributedMeshConstructFromDistributed)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
void	testMeshMoveAssign (const std::string &mesh_type, const std::string &mesh_creation_type)
template<class SrcClass , class DestClass >
void	testCopyConstruct ()
void	testMeshMoveAssignFromMemory ()
void	testReplicatedMeshMoveAssignFromMemory ()
void	testDistributedMeshMoveAssignFromMemory ()
void	testMeshMoveAssignFromFile ()
void	testReplicatedMeshMoveAssignFromFile ()
void	testDistributedMeshMoveAssignFromFile ()
void	testReplicatedMeshConstructFromReplicated ()
void	testReplicatedMeshConstructFromDistributed ()
void	testDistributedMeshConstructFromReplicated ()
void	testDistributedMeshConstructFromDistributed ()

Detailed Description

Definition at line 22 of file mesh_assign.C.

Member Function Documentation

CPPUNIT_TEST() [1/10]

MeshAssignTest::CPPUNIT_TEST

(

testMeshMoveAssignFromMemory

)

CPPUNIT_TEST() [2/10]

MeshAssignTest::CPPUNIT_TEST

(

testReplicatedMeshMoveAssignFromMemory

)

CPPUNIT_TEST() [3/10]

MeshAssignTest::CPPUNIT_TEST

(

testDistributedMeshMoveAssignFromMemory

)

CPPUNIT_TEST() [4/10]

MeshAssignTest::CPPUNIT_TEST

(

testMeshMoveAssignFromFile

)

CPPUNIT_TEST() [5/10]

MeshAssignTest::CPPUNIT_TEST

(

testReplicatedMeshMoveAssignFromFile

)

CPPUNIT_TEST() [6/10]

MeshAssignTest::CPPUNIT_TEST

(

testDistributedMeshMoveAssignFromFile

)

CPPUNIT_TEST() [7/10]

MeshAssignTest::CPPUNIT_TEST

(

testReplicatedMeshConstructFromReplicated

)

CPPUNIT_TEST() [8/10]

MeshAssignTest::CPPUNIT_TEST

(

testReplicatedMeshConstructFromDistributed

)

CPPUNIT_TEST() [9/10]

MeshAssignTest::CPPUNIT_TEST

(

testDistributedMeshConstructFromReplicated

)

CPPUNIT_TEST() [10/10]

MeshAssignTest::CPPUNIT_TEST

(

testDistributedMeshConstructFromDistributed

)

CPPUNIT_TEST_SUITE_END()

MeshAssignTest::CPPUNIT_TEST_SUITE_END

(

)

LIBMESH_CPPUNIT_TEST_SUITE()

MeshAssignTest::LIBMESH_CPPUNIT_TEST_SUITE

(

MeshAssignTest

)

This test verifies the operations of the move assignment operator for MeshBase and derived classes.

Future extensions can include copy assignment, move and copy constructors.

setUp()

void MeshAssignTest::setUp ( )

inline

Definition at line 51 of file mesh_assign.C.

  {
  }

tearDown()

void MeshAssignTest::tearDown ( )

inline

Definition at line 55 of file mesh_assign.C.

  {
  }

testCopyConstruct()

template<class SrcClass , class DestClass >

void MeshAssignTest::testCopyConstruct ( )

inline

Definition at line 221 of file mesh_assign.C.

References libMesh::MeshTools::Generation::build_square(), TIMPI::Communicator::sum(), TestCommWorld, and TIMPI::Communicator::verify().

  {
    SrcClass src_mesh(*TestCommWorld);

    MeshTools::Generation::build_square(src_mesh, 4, 4);

    DestClass dest_mesh(src_mesh);

    // Check for consistency
    CPPUNIT_ASSERT(TestCommWorld->verify(dest_mesh.n_elem()));
    CPPUNIT_ASSERT(TestCommWorld->verify(dest_mesh.n_nodes()));
    dof_id_type n_dest_elem = dest_mesh.n_local_elem();
    TestCommWorld->sum(n_dest_elem);
    dof_id_type n_dest_nodes = dest_mesh.n_local_nodes();
    TestCommWorld->sum(n_dest_nodes);
    CPPUNIT_ASSERT_EQUAL(n_dest_elem, dest_mesh.n_elem());
    CPPUNIT_ASSERT_EQUAL(n_dest_nodes, dest_mesh.n_nodes());
    CPPUNIT_ASSERT_EQUAL(src_mesh.n_elem(), dest_mesh.n_elem());
    CPPUNIT_ASSERT_EQUAL(src_mesh.n_nodes(), dest_mesh.n_nodes());
  }

testDistributedMeshConstructFromDistributed()

void MeshAssignTest::testDistributedMeshConstructFromDistributed ( )

inline

Definition at line 269 of file mesh_assign.C.

  { LOG_UNIT_TEST; testCopyConstruct<DistributedMesh, DistributedMesh>(); }

testDistributedMeshConstructFromReplicated()

void MeshAssignTest::testDistributedMeshConstructFromReplicated ( )

inline

Definition at line 266 of file mesh_assign.C.

  { LOG_UNIT_TEST; testCopyConstruct<ReplicatedMesh, DistributedMesh>(); }

testDistributedMeshMoveAssignFromFile()

void MeshAssignTest::testDistributedMeshMoveAssignFromFile ( )

inline

Definition at line 257 of file mesh_assign.C.

  { LOG_UNIT_TEST; testMeshMoveAssign("distributed", "from_file"); }

testDistributedMeshMoveAssignFromMemory()

void MeshAssignTest::testDistributedMeshMoveAssignFromMemory ( )

inline

Definition at line 248 of file mesh_assign.C.

  { LOG_UNIT_TEST; testMeshMoveAssign("distributed", "from_memory"); }

testMeshMoveAssign()

void MeshAssignTest::testMeshMoveAssign ( const std::string &  mesh_type, const std::string &  mesh_creation_type  )

inline

Build a 2d 2x2 square mesh (mesh_one) covering [0.0, 1.0] x [0.0, 1.0] with linear Quad elements. A new mesh will later be moved to this same object using MeshBase::operator = (&&).

Create an ES based on the mesh, with a single variable. We will set non-homogenous bc u = 1.0 on the bottom and right sides of the mesh. After moving a new mesh into mesh_one, we will verify that u is projected properly onto the new mesh_one topology.

Build another 2d 2x2 square mesh (mesh_two) covering [0.0, 1.0] x [0.0, 1.0] with linear Quad elements. We will later refine this mesh and replace mesh_one with it.

Definition at line 59 of file mesh_assign.C.

References libMesh::DofMap::add_dirichlet_boundary(), libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshBase::assign(), libMesh::MeshTools::Generation::build_square(), libMesh::MeshBase::clear(), libMesh::FIRST, libMesh::System::get_dof_map(), libMesh::System::get_equation_systems(), libMesh::System::get_mesh(), libMesh::EquationSystems::init(), libMesh::MeshBase::n_elem(), libMesh::QUAD4, libMesh::QUAD9, libMesh::EquationSystems::reinit(), libMesh::EquationSystems::reinit_mesh(), and libMesh::MeshBase::write().

  {
    // Create two mesh ptrs.
    std::shared_ptr<UnstructuredMesh> mesh_one;
    std::shared_ptr<UnstructuredMesh> mesh_two;

       if (mesh_type.compare("Mesh") == 0)
       {
        mesh_one = std::make_shared<Mesh>(*TestCommWorld);
       }
       else if (mesh_type.compare("replicated") == 0)
       {
        mesh_one = std::make_shared<ReplicatedMesh>(*TestCommWorld);
       }
       else if (mesh_type.compare("distributed") == 0)
       {
        mesh_one = std::make_shared<DistributedMesh>(*TestCommWorld);
       }
       else
       {
        libmesh_error_msg("Error: specified mesh_type not understood");
       }

       MeshTools::Generation::build_square(*mesh_one,
                                          2, 2,
                                          0., 1.,
                                          0., 1.,
                                          QUAD9);

       // build_square adds boundary_ids 0,1,2,3 for the bottom, right,
       // top, and left sides, respectively.

       EquationSystems es(*mesh_one);
       System & system = es.add_system<System> ("SimpleSystem");
       system.add_variable("u", FIRST);

       // Now set the Dirichlet bcs: u = 1.0, when boundary id = 0 and 1.
       // The function describing the boundary value
       ConstFunction<Number> one(1.0);

       // The boundary ids of the boundaries where the value is to be set.
       const boundary_id_type all_bdry_ids[4] = {0, 1, 2, 3};
       const std::set<boundary_id_type> bottom_right_bdry_ids(all_bdry_ids, all_bdry_ids + 1);

       // The variables for which we are defining the bc.
       std::vector<unsigned int> variables = {0};
       variables.push_back(0);

       DirichletBoundary dirichlet_bc(bottom_right_bdry_ids, variables, &one);

       system.get_dof_map().add_dirichlet_boundary(dirichlet_bc);

       es.init();

       if (mesh_type.compare("Mesh") == 0)
       {
        mesh_two = std::make_shared<Mesh>(*TestCommWorld);
       }
       else if (mesh_type.compare("replicated") == 0)
       {
        mesh_two = std::make_shared<ReplicatedMesh>(*TestCommWorld);
       }
       else if (mesh_type.compare("distributed") == 0)
       {
        mesh_two = std::make_shared<DistributedMesh>(*TestCommWorld);
       }
       else
       {
        libmesh_error_msg("Error: specified mesh_type not understood");
       }

#ifdef LIBMESH_ENABLE_AMR // We refine or read refined meshes for this test
       if(mesh_creation_type.compare("from_memory") == 0)
       {
          MeshTools::Generation::build_square(*mesh_two,
                                              2, 2,
                                              0., 1.,
                                              0., 1.,
                                              QUAD4);

          // Uniformly refine mesh_two
          std::unique_ptr<MeshRefinement> mesh_refinement(std::make_unique<MeshRefinement>(*mesh_two));

          mesh_refinement->uniformly_refine(1);

          std::unique_ptr<MeshBase> mesh_two_clone =
            mesh_two->clone();

          // Move mesh_two into mesh_one
          system.get_mesh().clear();
          system.get_mesh().assign(std::move(*mesh_two));
          mesh_two->clear();

          // Assert that the moved into mesh has the right number of elements.
          CPPUNIT_ASSERT_EQUAL(system.get_mesh().n_elem(), static_cast<dof_id_type>(20));

          CPPUNIT_ASSERT(system.get_mesh() == *mesh_two_clone);

          // Reinit the dofs and other system related data structures
          // based on its mesh
          system.get_equation_systems().reinit_mesh();

          // Reinit
          system.get_equation_systems().reinit();

          // Write out the mesh xda, this currently fails with DistributedMesh,
          // running on more than 8 processors, when the mesh to be moved in is
          // read from a file.
          system.get_mesh().write("mesh.out.memory.moved.xda");

          system.get_mesh().clear();
        }
        else if (mesh_creation_type.compare("from_file") == 0)
        {
          mesh_two->read("meshes/mesh_assign_test_mesh.xda");

          std::unique_ptr<MeshBase> mesh_two_clone =
            mesh_two->clone();

          system.get_mesh().clear();
          system.get_mesh().assign(std::move(*mesh_two));

          mesh_two->clear();

          // Assert that the moved into mesh has the right number of elements.
          CPPUNIT_ASSERT_EQUAL(system.get_mesh().n_elem(), static_cast<dof_id_type>(42));

          CPPUNIT_ASSERT(system.get_mesh() == *mesh_two_clone);

          system.get_equation_systems().reinit_mesh();
          system.get_equation_systems().reinit();

          system.get_mesh().write("mesh.out.file.moved.xda");

          system.get_mesh().clear();
        }
         else
        {
         libmesh_error_msg("Error: invalid mesh two case type.");
        }
#endif // LIBMESH_ENABLE_AMR
  }

testMeshMoveAssignFromFile()

void MeshAssignTest::testMeshMoveAssignFromFile ( )

inline

Definition at line 251 of file mesh_assign.C.

  { LOG_UNIT_TEST; testMeshMoveAssign("Mesh", "from_file"); }

testMeshMoveAssignFromMemory()

void MeshAssignTest::testMeshMoveAssignFromMemory ( )

inline

Definition at line 242 of file mesh_assign.C.

  { LOG_UNIT_TEST; testMeshMoveAssign("Mesh", "from_memory"); }

testReplicatedMeshConstructFromDistributed()

void MeshAssignTest::testReplicatedMeshConstructFromDistributed ( )

inline

Definition at line 263 of file mesh_assign.C.

  { LOG_UNIT_TEST; testCopyConstruct<DistributedMesh, ReplicatedMesh>(); }

testReplicatedMeshConstructFromReplicated()

void MeshAssignTest::testReplicatedMeshConstructFromReplicated ( )

inline

Definition at line 260 of file mesh_assign.C.

  { LOG_UNIT_TEST; testCopyConstruct<ReplicatedMesh, ReplicatedMesh>(); }

testReplicatedMeshMoveAssignFromFile()

void MeshAssignTest::testReplicatedMeshMoveAssignFromFile ( )

inline

Definition at line 254 of file mesh_assign.C.

  { LOG_UNIT_TEST; testMeshMoveAssign("replicated", "from_file"); }

testReplicatedMeshMoveAssignFromMemory()

void MeshAssignTest::testReplicatedMeshMoveAssignFromMemory ( )

inline

Definition at line 245 of file mesh_assign.C.

  { LOG_UNIT_TEST; testMeshMoveAssign("replicated", "from_memory"); }

---

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

• tests/mesh/mesh_assign.C