RadialGreensConvolution

Perform a radial Green's function convolution

Given a Green's function $var element = document.getElementById("moose-equation-bc6a10cf-f389-4cf5-8027-c8d674ad8210");katex.render("G(r)", element, {displayMode:false,throwOnError:false});$ and a variable field $var element = document.getElementById("moose-equation-8ab3c9bc-ce09-48b2-8b11-330d8248dc92");katex.render("c(\\vec r)", element, {displayMode:false,throwOnError:false});$ this userobject calculates a convolution $var element = document.getElementById("moose-equation-43b08cf3-5ea6-4845-84a9-ff1bf0f7c1b3");katex.render("c'(\\vec r)", element, {displayMode:false,throwOnError:false});$ such that

$var element = document.getElementById("moose-equation-ab0b889f-cdc2-464e-a986-8dec3ed6a4f2");katex.render("c'(\\vec r) = \\frac1{4\\pi}\\int_{\\Omega(\\vec{r})} \\frac{G(|\\vec r - \\vec{r'}|)}{|\\vec r - \\vec{r'}|^2} c(\\vec{r'})\\,d\\vec{r'},", element, {displayMode:true,throwOnError:false});$

where the integration domain $var element = document.getElementById("moose-equation-7cad1f79-eceb-4638-a555-c40d5a16dddb");katex.render("\\Omega", element, {displayMode:false,throwOnError:false});$ is defined as the ball with radius $var element = document.getElementById("moose-equation-0d8ee6d2-1653-462f-9eca-3b669f1fbb5e");katex.render("r_{cut}", element, {displayMode:false,throwOnError:false});$ (r_cut)

$var element = document.getElementById("moose-equation-4824fa0c-a9cc-493e-8ba7-9b46ec9cfe97");katex.render("\\Omega(\\vec r) = \\left\\{\\vec{r'} \\in \\mathbb{R}^3: |\\vec r - \\vec{r'}| < r_{cut}\\right\\}.", element, {displayMode:true,throwOnError:false});$

note

Note that the geometrical attenuation $var element = document.getElementById("moose-equation-138393a7-dbcd-41af-bf9d-b08d79e13c43");katex.render("\\frac1{4\\pi |\\vec r - \\vec{r'}|^2}", element, {displayMode:false,throwOnError:false});$ is not part of $var element = document.getElementById("moose-equation-862207ce-d115-4f0c-8b35-1912aa0ceec0");katex.render("G", element, {displayMode:false,throwOnError:false});$ .

note

The convolution will always be computed in 3D, no matter what the mesh dimension is.

Applications

$var element = document.getElementById("moose-equation-66b1e15e-053b-4ca4-9d94-b92a9fbf1b9e");katex.render("G(r)", element, {displayMode:false,throwOnError:false});$ could be a probability distribution for ballistically knocking an atom in the sample for a distance $var element = document.getElementById("moose-equation-a0af8ed8-380c-4ace-8844-660a29731008");katex.render("r", element, {displayMode:false,throwOnError:false});$ . Such a function could be obtained using a binary collision Monte Carlo code.

Applying this convolution using a RadialGreensSource kernel would then correspond to applying ballistic mixing to the sample. The probability of hitting an atom at all would be cntrolled using the gamma parameter in the kernel.

Design

The RadialGreensFunction user object is derived from ElementUserObject and works in two stages.

In the element loop (in the execute() method) a list of all quadrature points, their locations, indices, and selected variable value is compiled.
In the finalize() method
1. the list is communicated in parallel
2. a KD-tree is filled witha ll quadrature point entries (utilizing the nanoflann library bundled with libMesh)
3. a loop over all QPs is performed and at each QP a $var element = document.getElementById("moose-equation-abb940be-e70d-4c25-9025-e3bfcd4dfb6b");katex.render("r_{cut}", element, {displayMode:false,throwOnError:false});$ (r_cut) radius search in the KD-tree is performed
4. the results from the search are used to spatially integrate the selected variable field multiplied with the Green's Function $var element = document.getElementById("moose-equation-d5f609cf-1032-4f1a-acad-3a28905554c0");katex.render("G", element, {displayMode:false,throwOnError:false});$ and the geometric attenuation $var element = document.getElementById("moose-equation-dcb06b93-bbb7-42e7-a6a0-8dfc155a2687");katex.render("\\left(4\\pi |\\vec r - \\vec{r'}|^2\\right)^{-1}", element, {displayMode:false,throwOnError:false});$ .
5. The integral is normalized to ensure mass conservation

Input Parameters

functionGreen's function (distance is substituted for x) without geometrical attenuation
C++ Type:FunctionName
Unit:(no unit assumed)
Controllable:No
Description:Green's function (distance is substituted for x) without geometrical attenuation
r_cutCut-off radius for the Green's function
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Cut-off radius for the Green's function

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
normalizeFalseNormalize the Green's function integral to one
Default:False
C++ Type:bool
Controllable:No
Description:Normalize the Green's function integral to one
vVariable to gather
C++ Type:std::vector<VariableName>
Unit:(no unit assumed)
Controllable:No
Description:Variable to gather

Optional Parameters

allow_duplicate_execution_on_initialFalseIn the case where this UserObject is depended upon by an initial condition, allow it to be executed twice during the initial setup (once before the IC and again after mesh adaptivity (if applicable).
Default:False
C++ Type:bool
Controllable:No
Description:In the case where this UserObject is depended upon by an initial condition, allow it to be executed twice during the initial setup (once before the IC and again after mesh adaptivity (if applicable).
execute_onTIMESTEP_BEGINThe 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:TIMESTEP_BEGIN
C++ Type:ExecFlagEnum
Options: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
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.
execution_order_group0Execution order groups are executed in increasing order (e.g., the lowest number is executed first). Note that negative group numbers may be used to execute groups before the default (0) group. Please refer to the user object documentation for ordering of user object execution within a group.
Default:0
C++ Type:int
Controllable:No
Description:Execution order groups are executed in increasing order (e.g., the lowest number is executed first). Note that negative group numbers may be used to execute groups before the default (0) group. Please refer to the user object documentation for ordering of user object execution within a group.
force_postauxFalseForces the UserObject to be executed in POSTAUX
Default:False
C++ Type:bool
Controllable:No
Description:Forces the UserObject to be executed in POSTAUX
force_preauxFalseForces the UserObject to be executed in PREAUX
Default:False
C++ Type:bool
Controllable:No
Description:Forces the UserObject to be executed in PREAUX
force_preicFalseForces the UserObject to be executed in PREIC during initial setup
Default:False
C++ Type:bool
Controllable:No
Description:Forces the UserObject to be executed in PREIC during initial setup

Execution Scheduling 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.
implicitTrueDetermines whether this object is calculated using an implicit or explicit form
Default:True
C++ Type:bool
Controllable:No
Description:Determines whether this object is calculated using an implicit or explicit form
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

Input Files

(examples/convolution/diffusion_validation.i)
(tests/greens/parallel.i)
(tests/greens/dimension.i)
(tests/greens/test.i)

References

No citations exist within this document.

(examples/convolution/diffusion_validation.i)

#
# Validate the Green's Function convolution user object by comparing the
# time integration of the Diffusion equation using the TimeDerivative and Diffusion
# Kernels (c1) to the repeated application of the Green's Function of the Diffusion
# equation (c2).
#
# Compare the results in gnuplot using
#   gnuplot> set datafile separator ','; set key autotitle columnhead
#   gnuplot> pl 'diffusion_validation_out_c_0020.csv' u 1:5 w l, 'diffusion_validation_out_c_0020.csv' u 1:6 w l
#

[Mesh]
  type = GeneratedMesh
  dim = 1
  nx = 200
  xmin = -10
  xmax = 10
[]

[Functions]
  [ic]
    type = ParsedFunction
    # box profile initial condition (Note: this causes Gibbs oscillations that get amplified in the c2 solution)
    expression = 'if(abs(x)<=2,1,0)'
  []
  [G]
    type = ParsedFunction
    # adjust the simulation timestep here!
    symbol_names = dt
    symbol_values = 0.1
    # the diffusion Green's function for D=1 is
    # exp(-r^2/(4*dt))
    # Note1: We need to multiply with r^2 to compensate for the r^-2 geometrical
    # attenuation term that is multiplied on by the userobject (x <=> r)
    # Note2: we use normalize = true below to autonormalize the Green's function
    # so we can leave off the prefactor
    expression = exp(-x^2/(4*dt))*x^2
  []
[]

[Variables]
  [c1]
    [InitialCondition]
      type = FunctionIC
      function = ic
    []
  []
  [c2]
    [InitialCondition]
      type = FunctionIC
      function = ic
    []
  []
[]

[BCs]
  [Periodic]
    [all]
      auto_direction = x
    []
  []
[]

[Kernels]
  [dt1]
    type = TimeDerivative
    variable = c1
  []
  [diff1]
    type = Diffusion
    variable = c1
  []

  [dt2]
    type = TimeDerivative
    variable = c2
  []
  [source2]
    type = RadialGreensSource
    variable = c2
    # set gamma = 1/dt
    # otherwise the convolution result is not fully applied. We are not using the
    # convolution result as a rate, but want to change the variable field into the
    # convolution result
    gamma = 10
    convolution = convolution
  []
[]

[UserObjects]
  [convolution]
    type = RadialGreensConvolution
    normalize = true
    v = c2
    function = G
    r_cut = 2.0
  []
[]

[VectorPostprocessors]
  [c]
    type = LineValueSampler
    execute_on = 'INITIAL TIMESTEP_END'
    variable = 'c1 c2'
    start_point = '-10 0 0'
    end_point = '10 0 0'
    # sample at element edges (nodes) and centers |---*---|---*---|
    num_points = 399
    sort_by = x
  []
[]

[Executioner]
  type = Transient
  # use a small timestep to reduce time integration error
  dt = 0.1
  num_steps = 20
[]

[Outputs]
  csv = true
[]

(tests/greens/parallel.i)

[Mesh]
  type = GeneratedMesh
  dim = 2
  xmin = 0
  ymin = 0
  xmax = 100
  ymax = 100
  nx = 100
  ny = 100
  parallel_type = DISTRIBUTED
[]

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

[Variables]
  [./c]
    initial_condition = 1
  [../]
[]

[BCs]
  [./Periodic]
    [./all]
      auto_direction = 'x y'
    [../]
  [../]
[]

[Kernels]
  [./dt]
    type = TimeDerivative
    variable = c
  [../]
  [./cc1]
    type = RadialGreensSource
    variable = c
    gamma = 1
    convolution = green
  [../]
[]

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

[UserObjects]
  [./green]
    type = RadialGreensConvolution
    execute_on = TIMESTEP_BEGIN
    v = c
    r_cut = 5.0001
    function = '5.0001-x'
    normalize = true
  [../]
[]


[Postprocessors]
  [./c_min]
    type = ElementExtremeValue
    value_type = min
    execute_on = 'INITIAL TIMESTEP_END'
    variable = c
  [../]
  [./c_max]
    type = ElementExtremeValue
    value_type = max
    execute_on = 'INITIAL TIMESTEP_END'
    variable = c
  [../]
[]

[Executioner]
  type = Transient
  nl_abs_tol = 1e-10
  num_steps = 1
[]

[Outputs]
  csv = true
  execute_on = FINAL
  [./perf]
    type = PerfGraphOutput
    level = 3
  [../]
[]

(tests/greens/dimension.i)

#
# Example problem showing how to use the DerivativeParsedMaterial with SplitCHParsed.
# The free energy is identical to that from SplitCHMath, f_bulk = 1/4*(1-c)^2*(1+c)^2.
#

[Mesh]
  type = GeneratedMesh
  dim = ${dim}
  nx = 20
  ny = 5
  nz = 5
  xmin = -25
  ymin = -10
  zmin = -10
  xmax = 25
  ymax = 10
  zmax = 10
[]

[Variables]
  [./c]
  [../]
[]

[ICs]
  [./xstep]
    type = FunctionIC
    variable = c
    function = 'if(x>0,
      if(x<1, 1+2*x^3-3*x^2, 0),
      if(x<-24, 3*(x+25)^2-2*(x+25)^3, 1)
    )'
  [../]
[]

[Kernels]
  [./c_dot]
    type = TimeDerivative
    variable = c
  [../]
  [./green]
    type = RadialGreensSource
    variable = c
    gamma = 1
    convolution = green
  [../]
[]

[UserObjects]
  [./green]
    type = RadialGreensConvolution
    v = c
    r_cut = 10
    normalize = true
    function = 'exp(-x/5)'
  [../]
[]

[BCs]
  [./Periodic]
    [./all]
      auto_direction = ${pbc}
    [../]
  [../]
[]

[VectorPostprocessors]
  [./c]
    type = LineValueSampler
    execute_on = 'INITIAL TIMESTEP_END'
    variable = c
    start_point = '-25 0 0'
    end_point = '25 0 0'
    num_points = 40
    sort_by = x
  [../]
[]

[Executioner]
  type = Transient
  solve_type = NEWTON
  scheme = bdf2

  petsc_options_iname = '-pc_type -sub_pc_type'
  petsc_options_value = 'asm      ilu         '

  l_max_its = 60
  l_tol = 1e-4
  nl_max_its = 30
  nl_rel_tol = 1e-9
  nl_abs_tol = 1e-10

  dt = 1
  num_steps = 1
[]

[Outputs]
  execute_on = FINAL
  file_base = dimension${dim}_out
  csv = true
  print_linear_residuals = false
[]

(tests/greens/test.i)

[Mesh]
  type = GeneratedMesh
  dim = 2
  xmin = -10
  ymin = -10
  xmax = 10
  ymax = 10
  nx = 20
  ny = 20
[]

[Variables]
  [./c]
    [./InitialCondition]
      type = FunctionIC
      function = 'if((x+6)^2+(y-5)^2<16,1,0)'
    [../]
  [../]
[]

[BCs]
  [./Periodic]
    [./all]
      auto_direction = 'x y'
    [../]
  [../]
[]

[Kernels]
  [./dt]
    type = TimeDerivative
    variable = c
  [../]
  [./cc1]
    type = RadialGreensSource
    variable = c
    gamma = 1
    convolution = green1
  [../]
  [./cc2]
    type = RadialGreensSource
    variable = c
    gamma = 1e-1
    convolution = green2
  [../]
[]

[UserObjects]
  [./green1]
    type = RadialGreensConvolution
    execute_on = TIMESTEP_BEGIN
    v = c
    r_cut = 8
    function = 'exp(-x/2)'
    normalize = true
  [../]
  [./green2]
    type = RadialGreensConvolution
    execute_on = TIMESTEP_BEGIN
    v = c
    r_cut = 6.28
    function = 'sin(x)'
    normalize = true
  [../]
[]

[AuxVariables]
  [./cc1]
    order = CONSTANT
    family = MONOMIAL
  [../]
  [./cc2]
    order = CONSTANT
    family = MONOMIAL
  [../]
[]

[AuxKernels]
  [./cc1]
    type = RadialGreensAux
    variable = cc1
    convolution = green1

  [../]
  [./cc2]
    type = RadialGreensAux
    variable = cc2
    convolution = green2
  [../]
[]

[Postprocessors]
  [./C]
    type = ElementIntegralVariablePostprocessor
    execute_on = 'INITIAL TIMESTEP_END'
    variable = c
  [../]
  [./CC1]
    type = ElementIntegralVariablePostprocessor
    execute_on = 'INITIAL TIMESTEP_END'
    variable = cc1
  [../]
  [./CC2]
    type = ElementIntegralVariablePostprocessor
    execute_on = 'INITIAL TIMESTEP_END'
    variable = cc2
  [../]
[]

[Executioner]
  type = Transient
  num_steps = 1
[]

[Outputs]
  exodus = true
  execute_on = FINAL
[]

Applications
Design
Input Parameters
Input Files
References