PartitionerTest< PartitionerSubclass, MeshClass > Class Template Reference

#include <partitioner_test.h>

Inheritance diagram for PartitionerTest< PartitionerSubclass, MeshClass >:

Public Member Functions
void	setUp ()
void	tearDown ()
void	testBuild ()
void	testPartition (processor_id_type n_parts)
void	testPartitionEmpty ()
void	testPartition1 ()
void	testPartition2 ()
void	testPartitionNProc ()

Protected Attributes
std::string	libmesh_suite_name

Detailed Description

template<typename PartitionerSubclass, typename MeshClass>
class PartitionerTest< PartitionerSubclass, MeshClass >

Definition at line 28 of file partitioner_test.h.

Member Function Documentation

setUp()

template<typename PartitionerSubclass , typename MeshClass >

void PartitionerTest< PartitionerSubclass, MeshClass >::setUp ( )

inline

Definition at line 34 of file partitioner_test.h.

  {}

tearDown()

template<typename PartitionerSubclass , typename MeshClass >

void PartitionerTest< PartitionerSubclass, MeshClass >::tearDown ( )

inline

Definition at line 37 of file partitioner_test.h.

  {}

testBuild()

template<typename PartitionerSubclass , typename MeshClass >

void PartitionerTest< PartitionerSubclass, MeshClass >::testBuild ( )

inline

Definition at line 40 of file partitioner_test.h.

References libMesh::Partitioner::build().

  {
    PartitionerSubclass myclass;

    PartitionerType type = myclass.type();

    auto new_build = Partitioner::build(type);

    CPPUNIT_ASSERT_EQUAL(new_build->type(), type);
  }

testPartition()

template<typename PartitionerSubclass , typename MeshClass >

void PartitionerTest< PartitionerSubclass, MeshClass >::testPartition ( processor_id_type  n_parts )

inline

Definition at line 51 of file partitioner_test.h.

References libMesh::MeshBase::allgather(), libMesh::MeshTools::Generation::build_cube(), distance(), libMesh::HEX8, mesh, and TestCommWorld.

  {
    MeshClass mesh(*TestCommWorld);

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

    // FIXME: Splitting meshes into more than n_proc parts currently
    // requires us to start with a mesh entirely assigned to proc 0
    PartitionerSubclass newpart;
    newpart.partition(mesh, 1);

    for (auto elem : mesh.element_ptr_range())
      CPPUNIT_ASSERT_EQUAL(elem->processor_id(), processor_id_type(0));

    for (auto node : mesh.node_ptr_range())
      CPPUNIT_ASSERT_EQUAL(node->processor_id(), processor_id_type(0));

    // But then we can manually partition, into at most many parts as
    // were requested.
    newpart.partition(mesh, n_parts);

    // We expect the partitioner not to suck - every processor
    // rank (up to n_elem()) ought to have at least one element on it.
    const processor_id_type n_nonempty =
      std::min(n_parts, processor_id_type(3*3*3));

    // Let's make sure we can see them all even on a DistributedMesh
    mesh.allgather();

    processor_id_type nonempty_procs = 0;
    for (processor_id_type p=0; p != n_nonempty; ++p)
      {
        const std::size_t n_elem_on_p =
          std::distance(mesh.pid_elements_begin(p),
                        mesh.pid_elements_end(p));
        if (n_elem_on_p)
          nonempty_procs++;
      }

    // Unfortunately, it turns out that our partitioners *do* suck:
    //
    // * Metis and ParMetis can't reliably give us more than
    // 13 non-empty ranks on the above 27 element mesh.
    //
    // * Our SFC partitioners are suboptimal with 8 or more ranks for
    // only 27 elements: the smallest integer block size for 27/8
    // elements-per-rank that won't overflow is 4, but that only fills
    // 7 ranks, because we don't equidistribute the underflow.
    CPPUNIT_ASSERT(nonempty_procs >= n_nonempty ||
                   nonempty_procs >= 13 ||
                   (nonempty_procs >= 7 &&
                    n_nonempty == 8) ||
                   (nonempty_procs >= 9 &&
                    n_nonempty >= 10));
  }

testPartition1()

template<typename PartitionerSubclass , typename MeshClass >

void PartitionerTest< PartitionerSubclass, MeshClass >::testPartition1 ( )

inline

Definition at line 122 of file partitioner_test.h.

  {
    LOG_UNIT_TEST;

    this->testPartition(1);
  }

testPartition2()

template<typename PartitionerSubclass , typename MeshClass >

void PartitionerTest< PartitionerSubclass, MeshClass >::testPartition2 ( )

inline

Definition at line 129 of file partitioner_test.h.

  {
    LOG_UNIT_TEST;

    this->testPartition(2);
  }

testPartitionEmpty()

template<typename PartitionerSubclass , typename MeshClass >

void PartitionerTest< PartitionerSubclass, MeshClass >::testPartitionEmpty ( )

inline

Definition at line 110 of file partitioner_test.h.

References mesh, TIMPI::Communicator::size(), and TestCommWorld.

  {
    LOG_UNIT_TEST;

    MeshClass mesh(*TestCommWorld);
    PartitionerSubclass newpart;

    // With a 0 element mesh this should just give us 0 subpartitions
    // regardless of n_procs
    newpart.partition(mesh, TestCommWorld->size());
  }

testPartitionNProc()

template<typename PartitionerSubclass , typename MeshClass >

void PartitionerTest< PartitionerSubclass, MeshClass >::testPartitionNProc ( )

inline

Definition at line 136 of file partitioner_test.h.

References TIMPI::Communicator::size(), and TestCommWorld.

  {
    LOG_UNIT_TEST;

    this->testPartition(TestCommWorld->size());
  }

Member Data Documentation

libmesh_suite_name

template<typename PartitionerSubclass , typename MeshClass >

std::string PartitionerTest< PartitionerSubclass, MeshClass >::libmesh_suite_name

protected

Definition at line 31 of file partitioner_test.h.

---

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

• tests/partitioning/partitioner_test.h