MOOSE User Short Workshop

Idaho National Laboratory

Established in 2005, INL is the lead nuclear energy R&D laboratory for the Department of Energy

"Establish a world-class capability in the modeling and simulation of advanced energy systems..."

INL is the one of the largest employers in Idaho with over 6,000 employees and 500 interns
In 2024 the INL budget was over $2 billion

INL is the site where 52 nuclear reactors were designed and constructed, including the first reactor to generate usable amounts of electricity: Experimental Breeder Reactor I (EBR-1)

Advanced Test Reactor (ATR)

World's most powerful test reactor (250 MW thermal)
Constructed in 1967
Volume of 1.4 cubic meters, with 43 kg of uranium, and operates at 60C

Advanced Test Reactor, demonstrating Cherenkov radiation.

Transient Reactor Test Facility (TREAT)

TREAT is a test facility specifically designed to evaluate the response of fuels and materials to accident conditions

High-intensity (20 GW), short-duration (80 ms) neutron pulses for severe accident testing

National Reactor Innovation Center (NRIC)

NRIC is composed of two physical test beds to build prototypes of advanced nuclear reactors:

DOME (Demonstration of Microreactor Experiments) in the historic EBR-II facility, a test bed site capable of hosting operational nuclear reactor concepts that produce less than 20MW thermal power.
LOTUS (Laboratory for Operation and Testing in the U.S.) in the historic Zero Power Physics Reactor (ZPPR) Cell, a test bed site capable of hosting operational nuclear reactor concepts that produce less than 500kW thermal power.

NRIC also manages the open-source Virtual Test Bed to demonstrate advanced reactors through modeling and simulation. More information about NRIC can be found at https://nric.inl.gov.

Advanced Reactor Demonstration Timeline

MOOSE

Multi-physics Object Oriented Simulation Environment

History and Purpose

Development started in 2008
Open-sourced in 2014
Designed to solve computational engineering problems and reduce the expense and time required to develop new applications by:
- Being easily extended and maintained
- Working efficiently on a few and many processors
- Providing an object-oriented, extensible system for creating all aspects of a simulation tool
Motivated by multiphysics problems in nuclear engineering, but applications have extended into diverse fields
Core team at Idaho National Laboratory, but with significant contributions from other laboratories, universities, and industry, both domestically and internationally

By The Numbers

250 contributors
58,000 commits
5,000 unique visitors per month
~40 new Discussion participants per week
150M tests per week

General Capabilities

Continuous and Discontinuous Galerkin FEM
Finite Volume
Supports fully coupled or segregated systems, fully implicit and explicit time integration
Automatic differentiation (AD)
Unstructured mesh with FEM shapes
Higher order geometry
Mesh adaptivity (refinement and coarsening)
Massively parallel (MPI and threads)
User code agnostic of dimension, parallelism, shape functions, etc.
Native support for executing multiphysics simulations across applications
GPU support for execution via MFEM and Kokkos
Operating Systems:
- macOS (Conda, Docker)
- Linux (Apptainer, Conda, Docker)
- Windows (Docker, WSL)

Object-oriented, pluggable system

Example Code

The relationship between the strong form of an equation, the weak form, and the code for one of the terms.

Software Quality

Follows a Nuclear Quality Assurance Level 1 (NQA-1) development process
All changes undergo independent review and must pass regression tests before merge
Includes a test suite and documentation system to allow for agile development while maintaining a NQA-1 process
External contributions are guided through the process by the team, and are very welcome!

Development Process

Flowchart for developing MOOSE, including continuous integration.

Community

github.com/idaholab/moose/discussions

License

LGPL 2.1
Does not limit what you can do with your application
- Can license/sell your application as closed source
Modifications to the library itself (or the modules) are open source
New contributions are automatically LGPL 2.1

MOOSE Modules and Applications

MOOSE Modules

MOOSE has numerous optional modules:

Physics
Chemical Reactions
Contact
Electromagnetics
Fluid Structure Interaction (FSI)
Geochemistry
Heat Transfer
Level Set
Navier Stokes
Peridynamics
Phase Field
Porous Flow
Solid Mechanics
Subchannel
Thermal Hydraulics

Numerics
External PETSc Solver
Function Expansion Tools
Optimization
Ray Tracing
rDG
Stochastic Tools
XFEM

Physics support
Fluid Properties
Solid Properties
Reactor

MOOSE Ecosystem

Open-Source Applications

Some open-source MOOSE applications:

Code	Description	Link
Cardinal	Multiphysics (MOOSE, OpenMC, NekRS)	Repo
MASTODON	Seismic analysis	Repo
OpenPronghorn	Coarse-mesh thermal hydraulics	Repo
TMAP8	Tritium migration	Repo

NCRC Applications

The Nuclear Computational Resource Center (NCRC) licenses several MOOSE applications:

Code	Description
Bison	Fuel performance, thermomechanics
BlueCRAB	Multiphysics (Griffin, Bison, Pronghorn, SAM, TRACE, Sockeye)
DireWolf	Microreactor multiphysics (Griffin, Bison, Sockeye)
Griffin	Deterministic radiation transport
Grizzly	Component aging
Pronghorn	Coarse-mesh thermal hydraulics
SAM	Advanced reactor systems analysis
Sabertooth	Multiphysics (Griffin, Bison, RELAP-7)
Sockeye	Heat pipe analysis

Apply for access: NCRC

Multiphysics Simulation

Historical Multiphysics Simulation

Predictive multiphysics capability involved best-estimate calculations
- Best estimates: data and correlation driven, many approximations
- Necessitated experimental data for each design
Physics performed independently
- Was a "siloed" task; handoffs of data/results from person to person
While individual codes were computationally efficient and well validated, coupling them was neither efficient nor well validated
Used many approximations for evaluations of safety parameters
- Pin-power reconstruction, gap conductance, spacer grid models

Modern Multiphysics Simulation

Direct, physics-based models of all components
- Reduces approximations as needed
- Can be computationally expensive
Can employ tighter and more consistent coupling
Length and time scales of physics can be vastly different
- What does this change for the analyst?
Not as well validated:
- Experiments prohibitively expensive
- Very large design space

Modularity is Key

Data should be accessed through strict interfaces with code having separation of responsibilities
- Allows for "decoupling" of code
- Leads to more reuse and less bugs
- Challenging for FEM
  - Shape functions, degrees of freedom, meshing, quadrature points, material properties, analytic functions, global integrals, data transfer, ...
  - The complexity makes computational science codes brittle and hard to reuse
A consistent set of "systems" are needed to carry out common actions, these systems should be separated by interfaces

Finite-Element Reactor Fuel Simulation

MOOSE Coupling Strategies

Coupling strategies:
- Full coupling: Solve all physics in a single (linear or nonlinear) system
- Loose coupling: Solve each physics sequentially
- Tight coupling: Solve each physics sequentially and iterate
Segregated (loose/tight) coupling achieved using MultiApps
- Physics coupled via in-memory transfer of fields and scalars
Coupling specified in the input file (no code needed)
No universally superior coupling strategy; correct choice depends on problem
Provides a standardized interface for an analyst to produce a coupled model

MOOSE MultiApp Hierarchy Example

Tutorial Steps

Step 1: Input and Meshing
Step 2: Diffusion
Step 3: Postprocessing
Step 4: Materials
Step 5: Heat Conduction
Step 6: Coupling

Step 1: Input and Meshing

MOOSE Input

An input file defines a MOOSE simulation and follows a standardized syntax, the "hierarchical input text" (HIT) format.

A basic MOOSE input file typically has six "blocks":

[Mesh]: Define the geometry of the domain
[Variables]: Define the unknown(s) of the problem
[Kernels]: Define the equation(s) to solve
[BCs]: Define the boundary condition(s) of the problem
[Executioner]: Define how the problem will be solved
[Outputs]: Define how the solution will be returned

There are caveats to the above and many other blocks exist. Shortcut syntax can also be created to simplify input.

A listing of all syntax can be found here.

The Moose Language Support VSCode extension adds diagnostics and autocompletion to input in VSCode.

Introduction to Input

We will work through the process of mesh generation as an introduction to building MOOSE input.

The first step will be the generation of a mesh that is uniform two-dimensional grid using the GeneratedMeshGenerator.

Basic Mesh Input

[Mesh<<<{"href": "../syntax/Mesh/index.html"}>>>]
  [gmg]
    type = GeneratedMeshGenerator<<<{"description": "Create a line, square, or cube mesh with uniformly spaced or biased elements.", "href": "../source/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"}>>> = 10
  []
[]

(tutorials/user_short_workshop/inputs/step1_input_and_meshing/basic.i)

The above defines a GeneratedMeshGenerator named gmg with the parameters:

dim: sets the dimension to $var element = document.getElementById("moose-equation-97804243-35d9-47b3-85bc-25b3a33f92a8");katex.render("2", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$
nx: which builds $var element = document.getElementById("moose-equation-a78cf77c-fb98-4d8d-8425-d7fa8e6478bf");katex.render("10", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ elements in the $var element = document.getElementById("moose-equation-81512c6f-e434-470b-973b-74fde3e5b226");katex.render("x", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ -direction
ny: which builds $var element = document.getElementById("moose-equation-c3b60c44-cd58-4dad-b7a1-9f3f50bc27eb");katex.render("10", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ elements in the $var element = document.getElementById("moose-equation-c379fcf1-a760-4ccf-a8c2-2046744a837c");katex.render("y", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ -direction

Run: Basic Mesh Input


$ cd moose/step1_input_and_meshing
$ moose-opt -i basic.i --mesh-only

The argument -i specifies which input file to run
The --mesh-only argument forces only mesh generation and output in Exodus format
- Without arguments to --mesh-only, the mesh will be output as Exodus in the same folder as the input with the name <input_file>_in.e, i.e., basic_in.e
- If an argument is provided to --mesh-only, that argument will be used as the output path for the generated mesh
This output format, Exodus, is commonly inspected using Paraview

Result: Basic Mesh Input

From basic_in.e in Paraview

MeshGenerator System

The previous example utilized the MOOSE MeshGenerator system:

Enables the programmatic construction of a mesh
Generation can be chained together through dependencies so that complex meshes may be built up from a series of simple processes
Several built-in generators exist but you can develop your own MeshGenerators
- Built-in examples: building grids and concentric circles; triangulation and tetrahedralization; extrusion; renaming and merging of blocks and sidesets; stitching; scaling, translating, and rotating; image conversion
Supports distributed mesh generation and modification
Enables the addition of "metadata" to meshes
- Particularly useful in neutronics for storing things like depletion zones

All of our examples that follow (including the Cardinal tutorial) will utilize the MeshGenerator system. Of significant note is the Reactor module, which supports the systematic mesh generation of common reactor types.

Loading Meshes From File

Meshes can also be loaded from file, of which we support a variety of formats like Exodus, GMSH, Nemesis, Tecplot, VTK, etc


[Mesh]
  [from_file]
    type = FileMeshGenerator
    file = foo.e
  []
[]

Other Input Syntax


# Include the input at file.i here
!include file.i

value = true       # boolean
value = '1 2 3 4'  # vector -> [1, 2, 3, 4]
value = '1 2; 3 4' # vector-of-vectors -> [[1, 2], [3, 4]]

# Equivalent to [Mesh][gmg]
[Mesh/gmg]
  type = GeneratedMeshGenerator
  ...
[]

# Reference another value
value = 1.0
another_value = ${value}

# Perform basic arithmetic on another parameter (raidus = 0.5)
diameter = 1.0
radius = ${fparse diameter/2}

Concentric Circle Mesh

The grid we first generated isn't particularly interesting.

Let's generate a mesh that represents represents a fuel pin surrounded by water in a square lattice using the ConcentricCircleMeshGenerator with the following dimensions:

Quantity	Value
Hole radius	$var element = document.getElementById("moose-equation-ce678c07-d41b-42c6-94d2-c9efb55adfd0");katex.render("0.08", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ cm
Pellet radius	$var element = document.getElementById("moose-equation-797f959c-e454-40b1-aeb7-ef5e9c4eeb18");katex.render("0.26", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ cm
Clad radius	$var element = document.getElementById("moose-equation-7ded7c7b-3335-4681-b202-79bd170d5c4d");katex.render("0.3", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ cm
Pitch	$var element = document.getElementById("moose-equation-cf6fcfe3-fb1a-45f8-a9ba-9de5aa0a7d28");katex.render("0.695", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ cm

We will also apply a special treatment at the clad-fluid interface to support a thermal-hydraulics solve with a boundary layer.

Input: Concentric Circle Mesh

hole_radius = 0.08e-2     # [m]
pellet_radius = 0.26e-2   # [m]
clad_radius = 0.3e-2      # [m]
water_radius = 0.3475e-2  # [m]

boundary_layer_frac = 0.1
boundary_layer_radius = ${fparse ((water_radius - clad_radius) * boundary_layer_frac + clad_radius)}

[Mesh<<<{"href": "../syntax/Mesh/index.html"}>>>]
  [concentric_circle]
    type = ConcentricCircleMeshGenerator<<<{"description": "This ConcentricCircleMeshGenerator source code is to generate concentric circle meshes.", "href": "../source/meshgenerators/ConcentricCircleMeshGenerator.html"}>>>
    num_sectors<<<{"description": "num_sectors % 2 = 0, num_sectors > 0Number of azimuthal sectors in each quadrant'num_sectors' must be an even number."}>>> = 12
    radii<<<{"description": "Radii of major concentric circles"}>>> = '${hole_radius} ${pellet_radius} ${clad_radius} ${boundary_layer_radius}'
    has_outer_square<<<{"description": "It determines if meshes for a outer square are added to concentric circle meshes."}>>> = true
    preserve_volumes<<<{"description": "Volume of concentric circles can be preserved using this function."}>>> = false
    rings<<<{"description": "Number of rings in each circle or in the enclosing square"}>>> = '1 3 1 1 3'
    pitch<<<{"description": "The enclosing square can be added to the completed concentric circle mesh.Elements are quad meshes."}>>> = ${fparse water_radius * 2}
  []
[]

(tutorials/user_short_workshop/inputs/step1_input_and_meshing/concentric_circle.i)

Run: Concentric Circle Mesh


$ moose-opt -i concentric_circle.i --mesh-only


 Mesh Information:
  elem_dimensions()={2}
  elem_default_orders()={FIRST}
  supported_nodal_order()=1
  spatial_dimension()=2
  n_nodes()=729
    n_local_nodes()=729
  n_elem()=688
    n_local_elem()=688
    n_active_elem()=688
  n_subdomains()=5
  n_elemsets()=0
  n_partitions()=1
  n_processors()=1
  n_threads()=1
  processor_id()=0
  is_prepared()=true
  is_replicated()=true

 Mesh Bounding Box:
  Minimum: (x,y,z)=(-0.003475, -0.003475,        0)
  Maximum: (x,y,z)=(0.003475, 0.003475,        0)
  Delta:   (x,y,z)=( 0.00695,  0.00695,        0)

 Mesh Element Type(s):
  QUAD4

 Mesh Nodesets:
  Nodeset 1, 21 nodes
   Bounding box minimum: (x,y,z)=(-0.003475, -0.003475,        0)
   Bounding box maximum: (x,y,z)=(-0.003475, 0.003475,        0)
   Bounding box delta: (x,y,z)=(4.33681e-19,  0.00695,        0)
  Nodeset 2, 21 nodes
   Bounding box minimum: (x,y,z)=(-0.003475, -0.003475,        0)
   Bounding box maximum: (x,y,z)=(0.003475, -0.003475,        0)
   Bounding box delta: (x,y,z)=( 0.00695, 8.67362e-19,        0)
  Nodeset 3, 21 nodes
   Bounding box minimum: (x,y,z)=(0.003475, -0.003475,        0)
   Bounding box maximum: (x,y,z)=(0.003475, 0.003475,        0)
   Bounding box delta: (x,y,z)=(4.33681e-19,  0.00695,        0)
  Nodeset 4, 21 nodes
   Bounding box minimum: (x,y,z)=(-0.003475, 0.003475,        0)
   Bounding box maximum: (x,y,z)=(0.003475, 0.003475,        0)
   Bounding box delta: (x,y,z)=( 0.00695,        0,        0)

 Mesh Sidesets:
  Sideset 1 (left), 20 sides (EDGE2), 20 elems (QUAD4), 21 nodes
   Side volume: 0.00695
   Bounding box minimum: (x,y,z)=(-0.003475, -0.003475,        0)
   Bounding box maximum: (x,y,z)=(-0.003475, 0.003475,        0)
   Bounding box delta: (x,y,z)=(4.33681e-19,  0.00695,        0)
  Sideset 2 (bottom), 20 sides (EDGE2), 20 elems (QUAD4), 21 nodes
   Side volume: 0.00695
   Bounding box minimum: (x,y,z)=(-0.003475, -0.003475,        0)
   Bounding box maximum: (x,y,z)=(0.003475, -0.003475,        0)
   Bounding box delta: (x,y,z)=( 0.00695, 8.67362e-19,        0)
  Sideset 3 (right), 20 sides (EDGE2), 20 elems (QUAD4), 21 nodes
   Side volume: 0.00695
   Bounding box minimum: (x,y,z)=(0.003475, -0.003475,        0)
   Bounding box maximum: (x,y,z)=(0.003475, 0.003475,        0)
   Bounding box delta: (x,y,z)=(4.33681e-19,  0.00695,        0)
  Sideset 4 (top), 20 sides (EDGE2), 20 elems (QUAD4), 21 nodes
   Side volume: 0.00695
   Bounding box minimum: (x,y,z)=(-0.003475, 0.003475,        0)
   Bounding box maximum: (x,y,z)=(0.003475, 0.003475,        0)
   Bounding box delta: (x,y,z)=( 0.00695,        0,        0)

 Mesh Edgesets:
  None

 Mesh Subdomains:
  Subdomain 1: 192 elems (QUAD4, 192 active), 217 active nodes
   Volume: 2.00488e-06
   Bounding box minimum: (x,y,z)=( -0.0008,  -0.0008,        0)
   Bounding box maximum: (x,y,z)=(  0.0008,   0.0008,        0)
   Bounding box delta: (x,y,z)=(  0.0016,   0.0016,        0)
  Subdomain 2: 144 elems (QUAD4, 144 active), 192 active nodes
   Volume: 1.91717e-05
   Bounding box minimum: (x,y,z)=( -0.0026,  -0.0026,        0)
   Bounding box maximum: (x,y,z)=(  0.0026,   0.0026,        0)
   Bounding box delta: (x,y,z)=(  0.0052,   0.0052,        0)
  Subdomain 3: 48 elems (QUAD4, 48 active), 96 active nodes
   Volume: 7.01709e-06
   Bounding box minimum: (x,y,z)=(  -0.003,   -0.003,        0)
   Bounding box maximum: (x,y,z)=(   0.003,    0.003,        0)
   Bounding box delta: (x,y,z)=(   0.006,    0.006,        0)
  Subdomain 4: 48 elems (QUAD4, 48 active), 96 active nodes
   Volume: 8.99867e-07
   Bounding box minimum: (x,y,z)=(-0.0030475, -0.0030475,        0)
   Bounding box maximum: (x,y,z)=(0.0030475, 0.0030475,        0)
   Bounding box delta: (x,y,z)=(0.006095, 0.006095,        0)
  Subdomain 5: 256 elems (QUAD4, 256 active), 320 active nodes
   Volume: 1.9209e-05
   Bounding box minimum: (x,y,z)=(-0.003475, -0.003475,        0)
   Bounding box maximum: (x,y,z)=(0.003475, 0.003475,        0)
   Bounding box delta: (x,y,z)=( 0.00695,  0.00695,        0)
  Global mesh volume = 4.83025e-05

Result: Concentric Circle Mesh Input

This mesh in concentric_circle_in.e has five blocks (also called subdomains):

$var element = document.getElementById("moose-equation-d50bb9f7-d78a-4206-aa56-5b424ebdcc4d");katex.render("1", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ : Inner hole (grey)
$var element = document.getElementById("moose-equation-be997877-abc1-481e-999b-4832cbb1b620");katex.render("2", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ : Fuel (red)
$var element = document.getElementById("moose-equation-3c6f8cda-db87-4fec-9ad1-3f8319de63f2");katex.render("3", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ : Cladding (green)
$var element = document.getElementById("moose-equation-2a02339f-0e3c-4806-ad1b-f902ad310142");katex.render("4", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ : Fluid boundary layer (blue)
$var element = document.getElementById("moose-equation-46226406-020e-4daa-90f4-9109c1329862");katex.render("5", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ : Remaining fluid (yellow)

Separating Meshes

Later in this tutorial, we will be treating the fuel pin and the surrounding fluid independently. Thus, we will now take the mesh that we just generated and separate it into two components: one for the fuel pin and one for the fluid.

This task reveals a capability of MeshGenerators – they can be combined together. Some MeshGenerators generate meshes, some modify meshes, and some do both. Oftentimes a generator will have an input parameter called input, which is used as the name of another MeshGenerator to be used as input to modify.

For the tasks that follow, we will utilize the:

BlockDeletionGenerator: Removes blocks from a mesh
RenameBlockGenerator: Renames and optionally merges blocks on a mesh
RenameBoundaryGenerator: Renames and optionally merges boundaries on a mesh

Fuel Mesh

Remove the hole (assume no net heat transfer across the hole) using the BlockDeletionGenerator
Remove the water elements using the BlockDeletionGenerator
Name the blocks that contain the fuel and cladding using the RenameBlockGenerator

Input: Fuel Mesh

# Include Mesh/concentric_circle, which builds the
# full concentric circle mesh
!include concentric_circle.i

[Mesh]
  # Remove block 1 (hole) and define a boundary
  # "inner" on the interface (the inside)
  [remove_hole]
    type = BlockDeletionGenerator
    input = concentric_circle
    block = 1
    new_boundary = inner
  []

  # Remove block 4 (water boundary layer) and
  # block 5 (water bulk) and define a boundary
  # "water_solid_interface" on the interface
  # (the outside)
  [remove_water]
    type = BlockDeletionGenerator
    input = remove_hole
    block = '4 5'
    new_boundary = water_solid_interface
  []

  # Rename the remaining blocks (2: fuel, 3: clad)
  [rename_blocks]
    type = RenameBlockGenerator
    input = remove_water
    old_block = '2 3'
    new_block = 'fuel clad'
  []
[]

(tutorials/user_short_workshop/inputs/step1_input_and_meshing/fuel_pin.i)

Run: Fuel Mesh


$ moose-opt -i fuel_pin.i --mesh-only


 Mesh Information:
  elem_dimensions()={2}
  elem_default_orders()={FIRST}
  supported_nodal_order()=1
  spatial_dimension()=2
  n_nodes()=240
    n_local_nodes()=240
  n_elem()=192
    n_local_elem()=192
    n_active_elem()=192
  n_subdomains()=2
  n_elemsets()=0
  n_partitions()=1
  n_processors()=1
  n_threads()=1
  processor_id()=0
  is_prepared()=true
  is_replicated()=true

 Mesh Bounding Box:
  Minimum: (x,y,z)=(  -0.003,   -0.003,        0)
  Maximum: (x,y,z)=(   0.003,    0.003,        0)
  Delta:   (x,y,z)=(   0.006,    0.006,        0)

 Mesh Element Type(s):
  QUAD4

 Mesh Nodesets:
  Nodeset 5, 48 nodes
   Bounding box minimum: (x,y,z)=( -0.0008,  -0.0008,        0)
   Bounding box maximum: (x,y,z)=(  0.0008,   0.0008,        0)
   Bounding box delta: (x,y,z)=(  0.0016,   0.0016,        0)
  Nodeset 6, 48 nodes
   Bounding box minimum: (x,y,z)=(  -0.003,   -0.003,        0)
   Bounding box maximum: (x,y,z)=(   0.003,    0.003,        0)
   Bounding box delta: (x,y,z)=(   0.006,    0.006,        0)

 Mesh Sidesets:
  Sideset 5 (inner), 48 sides (EDGE2), 48 elems (QUAD4), 48 nodes
   Side volume: 0.00502296
   Bounding box minimum: (x,y,z)=( -0.0008,  -0.0008,        0)
   Bounding box maximum: (x,y,z)=(  0.0008,   0.0008,        0)
   Bounding box delta: (x,y,z)=(  0.0016,   0.0016,        0)
  Sideset 6 (water_solid_interface), 48 sides (EDGE2), 48 elems (QUAD4), 48 nodes
   Side volume: 0.0188361
   Bounding box minimum: (x,y,z)=(  -0.003,   -0.003,        0)
   Bounding box maximum: (x,y,z)=(   0.003,    0.003,        0)
   Bounding box delta: (x,y,z)=(   0.006,    0.006,        0)

 Mesh Edgesets:
  None

 Mesh Subdomains:
  Subdomain 2 (fuel): 144 elems (QUAD4, 144 active), 192 active nodes
   Volume: 1.91717e-05
   Bounding box minimum: (x,y,z)=( -0.0026,  -0.0026,        0)
   Bounding box maximum: (x,y,z)=(  0.0026,   0.0026,        0)
   Bounding box delta: (x,y,z)=(  0.0052,   0.0052,        0)
  Subdomain 3 (clad): 48 elems (QUAD4, 48 active), 96 active nodes
   Volume: 7.01709e-06
   Bounding box minimum: (x,y,z)=(  -0.003,   -0.003,        0)
   Bounding box maximum: (x,y,z)=(   0.003,    0.003,        0)
   Bounding box delta: (x,y,z)=(   0.006,    0.006,        0)
  Global mesh volume = 2.61888e-05

Result: Fuel Mesh

From fuel_pin_in.e: The grey elements represent the fuel (block fuel), and the red elements represent the cladding (block clad). There is a sideset on the outer boundary with name water_solid_interface and sideset on the inner boundary with the name inner.

Fluid Mesh

Remove the fuel pin elements using the BlockDeletionGenerator
Merge the water boundary layer and remaining water blocks into a single block named water using the RenameBlockGenerator
Rename and merge the outer boundaries into a single boundary outer using the RenameBoundaryGenerator

Input: Fluid Mesh

# Include Mesh/concentric_circle, which builds the
# full concentric circle mesh
!include concentric_circle.i

[Mesh]
  # Remove block 1 (hole), 2 (fuel), 3 (clad)
  # and define a boundary "water_solid_interface"
  # on the interface (the inside)
  [remove_fuel_pin]
    type = BlockDeletionGenerator
    input = concentric_circle
    block = '1 2 3'
    new_boundary = water_solid_interface
  []

  # Merge the remaining blocks (4 - water boundary layer,
  # 5 - water bulk) into a single block "water"
  [rename_blocks]
    type = RenameBlockGenerator
    input = remove_fuel_pin
    old_block = '4 5'
    new_block = 'water water'
  []

  # Rename and merge the outer boundaries created by
  # the ConcentricCircleMeshGenerator (top, right,
  # bottom, left) into a single boundary (water)
  [merge_outer]
    type = RenameBoundaryGenerator
    input = rename_blocks
    old_boundary = 'top right bottom left'
    new_boundary = 'outer outer outer outer'
  []
[]

(tutorials/user_short_workshop/inputs/step1_input_and_meshing/fluid.i)

Run: Fluid Mesh


$ moose-opt -i fluid.i --mesh-only


 Mesh Information:
  elem_dimensions()={2}
  elem_default_orders()={FIRST}
  supported_nodal_order()=1
  spatial_dimension()=2
  n_nodes()=368
    n_local_nodes()=368
  n_elem()=304
    n_local_elem()=304
    n_active_elem()=304
  n_subdomains()=1
  n_elemsets()=0
  n_partitions()=1
  n_processors()=1
  n_threads()=1
  processor_id()=0
  is_prepared()=true
  is_replicated()=true

 Mesh Bounding Box:
  Minimum: (x,y,z)=(-0.003475, -0.003475,        0)
  Maximum: (x,y,z)=(0.003475, 0.003475,        0)
  Delta:   (x,y,z)=( 0.00695,  0.00695,        0)

 Mesh Element Type(s):
  QUAD4

 Mesh Nodesets:
  Nodeset 4, 80 nodes
   Bounding box minimum: (x,y,z)=(-0.003475, -0.003475,        0)
   Bounding box maximum: (x,y,z)=(0.003475, 0.003475,        0)
   Bounding box delta: (x,y,z)=( 0.00695,  0.00695,        0)
  Nodeset 5, 48 nodes
   Bounding box minimum: (x,y,z)=(  -0.003,   -0.003,        0)
   Bounding box maximum: (x,y,z)=(   0.003,    0.003,        0)
   Bounding box delta: (x,y,z)=(   0.006,    0.006,        0)

 Mesh Sidesets:
  Sideset 4 (outer), 80 sides (EDGE2), 76 elems (QUAD4), 80 nodes
   Side volume: 0.0278
   Bounding box minimum: (x,y,z)=(-0.003475, -0.003475,        0)
   Bounding box maximum: (x,y,z)=(0.003475, 0.003475,        0)
   Bounding box delta: (x,y,z)=( 0.00695,  0.00695,        0)
  Sideset 5 (water_solid_interface), 48 sides (EDGE2), 48 elems (QUAD4), 48 nodes
   Side volume: 0.0188361
   Bounding box minimum: (x,y,z)=(  -0.003,   -0.003,        0)
   Bounding box maximum: (x,y,z)=(   0.003,    0.003,        0)
   Bounding box delta: (x,y,z)=(   0.006,    0.006,        0)

 Mesh Edgesets:
  None

 Mesh Subdomains:
  Subdomain 4 (water): 304 elems (QUAD4, 304 active), 368 active nodes
   Volume: 2.01088e-05
   Bounding box minimum: (x,y,z)=(-0.003475, -0.003475,        0)
   Bounding box maximum: (x,y,z)=(0.003475, 0.003475,        0)
   Bounding box delta: (x,y,z)=( 0.00695,  0.00695,        0)
  Global mesh volume = 2.01088e-05

Result: Fluid Mesh

From fluid_in.e: The grey elements represent the water (block water). There is a sideset on the inner boundary with the name water_solid_interface and a sideset on the outer boundary with the name outer.

Reusing the Meshes

We can then load these meshes in later inputs with:


[Mesh/fuel_pin]
  type = FileMeshGenerator
  file = ../step1_input_and_meshing/fuel_pin_in.e
[]


[Mesh/fluid]
  type = FileMeshGenerator
  file = ../step1_input_and_meshing/fluid_in.e
[]

Step 2: Diffusion

Diffusion Problem

Let's solve a diffusion problem on our pin mesh to introduce the solving of a basic finite element problem.

Consider the steady-state diffusion equation on the domain $var element = document.getElementById("moose-equation-4459caea-8cbb-4d25-bcf1-fe126a8b43da");katex.render("\\Omega", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ (our pin cell mesh, ../step1_input_and_meshing/fuel_pin_in.e): find $var element = document.getElementById("moose-equation-e7ad53aa-3103-45c8-82a3-5e1d5583c9cc");katex.render("u", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ such that

var element = document.getElementById("moose-equation-2bcc111a-43f6-48e4-872c-2982ca44df2b");katex.render("-\\nabla \\cdot \\nabla u = 0,", element, {displayMode:true,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});

where $var element = document.getElementById("moose-equation-e063e4ed-10b3-406c-ae84-3367213c85ac");katex.render("u = 0", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ on the interior boundary (inner) and $var element = document.getElementById("moose-equation-309c296b-4ebf-4eed-8ae9-c33ee9d15e96");katex.render("u = 1", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ on the exterior boundary (water_solid_interface).

Multiplying by the test function $var element = document.getElementById("moose-equation-5e0a2289-f464-43e6-ab3e-80ece291ae14");katex.render("\\psi_i", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ and integrating by parts gives the weak form of this equation, where $var element = document.getElementById("moose-equation-e6d8c55f-d109-4995-8de1-786fd487bb69");katex.render("u_h", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ is our numerical solution:

var element = document.getElementById("moose-equation-11602897-6aee-4bed-be78-5199ec2d1e9b");katex.render("\\left(\\nabla u_h, \\nabla \\psi_i\\right)_\\Omega - \\left<\\nabla u_h, \\psi_i \\mathbf{n}\\right>_{\\partial\\Omega} = 0.", element, {displayMode:true,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});

Required MOOSE Systems

We will utilize the following systems in MOOSE in addition to [Mesh] in our input:

[Variables]: Define the unknown(s) of the problem
- The variable $var element = document.getElementById("moose-equation-82488092-fc8a-4145-b5d4-25fb58917cf2");katex.render("u", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$
[Kernels]: Define the equation(s) to solve
- The diffusion operator
[BCs]: Define the boundary condition(s) of the problem
- Dirichlet boundary conditions on the interior and exterior
[Executioner]: Define how the problem will be solved
- A steady state problem
[Outputs]: Define how the solution will be returned
- Exodus output for field visualization

Variable Definition

Define the variable $var element = document.getElementById("moose-equation-36fa2260-0946-4022-b12b-6d387b0134c5");katex.render("u", element, {displayMode:false,throwOnError:false,macros:{"\\vec":"\\bar","\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ :

[Variables<<<{"href": "../syntax/Variables/index.html"}>>>]
  [u]
  []
[]