LibmeshPartitioner

Mesh partitioning using capabilities defined in libMesh.

The libMesh partitioners available are:

METIS, which uses the METIS library for graph partitioning
ParMETIS, which uses the parallel METIS library for graph partitioning
linear partitioner, which partitions elements based solely on their ids.
centroid partitioner, which partitions based on the element centroids. An ordering relation must be created to order the element centroids
hilbert_sfc partitioner which uses Hilbert's space filling curve algorithm
morton_sfc partitioner which uses Morton's space filling curve algorithm
subdomain partitioner, which partitions using the element subdomains

note

The LibmeshPartitioner partitions the mesh, not the numerical system. If parts of the mesh have more variables/DoFs than others, this may cause imbalance.

Example input syntax

In this example, a LibmeshPartitioner is used to perform linear partitioning of the mesh.

[Mesh<<<{"href": "../../syntax/Mesh/index.html"}>>>]
  [gen]
    type = GeneratedMeshGenerator<<<{"description": "Create a line, square, or cube mesh with uniformly spaced or biased elements.", "href": "../meshgenerators/GeneratedMeshGenerator.html"}>>>
    dim<<<{"description": "The dimension of the mesh to be generated"}>>> = 2

    nx<<<{"description": "Number of elements in the X direction"}>>> = 10
    ny<<<{"description": "Number of elements in the Y direction"}>>> = 100

    xmin<<<{"description": "Lower X Coordinate of the generated mesh"}>>> = 0.0
    xmax<<<{"description": "Upper X Coordinate of the generated mesh"}>>> = 1.0

    ymin<<<{"description": "Lower Y Coordinate of the generated mesh"}>>> = 0.0
    ymax<<<{"description": "Upper Y Coordinate of the generated mesh"}>>> = 10.0
  []

  # Custom linear partitioner
  [./Partitioner<<<{"href": "../../syntax/Mesh/Partitioner/index.html"}>>>]
    type = LibmeshPartitioner
    partitioner = linear
  [../]
  parallel_type = replicated
[]

Input Parameters

partitionerSpecifies a mesh partitioner to use when splitting the mesh for a parallel computation.
C++ Type:MooseEnum
Options:metis, parmetis, linear, centroid, hilbert_sfc, morton_sfc, subdomain_partitioner
Controllable:No
Description:Specifies a mesh partitioner to use when splitting the mesh for a parallel computation.

Required Parameters

blocksBlock is seperated by ;, and partition mesh block by block.
C++ Type:std::vector<std::vector<SubdomainName>>
Controllable:No
Description:Block is seperated by ;, and partition mesh block by block.
centroid_partitioner_directionSpecifies the sort direction if using the centroid partitioner. Available options: x, y, z, radial
C++ Type:MooseEnum
Options:x, y, z, radial
Controllable:No
Description:Specifies the sort direction if using the centroid partitioner. Available options: x, y, z, radial

Optional Parameters

control_tagsAdds user-defined labels for accessing object parameters via control logic.
C++ Type:std::vector<std::string>
Controllable:No
Description:Adds user-defined labels for accessing object parameters via control logic.
enableTrueSet the enabled status of the MooseObject.
Default:True
C++ Type:bool
Controllable:No
Description:Set the enabled status of the MooseObject.

Advanced Parameters

(moose/test/tests/mesh/custom_partitioner/custom_linear_partitioner_test.i)

###########################################################
# This is a test of the custom partitioner system. It
# demonstrates the usage of a linear partitioner on the
# elements of a mesh.
#
# @Requirement F2.30
###########################################################


[Mesh]
  [gen]
    type = GeneratedMeshGenerator
    dim = 2

    nx = 10
    ny = 100

    xmin = 0.0
    xmax = 1.0

    ymin = 0.0
    ymax = 10.0
  []

  # Custom linear partitioner
  [./Partitioner]
    type = LibmeshPartitioner
    partitioner = linear
  [../]
  parallel_type = replicated
[]


[Variables]
  active = 'u'

  [./u]
    order = FIRST
    family = LAGRANGE
  [../]
[]

[AuxVariables]
  [./proc_id]
    order = CONSTANT
    family = MONOMIAL
  [../]
[]

[Kernels]
  active = 'diff'

  [./diff]
    type = Diffusion
    variable = u
  [../]
[]

[AuxKernels]
  [./proc_id]
    type = ProcessorIDAux
    variable = proc_id
  [../]
[]

[BCs]
  active = 'left right'

  [./left]
    type = DirichletBC
    variable = u
    boundary = 3
    value = 0
  [../]

  [./right]
    type = DirichletBC
    variable = u
    boundary = 1
    value = 1
  [../]
[]

[Executioner]
  type = Steady

  solve_type = 'PJFNK'
[]

[Outputs]
  file_base = custom_linear_partitioner_test_out
  [./exodus]
    type = Exodus
    elemental_as_nodal = true
  [../]
[]