LibmeshPartitioner

construction:Undocumented Class

The LibmeshPartitioner has not been documented. The content listed below should be used as a starting point for documenting the class, which includes the typical automatic documentation associated with a MooseObject; however, what is contained is ultimately determined by what is necessary to make the documentation clear for users.


# LibmeshPartitioner

!syntax description /Mesh/Partitioner/LibmeshPartitioner

## Overview

!! Replace these lines with information regarding the LibmeshPartitioner object.

## Example Input File Syntax

!! Describe and include an example of how to use the LibmeshPartitioner object.

!syntax parameters /Mesh/Partitioner/LibmeshPartitioner

!syntax inputs /Mesh/Partitioner/LibmeshPartitioner

!syntax children /Mesh/Partitioner/LibmeshPartitioner

Mesh partitioning using capabilities defined in libMesh.

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
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>>
Options:
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
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>
Options:
Description:Adds user-defined labels for accessing object parameters via control logic.
enableTrueSet the enabled status of the MooseObject.
Default:True
C++ Type:bool
Options:
Description:Set the enabled status of the MooseObject.

Advanced Parameters

Input Files

(test/tests/mesh/custom_partitioner/custom_linear_partitioner_test.i)
(test/tests/mesh/custom_partitioner/custom_linear_partitioner_test_displacement.i)
(test/tests/mesh/custom_partitioner/custom_linear_partitioner_restart_test.i)
(test/tests/mesh/subdomain_partitioner/subdomain_partitioner.i)
(test/tests/outputs/variables/nemesis_hide.i)

(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
  [../]
[]

(test/tests/mesh/custom_partitioner/custom_linear_partitioner_test_displacement.i)

[Mesh]
  [gen]
    dim = 2
    type = GeneratedMeshGenerator
    nx = 3
    ny = 3
    xmin = 0.0
    xmax = 1.0
    ymin = 0.0
    ymax = 10.0
  []
  uniform_refine = 2
  displacements = 'u aux_v'

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

[Functions]
  [./aux_v_fn]
    type = ParsedFunction
    value = x*(y-0.5)/5
  [../]
[]

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

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

[Kernels]
  [./udiff]
    type = Diffusion
    variable = u
  [../]

  [./uie]
    type = TimeDerivative
    variable = u
  [../]

  [./vdiff]
    type = Diffusion
    variable = v
  [../]


  [./vie]
    type = TimeDerivative
    variable = v
  [../]
[]

[BCs]
  [./uleft]
    type = DirichletBC
    variable = u
    boundary = 1
    value = 0
  [../]

  [./uright]
    type = DirichletBC
    variable = u
    boundary = 2
    value = 0.1
  [../]

  [./vleft]
    type = DirichletBC
    variable = v
    boundary = 1
    value = 1
  [../]

  [./vright]
    type = DirichletBC
    variable = v
    boundary = 2
    value = 0
  [../]
[]

[AuxVariables]
  [./aux_v]
    order = FIRST
    family = LAGRANGE
  [../]
[]

[AuxKernels]
  [./aux_k_1]
    type = FunctionAux
    variable = aux_v
    function = aux_v_fn
  [../]
[]

[Executioner]
  type = Transient
  solve_type = 'PJFNK'
  start_time = 0.0
  num_steps = 2
  dt = .1

  [./Adaptivity]
    refine_fraction = 0.2
    coarsen_fraction = 0.3
    max_h_level = 4
  [../]
[]

[Outputs]
  file_base = custom_linear_partitioner_test_displacement
  [./out]
    type = Exodus
    use_displaced = true
  [../]
[]

(test/tests/mesh/custom_partitioner/custom_linear_partitioner_restart_test.i)

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

    nx = 10
    ny = 10

    xmin = 0.0
    xmax = 1.0

    ymin = 0.0
    ymax = 10.0
  []

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

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

[Kernels]
  active = 'bodyforce ie'

  [./bodyforce]
    type = BodyForce
    variable = u
    value = 10.0
  [../]

  [./ie]
    type = TimeDerivative
    variable = u
  [../]
[]

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

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

[Executioner]
  type = Transient

  solve_type = 'PJFNK'

  start_time = 0.0
  num_steps = 10
  dt = .1
[]

[Outputs]
  file_base =  custom_linear_partitioner_restart_test_out
  exodus = true
[]

(test/tests/mesh/subdomain_partitioner/subdomain_partitioner.i)

[Mesh]
  [file]
    type = FileMeshGenerator
    file = test_subdomain_partitioner.e
  []

  [./Partitioner]
    type = LibmeshPartitioner
    partitioner = subdomain_partitioner
    blocks = '1 2 3 4; 1001 1002 1003 1004'
  [../]
[]

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

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

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

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


[Executioner]
  type = Steady

  solve_type = 'PJFNK'
[]

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

(test/tests/outputs/variables/nemesis_hide.i)

# Solving for 2 variables, putting one into hide list and the other one into show list
# We should only see the variable that is in show list in the output.

[Mesh]
  [gen]
    type = GeneratedMeshGenerator
    dim = 2
    xmin = 0
    xmax = 1
    ymin = 0
    ymax = 1
    nx = 2
    ny = 2
    elem_type = QUAD4
  []
  # This should be the same as passing --distributed-mesh on the
  # command line. You can verify this by looking at what MOOSE prints
  # out for the "Mesh" information.
  parallel_type = distributed

  [./Partitioner]
    type = LibmeshPartitioner
    partitioner = linear
  [../]
[]

[Functions]
  [./fn_x]
    type = ParsedFunction
    value = x
  [../]
  [./fn_y]
    type = ParsedFunction
    value = y
  [../]
[]

[Variables]
  [./u]
  [../]
  [./v]
  [../]
[]

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

[Kernels]
  [./diff_u]
    type = Diffusion
    variable = u
  [../]

  [./diff_v]
    type = Diffusion
    variable = v
  [../]
[]

[AuxKernels]
  [./auxk_u]
    type = FunctionAux
    variable = aux_u
    function = 'x*x+y*y'
  [../]
  [./auxk_v]
    type = FunctionAux
    variable = aux_v
    function = '-(x*x+y*y)'
  [../]
  [./auxk_proc_id]
    variable = proc_id
    type = ProcessorIDAux
  [../]
[]

[BCs]
  [./u_bc]
    type = FunctionDirichletBC
    variable = u
    boundary = '1 3'
    function = fn_x
  [../]

  [./v_bc]
    type = FunctionDirichletBC
    variable = v
    boundary = '0 2'
    function = fn_y
  [../]
[]

[Executioner]
  type = Steady
  solve_type = 'NEWTON'
[]

[Outputs]
  console = true
  [./out]
    type = Nemesis
    hide = 'u aux_v'
  [../]
[]

Input Parameters
Input Files

Install MOOSE

New Users

Examples and Tutorials

Application Usage

Physics and Syntax

Application Development

Framework Development

MOOSEDocs

Infrastructure

Questions

Information and Tools

INL Applications and Remote Access