libMesh::CentroidPartitioner Class Reference

#include <centroid_partitioner.h>

Inheritance diagram for libMesh::CentroidPartitioner:

[legend]

List of all members.

Public Types
enum	CentroidSortMethod {   X = 0, Y, Z, RADIAL,   INVALID_METHOD }
Public Member Functions
	CentroidPartitioner (const CentroidSortMethod sm=X)
virtual AutoPtr< Partitioner >	clone () const
CentroidSortMethod	sort_method () const
void	set_sort_method (const CentroidSortMethod sm)
void	partition (MeshBase &mesh, const unsigned int n=libMesh::n_processors())
void	repartition (MeshBase &mesh, const unsigned int n=libMesh::n_processors())
virtual void	attach_weights (ErrorVector *)
Static Public Member Functions
static void	partition_unpartitioned_elements (MeshBase &mesh, const unsigned int n=libMesh::n_processors())
static void	set_parent_processor_ids (MeshBase &mesh)
static void	set_node_processor_ids (MeshBase &mesh)
Protected Member Functions
virtual void	_do_partition (MeshBase &mesh, const unsigned int n)
void	single_partition (MeshBase &mesh)
virtual void	_do_repartition (MeshBase &mesh, const unsigned int n)
Protected Attributes
ErrorVector *	_weights
Static Protected Attributes
static const dof_id_type	communication_blocksize = 1000000
Private Member Functions
void	compute_centroids (MeshBase &mesh)
Static Private Member Functions
static bool	sort_x (const std::pair< Point, Elem * > &lhs, const std::pair< Point, Elem * > &rhs)
static bool	sort_y (const std::pair< Point, Elem * > &lhs, const std::pair< Point, Elem * > &rhs)
static bool	sort_z (const std::pair< Point, Elem * > &lhs, const std::pair< Point, Elem * > &rhs)
static bool	sort_radial (const std::pair< Point, Elem * > &lhs, const std::pair< Point, Elem * > &rhs)
Private Attributes
CentroidSortMethod	_sort_method
std::vector< std::pair< Point, Elem * > >	_elem_centroids

---

Detailed Description

The centroid partitioner partitions simply based on the locations of element centroids. You must define what you mean by "less than" for the list of element centroids, e.g. if you only care about distance in the z-direction, you would define "less than" differently than if you cared about radial distance.

Author:

John W. Peterson and Benjamin S. Kirk, 2003

Definition at line 52 of file centroid_partitioner.h.

---

Member Enumeration Documentation

enum libMesh::CentroidPartitioner::CentroidSortMethod

A typedef which is reserved only for use within this class. If X is chosen, then centroid locations will be sorted according to their X-location, etc...

Enumerator:

X
Y
Z
RADIAL
INVALID_METHOD

Definition at line 62 of file centroid_partitioner.h.

                          {X=0,
                           Y,
                           Z,
                           RADIAL,
                           INVALID_METHOD};

---

Constructor & Destructor Documentation

libMesh::CentroidPartitioner::CentroidPartitioner

(

const CentroidSortMethod

sm = X

)

[inline, explicit]

Constructor. Takes the CentroidSortMethod to use, which defaults to X ordering.

Definition at line 73 of file centroid_partitioner.h.

Referenced by clone().

: _sort_method(sm) {}

---

Member Function Documentation

void libMesh::CentroidPartitioner::_do_partition	(	MeshBase &	mesh,
		const unsigned int	n
	)			[protected, virtual]

Partitions the mesh into n subdomains. This is a required interface for the class.

Implements libMesh::Partitioner.

Definition at line 32 of file centroid_partitioner.C.

References _elem_centroids, compute_centroids(), std::min(), libMesh::MeshTools::n_elem(), libMesh::MeshBase::n_elem(), libMesh::DofObject::processor_id(), RADIAL, libMesh::Partitioner::single_partition(), sort_method(), sort_radial(), sort_x(), sort_y(), sort_z(), X, Y, and Z.

{
  // Check for an easy return
  if (n == 1)
    {
      this->single_partition (mesh);
      return;
    }


  // Possibly reconstruct centroids
  if (mesh.n_elem() != _elem_centroids.size())
    this->compute_centroids (mesh);



  switch (this->sort_method())
    {
    case X:
      {
        std::sort(_elem_centroids.begin(),
                  _elem_centroids.end(),
                  CentroidPartitioner::sort_x);

        break;
      }


    case Y:
      {
        std::sort(_elem_centroids.begin(),
                  _elem_centroids.end(),
                  CentroidPartitioner::sort_y);

        break;

      }


    case Z:
      {
        std::sort(_elem_centroids.begin(),
                  _elem_centroids.end(),
                  CentroidPartitioner::sort_z);

        break;
      }


     case RADIAL:
      {
        std::sort(_elem_centroids.begin(),
                  _elem_centroids.end(),
                  CentroidPartitioner::sort_radial);

        break;
      }
    default:
      libmesh_error();
    }


  // Make sure the user has not handed us an
  // invalid number of partitions.
  libmesh_assert_greater (n, 0);

  // the number of elements, e.g. 1000
  const dof_id_type n_elem      = mesh.n_elem();
  // the number of elements per processor, e.g 400
  const dof_id_type target_size = n_elem / n;

  // Make sure the mesh hasn't changed since the
  // last time we computed the centroids.
  libmesh_assert_equal_to (mesh.n_elem(), _elem_centroids.size());

  for (dof_id_type i=0; i<n_elem; i++)
    {
      Elem* elem = _elem_centroids[i].second;

      elem->processor_id() =
        std::min (libmesh_cast_int<processor_id_type>(i / target_size),
                  libmesh_cast_int<processor_id_type>(n-1));
    }
}

virtual void libMesh::Partitioner::_do_repartition	(	MeshBase &	mesh,
		const unsigned int	n
	)			[inline, protected, virtual, inherited]

This is the actual re-partitioning method which can be overloaded in derived classes. Note that the default behavior is to simply call the partition function.

Reimplemented in libMesh::ParmetisPartitioner.

Definition at line 143 of file partitioner.h.

References libMesh::Partitioner::_do_partition().

Referenced by libMesh::Partitioner::repartition().

                                                      { this->_do_partition (mesh, n); }

virtual void libMesh::Partitioner::attach_weights

(

ErrorVector *

)

[inline, virtual, inherited]

Attach weights that can be used for partitioning. This ErrorVector should be _exactly_ the same on every processor and should have mesh->max_elem_id() entries.

Reimplemented in libMesh::MetisPartitioner.

Definition at line 118 of file partitioner.h.

{ libmesh_not_implemented(); }

virtual AutoPtr<Partitioner> libMesh::CentroidPartitioner::clone

(

)

const [inline, virtual]

Creates a new partitioner of this type and returns it in an AutoPtr.

Implements libMesh::Partitioner.

Definition at line 79 of file centroid_partitioner.h.

References CentroidPartitioner(), and sort_method().

                                              {
    AutoPtr<Partitioner> cloned_partitioner
      (new CentroidPartitioner(sort_method()));
    return cloned_partitioner;
  }

void libMesh::CentroidPartitioner::compute_centroids

(

MeshBase &

mesh

)

[private]

Computes a list of element centroids for the mesh. This list will be kept around in case a repartition is desired.

Definition at line 125 of file centroid_partitioner.C.

References _elem_centroids, libMesh::Elem::centroid(), libMesh::MeshBase::elements_begin(), libMesh::MeshBase::elements_end(), and libMesh::MeshBase::n_elem().

Referenced by _do_partition().

{
  _elem_centroids.clear();
  _elem_centroids.reserve(mesh.n_elem());

//   elem_iterator it(mesh.elements_begin());
//   const elem_iterator it_end(mesh.elements_end());

  MeshBase::element_iterator       it     = mesh.elements_begin();
  const MeshBase::element_iterator it_end = mesh.elements_end();

  for (; it != it_end; ++it)
    {
      Elem* elem = *it;

      _elem_centroids.push_back(std::make_pair(elem->centroid(), elem));
    }
}

void libMesh::Partitioner::partition	(	MeshBase &	mesh,
		const unsigned int	n = libMesh::n_processors()
	)			[inherited]

Partition the MeshBase into n parts. If the user does not specify a number of pieces into which the mesh should be partitioned, then the default behavior of the partitioner is to partition according to the number of processors defined in libMesh::n_processors(). The partitioner currently does not modify the subdomain_id of each element. This number is reserved for things like material properties, etc.

Definition at line 48 of file partitioner.C.

References libMesh::Partitioner::_do_partition(), libMesh::MeshTools::libmesh_assert_valid_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_remote_elems(), std::min(), libMesh::MeshBase::n_active_elem(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::MeshBase::redistribute(), libMesh::MeshBase::set_n_partitions(), libMesh::Partitioner::set_node_processor_ids(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::Partitioner::single_partition(), and libMesh::MeshBase::update_post_partitioning().

Referenced by libMesh::SFCPartitioner::_do_partition(), libMesh::MetisPartitioner::_do_partition(), and libMesh::ParmetisPartitioner::_do_repartition().

{
  parallel_only();

  // BSK - temporary fix while redistribution is integrated 6/26/2008
  // Uncomment this to not repartition in parallel
//   if (!mesh.is_serial())
//     return;

  // we cannot partition into more pieces than we have
  // active elements!
  const unsigned int n_parts =
    static_cast<unsigned int>
      (std::min(mesh.n_active_elem(), static_cast<dof_id_type>(n)));

  // Set the number of partitions in the mesh
  mesh.set_n_partitions()=n_parts;

  if (n_parts == 1)
    {
      this->single_partition (mesh);
      return;
    }

  // First assign a temporary partitioning to any unpartitioned elements
  Partitioner::partition_unpartitioned_elements(mesh, n_parts);

  // Call the partitioning function
  this->_do_partition(mesh,n_parts);

  // Set the parent's processor ids
  Partitioner::set_parent_processor_ids(mesh);

  // Redistribute elements if necessary, before setting node processor
  // ids, to make sure those will be set consistently
  mesh.redistribute();

#ifdef DEBUG
  MeshTools::libmesh_assert_valid_remote_elems(mesh);

  // Messed up elem processor_id()s can leave us without the child
  // elements we need to restrict vectors on a distributed mesh
  MeshTools::libmesh_assert_valid_procids<Elem>(mesh);
#endif

  // Set the node's processor ids
  Partitioner::set_node_processor_ids(mesh);

#ifdef DEBUG
  MeshTools::libmesh_assert_valid_procids<Elem>(mesh);
#endif

  // Give derived Mesh classes a chance to update any cached data to
  // reflect the new partitioning
  mesh.update_post_partitioning();
}

void libMesh::Partitioner::partition_unpartitioned_elements	(	MeshBase &	mesh,
		const unsigned int	n = libMesh::n_processors()
	)			[static, inherited]

This function

Definition at line 168 of file partitioner.C.

References libMesh::MeshTools::bounding_box(), end, libMesh::MeshTools::n_elem(), libMesh::n_processors(), libMesh::DofObject::processor_id(), libMesh::MeshBase::unpartitioned_elements_begin(), and libMesh::MeshBase::unpartitioned_elements_end().

Referenced by libMesh::Partitioner::partition(), and libMesh::Partitioner::repartition().

{
  MeshBase::element_iterator       it  = mesh.unpartitioned_elements_begin();
  const MeshBase::element_iterator end = mesh.unpartitioned_elements_end();

  const dof_id_type n_unpartitioned_elements = MeshTools::n_elem (it, end);

  // the unpartitioned elements must exist on all processors. If the range is empty on one
  // it is empty on all, and we can quit right here.
  if (!n_unpartitioned_elements) return;

  // find the target subdomain sizes
  std::vector<dof_id_type> subdomain_bounds(libMesh::n_processors());

  for (processor_id_type pid=0; pid<libMesh::n_processors(); pid++)
    {
      dof_id_type tgt_subdomain_size = 0;

      // watch out for the case that n_subdomains < n_processors
      if (pid < n_subdomains)
        {
          tgt_subdomain_size = n_unpartitioned_elements/n_subdomains;

          if (pid < n_unpartitioned_elements%n_subdomains)
            tgt_subdomain_size++;

        }

      //libMesh::out << "pid, #= " << pid << ", " << tgt_subdomain_size << std::endl;
      if (pid == 0)
        subdomain_bounds[0] = tgt_subdomain_size;
      else
        subdomain_bounds[pid] = subdomain_bounds[pid-1] + tgt_subdomain_size;
    }

  libmesh_assert_equal_to (subdomain_bounds.back(), n_unpartitioned_elements);

  // create the unique mapping for all unpartitioned elements independent of partitioning
  // determine the global indexing for all the unpartitoned elements
  std::vector<dof_id_type> global_indices;

  // Calling this on all processors a unique range in [0,n_unpartitioned_elements) is constructed.
  // Only the indices for the elements we pass in are returned in the array.
  MeshCommunication().find_global_indices (MeshTools::bounding_box(mesh), it, end,
                                           global_indices);

  for (dof_id_type cnt=0; it != end; ++it)
    {
      Elem *elem = *it;

      libmesh_assert_less (cnt, global_indices.size());
      const dof_id_type global_index =
        global_indices[cnt++];

      libmesh_assert_less (global_index, subdomain_bounds.back());
      libmesh_assert_less (global_index, n_unpartitioned_elements);

      const processor_id_type subdomain_id =
        libmesh_cast_int<processor_id_type>
        (std::distance(subdomain_bounds.begin(),
                       std::upper_bound(subdomain_bounds.begin(),
                                        subdomain_bounds.end(),
                                        global_index)));
      libmesh_assert_less (subdomain_id, n_subdomains);

      elem->processor_id() = subdomain_id;
      //libMesh::out << "assigning " << global_index << " to " << subdomain_id << std::endl;
    }
}

void libMesh::Partitioner::repartition	(	MeshBase &	mesh,
		const unsigned int	n = libMesh::n_processors()
	)			[inherited]

Repartitions the MeshBase into n parts. This is required since some partitoning algorithms can repartition more efficiently than computing a new partitioning from scratch. The default behavior is to simply call this->partition(n)

Definition at line 110 of file partitioner.C.

References libMesh::Partitioner::_do_repartition(), std::min(), libMesh::MeshBase::n_active_elem(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::MeshBase::set_n_partitions(), libMesh::Partitioner::set_node_processor_ids(), libMesh::Partitioner::set_parent_processor_ids(), and libMesh::Partitioner::single_partition().

{
  // we cannot partition into more pieces than we have
  // active elements!
  const unsigned int n_parts =
    static_cast<unsigned int>
      (std::min(mesh.n_active_elem(), static_cast<dof_id_type>(n)));

  // Set the number of partitions in the mesh
  mesh.set_n_partitions()=n_parts;

  if (n_parts == 1)
    {
      this->single_partition (mesh);
      return;
    }

  // First assign a temporary partitioning to any unpartitioned elements
  Partitioner::partition_unpartitioned_elements(mesh, n_parts);

  // Call the partitioning function
  this->_do_repartition(mesh,n_parts);

  // Set the parent's processor ids
  Partitioner::set_parent_processor_ids(mesh);

  // Set the node's processor ids
  Partitioner::set_node_processor_ids(mesh);
}

void libMesh::Partitioner::set_node_processor_ids

(

MeshBase &

mesh

)

[static, inherited]

This function is called after partitioning to set the processor IDs for the nodes. By definition, a Node's processor ID is the minimum processor ID for all of the elements which share the node.

Definition at line 419 of file partitioner.C.

References libMesh::MeshBase::active_elements_begin(), libMesh::MeshBase::active_elements_end(), libMesh::CommWorld, libMesh::Elem::get_node(), libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, libMesh::DofObject::invalidate_processor_id(), libMesh::MeshTools::libmesh_assert_valid_procids< Node >(), std::min(), libMesh::MeshTools::n_elem(), libMesh::Elem::n_nodes(), libMesh::MeshBase::n_partitions(), libMesh::n_processors(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::nodes_begin(), libMesh::MeshBase::nodes_end(), libMesh::MeshBase::not_active_elements_begin(), libMesh::MeshBase::not_active_elements_end(), libMesh::processor_id(), libMesh::DofObject::processor_id(), libMesh::Parallel::Communicator::send_receive(), libMesh::MeshBase::subactive_elements_begin(), libMesh::MeshBase::subactive_elements_end(), libMesh::MeshBase::unpartitioned_elements_begin(), and libMesh::MeshBase::unpartitioned_elements_end().

Referenced by libMesh::UnstructuredMesh::all_first_order(), libMesh::Partitioner::partition(), libMesh::XdrIO::read(), libMesh::Partitioner::repartition(), and libMesh::BoundaryInfo::sync().

{
  START_LOG("set_node_processor_ids()","Partitioner");

  // This function must be run on all processors at once
  parallel_only();

  // If we have any unpartitioned elements at this
  // stage there is a problem
  libmesh_assert (MeshTools::n_elem(mesh.unpartitioned_elements_begin(),
                            mesh.unpartitioned_elements_end()) == 0);


//   const dof_id_type orig_n_local_nodes = mesh.n_local_nodes();

//   libMesh::err << "[" << libMesh::processor_id() << "]: orig_n_local_nodes="
//          << orig_n_local_nodes << std::endl;

  // Build up request sets.  Each node is currently owned by a processor because
  // it is connected to an element owned by that processor.  However, during the
  // repartitioning phase that element may have been assigned a new processor id, but
  // it is still resident on the original processor.  We need to know where to look
  // for new ids before assigning new ids, otherwise we may be asking the wrong processors
  // for the wrong information.
  //
  // The only remaining issue is what to do with unpartitioned nodes.  Since they are required
  // to live on all processors we can simply rely on ourselves to number them properly.
  std::vector<std::vector<dof_id_type> >
    requested_node_ids(libMesh::n_processors());

  // Loop over all the nodes, count the ones on each processor.  We can skip ourself
  std::vector<dof_id_type> ghost_nodes_from_proc(libMesh::n_processors(), 0);

  MeshBase::node_iterator       node_it  = mesh.nodes_begin();
  const MeshBase::node_iterator node_end = mesh.nodes_end();

  for (; node_it != node_end; ++node_it)
    {
      Node *node = *node_it;
      libmesh_assert(node);
      const processor_id_type current_pid = node->processor_id();
      if (current_pid != libMesh::processor_id() &&
          current_pid != DofObject::invalid_processor_id)
        {
          libmesh_assert_less (current_pid, ghost_nodes_from_proc.size());
          ghost_nodes_from_proc[current_pid]++;
        }
    }

  // We know how many objects live on each processor, so reserve()
  // space for each.
  for (processor_id_type pid=0; pid != libMesh::n_processors(); ++pid)
    requested_node_ids[pid].reserve(ghost_nodes_from_proc[pid]);

  // We need to get the new pid for each node from the processor
  // which *currently* owns the node.  We can safely skip ourself
  for (node_it = mesh.nodes_begin(); node_it != node_end; ++node_it)
    {
      Node *node = *node_it;
      libmesh_assert(node);
      const processor_id_type current_pid = node->processor_id();
      if (current_pid != libMesh::processor_id() &&
          current_pid != DofObject::invalid_processor_id)
        {
          libmesh_assert_less (current_pid, requested_node_ids.size());
          libmesh_assert_less (requested_node_ids[current_pid].size(),
                              ghost_nodes_from_proc[current_pid]);
          requested_node_ids[current_pid].push_back(node->id());
        }

      // Unset any previously-set node processor ids
      node->invalidate_processor_id();
    }

  // Loop over all the active elements
  MeshBase::element_iterator       elem_it  = mesh.active_elements_begin();
  const MeshBase::element_iterator elem_end = mesh.active_elements_end();

  for ( ; elem_it != elem_end; ++elem_it)
    {
      Elem* elem = *elem_it;
      libmesh_assert(elem);

      libmesh_assert_not_equal_to (elem->processor_id(), DofObject::invalid_processor_id);

      // For each node, set the processor ID to the min of
      // its current value and this Element's processor id.
      //
      // TODO: we would probably get better parallel partitioning if
      // we did something like "min for even numbered nodes, max for
      // odd numbered".  We'd need to be careful about how that would
      // affect solution ordering for I/O, though.
      for (unsigned int n=0; n<elem->n_nodes(); ++n)
        elem->get_node(n)->processor_id() = std::min(elem->get_node(n)->processor_id(),
                                                     elem->processor_id());
    }

  // And loop over the subactive elements, but don't reassign
  // nodes that are already active on another processor.
  MeshBase::element_iterator       sub_it  = mesh.subactive_elements_begin();
  const MeshBase::element_iterator sub_end = mesh.subactive_elements_end();

  for ( ; sub_it != sub_end; ++sub_it)
    {
      Elem* elem = *sub_it;
      libmesh_assert(elem);

      libmesh_assert_not_equal_to (elem->processor_id(), DofObject::invalid_processor_id);

      for (unsigned int n=0; n<elem->n_nodes(); ++n)
        if (elem->get_node(n)->processor_id() == DofObject::invalid_processor_id)
          elem->get_node(n)->processor_id() = elem->processor_id();
    }

  // Same for the inactive elements -- we will have already gotten most of these
  // nodes, *except* for the case of a parent with a subset of children which are
  // ghost elements.  In that case some of the parent nodes will not have been
  // properly handled yet
  MeshBase::element_iterator       not_it  = mesh.not_active_elements_begin();
  const MeshBase::element_iterator not_end = mesh.not_active_elements_end();

  for ( ; not_it != not_end; ++not_it)
    {
      Elem* elem = *not_it;
      libmesh_assert(elem);

      libmesh_assert_not_equal_to (elem->processor_id(), DofObject::invalid_processor_id);

      for (unsigned int n=0; n<elem->n_nodes(); ++n)
        if (elem->get_node(n)->processor_id() == DofObject::invalid_processor_id)
          elem->get_node(n)->processor_id() = elem->processor_id();
    }

  // We can't assert that all nodes are connected to elements, because
  // a ParallelMesh with NodeConstraints might have pulled in some
  // remote nodes solely for evaluating those constraints.
  // MeshTools::libmesh_assert_connected_nodes(mesh);

  // For such nodes, we'll do a sanity check later when making sure
  // that we successfully reset their processor ids to something
  // valid.

  // Next set node ids from other processors, excluding self
  for (processor_id_type p=1; p != libMesh::n_processors(); ++p)
    {
      // Trade my requests with processor procup and procdown
      processor_id_type procup = (libMesh::processor_id() + p) %
                                  libMesh::n_processors();
      processor_id_type procdown = (libMesh::n_processors() +
                                    libMesh::processor_id() - p) %
                                    libMesh::n_processors();
      std::vector<dof_id_type> request_to_fill;
      CommWorld.send_receive(procup, requested_node_ids[procup],
                             procdown, request_to_fill);

      // Fill those requests in-place
      for (std::size_t i=0; i != request_to_fill.size(); ++i)
        {
          Node *node = mesh.node_ptr(request_to_fill[i]);
          libmesh_assert(node);
          const processor_id_type new_pid = node->processor_id();
          libmesh_assert_not_equal_to (new_pid, DofObject::invalid_processor_id);
          libmesh_assert_less (new_pid, mesh.n_partitions()); // this is the correct test --
          request_to_fill[i] = new_pid;           //  the number of partitions may
        }                                         //  not equal the number of processors

      // Trade back the results
      std::vector<dof_id_type> filled_request;
      CommWorld.send_receive(procdown, request_to_fill,
                             procup,   filled_request);
      libmesh_assert_equal_to (filled_request.size(), requested_node_ids[procup].size());

      // And copy the id changes we've now been informed of
      for (std::size_t i=0; i != filled_request.size(); ++i)
        {
          Node *node = mesh.node_ptr(requested_node_ids[procup][i]);
          libmesh_assert(node);
          libmesh_assert_less (filled_request[i], mesh.n_partitions()); // this is the correct test --
          node->processor_id(filled_request[i]);           //  the number of partitions may
        }                                                  //  not equal the number of processors
    }

#ifdef DEBUG
  MeshTools::libmesh_assert_valid_procids<Node>(mesh);
#endif

  STOP_LOG("set_node_processor_ids()","Partitioner");
}

static void libMesh::Partitioner::set_parent_processor_ids

(

MeshBase &

mesh

)

[static, inherited]

This function is called after partitioning to set the processor IDs for the inactive parent elements. A Parent's processor ID is the same as its first child.

Referenced by libMesh::Partitioner::partition(), and libMesh::Partitioner::repartition().

void libMesh::CentroidPartitioner::set_sort_method

(

const CentroidSortMethod

sm

)

[inline]

Change how the elements will be sorted.

Definition at line 93 of file centroid_partitioner.h.

References _sort_method.

{_sort_method = sm; }

void libMesh::Partitioner::single_partition

(

MeshBase &

mesh

)

[protected, inherited]

Trivially "partitions" the mesh for one processor. Simply loops through the elements and assigns all of them to processor 0. Is is provided as a separate function so that derived classes may use it without reimplementing it.

Definition at line 145 of file partitioner.C.

References libMesh::MeshBase::elements_begin(), libMesh::MeshBase::elements_end(), libMesh::MeshBase::nodes_begin(), and libMesh::MeshBase::nodes_end().

Referenced by libMesh::SFCPartitioner::_do_partition(), libMesh::MetisPartitioner::_do_partition(), libMesh::LinearPartitioner::_do_partition(), _do_partition(), libMesh::ParmetisPartitioner::_do_repartition(), libMesh::Partitioner::partition(), and libMesh::Partitioner::repartition().

{
  START_LOG("single_partition()","Partitioner");

  // Loop over all the elements and assign them to processor 0.
  MeshBase::element_iterator       elem_it  = mesh.elements_begin();
  const MeshBase::element_iterator elem_end = mesh.elements_end();

  for ( ; elem_it != elem_end; ++elem_it)
    (*elem_it)->processor_id() = 0;

  // For a single partition, all the nodes are on processor 0
  MeshBase::node_iterator       node_it  = mesh.nodes_begin();
  const MeshBase::node_iterator node_end = mesh.nodes_end();

  for ( ; node_it != node_end; ++node_it)
    (*node_it)->processor_id() = 0;

  STOP_LOG("single_partition()","Partitioner");
}

CentroidSortMethod libMesh::CentroidPartitioner::sort_method

(

)

const [inline]

Specifies how the elements will be sorted.

Definition at line 88 of file centroid_partitioner.h.

References _sort_method.

Referenced by _do_partition(), and clone().

{ return _sort_method; }

bool libMesh::CentroidPartitioner::sort_radial	(	const std::pair< Point, Elem * > &	lhs,
		const std::pair< Point, Elem * > &	rhs
	)			[static, private]

Partition the list of centroids based on the radial position of the centroid. This provides a function which may be passed to the std::sort routine for sorting the elements by centroid.

Definition at line 174 of file centroid_partitioner.C.

Referenced by _do_partition().

{
  return (lhs.first.size() < rhs.first.size());
}

bool libMesh::CentroidPartitioner::sort_x	(	const std::pair< Point, Elem * > &	lhs,
		const std::pair< Point, Elem * > &	rhs
	)			[static, private]

Partition the list of centroids based on the x-coordinate of the centroid. This provides a function which may be passed to the std::sort routine for sorting the elements by centroid.

Definition at line 147 of file centroid_partitioner.C.

Referenced by _do_partition().

{
  return (lhs.first(0) < rhs.first(0));
}

bool libMesh::CentroidPartitioner::sort_y	(	const std::pair< Point, Elem * > &	lhs,
		const std::pair< Point, Elem * > &	rhs
	)			[static, private]

Partition the list of centroids based on the y-coordinate of the centroid. This provides a function which may be passed to the std::sort routine for sorting the elements by centroid.

Definition at line 156 of file centroid_partitioner.C.

Referenced by _do_partition().

{
  return (lhs.first(1) < rhs.first(1));
}

bool libMesh::CentroidPartitioner::sort_z	(	const std::pair< Point, Elem * > &	lhs,
		const std::pair< Point, Elem * > &	rhs
	)			[static, private]

Partition the list of centroids based on the z-coordinate of the centroid. This provides a function which may be passed to the std::sort routine for sorting the elements by centroid.

Definition at line 166 of file centroid_partitioner.C.

Referenced by _do_partition().

{
  return (lhs.first(2) < rhs.first(2));
}

---

Member Data Documentation

std::vector<std::pair<Point, Elem*> > libMesh::CentroidPartitioner::_elem_centroids [private]

Vector which holds pairs of centroids and their respective element pointers.

Definition at line 160 of file centroid_partitioner.h.

Referenced by _do_partition(), and compute_centroids().

CentroidSortMethod libMesh::CentroidPartitioner::_sort_method [private]

Store a flag which tells which type of sort method we are using.

Definition at line 154 of file centroid_partitioner.h.

Referenced by set_sort_method(), and sort_method().

ErrorVector* libMesh::Partitioner::_weights [protected, inherited]

The weights that might be used for partitioning.

Definition at line 155 of file partitioner.h.

Referenced by libMesh::MetisPartitioner::_do_partition(), and libMesh::MetisPartitioner::attach_weights().

const dof_id_type libMesh::Partitioner::communication_blocksize = 1000000 [static, protected, inherited]

The blocksize to use when doing blocked parallel communication. This limits the maximum vector size which can be used in a single communication step.

Definition at line 150 of file partitioner.h.

---

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

• centroid_partitioner.h
• centroid_partitioner.C