CheckpointIOTest Class Reference

Inheritance diagram for CheckpointIOTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (CheckpointIOTest)
	This test verifies that we can write files with the CheckpointIO object.
	CPPUNIT_TEST (testAsciiDistRepSplitter)
	CPPUNIT_TEST (testBinaryDistRepSplitter)
	CPPUNIT_TEST (testAsciiRepDistSplitter)
	CPPUNIT_TEST (testBinaryRepDistSplitter)
	CPPUNIT_TEST (testAsciiRepRepSplitter)
	CPPUNIT_TEST (testBinaryRepRepSplitter)
	CPPUNIT_TEST (testAsciiDistDistSplitter)
	CPPUNIT_TEST (testBinaryDistDistSplitter)
	CPPUNIT_TEST (testAsciiC0Polygon)
	CPPUNIT_TEST (testBinaryC0Polygon)
	CPPUNIT_TEST (testAsciiC0Polyhedron)
	CPPUNIT_TEST (testBinaryC0Polyhedron)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
template<typename MeshA , typename MeshB >
void	testSplitter (bool binary, bool using_distmesh, bool skip_partition=false)
void	testC0PolygonCheckpoint (bool binary)
void	testC0PolyhedronCheckpoint (bool binary)
void	testAsciiDistRepSplitter ()
void	testBinaryDistRepSplitter ()
void	testAsciiRepDistSplitter ()
void	testBinaryRepDistSplitter ()
void	testAsciiRepRepSplitter ()
void	testBinaryRepRepSplitter ()
void	testAsciiDistDistSplitter ()
void	testBinaryDistDistSplitter ()
void	testAsciiC0Polygon ()
void	testBinaryC0Polygon ()
void	testAsciiC0Polyhedron ()
void	testBinaryC0Polyhedron ()
void	testAsciiDistDistSplitterCache ()

Detailed Description

Definition at line 19 of file checkpoint.C.

Member Function Documentation

CPPUNIT_TEST() [1/12]

CheckpointIOTest::CPPUNIT_TEST

(

testAsciiC0Polygon

)

CPPUNIT_TEST() [2/12]

CheckpointIOTest::CPPUNIT_TEST

(

testAsciiC0Polyhedron

)

CPPUNIT_TEST() [3/12]

CheckpointIOTest::CPPUNIT_TEST

(

testAsciiDistDistSplitter

)

CPPUNIT_TEST() [4/12]

CheckpointIOTest::CPPUNIT_TEST

(

testAsciiDistRepSplitter

)

CPPUNIT_TEST() [5/12]

CheckpointIOTest::CPPUNIT_TEST

(

testAsciiRepDistSplitter

)

CPPUNIT_TEST() [6/12]

CheckpointIOTest::CPPUNIT_TEST

(

testAsciiRepRepSplitter

)

CPPUNIT_TEST() [7/12]

CheckpointIOTest::CPPUNIT_TEST

(

testBinaryC0Polygon

)

CPPUNIT_TEST() [8/12]

CheckpointIOTest::CPPUNIT_TEST

(

testBinaryC0Polyhedron

)

CPPUNIT_TEST() [9/12]

CheckpointIOTest::CPPUNIT_TEST

(

testBinaryDistDistSplitter

)

CPPUNIT_TEST() [10/12]

CheckpointIOTest::CPPUNIT_TEST

(

testBinaryDistRepSplitter

)

CPPUNIT_TEST() [11/12]

CheckpointIOTest::CPPUNIT_TEST

(

testBinaryRepDistSplitter

)

CPPUNIT_TEST() [12/12]

CheckpointIOTest::CPPUNIT_TEST

(

testBinaryRepRepSplitter

)

CPPUNIT_TEST_SUITE_END()

CheckpointIOTest::CPPUNIT_TEST_SUITE_END

(

)

LIBMESH_CPPUNIT_TEST_SUITE()

CheckpointIOTest::LIBMESH_CPPUNIT_TEST_SUITE

(

CheckpointIOTest

)

This test verifies that we can write files with the CheckpointIO object.

setUp()

void CheckpointIOTest::setUp ( )

inline

Definition at line 48 of file checkpoint.C.

  {
  }

tearDown()

void CheckpointIOTest::tearDown ( )

inline

Definition at line 52 of file checkpoint.C.

  {
  }

testAsciiC0Polygon()

void CheckpointIOTest::testAsciiC0Polygon ( )

inline

Definition at line 371 of file checkpoint.C.

  {
    LOG_UNIT_TEST;
 
    testC0PolygonCheckpoint(false);
  }

References testC0PolygonCheckpoint().

testAsciiC0Polyhedron()

void CheckpointIOTest::testAsciiC0Polyhedron ( )

inline

Definition at line 386 of file checkpoint.C.

  {
    LOG_UNIT_TEST;
 
    testC0PolyhedronCheckpoint(false);
  }

References testC0PolyhedronCheckpoint().

testAsciiDistDistSplitter()

void CheckpointIOTest::testAsciiDistDistSplitter ( )

inline

Definition at line 357 of file checkpoint.C.

  {
    LOG_UNIT_TEST;
 
    testSplitter<DistributedMesh, DistributedMesh>(false, true);
  }

testAsciiDistDistSplitterCache()

void CheckpointIOTest::testAsciiDistDistSplitterCache ( )

inline

Definition at line 401 of file checkpoint.C.

  {
    LOG_UNIT_TEST;
 
    testSplitter<DistributedMesh, DistributedMesh>(false, true, true);
  }

testAsciiDistRepSplitter()

void CheckpointIOTest::testAsciiDistRepSplitter ( )

inline

Definition at line 315 of file checkpoint.C.

  {
    LOG_UNIT_TEST;
 
    testSplitter<DistributedMesh, ReplicatedMesh>(false, true);
  }

testAsciiRepDistSplitter()

void CheckpointIOTest::testAsciiRepDistSplitter ( )

inline

Definition at line 329 of file checkpoint.C.

  {
    LOG_UNIT_TEST;
 
    testSplitter<ReplicatedMesh, DistributedMesh>(false, true);
  }

testAsciiRepRepSplitter()

void CheckpointIOTest::testAsciiRepRepSplitter ( )

inline

Definition at line 343 of file checkpoint.C.

  {
    LOG_UNIT_TEST;
 
    testSplitter<ReplicatedMesh, ReplicatedMesh>(false, false);
  }

testBinaryC0Polygon()

void CheckpointIOTest::testBinaryC0Polygon ( )

inline

Definition at line 378 of file checkpoint.C.

  {
    LOG_UNIT_TEST;
 
    testC0PolygonCheckpoint(true);
  }

References testC0PolygonCheckpoint().

testBinaryC0Polyhedron()

void CheckpointIOTest::testBinaryC0Polyhedron ( )

inline

Definition at line 393 of file checkpoint.C.

  {
    LOG_UNIT_TEST;
 
    testC0PolyhedronCheckpoint(true);
  }

References testC0PolyhedronCheckpoint().

testBinaryDistDistSplitter()

void CheckpointIOTest::testBinaryDistDistSplitter ( )

inline

Definition at line 364 of file checkpoint.C.

  {
    LOG_UNIT_TEST;
 
    testSplitter<DistributedMesh, DistributedMesh>(true, true);
  }

testBinaryDistRepSplitter()

void CheckpointIOTest::testBinaryDistRepSplitter ( )

inline

Definition at line 322 of file checkpoint.C.

  {
    LOG_UNIT_TEST;
 
    testSplitter<DistributedMesh, ReplicatedMesh>(true, true);
  }

testBinaryRepDistSplitter()

void CheckpointIOTest::testBinaryRepDistSplitter ( )

inline

Definition at line 336 of file checkpoint.C.

  {
    LOG_UNIT_TEST;
 
    testSplitter<ReplicatedMesh, DistributedMesh>(true, true);
  }

testBinaryRepRepSplitter()

void CheckpointIOTest::testBinaryRepRepSplitter ( )

inline

Definition at line 350 of file checkpoint.C.

  {
    LOG_UNIT_TEST;
 
    testSplitter<ReplicatedMesh, ReplicatedMesh>(true, false);
  }

testC0PolygonCheckpoint()

void CheckpointIOTest::testC0PolygonCheckpoint ( bool  binary )

inline

Definition at line 141 of file checkpoint.C.

  {
#ifdef LIBMESH_HAVE_XDR
    // Parallel element packing does not yet support runtime topology,
    // so exercise serial CheckpointIO independently on rank 0.
    if (TestCommWorld->rank() != 0)
      return;
 
    Parallel::Communicator comm_self;
    const std::string filename =
      std::string("checkpoint_c0polygon.cp") + (binary ? "r" : "a");
    const std::vector<Point> points =
      {{0., 0.}, {1., 0.}, {1.5, 0.5}, {1., 1.}, {0., 1.}};
 
    {
      Mesh mesh(comm_self, 2);
      mesh.allow_renumbering(false);
 
      auto polygon =
        std::make_unique<C0Polygon>(cast_int<unsigned int>(points.size()));
      polygon->set_id() = 0;
      for (auto n : index_range(points))
        polygon->set_node(n, mesh.add_point(points[n], n));
 
      mesh.add_elem(std::move(polygon));
      mesh.prepare_for_use();
 
      CheckpointIO checkpoint(mesh, binary);
      checkpoint.write(filename);
    }
 
    {
      Mesh mesh(comm_self);
      CheckpointIO checkpoint(mesh, binary);
      checkpoint.read(filename);
 
      CPPUNIT_ASSERT_EQUAL(dof_id_type(1), mesh.n_elem());
      CPPUNIT_ASSERT_EQUAL(dof_id_type(5), mesh.n_nodes());
      CPPUNIT_ASSERT_EQUAL(2u, static_cast<unsigned int>(mesh.mesh_dimension()));
 
      const Elem * elem = mesh.query_elem_ptr(0);
      bool found_elem = elem;
      mesh.comm().max(found_elem);
      CPPUNIT_ASSERT(found_elem);
 
      if (elem)
        {
          CPPUNIT_ASSERT_EQUAL(C0POLYGON, elem->type());
          CPPUNIT_ASSERT_EQUAL(5u, elem->n_nodes());
          CPPUNIT_ASSERT_EQUAL(5u, elem->n_vertices());
          CPPUNIT_ASSERT_EQUAL(5u, elem->n_sides());
          CPPUNIT_ASSERT_EQUAL(5u, elem->n_edges());
 
          for (auto n : index_range(points))
            {
              CPPUNIT_ASSERT_EQUAL(cast_int<dof_id_type>(n), elem->node_id(n));
              CPPUNIT_ASSERT_EQUAL(points[n], elem->point(n));
 
              const auto side_nodes = elem->nodes_on_side(n);
              CPPUNIT_ASSERT_EQUAL(std::size_t(2), side_nodes.size());
              CPPUNIT_ASSERT_EQUAL(cast_int<unsigned int>(n), side_nodes[0]);
              CPPUNIT_ASSERT_EQUAL
                (cast_int<unsigned int>((n + 1) % points.size()), side_nodes[1]);
            }
        }
    }
 
    CheckpointIO::cleanup(filename, 1);
#endif // LIBMESH_HAVE_XDR
  }

References libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::MeshBase::allow_renumbering(), libMesh::C0POLYGON, libMesh::CheckpointIO::cleanup(), libMesh::ParallelObject::comm(), libMesh::index_range(), libMesh::Parallel::Communicator::max(), mesh, libMesh::MeshBase::mesh_dimension(), libMesh::Elem::n_edges(), libMesh::MeshBase::n_elem(), libMesh::Elem::n_nodes(), libMesh::MeshBase::n_nodes(), libMesh::Elem::n_sides(), libMesh::Elem::n_vertices(), libMesh::Elem::node_id(), libMesh::Elem::nodes_on_side(), libMesh::Elem::point(), libMesh::MeshBase::prepare_for_use(), libMesh::MeshBase::query_elem_ptr(), libMesh::CheckpointIO::read(), TestCommWorld, libMesh::Elem::type(), and libMesh::CheckpointIO::write().

Referenced by testAsciiC0Polygon(), and testBinaryC0Polygon().

testC0PolyhedronCheckpoint()

void CheckpointIOTest::testC0PolyhedronCheckpoint ( bool  binary )

inline

Definition at line 213 of file checkpoint.C.

  {
#ifdef LIBMESH_HAVE_XDR
    // Parallel element packing does not yet support runtime topology,
    // so exercise serial CheckpointIO independently on rank 0.
    if (TestCommWorld->rank() != 0)
      return;
 
    Parallel::Communicator comm_self;
    const std::string filename =
      std::string("checkpoint_c0polyhedron.cp") + (binary ? "r" : "a");
    const std::vector<Point> points =
      {{0., -2., 0.}, {-1., -1., 0.}, {-1., 1., 0.},
       {0., 2., 0.}, {1., 1., 0.}, {1., -1., 0.},
       {0., -2., 1.}, {-1., -1., 1.}, {-1., 1., 1.},
       {0., 2., 1.}, {1., 1., 1.}, {1., -1., 1.}};
    const std::vector<std::vector<unsigned int>> nodes_on_sides =
      {{0, 1, 2, 3, 4, 5},
       {0, 1, 7, 6},
       {1, 2, 8, 7},
       {2, 3, 9, 8},
       {3, 4, 10, 9},
       {4, 5, 11, 10},
       {5, 0, 6, 11},
       {6, 7, 8, 9, 10, 11}};
 
    {
      Mesh mesh(comm_self, 3);
      mesh.allow_renumbering(false);
      for (auto n : index_range(points))
        mesh.add_point(points[n], n);
 
      std::vector<std::shared_ptr<Polygon>> sides(nodes_on_sides.size());
      for (auto s : index_range(nodes_on_sides))
        {
          const auto & side_nodes = nodes_on_sides[s];
          auto side =
            std::make_shared<C0Polygon>
              (cast_int<unsigned int>(side_nodes.size()));
          for (auto n : index_range(side_nodes))
            side->set_node(n, mesh.node_ptr(side_nodes[n]));
          sides[s] = std::move(side);
        }
 
      std::unique_ptr<Node> mid_elem_node;
      auto polyhedron =
        std::make_unique<C0Polyhedron>(sides, mid_elem_node);
      CPPUNIT_ASSERT(mid_elem_node);
 
      // Explicit id so DistributedMesh matches ReplicatedMesh
      mid_elem_node->set_id(points.size());
 
      mesh.add_node(std::move(mid_elem_node));
      polyhedron->set_id() = 0;
      mesh.add_elem(std::move(polyhedron));
      mesh.prepare_for_use();
 
      CheckpointIO checkpoint(mesh, binary);
      checkpoint.write(filename);
    }
 
    {
      Mesh mesh(comm_self);
      CheckpointIO checkpoint(mesh, binary);
      checkpoint.read(filename);
 
      CPPUNIT_ASSERT_EQUAL(dof_id_type(1), mesh.n_elem());
      CPPUNIT_ASSERT_EQUAL(dof_id_type(13), mesh.n_nodes());
      CPPUNIT_ASSERT_EQUAL(3u, static_cast<unsigned int>(mesh.mesh_dimension()));
 
      const Elem * elem = mesh.query_elem_ptr(0);
      bool found_elem = elem;
      mesh.comm().max(found_elem);
      CPPUNIT_ASSERT(found_elem);
 
      if (elem)
        {
          CPPUNIT_ASSERT_EQUAL(C0POLYHEDRON, elem->type());
          CPPUNIT_ASSERT_EQUAL(12u, elem->n_vertices());
          CPPUNIT_ASSERT_EQUAL(13u, elem->n_nodes());
          CPPUNIT_ASSERT_EQUAL(8u, elem->n_sides());
          CPPUNIT_ASSERT_EQUAL(18u, elem->n_edges());
          CPPUNIT_ASSERT_EQUAL(dof_id_type(12),
                               elem->node_id(elem->n_vertices()));
 
          for (auto s : index_range(nodes_on_sides))
            {
              const auto side_nodes = elem->nodes_on_side(s);
              CPPUNIT_ASSERT_EQUAL(nodes_on_sides[s].size(), side_nodes.size());
              for (auto n : index_range(side_nodes))
                CPPUNIT_ASSERT_EQUAL
                  (cast_int<dof_id_type>(nodes_on_sides[s][n]),
                   elem->node_id(side_nodes[n]));
            }
        }
    }
 
    CheckpointIO::cleanup(filename, 1);
#endif // LIBMESH_HAVE_XDR
  }

References libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_node(), libMesh::MeshBase::add_point(), libMesh::MeshBase::allow_renumbering(), libMesh::C0POLYHEDRON, libMesh::CheckpointIO::cleanup(), libMesh::ParallelObject::comm(), libMesh::index_range(), libMesh::Parallel::Communicator::max(), mesh, libMesh::MeshBase::mesh_dimension(), libMesh::Elem::n_edges(), libMesh::MeshBase::n_elem(), libMesh::Elem::n_nodes(), libMesh::MeshBase::n_nodes(), libMesh::Elem::n_sides(), libMesh::Elem::n_vertices(), libMesh::Elem::node_id(), libMesh::MeshBase::node_ptr(), libMesh::Elem::nodes_on_side(), libMesh::MeshBase::prepare_for_use(), libMesh::MeshBase::query_elem_ptr(), libMesh::CheckpointIO::read(), libMesh::DofObject::set_id(), TestCommWorld, libMesh::Elem::type(), and libMesh::CheckpointIO::write().

Referenced by testAsciiC0Polyhedron(), and testBinaryC0Polyhedron().

testSplitter()

template<typename MeshA , typename MeshB >

void CheckpointIOTest::testSplitter ( bool  binary, bool  using_distmesh, bool  skip_partition = false  )

inline

Definition at line 58 of file checkpoint.C.

  {
    // The CheckpointIO-based splitter requires XDR.
#ifdef LIBMESH_HAVE_XDR
 
    // In this test, we partition the mesh into n_procs parts.  Don't
    // try to partition a DistributedMesh into more parts than we have
    // processors, though.
    const unsigned int n_procs = using_distmesh ?
      std::min(static_cast<processor_id_type>(2), TestCommWorld->size()) :
      2;
 
    // The number of elements in the original mesh.  For verification
    // later.
    dof_id_type original_n_elem = 0;
 
    const std::string filename =
      std::string("checkpoint_splitter.cp") + (binary ? "r" : "a");
 
    {
      MeshA mesh(*TestCommWorld);
 
      MeshTools::Generation::build_square(mesh,
                                          4,  4,
                                          0., 1.,
                                          0., 1.,
                                          QUAD4);
 
      // Store the number of elements that were in the original mesh.
      original_n_elem = mesh.n_elem();
 
      // Partition the mesh into n_procs pieces
      mesh.partition(n_procs);
 
      // Write out checkpoint files for each piece.  Since on a
      // ReplicatedMesh we might have more pieces than we do
      // processors, some processors may have to write out more than
      // one piece.
      CheckpointIO cpr(mesh);
      cpr.current_processor_ids().clear();
      for (processor_id_type pid = mesh.processor_id(); pid < n_procs; pid += mesh.n_processors())
        cpr.current_processor_ids().push_back(pid);
      cpr.current_n_processors() = n_procs;
      cpr.binary() = binary;
      cpr.parallel() = true;
      cpr.write(filename);
    }
 
    TestCommWorld->barrier();
 
    // Test that we can read in the files we wrote and sum up to the
    // same total number of elements.
    {
      MeshB mesh(*TestCommWorld);
      if (skip_partition)
        mesh.skip_partitioning(true);
 
      CheckpointIO cpr(mesh);
      cpr.current_n_processors() = n_procs;
      cpr.binary() = binary;
      cpr.read(filename);
 
      // If we decided to skip partitioning, then we shouldn't be
      // waiting for a partition() call to get our n_partitions()
      // cache in order
      if (skip_partition)
        CPPUNIT_ASSERT_EQUAL(mesh.n_partitions(), n_procs);
 
      std::size_t read_in_elements = 0;
 
      for (unsigned pid=mesh.processor_id(); pid<n_procs; pid += mesh.n_processors())
        {
          read_in_elements += std::distance(mesh.pid_elements_begin(pid),
                                            mesh.pid_elements_end(pid));
        }
      mesh.comm().sum(read_in_elements);
 
      // Verify that we read in exactly as many elements as we started with.
      CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(read_in_elements), original_n_elem);
    }
#endif // LIBMESH_HAVE_XDR
  }

References libMesh::CheckpointIO::binary(), libMesh::MeshTools::Generation::build_square(), libMesh::ParallelObject::comm(), libMesh::CheckpointIO::current_n_processors(), libMesh::CheckpointIO::current_processor_ids(), mesh, libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_partitions(), libMesh::ParallelObject::n_processors(), libMesh::CheckpointIO::parallel(), libMesh::MeshBase::partition(), libMesh::ParallelObject::processor_id(), libMesh::QUAD4, libMesh::CheckpointIO::read(), libMesh::MeshBase::skip_partitioning(), libMesh::Parallel::Communicator::sum(), TestCommWorld, and libMesh::CheckpointIO::write().

---

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

• tests/mesh/checkpoint.C