PotentialToFieldAux

An AuxKernel that calculates the electrostatic electric field given the electrostatic potential.

Overview

This AuxKernel object uses the following equation for electric field:

$var element = document.getElementById("moose-equation-d6fa434d-3034-4643-b399-cadf4d66f883");katex.render(" \\mathbf{E} = s \\nabla V", element, {displayMode:true,throwOnError:false});$

where

$var element = document.getElementById("moose-equation-62e65725-2cd9-40e5-be6f-68d74ee676cc");katex.render("\\mathbf{E}", element, {displayMode:false,throwOnError:false});$ is the electric field in units of Volts per meter,
$var element = document.getElementById("moose-equation-09e9a1fc-9982-4358-9105-66deec8f5766");katex.render("V", element, {displayMode:false,throwOnError:false});$ is the electrostatic potential in units of Volts, and
$var element = document.getElementById("moose-equation-74605a24-3905-4d6a-8398-2dc748e8804c");katex.render("s", element, {displayMode:false,throwOnError:false});$ is a coefficient set via the "sign" parameter, and defaults to $var element = document.getElementById("moose-equation-7e61f12d-ca20-44d5-b2e3-a9bd023f8f63");katex.render("-1", element, {displayMode:false,throwOnError:false});$ .

The sign of the resulting calculation can be changed from the default, if needed, by setting "sign" to positive. This option is the result of the desire to keep the object code as general as possible for use in other scenarios where the positive gradient of a solution variable is desired, while still retaining the traditional and expected electrostatic field result from various electrodynamics texts by default.

Example Input File Syntax

[AuxKernels<<<{"href": "../../syntax/AuxKernels/index.html"}>>>]
  [Ex_aux]
    type = PotentialToFieldAux<<<{"description": "An AuxKernel that calculates the electrostatic electric field given the electrostatic potential.", "href": "PotentialToFieldAux.html"}>>>
    variable<<<{"description": "The name of the variable that this object applies to"}>>> = Ex
    gradient_variable<<<{"description": "The variable from which to compute the gradient component"}>>> = potential
    sign<<<{"description": "Sign of potential gradient."}>>> = negative
    component<<<{"description": "The gradient component to compute"}>>> = x
  []
[]

Input Parameters

gradient_variableThe variable from which to compute the gradient component
C++ Type:std::vector<VariableName>
Unit:(no unit assumed)
Controllable:No
Description:The variable from which to compute the gradient component
variableThe name of the variable that this object applies to
C++ Type:AuxVariableName
Unit:(no unit assumed)
Controllable:No
Description:The name of the variable that this object applies to

Required Parameters

blockThe list of blocks (ids or names) that this object will be applied
C++ Type:std::vector<SubdomainName>
Controllable:No
Description:The list of blocks (ids or names) that this object will be applied
boundaryThe list of boundaries (ids or names) from the mesh where this object applies
C++ Type:std::vector<BoundaryName>
Controllable:No
Description:The list of boundaries (ids or names) from the mesh where this object applies
check_boundary_restrictedTrueWhether to check for multiple element sides on the boundary in the case of a boundary restricted, element aux variable. Setting this to false will allow contribution to a single element's elemental value(s) from multiple boundary sides on the same element (example: when the restricted boundary exists on two or more sides of an element, such as at a corner of a mesh
Default:True
C++ Type:bool
Controllable:No
Description:Whether to check for multiple element sides on the boundary in the case of a boundary restricted, element aux variable. Setting this to false will allow contribution to a single element's elemental value(s) from multiple boundary sides on the same element (example: when the restricted boundary exists on two or more sides of an element, such as at a corner of a mesh
componentThe gradient component to compute
C++ Type:MooseEnum
Options:x, y, z
Controllable:No
Description:The gradient component to compute
execute_onLINEAR TIMESTEP_ENDThe list of flag(s) indicating when this object should be executed. For a description of each flag, see https://mooseframework.inl.gov/source/interfaces/SetupInterface.html.
Default:LINEAR TIMESTEP_END
C++ Type:ExecFlagEnum
Options:XFEM_MARK, NONE, INITIAL, LINEAR, LINEAR_CONVERGENCE, NONLINEAR, NONLINEAR_CONVERGENCE, POSTCHECK, TIMESTEP_END, TIMESTEP_BEGIN, MULTIAPP_FIXED_POINT_END, MULTIAPP_FIXED_POINT_BEGIN, MULTIAPP_FIXED_POINT_CONVERGENCE, FINAL, CUSTOM, PRE_DISPLACE
Controllable:No
Description:The list of flag(s) indicating when this object should be executed. For a description of each flag, see https://mooseframework.inl.gov/source/interfaces/SetupInterface.html.
signnegativeSign of potential gradient.
Default:negative
C++ Type:MooseEnum
Options:negative, positive
Controllable:No
Description:Sign of potential gradient.

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:Yes
Description:Set the enabled status of the MooseObject.
search_methodnearest_node_connected_sidesChoice of search algorithm. All options begin by finding the nearest node in the primary boundary to a query point in the secondary boundary. In the default nearest_node_connected_sides algorithm, primary boundary elements are searched iff that nearest node is one of their nodes. This is fast to determine via a pregenerated node-to-elem map and is robust on conforming meshes. In the optional all_proximate_sides algorithm, primary boundary elements are searched iff they touch that nearest node, even if they are not topologically connected to it. This is more CPU-intensive but is necessary for robustness on any boundary surfaces which has disconnections (such as Flex IGA meshes) or non-conformity (such as hanging nodes in adaptively h-refined meshes).
Default:nearest_node_connected_sides
C++ Type:MooseEnum
Options:nearest_node_connected_sides, all_proximate_sides
Controllable:No
Description:Choice of search algorithm. All options begin by finding the nearest node in the primary boundary to a query point in the secondary boundary. In the default nearest_node_connected_sides algorithm, primary boundary elements are searched iff that nearest node is one of their nodes. This is fast to determine via a pregenerated node-to-elem map and is robust on conforming meshes. In the optional all_proximate_sides algorithm, primary boundary elements are searched iff they touch that nearest node, even if they are not topologically connected to it. This is more CPU-intensive but is necessary for robustness on any boundary surfaces which has disconnections (such as Flex IGA meshes) or non-conformity (such as hanging nodes in adaptively h-refined meshes).
seed0The seed for the master random number generator
Default:0
C++ Type:unsigned int
Controllable:No
Description:The seed for the master random number generator
use_displaced_meshFalseWhether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.
Default:False
C++ Type:bool
Controllable:No
Description:Whether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.

Advanced Parameters

prop_getter_suffixAn optional suffix parameter that can be appended to any attempt to retrieve/get material properties. The suffix will be prepended with a '_' character.
C++ Type:MaterialPropertyName
Unit:(no unit assumed)
Controllable:No
Description:An optional suffix parameter that can be appended to any attempt to retrieve/get material properties. The suffix will be prepended with a '_' character.
use_interpolated_stateFalseFor the old and older state use projected material properties interpolated at the quadrature points. To set up projection use the ProjectedStatefulMaterialStorageAction.
Default:False
C++ Type:bool
Controllable:No
Description:For the old and older state use projected material properties interpolated at the quadrature points. To set up projection use the ProjectedStatefulMaterialStorageAction.

Material Property Retrieval Parameters

(moose/modules/electromagnetics/test/tests/benchmarks/eigenvalue_problems/eigen_base.i)

# Base input file for eigenvalue example tests for multiple waveguide geometries
# RECTANGULAR (Default)
#     Mesh file rectangular.e based on Mesh block:
#         [Mesh]
#           [gmg]
#             type = GeneratedMeshGenerator
#             dim = 2
#             nx = 50
#             ny = 25
#             xmin = 0
#             xmax = 2
#             ymin = 0
#             ymax = 1
#             elem_type = TRI3
#           []
#         []
#     Expected analytic eigenvalue = 12.337005
#     EM Module calculated eigenvalue = 12.363806
# CIRCULAR (Mesh/file=circle.msh, BCs/active='circle eigen_circle')
#     Mesh generated using gmsh
#       radius = 1
#       center = (0, 0)
#     Expected analytic eigenvalue = 5.784025
#     EM Module calculated eigenvalue = 5.824152
# COAXIAL (Mesh/file=coaxial.msh, BCs/active='coaxial eigen_coaxial')
#     Mesh generated using gmsh with coaxial.geo
#       inner_radius = 0.125
#       outer_radius = 0.5
#       center = (0, 0)
#     Expected analytic eigenvalue = 67.108864
#     EM Module calculated eigenvalue = 68.007802


[Mesh]
  [fmg]
    type = FileMeshGenerator
    file = rectangular.e
  []
[]

[Variables]
  [potential]
    order = FIRST
    family = LAGRANGE
  []
[]

[AuxVariables]
  [Ex]
    order = CONSTANT
    family = MONOMIAL
  []
  [Ey]
    order = CONSTANT
    family = MONOMIAL
  []
[]

[Kernels]
  [diff]
    type = Diffusion
    variable = potential
  []
  [coeff]
    type = CoefReaction
    coefficient = -1
    variable = potential
    extra_vector_tags = 'eigen'
  []
[]

[AuxKernels]
  [Ex_aux]
    type = PotentialToFieldAux
    variable = Ex
    gradient_variable = potential
    sign = negative
    component = x
  []
  [Ey_aux]
    type = PotentialToFieldAux
    variable = Ey
    gradient_variable = potential
    sign = negative
    component = y
  []
[]

[BCs]
  active = 'rectangle eigen_rectangle'
  [rectangle]
    type = DirichletBC
    variable = potential
    boundary = 'left right top bottom'
    value = 0
  []
  [eigen_rectangle]
    type = EigenDirichletBC
    variable = potential
    boundary = 'left right top bottom'
  []
  # alternative BCs for circle case
  [circle]
    type = DirichletBC
    variable = potential
    boundary = 'wall'
    value = 0
  []
  [eigen_circle]
    type = EigenDirichletBC
    variable = potential
    boundary = 'wall'
  []
  # alternative BCs for coaxial case
  [coaxial]
    type = DirichletBC
    variable = potential
    boundary = 'outer inner'
    value = 0
  []
  [eigen_coaxial]
    type = EigenDirichletBC
    variable = potential
    boundary = 'outer inner'
  []
[]

[VectorPostprocessors]
  [eigenvalues]
    type = Eigenvalues
  []
[]

[Executioner]
  type = Eigenvalue
[]

[Outputs]
  csv = true
  exodus = false
  execute_on = FINAL
[]

Overview
Example Input File Syntax
Input Parameters