TrappingNodalKernelDimensionless

Implements the trapping source term for a dimensionless trapped-species variable Ct_hat = C_t / C_t_ref. The mobile concentration may be either physical or dimensionless. No equation scaling is applied; the residual is O(k_t_hat).

Overview

TrappingNodalKernelDimensionless is the dimensionless analogue of TrappingNodalKernel. It applies the trapping source term to a dimensionless trapped-species variable, $var element = document.getElementById("moose-equation-e9f4b51e-9682-41b8-817d-e5e87ec158ca");katex.render("\\hat{C}_t = C_t / C_{t,\\mathrm{ref}}", element, {displayMode:false,throwOnError:false});$ with $var element = document.getElementById("moose-equation-7877d7c9-4be8-49ad-a2c0-94062cd5638f");katex.render("C_t", element, {displayMode:false,throwOnError:false});$ the trapped-species variable and $var element = document.getElementById("moose-equation-84940243-fb30-4672-b324-d0e11accaa5b");katex.render("C_{t,\\mathrm{ref}}", element, {displayMode:false,throwOnError:false});$ the characteristic trapped-species scale in the same unit as $var element = document.getElementById("moose-equation-6508f66f-dea1-4c90-be11-0e038f6feae5");katex.render("C_t", element, {displayMode:false,throwOnError:false});$ .

This object implements the residual

$var element = document.getElementById("moose-equation-6a4e39c2-6fcb-4556-bd26-3c2511e0b1a3");katex.render("\\hat{k}_t \\exp(-\\epsilon / T) \\left( \\frac{N C_{t0} - C_{t,\\mathrm{ref}} \\hat{C}_t - \\sum_j C_{t,\\mathrm{ref},j} \\hat{C}_{t,j}} {C_{t,\\mathrm{ref}}} \\right) \\hat{C}_m", element, {displayMode:true,throwOnError:false});$

where $var element = document.getElementById("moose-equation-47a6e4d3-fc41-4f14-b3eb-6d4ecf7db40e");katex.render("\\hat{k}_t", element, {displayMode:false,throwOnError:false});$ is the dimensionless trapping rate, $var element = document.getElementById("moose-equation-4b634762-339f-49aa-9b48-f7017463cc5a");katex.render("\\epsilon", element, {displayMode:false,throwOnError:false});$ is the trapping activation energy in Kelvin, $var element = document.getElementById("moose-equation-6742a771-75da-4cf8-bbf2-ffb7c82ce128");katex.render("T", element, {displayMode:false,throwOnError:false});$ is the temperature in Kelvin, $var element = document.getElementById("moose-equation-6ee15cd7-8e2e-4fdd-91b1-80d7cc2b6abe");katex.render("N", element, {displayMode:false,throwOnError:false});$ is the atomic number density of the host material, $var element = document.getElementById("moose-equation-f88f1cfa-32d0-467e-9170-a8636ee017ee");katex.render("C_{t0}", element, {displayMode:false,throwOnError:false});$ is the fraction of host sites that can trap the species, $var element = document.getElementById("moose-equation-61727c65-f265-4d02-9e33-f5734e5ff0d1");katex.render("\\hat{C}_t", element, {displayMode:false,throwOnError:false});$ is the dimensionless concentration of this trapped species, $var element = document.getElementById("moose-equation-dc84fcca-cfd8-4096-b60f-ed983ace9cd8");katex.render("\\hat{C}_{t,j}", element, {displayMode:false,throwOnError:false});$ are optional competing trapped-species variables, and $var element = document.getElementById("moose-equation-ab0b2be5-158b-499d-a479-3d4c801453af");katex.render("\\hat{C}_m", element, {displayMode:false,throwOnError:false});$ is the coupled mobile concentration variable.

The implementation computes the available trapping sites in physical units,

$var element = document.getElementById("moose-equation-e9d1918f-c13d-41b7-9c5e-7c0117162abd");katex.render("N C_{t0} - C_{t,\\mathrm{ref}} \\hat{C}_t - \\sum_j C_{t,\\mathrm{ref},j} \\hat{C}_{t,j},", element, {displayMode:true,throwOnError:false});$

and then divides by $var element = document.getElementById("moose-equation-9259ce85-0c61-4166-a2d7-5dcfa140d2f9");katex.render("C_{t,\\mathrm{ref}}", element, {displayMode:false,throwOnError:false});$ so that the residual is written for the dimensionless unknown $var element = document.getElementById("moose-equation-fc37663a-44af-4864-8085-9f39390dcff3");katex.render("\\hat{C}_t", element, {displayMode:false,throwOnError:false});$ . Unlike TrappingNodalKernel, this object does not use the trap_per_free scaling factor that the dimensional kernel uses to convert between trapped-species and mobile-species concentration scales. Here, the conversion is handled explicitly through trap_concentration_reference ( $var element = document.getElementById("moose-equation-b5507d3d-0412-4a95-92a7-eb5e99bf4da9");katex.render("C_{t,\\mathrm{ref}}", element, {displayMode:false,throwOnError:false});$ ) and other_trap_concentration_references ( $var element = document.getElementById("moose-equation-aad3aace-eb54-45c0-bce4-a839b8602960");katex.render("C_{t,\\mathrm{ref},j}", element, {displayMode:false,throwOnError:false});$ ), so the residual is expected to remain $var element = document.getElementById("moose-equation-a016f66c-19cf-4f9c-9c64-7ee2cb6447db");katex.render("O(\\hat{k}_t)", element, {displayMode:false,throwOnError:false});$ when the variables are scaled with appropriate reference values.

Input Parameters

Ct0The fraction of host sites that can contribute to trapping as a function (-)
C++ Type:FunctionName
Unit:(no unit assumed)
Controllable:No
Description:The fraction of host sites that can contribute to trapping as a function (-)
NThe atomic number density of the host material (1/m^3)
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:The atomic number density of the host material (1/m^3)
dimensionless_trapping_rate_coefficientDimensionless trapping rate coefficient k_t_hat = t_ref * alpha_t * C_m_ref / N.
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Dimensionless trapping rate coefficient k_t_hat = t_ref * alpha_t * C_m_ref / N.
mobile_concentrationThe variable representing the mobile concentration of solute particles.
C++ Type:std::vector<VariableName>
Unit:(no unit assumed)
Controllable:No
Description:The variable representing the mobile concentration of solute particles.
temperatureThe temperature (K)
C++ Type:std::vector<VariableName>
Unit:(no unit assumed)
Controllable:No
Description:The temperature (K)
trap_concentration_referenceReference concentration C_t_ref for this trap species (same units as N). Typically set to N * Ct0_max. The variable stores Ct_hat = C_t / C_t_ref.
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Reference concentration C_t_ref for this trap species (same units as N). Typically set to N * Ct0_max. The variable stores Ct_hat = C_t / C_t_ref.
variableThe name of the variable that this residual object operates on
C++ Type:NonlinearVariableName
Unit:(no unit assumed)
Controllable:No
Description:The name of the variable that this residual object operates on

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
other_trap_concentration_referencesReference concentrations C_t_ref_j for each variable listed in other_trapped_concentration_variables, used to convert Ct_hat_j back to physical C_t_j when computing available trapping sites. Must match in length.
C++ Type:std::vector<double>
Unit:(no unit assumed)
Controllable:No
Description:Reference concentrations C_t_ref_j for each variable listed in other_trapped_concentration_variables, used to convert Ct_hat_j back to physical C_t_j when computing available trapping sites. Must match in length.
other_trapped_concentration_variablesDimensionless trapped-concentration variables (Ct_hat_j = C_t_j / C_t_ref_j) for other trap species that compete for the same trapping sites.
C++ Type:std::vector<VariableName>
Unit:(no unit assumed)
Controllable:No
Description:Dimensionless trapped-concentration variables (Ct_hat_j = C_t_j / C_t_ref_j) for other trap species that compete for the same trapping sites.
trapping_energy0The trapping energy (K)
Default:0
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:The trapping energy (K)

Optional Parameters

absolute_value_vector_tagsThe tags for the vectors this residual object should fill with the absolute value of the residual contribution
C++ Type:std::vector<TagName>
Controllable:No
Description:The tags for the vectors this residual object should fill with the absolute value of the residual contribution
extra_matrix_tagsThe extra tags for the matrices this Kernel should fill
C++ Type:std::vector<TagName>
Controllable:No
Description:The extra tags for the matrices this Kernel should fill
extra_vector_tagsThe extra tags for the vectors this Kernel should fill
C++ Type:std::vector<TagName>
Controllable:No
Description:The extra tags for the vectors this Kernel should fill
matrix_onlyFalseWhether this object is only doing assembly to matrices (no vectors)
Default:False
C++ Type:bool
Controllable:No
Description:Whether this object is only doing assembly to matrices (no vectors)
matrix_tagssystemThe tag for the matrices this Kernel should fill
Default:system
C++ Type:MultiMooseEnum
Options:nontime, system
Controllable:No
Description:The tag for the matrices this Kernel should fill
vector_tagsnontimeThe tag for the vectors this Kernel should fill
Default:nontime
C++ Type:MultiMooseEnum
Options:nontime, time
Controllable:No
Description:The tag for the vectors this Kernel should fill

Contribution To Tagged Field Data 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.
diag_save_inThe name of auxiliary variables to save this BC's diagonal jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.)
C++ Type:std::vector<AuxVariableName>
Unit:(no unit assumed)
Controllable:No
Description:The name of auxiliary variables to save this BC's diagonal jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.)
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
save_inThe name of auxiliary variables to save this BC's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.)
C++ Type:std::vector<AuxVariableName>
Unit:(no unit assumed)
Controllable:No
Description:The name of auxiliary variables to save this BC's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.)
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

Overview
Input Parameters