diff --git a/.clang-format b/.clang-format new file mode 100644 index 00000000..165b53b5 --- /dev/null +++ b/.clang-format @@ -0,0 +1,31 @@ +BasedOnStyle: LLVM + +TabWidth: 2 +ColumnLimit: 100 +UseTab: Never + +CommentPragmas: '^/' +ReflowComments: true +AlignTrailingComments: true +SpacesBeforeTrailingComments: 1 + +SpaceBeforeParens: ControlStatements +SpacesInSquareBrackets: false +BreakBeforeBraces: Allman +PointerAlignment: Middle + +BinPackParameters: false +BinPackArguments: false +ConstructorInitializerAllOnOneLineOrOnePerLine: true +AllowShortBlocksOnASingleLine: false +AllowShortFunctionsOnASingleLine: true +AllowShortIfStatementsOnASingleLine: false +AllowShortLoopsOnASingleLine: false + +SortIncludes: false +IndentCaseLabels: true +ConstructorInitializerIndentWidth: 2 +AlwaysBreakAfterDefinitionReturnType: TopLevel +AlwaysBreakTemplateDeclarations: true + +FixNamespaceComments: false diff --git a/.clang-tidy b/.clang-tidy new file mode 100644 index 00000000..99b920ef --- /dev/null +++ b/.clang-tidy @@ -0,0 +1,15 @@ +HeaderFilterRegex: 'hephaestus/[ste]' +Checks: '-*,readability-identifier-naming,readability-redundant-member-init,modernize-*,-modernize-use-trailing-return-type,-modernize-avoid-c-arrays' +CheckOptions: + - key: readability-identifier-naming.AggressiveDependentMemberLookup + value: true + - key: readability-identifier-naming.ClassCase + value: 'CamelCase' + - key: readability-identifier-naming.MethodCase + value: 'CamelCase' + - key: readability-identifier-naming.MemberCase + value: 'lower_case' + - key: readability-identifier-naming.MemberPrefix + value: '_' + - key: readability-identifier-naming.LocalVariableCase + value: 'lower_case' \ No newline at end of file diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..9df77b4c --- /dev/null +++ b/.gitignore @@ -0,0 +1,254 @@ +.libs +*.la +*.lo +*.d +*.o +*.a +*-opt +*-dbg +*-oprof +*-prof +*-devel +*.e +*.nav +*.log +*.aux +*.toc +*.snm +*.csv +*.csv.* +*.dylib +*.so +*.so.* +*.vrb +*.jou +*.pyc +*.mod +*.e.* +*.e-s* +*.cfg +*.lbd.* +*.nem +*.spd +*.pex +*.pdf +*.plist* +*.bbl +*.blg +*.spl +*.idx +traceout*.txt +temp_print_trace.* +*.xda +*.xda.* +*.xdr +*.xdr.* +*.mps +*.msmp +*.msmp-* +*.muds +# Latex garbage +*.lot +*.lof +*.poly +*.mpx +*.btr +*.xml +*.xml.* +*.gmv +*.plt +*.slh +*.eps +*.dat +*.gp +*.plugin +*.outp +*.patch +*.txt +*.bib.bak +*.out +*.vtk +*.vtu +*.pvtu +.depend +*.png +*.gif +*.tif +*.jpg +*.tiff +*.ps +*.bmp +*.mp4 +*.webm +*.ico +*.html +*.xyz +*Revision.h +*.json +*.bak +*.processor.* +.clang_complete +.failed_tests +failed-unittest +compile_commands.json +build + +# Allow certain files in gold directories +!**/gold/*.e +!**/gold/*.e-s* +!**/gold/*.csv +!**/gold/*.csv.* +!**/gold/*.vtk +!**/gold/*.vtu +!**/gold/*.pvtu +!**/gold/*.xml* + +peacock_run_tmp.i +yaml_dump* +test/tests/outputs/format/dump.i + +# Generated header file +MooseRevision.h + +# Precompiled headers +moose/include/base/Precompiled.h.gch + +# test garbagge +*.FAILED.txt + +# eclipse garbage +.project +.cproject +.metadata +.settings +.pydevproject + +# vim garbage +*~ +.*.swp +.*.swo + +framework/contrib/exodiff/exodiff + +# Mac garbage +.DS_Store +*.dSYM + +# Unit testing stuffbmoose_unit/test_results.xml +!unit/data/csv/*.csv + +# gcov code coverage files +*.gcno +*.gcda +*.gcov + +# paraview state files +*.pvsm + +#Peacock generated files +peacock_*.i +peacock_*.e + +# On linux, shared libs end in .0 sometimes +libpcre-opt* +libpcre-dbg* +libmoose-opt* +libmoose-dbg* + +#doxygen generated +*/doc/doxygen/html/* +*/doc/doxygen/**/* +moose/doc/doxygen/html/* +modules/*/doc/doxygen/html/* +tutorials/*/*/doc/doxygen/html/* +ICE/ +framework/contrib/asio/ + +# Restartable Data +*.rd +*.rd-* + +# Checkpoint Files +*.cpa +*.cpr +*.cpa-* +*.cpr-* + +# Ignore petsc arch +petsc/arch-*/* + +# phase_field/tests/solution_rasterizer +out.xyz + +# JIT and automatic differentiation cache files +.jitcache/ +.jitdir/ +tmp_jit_* + +# Do not store ipython notebook checkpoints +*-checkpoint.ipynb* + +# HIT +framework/contrib/hit/hit + +# MooseDocs +site +python/MooseDocs/test/output +!**/doc/content/**/*.md +!**/doc/content/**/*.jpg +!**/doc/content/**/*.jpeg +!**/doc/content/**/*.gif +!**/doc/content/**/*.png +!**/doc/content/**/*.svg +!**/doc/content/**/*.ogg +!**/doc/content/**/*.webm +!**/doc/content/**/*.mp4 +!**/doc/content/**/*.css +!**/doc/content/**/*.js +!**/doc/content/**/*.bib +!**/doc/content/**/*.woff +!**/doc/content/**/*.woff2 +!python/MooseDocs/test/gold/**/*.json +!python/MooseDocs/test/gold/**/*.html +!python/MooseDocs/test/gold/**/*.tex +.ruby-version + +# Chigger +!python/chigger/tests/**/gold/*.png +!python/chigger/tests/input/*.e* +!python/chigger/logos/*.png +!python/chigger/contrib/*.xml + +# Peacock +python/peacock/tests/exodus_tab/TestOutputPlugin_repr.py +python/peacock/tests/exodus_tab/TestExodusPluginManager_repr.py +python/peacock/tests/input_tab/InputFileEditor/fsp_test.i +python/peacock/tests/postprocessor_tab/TestPostprocessorPluginManager_test_script.py +!python/peacock/tests/**/gold/*.png +!python/peacock/icons/**/*.* +!python/peacock/tests/**/input/*.* +peacock_tmp_diff.exo +*.e.diff + +# configure +_configs.sed +autom4te.cache +config.status +*MooseConfig.h +*MooseConfig.h.tmp +conf_vars.mk + +# GPerf performance +*.prof + +# Tarred Docker images +*docker/**/*.tar.gz + +# MFEM Joule outputs +*Joule_000* + +# Ignoring all of OutputData +**/OutputData/ + +#Ignore output mfem meshes +*.mesh diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml new file mode 100644 index 00000000..333b21d8 --- /dev/null +++ b/.gitlab-ci.yml @@ -0,0 +1,140 @@ +image: ubuntu:latest + +variables: + GIT_SUBMODULE_STRATEGY: recursive + +stages: + - build + - test + - quality + - security + - deploy + +# Build the software, along with all tests +build: + stage: build + script: + - mkdir build + - cd build + - cmake .. + - make -j + - cd .. + artifacts: + paths: + - build/ + - bin/ + - lib/ + expire_in: 1 day + +# Run tests + +.template: &coverage_template + stage: test + before_script: + - apt install gcovr + - cd build + - cmake .. -DBUILD_TYPE=TEST + - make -j +# after_script: +# - make gcovr + coverage: '/^lines: (\d+.\d+)%/' + + +unit_tests: + <<: *coverage_template + script: + - ../bin/unit_tests + - make gcovr + - mv gcovr unit_test_coverage + artifacts: + paths: + - build/unit_test_coverage + expire_in: 1 week + +integration_tests: + <<: *coverage_template + script: + - ../bin/integration_tests + - make gcovr + - mv gcovr integration_test_coverage + artifacts: + paths: + - build/integration_test_coverage + expire_in: 1 week + +regression_tests: + <<: *coverage_template + script: + - ../bin/regression_tests + - make gcovr + - mv gcovr regression_test_coverage + artifacts: + paths: + - build/regression_test_coverage + expire_in: 1 week + +format_tests: + stage: test + script: + - find ./{test,src}/ -iname *.h -o -iname *.cpp -o -iname *.hpp | xargs clang-format-8 -style=file | clang-format-diff-8 > out.txt + - if [[ -s out.txt ]]; then false; fi + allow_failure: true + +# Code quality +cyclomatic_complexity: + stage: quality + script: + - python /home/lizard/lizard.py --CCN=15 --length=100 --arguments=10 src + +static_analysis: + stage: quality + script: + - script -c "cppcheck src --enable=all" cppcheck.out + artifacts: + paths: + - cppcheck.out + expire_in: 1 week + +similarity: + stage: quality + script: + - script -c "sim_c++ -aRn src/*" similarity.out + artifacts: + paths: + - similarity.out + expire_in: 1 week + + +flaws: + stage: security + script: + - script -c "flawfinder src" flawfinder.out + artifacts: + paths: + - flawfinder.out + expire_in: 1 week + +pages: + stage: deploy + script: + # assuming build folder in the build stage is kept + - mkdir builddoc && cd builddoc + - cmake .. + - make doc + # doxygen output folder name is controlled in defined Doxygen.in + # gitlab pages request document must put into `public` folder of the repo directory + - mv public/html ../public + - cd .. + - mv build/unit_test_coverage public/unit_coverage + - mv build/integration_test_coverage public/integration_coverage + - mv build/regression_test_coverage public/regression_coverage + dependencies: + - unit_tests + - integration_tests + - regression_tests + only: + - master + artifacts: + paths: + - public + allow_failure: true # TODO change to false diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 00000000..6adf0b41 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,6 @@ +[submodule "python/pybind11"] + path = python/pybind11 + url = https://github.com/pybind/pybind11.git +[submodule "contrib/hephaestus"] + path = contrib/hephaestus + url = https://github.com/aurora-multiphysics/hephaestus diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 00000000..b8aee6cb --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,11 @@ +repos: +- repo: https://github.com/pre-commit/mirrors-clang-format + rev: v14.0.6 + hooks: + - id: clang-format + +- repo: https://github.com/pocc/pre-commit-hooks + rev: v1.3.5 + hooks: + - id: clang-tidy + args: [-p=./build, -config-file=./.clang-tidy, --warnings-as-errors=*, -extra-arg=-std=c++17, -extra-arg=-stdlib=libstdc++] \ No newline at end of file diff --git a/Makefile b/Makefile new file mode 100644 index 00000000..144e23c3 --- /dev/null +++ b/Makefile @@ -0,0 +1,67 @@ +############################################################################### +################### MOOSE Application Standard Makefile ####################### +############################################################################### +# +# Optional Environment variables +# MOOSE_DIR - Root directory of the MOOSE project +# +############################################################################### +# Use the MOOSE submodule if it exists and MOOSE_DIR is not set +MOOSE_SUBMODULE := $(CURDIR)/moose +ifneq ($(wildcard $(MOOSE_SUBMODULE)/framework/Makefile),) + MOOSE_DIR ?= $(MOOSE_SUBMODULE) +else + MOOSE_DIR ?= $(shell dirname `pwd`)/moose +endif + +# framework +FRAMEWORK_DIR := $(MOOSE_DIR)/framework +include $(FRAMEWORK_DIR)/build.mk +include $(FRAMEWORK_DIR)/moose.mk + +################################## MODULES #################################### +# To use certain physics included with MOOSE, set variables below to +# yes as needed. Or set ALL_MODULES to yes to turn on everything (overrides +# other set variables). + +ALL_MODULES := no + +CHEMICAL_REACTIONS := no +CONTACT := no +EXTERNAL_PETSC_SOLVER := no +FLUID_PROPERTIES := no +FUNCTIONAL_EXPANSION_TOOLS := no +HEAT_TRANSFER := yes +LEVEL_SET := no +MISC := no +NAVIER_STOKES := no +PHASE_FIELD := no +POROUS_FLOW := no +RDG := no +RICHARDS := no +SOLID_MECHANICS := yes +STOCHASTIC_TOOLS := no +TENSOR_MECHANICS := no +XFEM := no + +include $(MOOSE_DIR)/modules/modules.mk +############################################################################### + +.PHONY : printer + +printer: + @echo $(MFEM_LIB) + @echo $(MFEM_INC) + +# dep apps +APPLICATION_DIR := $(CURDIR) +PLATYPUS_DIR := $(CURDIR) +APPLICATION_NAME := platypus +BUILD_EXEC := yes +GEN_REVISION := no +DEP_APPS := $(shell $(FRAMEWORK_DIR)/scripts/find_dep_apps.py $(APPLICATION_NAME)) +include $(FRAMEWORK_DIR)/app.mk + + +############################################################################### +# Additional special case targets should be added here diff --git a/README.md b/README.md index f618e947..76ce82bc 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ Platypus ===== -Platypus is a MOOSE-based application created to enable custom MOOSE problems to be set up and solved using the MFEM finite element library as an alternative backend to libMesh. It is based off of the MOOSE electromagnetics app [Apollo](https://github.com/aurora-multiphysics/apollo) that uses MFEM for solving electromagnetics problems in a variety of formulations. +Platypus is a MOOSE-based application created to enable custom MOOSE problems to be set up and solved using the [MFEM](https://github.com/mfem/mfem) finite element library as an alternative backend to libMesh. It is based off of the MOOSE electromagnetics app [Apollo](https://github.com/aurora-multiphysics/apollo) that uses MFEM for solving electromagnetics problems in a variety of formulations. Platypus is under active development and is being updated frequently. diff --git a/contrib/hephaestus b/contrib/hephaestus new file mode 160000 index 00000000..ff359ff3 --- /dev/null +++ b/contrib/hephaestus @@ -0,0 +1 @@ +Subproject commit ff359ff38f1706fa0a960367c20dc1f712ca29f2 diff --git a/contrib/hephaestus.mk b/contrib/hephaestus.mk new file mode 100644 index 00000000..3f5f3ed8 --- /dev/null +++ b/contrib/hephaestus.mk @@ -0,0 +1,29 @@ +############################### HEPHAESTUS ###################################### +################################################################################# +MFEM_DIR :=$(APPLICATION_DIR)/../mfem/build +HEPHAESTUS_DIR :=$(APPLICATION_DIR)/contrib/hephaestus + +include $(MFEM_DIR)/config/config.mk +MFEM_INCLUDES := -I$(MFEM_INC_DIR)/config -I$(MFEM_DIR)/ -I$(MFEM_DIR)/../miniapps/common +MFEM_LIBS := -L$(MFEM_DIR) -lmfem -lrt -L$(MFEM_DIR)/miniapps/common -lmfem-common $(MFEM_LIB) + +HEPHAESTUS_LIB := $(HEPHAESTUS_DIR)/lib + +SPDLOG_LIB :=$(HEPHAESTUS_DIR)/build/_deps/spdlog-build/ +SPDLOG_INCLUDE :=$(HEPHAESTUS_DIR)/build/_deps/spdlog-src/include/ + +HEPHAESTUS_INCLUDE_LIB := $(sort $(dir $(shell find $(HEPHAESTUS_DIR)/src/ -name "*.hpp"))) +HEPHAESTUS_INCLUDE := $(foreach d, $(HEPHAESTUS_INCLUDE_LIB), -I$d) -I$(SPDLOG_INCLUDE) + +HEPHAESTUS_CXX_FLAGS := -Wall $(HEPHAESTUS_INCLUDE) $(MFEM_INCLUDES) -I$(MFEM_INC_DIR)/config +HEPHAESTUS_LDFLAGS := -Wl,-rpath,$(HEPHAESTUS_LIB) -L$(HEPHAESTUS_LIB) -lhephaestus $(MFEM_LIBS) -L$(SPDLOG_LIB) -lspdlog + +libmesh_CXXFlags += $(HEPHAESTUS_CXX_FLAGS) +libmesh_LDFLAGS += $(HEPHAESTUS_LDFLAGS) + +ADDITIONAL_CPPFLAGS += -DHEPHAESTUS_ENABLED +ADDITIONAL_INCLUDES += $(HEPHAESTUS_CXX_FLAGS) +ADDITIONAL_LIBS += $(HEPHAESTUS_LDFLAGS) + +$(info ADDITIONAL_INCLUDES = $(ADDITIONAL_INCLUDES)); +$(info ADDITIONAL_LIBS = $(ADDITIONAL_LIBS)); diff --git a/doc/config.yml b/doc/config.yml new file mode 100644 index 00000000..0cfa7005 --- /dev/null +++ b/doc/config.yml @@ -0,0 +1,24 @@ +Content: + Platypus: + root_dir: ${ROOT_DIR}/doc/content + moose: + root_dir: ${MOOSE_DIR}/framework/doc/content + content: + - js/* + - css/* + - contrib/** + - media/** + +Renderer: + type: MooseDocs.base.MaterializeRenderer + +Extensions: + MooseDocs.extensions.navigation: + name: Platypus + MooseDocs.extensions.appsyntax: + executable: ${ROOT_DIR} + hide: + framework: !include ${MOOSE_DIR}/framework/doc/hidden.yml + remove: !include ${MOOSE_DIR}/framework/doc/remove.yml + includes: + - include diff --git a/doc/content/index.md b/doc/content/index.md new file mode 100644 index 00000000..4c44eb8c --- /dev/null +++ b/doc/content/index.md @@ -0,0 +1,3 @@ +!config navigation breadcrumbs=False scrollspy=False + +# PlatypusApp diff --git a/doc/moosedocs.py b/doc/moosedocs.py new file mode 100755 index 00000000..3cb7f506 --- /dev/null +++ b/doc/moosedocs.py @@ -0,0 +1,29 @@ +#!/usr/bin/env python +#* This file is part of the MOOSE framework +#* https://www.mooseframework.org +#* +#* All rights reserved, see COPYRIGHT for full restrictions +#* https://github.com/idaholab/moose/blob/master/COPYRIGHT +#* +#* Licensed under LGPL 2.1, please see LICENSE for details +#* https://www.gnu.org/licenses/lgpl-2.1.html + +import sys +import os + +# Locate MOOSE directory +MOOSE_DIR = os.getenv('MOOSE_DIR', os.path.abspath(os.path.join(os.path.dirname(__name__), '..', 'moose'))) +if not os.path.exists(MOOSE_DIR): + MOOSE_DIR = os.path.abspath(os.path.join(os.path.dirname(__name__), '..', '..', 'moose')) +if not os.path.exists(MOOSE_DIR): + raise Exception('Failed to locate MOOSE, specify the MOOSE_DIR environment variable.') +os.environ['MOOSE_DIR'] = MOOSE_DIR + +# Append MOOSE python directory +MOOSE_PYTHON_DIR = os.path.join(MOOSE_DIR, 'python') +if MOOSE_PYTHON_DIR not in sys.path: + sys.path.append(MOOSE_PYTHON_DIR) + +from MooseDocs import main +if __name__ == '__main__': + sys.exit(main.run()) diff --git a/docker/platypus-deps/Dockerfile b/docker/platypus-deps/Dockerfile new file mode 100644 index 00000000..2b2bf6a3 --- /dev/null +++ b/docker/platypus-deps/Dockerfile @@ -0,0 +1,47 @@ +# Build Platypus dependencies +# Get base image +FROM alexanderianblair/hephaestus-deps:master + +# By default four cores are used to compile +ARG compile_cores=4 + +# By default we install everything under /opt +ARG WORKDIR=opt + +# Configure MOOSE +RUN export MOOSE_JOBS=$compile_cores && \ + cd /$WORKDIR && \ + git clone https://github.com/idaholab/moose && \ + cd moose && \ + git checkout master && \ + export PETSC_DIR=/$WORKDIR/petsc && \ + export PETSC_ARCH=arch-linux-c-opt && \ + export CC=mpicc && \ + export CXX=mpicxx && \ + export F90=mpif90 && \ + export F77=mpif77 && \ + export FC=mpif90 && \ + METHODS=opt ./scripts/update_and_rebuild_libmesh.sh --with-mpi && \ + ./configure --with-derivative-size=200 + +# Build WASP +RUN cd /$WORKDIR/moose/scripts && \ + METHODS=opt ./update_and_rebuild_wasp.sh + +# Build MOOSE +RUN cd /$WORKDIR/moose/framework && \ + METHOD=opt make -j$compile_cores + +RUN cd /$WORKDIR/moose/test && \ + METHOD=opt make -j$compile_cores + +# This is needed or it mpiexec complains because docker runs as root +# Discussion on this issue https://github.com/open-mpi/ompi/issues/4451 +ENV OMPI_ALLOW_RUN_AS_ROOT=1 +ENV OMPI_ALLOW_RUN_AS_ROOT_CONFIRM=1 + +# RUN cd /$WORKDIR/moose/test && \ +# ./run_tests -j"$compile_cores" --re='(?!initial_condition.newton_with_exact_initialization)' + +# ENV OMPI_ALLOW_RUN_AS_ROOT= +# ENV OMPI_ALLOW_RUN_AS_ROOT_CONFIRM= diff --git a/docker/platypus/Dockerfile b/docker/platypus/Dockerfile new file mode 100644 index 00000000..efe1f41e --- /dev/null +++ b/docker/platypus/Dockerfile @@ -0,0 +1,39 @@ +# Build and test Platypus image +# Get base image +FROM alexanderianblair/platypus-deps:master + +# By default four cores are used to compile +ARG compile_cores=4 + +# By default checkout master branch from aurora-multiphysics/platypus +ARG build_git_sha=master +ARG build_git_repo=aurora-multiphysics/platypus + +# By default we install everything under /opt +ARG WORKDIR=opt + +# Get Platypus with Hephaestus +RUN cd /$WORKDIR && \ + git clone https://github.com/$build_git_repo && \ + cd platypus && \ + git checkout $build_git_sha && \ + git submodule update --init --recursive + +# Build Hephaestus +RUN cd /$WORKDIR/platypus/contrib/hephaestus/ && \ + mkdir build && \ + cd build && \ + cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DMFEM_DIR=/$WORKDIR/mfem/build .. && \ + ninja + +# Test Hephaestus +RUN cd /$WORKDIR/platypus/contrib/hephaestus/build && \ + ninja test + +# Build Platypus +RUN cd /$WORKDIR/platypus && \ + make -j$compile_cores + +# Test Platypus +RUN cd /$WORKDIR/platypus && \ + make test diff --git a/include/actions/AddCoefficientAction.h b/include/actions/AddCoefficientAction.h new file mode 100644 index 00000000..21b113f5 --- /dev/null +++ b/include/actions/AddCoefficientAction.h @@ -0,0 +1,20 @@ +#pragma once + +#include "MooseObjectAction.h" +#include "MFEMProblem.h" +/** + * This class allows us to have a section of the input file like the + * following to add MFEM coefficients to the problem. + * + * [Coefficients] + * [] + */ +class AddCoefficientAction : public MooseObjectAction +{ +public: + static InputParameters validParams(); + + AddCoefficientAction(const InputParameters & parameters); + + virtual void act() override; +}; diff --git a/include/actions/AddFESpaceAction.h b/include/actions/AddFESpaceAction.h new file mode 100644 index 00000000..1897c2c7 --- /dev/null +++ b/include/actions/AddFESpaceAction.h @@ -0,0 +1,20 @@ +#pragma once + +#include "MooseObjectAction.h" +#include "MFEMProblem.h" +/** + * This class allows us to have a section of the input file like the + * following to add MFEM coefficients to the problem. + * + * [FESpaces] + * [] + */ +class AddFESpaceAction : public MooseObjectAction +{ +public: + static InputParameters validParams(); + + AddFESpaceAction(const InputParameters & parameters); + + virtual void act() override; +}; diff --git a/include/actions/AddFormulationAction.h b/include/actions/AddFormulationAction.h new file mode 100644 index 00000000..1193f08d --- /dev/null +++ b/include/actions/AddFormulationAction.h @@ -0,0 +1,20 @@ +#pragma once + +#include "MooseObjectAction.h" +#include "MFEMProblem.h" +/** + * This class allows us to have a section of the input file like the + * following to specify the EM formulation to build. + * + * [Formulation] + * [] + */ +class AddFormulationAction : public MooseObjectAction +{ +public: + static InputParameters validParams(); + + AddFormulationAction(const InputParameters & parameters); + + virtual void act() override; +}; diff --git a/include/actions/AddVectorCoefficientAction.h b/include/actions/AddVectorCoefficientAction.h new file mode 100644 index 00000000..978ce573 --- /dev/null +++ b/include/actions/AddVectorCoefficientAction.h @@ -0,0 +1,20 @@ +#pragma once + +#include "MooseObjectAction.h" +#include "MFEMProblem.h" +/** + * This class allows us to have a section of the input file like the + * following to add MFEM coefficients to the problem. + * + * [Coefficients] + * [] + */ +class AddVectorCoefficientAction : public MooseObjectAction +{ +public: + static InputParameters validParams(); + + AddVectorCoefficientAction(const InputParameters & parameters); + + virtual void act() override; +}; diff --git a/include/auxkernels/MFEMAuxSolver.h b/include/auxkernels/MFEMAuxSolver.h new file mode 100644 index 00000000..4607d5ab --- /dev/null +++ b/include/auxkernels/MFEMAuxSolver.h @@ -0,0 +1,25 @@ +#pragma once + +#include "GeneralUserObject.h" +#include "auxsolvers.hpp" +#include "gridfunctions.hpp" + +class MFEMAuxSolver : public GeneralUserObject +{ +public: + static InputParameters validParams(); + + MFEMAuxSolver(const InputParameters & parameters); + virtual ~MFEMAuxSolver(); + + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + + inline virtual std::shared_ptr getAuxSolver() const { return _auxsolver; } + + virtual void storeCoefficients(hephaestus::Coefficients & coefficients) {} + +protected: + std::shared_ptr _auxsolver{nullptr}; +}; diff --git a/include/auxkernels/MFEMJouleHeatingAux.h b/include/auxkernels/MFEMJouleHeatingAux.h new file mode 100644 index 00000000..bffe7ed6 --- /dev/null +++ b/include/auxkernels/MFEMJouleHeatingAux.h @@ -0,0 +1,78 @@ +#pragma once + +#include "MFEMAuxSolver.h" + +class JouleHeatingCoefficient : public hephaestus::CoupledCoefficient +{ +private: + mfem::Coefficient * sigma{nullptr}; + mfem::ParGridFunction * joule_heating_gf{nullptr}; + std::string conductivity_coef_name; + // std::string var_name; + +public: + JouleHeatingCoefficient(const hephaestus::InputParameters & params) + : hephaestus::CoupledCoefficient(params), + conductivity_coef_name(params.GetParam("ConductivityCoefName")) + { + } + + void Init(const hephaestus::GridFunctions & variables, hephaestus::Coefficients & coefficients) + { + // To ensure conductivity on subdomains is converted into global coefficient + // Hephaestus update for coefficients initialisation could address this + // if (!coefficients.scalars.Has(conductivity_coef_name)) + // { + // coefficients.scalars.Register( + // conductivity_coef_name, + // new mfem::PWCoefficient( + // coefficients.getGlobalScalarProperty(std::string(conductivity_coef_name))), + // true); + // } + + hephaestus::CoupledCoefficient::Init(variables, coefficients); + std::cout << "Intialising JouleHeating"; + sigma = coefficients._scalars.Get(conductivity_coef_name); + + joule_heating_gf = variables.Get("joule_heating"); + } + + virtual double Eval(mfem::ElementTransformation & T, const mfem::IntegrationPoint & ip) + { + mfem::Vector E; + double thisSigma; + _gf->GetVectorValue(T, ip, E); + thisSigma = sigma->Eval(T, ip); + return thisSigma * (E * E); + } + + void Solve(double t) + { + this->SetTime(t); + joule_heating_gf->ProjectCoefficient(*this); + } +}; + +class MFEMJouleHeatingAux : public MFEMAuxSolver +{ +public: + static InputParameters validParams(); + + MFEMJouleHeatingAux(const InputParameters & parameters); + virtual ~MFEMJouleHeatingAux(); + + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + + inline std::shared_ptr getAuxSolver() const override + { + return joule_heating_aux; + } + + virtual void storeCoefficients(hephaestus::Coefficients & coefficients) override; + +protected: + hephaestus::InputParameters joule_heating_params; + std::shared_ptr joule_heating_aux{nullptr}; +}; diff --git a/include/auxkernels/VectorVariableFromComponentsAux.h b/include/auxkernels/VectorVariableFromComponentsAux.h new file mode 100644 index 00000000..71c4d47a --- /dev/null +++ b/include/auxkernels/VectorVariableFromComponentsAux.h @@ -0,0 +1,29 @@ +#pragma once + +#include "WritableVectorAuxKernel.h" + +/** + * Construct a vector variable from 3 standard variables. + */ +class VectorVariableFromComponentsAux : public WritableVectorAuxKernel +{ +public: + static InputParameters validParams(); + + VectorVariableFromComponentsAux(const InputParameters & parameters); + +protected: + virtual void compute() override; + + MooseVariable & _component_x; + MooseVariable & _component_y; + MooseVariable & _component_z; + + const Order _vector_order; + const FEFamily _vector_family; + +private: + void checkVectorVariable() const; + void checkVectorComponents() const; + void checkVectorComponent(const MooseVariable & component_variable) const; +}; diff --git a/include/auxkernels/VectorVariableToComponentsAux.h b/include/auxkernels/VectorVariableToComponentsAux.h new file mode 100644 index 00000000..5f98c59c --- /dev/null +++ b/include/auxkernels/VectorVariableToComponentsAux.h @@ -0,0 +1,17 @@ +#pragma once + +#include "VectorVariableFromComponentsAux.h" + +/** + * Set 3 standard variables from a vector variable. + */ +class VectorVariableToComponentsAux : public VectorVariableFromComponentsAux +{ +public: + static InputParameters validParams(); + + VectorVariableToComponentsAux(const InputParameters & parameters); + +protected: + virtual void compute() override; +}; diff --git a/include/auxkernels/WritableVectorAuxKernel.h b/include/auxkernels/WritableVectorAuxKernel.h new file mode 100644 index 00000000..07c23270 --- /dev/null +++ b/include/auxkernels/WritableVectorAuxKernel.h @@ -0,0 +1,24 @@ +#pragma once + +#include "AuxKernel.h" + +/** + * Platypus wrapper around VectorAuxKernel. + * + * Enables subclasses to call "writableVariable". This is not possible for VectorAuxKernel derived + * classes due to a MOOSE limitation. + */ +class WritableVectorAuxKernel : public VectorAuxKernel +{ +public: + static InputParameters validParams() { return VectorAuxKernel::validParams(); } + + WritableVectorAuxKernel(const InputParameters & parameters) : VectorAuxKernel(parameters) {} + +protected: + // NB: not used. + virtual RealVectorValue computeValue() override { mooseError("Unused"); } + + // NB: see "writableVariable" method defined in "Coupleable.h". + MooseVariable & writableVariable(const std::string & var_name, unsigned int comp = 0); +}; diff --git a/include/base/PlatypusApp.h b/include/base/PlatypusApp.h new file mode 100644 index 00000000..15b1e2e4 --- /dev/null +++ b/include/base/PlatypusApp.h @@ -0,0 +1,17 @@ +#pragma once + +#include "MooseApp.h" + +class PlatypusApp : public MooseApp +{ +public: + static InputParameters validParams(); + + PlatypusApp(InputParameters parameters); + virtual ~PlatypusApp(); + + static void registerApps(); + static void registerAll(Factory & f, ActionFactory & af, Syntax & s); + static void associateSyntax(Syntax & syntax, ActionFactory & action_factory); +}; + diff --git a/include/bcs/MFEMBoundaryCondition.h b/include/bcs/MFEMBoundaryCondition.h new file mode 100644 index 00000000..75af5a8c --- /dev/null +++ b/include/bcs/MFEMBoundaryCondition.h @@ -0,0 +1,31 @@ +#pragma once + +#include "GeneralUserObject.h" +#include "boundary_conditions.hpp" +#include "gridfunctions.hpp" +#include "coefficients.hpp" +#include "Function.h" + +class MFEMBoundaryCondition : public GeneralUserObject +{ +public: + static InputParameters validParams(); + + MFEMBoundaryCondition(const InputParameters & parameters); + ~MFEMBoundaryCondition() override {} + + inline virtual std::shared_ptr getBC() const + { + return _boundary_condition; + } + + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + +protected: + std::vector _boundary_names; + mfem::Array bdr_attr; + + std::shared_ptr _boundary_condition{nullptr}; +}; diff --git a/include/bcs/MFEMComplexVectorDirichletBC.h b/include/bcs/MFEMComplexVectorDirichletBC.h new file mode 100644 index 00000000..7f50ef16 --- /dev/null +++ b/include/bcs/MFEMComplexVectorDirichletBC.h @@ -0,0 +1,22 @@ +#pragma once + +#include "MFEMBoundaryCondition.h" +#include "MFEMVectorFunctionCoefficient.h" +#include "boundary_conditions.hpp" + +class MFEMComplexVectorDirichletBC : public MFEMBoundaryCondition +{ +public: + static InputParameters validParams(); + + MFEMComplexVectorDirichletBC(const InputParameters & parameters); + ~MFEMComplexVectorDirichletBC() override {} + + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + +protected: + MFEMVectorCoefficient * _vec_coef_re{nullptr}; + MFEMVectorCoefficient * _vec_coef_im{nullptr}; +}; diff --git a/include/bcs/MFEMScalarDirichletBC.h b/include/bcs/MFEMScalarDirichletBC.h new file mode 100644 index 00000000..3455249b --- /dev/null +++ b/include/bcs/MFEMScalarDirichletBC.h @@ -0,0 +1,21 @@ +#pragma once + +#include "MFEMBoundaryCondition.h" +#include "MFEMFunctionCoefficient.h" +#include "boundary_conditions.hpp" + +class MFEMScalarDirichletBC : public MFEMBoundaryCondition +{ +public: + static InputParameters validParams(); + + MFEMScalarDirichletBC(const InputParameters & parameters); + ~MFEMScalarDirichletBC() override {} + + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + +protected: + MFEMCoefficient * _coef{nullptr}; +}; diff --git a/include/bcs/MFEMVectorDirichletBC.h b/include/bcs/MFEMVectorDirichletBC.h new file mode 100644 index 00000000..cfab0b1d --- /dev/null +++ b/include/bcs/MFEMVectorDirichletBC.h @@ -0,0 +1,21 @@ +#pragma once + +#include "MFEMBoundaryCondition.h" +#include "MFEMVectorFunctionCoefficient.h" +#include "boundary_conditions.hpp" + +class MFEMVectorDirichletBC : public MFEMBoundaryCondition +{ +public: + static InputParameters validParams(); + + MFEMVectorDirichletBC(const InputParameters & parameters); + ~MFEMVectorDirichletBC() override {} + + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + +protected: + MFEMVectorCoefficient * _vec_coef{nullptr}; +}; diff --git a/include/bcs/MFEMVectorNormalIntegratedBC.h b/include/bcs/MFEMVectorNormalIntegratedBC.h new file mode 100644 index 00000000..4140d56e --- /dev/null +++ b/include/bcs/MFEMVectorNormalIntegratedBC.h @@ -0,0 +1,21 @@ +#pragma once + +#include "MFEMBoundaryCondition.h" +#include "MFEMVectorFunctionCoefficient.h" +#include "boundary_conditions.hpp" + +class MFEMVectorNormalIntegratedBC : public MFEMBoundaryCondition +{ +public: + static InputParameters validParams(); + + MFEMVectorNormalIntegratedBC(const InputParameters & parameters); + ~MFEMVectorNormalIntegratedBC() override {} + + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + +protected: + MFEMVectorCoefficient * _vec_coef{nullptr}; +}; diff --git a/include/coefficients/MFEMCoefficient.h b/include/coefficients/MFEMCoefficient.h new file mode 100644 index 00000000..40d98164 --- /dev/null +++ b/include/coefficients/MFEMCoefficient.h @@ -0,0 +1,25 @@ +#pragma once + +#include "GeneralUserObject.h" +#include "coefficients.hpp" +#include "Function.h" + +libMesh::Point PointFromMFEMVector(const mfem::Vector & vec); + +class MFEMCoefficient : public GeneralUserObject +{ +public: + static InputParameters validParams(); + + MFEMCoefficient(const InputParameters & parameters); + virtual ~MFEMCoefficient(); + + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + + virtual std::shared_ptr getCoefficient() const + { + mooseError("Base class MFEMCoefficient cannot return a valid Coefficient. Use a child class."); + } +}; diff --git a/include/coefficients/MFEMConstantCoefficient.h b/include/coefficients/MFEMConstantCoefficient.h new file mode 100644 index 00000000..4b10c78c --- /dev/null +++ b/include/coefficients/MFEMConstantCoefficient.h @@ -0,0 +1,22 @@ +#pragma once + +#include "MFEMCoefficient.h" +#include "gridfunctions.hpp" + +class MFEMConstantCoefficient : public MFEMCoefficient +{ +public: + static InputParameters validParams(); + + MFEMConstantCoefficient(const InputParameters & parameters); + virtual ~MFEMConstantCoefficient(); + + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + + std::shared_ptr getCoefficient() const override { return coefficient; } + +private: + std::shared_ptr coefficient{nullptr}; +}; diff --git a/include/coefficients/MFEMFunctionCoefficient.h b/include/coefficients/MFEMFunctionCoefficient.h new file mode 100644 index 00000000..63cc9a68 --- /dev/null +++ b/include/coefficients/MFEMFunctionCoefficient.h @@ -0,0 +1,21 @@ +#pragma once +#include "MFEMCoefficient.h" + +class MFEMFunctionCoefficient : public MFEMCoefficient +{ +public: + static InputParameters validParams(); + + MFEMFunctionCoefficient(const InputParameters & parameters); + virtual ~MFEMFunctionCoefficient(); + + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + + std::shared_ptr getCoefficient() const override { return _coefficient; }; + +private: + const Function & _func; + std::shared_ptr _coefficient{nullptr}; +}; diff --git a/include/coefficients/MFEMParsedCoefficient.h b/include/coefficients/MFEMParsedCoefficient.h new file mode 100644 index 00000000..fd2c5c94 --- /dev/null +++ b/include/coefficients/MFEMParsedCoefficient.h @@ -0,0 +1,16 @@ +#pragma once + +#include "MFEMParsedCoefficientHelper.h" +#include "MFEMParsedCoefficientBase.h" + +/** + * MFEMCoefficient child class to evaluate a parsed function. The function + * can access non-linear and aux variables (unlike MooseParsedFunction). + */ +class MFEMParsedCoefficient : public MFEMParsedCoefficientHelper, public MFEMParsedCoefficientBase +{ +public: + static InputParameters validParams(); + + MFEMParsedCoefficient(const InputParameters & parameters); +}; diff --git a/include/coefficients/MFEMParsedCoefficientBase.h b/include/coefficients/MFEMParsedCoefficientBase.h new file mode 100644 index 00000000..8d461135 --- /dev/null +++ b/include/coefficients/MFEMParsedCoefficientBase.h @@ -0,0 +1,27 @@ +#pragma once + +#include "InputParameters.h" + +/** + * Base class for MFEMParsedCoefficient + * to declare and read the input parameters. + */ +class MFEMParsedCoefficientBase +{ +public: + static InputParameters validParams(); + + MFEMParsedCoefficientBase(const InputParameters & parameters); + +protected: + /// function expression + std::string _function; + + /// constant vectors + std::vector _constant_names; + std::vector _constant_expressions; + + /// mfem object names + std::vector _mfem_coefficient_names; + std::vector _mfem_gridfunction_names; +}; diff --git a/include/coefficients/MFEMParsedCoefficientHelper.h b/include/coefficients/MFEMParsedCoefficientHelper.h new file mode 100644 index 00000000..c118d1e5 --- /dev/null +++ b/include/coefficients/MFEMParsedCoefficientHelper.h @@ -0,0 +1,86 @@ +#pragma once + +#include "FunctionParserUtils.h" +#include "MFEMCoefficient.h" +#include "PlatypusUtils.h" +#include "auxsolvers.hpp" +#include "libmesh/fparser_ad.hh" +#include "libmesh/quadrature.h" + +#define usingMFEMParsedCoefficientHelperMembers() \ + usingFunctionParserUtilsMembers(); \ + using typename MFEMParsedCoefficientHelper::VariableNameMappingMode; \ + using typename MFEMParsedCoefficientHelper::MatPropDescriptorList; \ + using MFEMParsedCoefficientHelper::functionParse; \ + using MFEMParsedCoefficientHelper::functionsPostParse; \ + using MFEMParsedCoefficientHelper::functionsOptimize; \ + using MFEMParsedCoefficientHelper::_func_F; \ + using MFEMParsedCoefficientHelper::_symbol_names; \ + using MFEMParsedCoefficientHelper::_gridfunction_names; \ + using MFEMParsedCoefficientHelper::_coefficient_names; \ + using MFEMParsedCoefficientHelper::_map_mode + +/** + * Helper class to perform the parsing and optimization of the + * function expression. + */ +class MFEMParsedCoefficientHelper : public MFEMCoefficient, + public hephaestus::CoupledCoefficient, + public FunctionParserUtils +{ +public: + enum class VariableNameMappingMode + { + USE_MOOSE_NAMES, + USE_PARAM_NAMES + }; + + MFEMParsedCoefficientHelper(const InputParameters & parameters, VariableNameMappingMode map_mode); + + static InputParameters validParams(); + + void functionParse(const std::string & function_expression); + void functionParse(const std::string & function_expression, + const std::vector & constant_names, + const std::vector & constant_expressions); + void functionParse(const std::string & function_expression, + const std::vector & constant_names, + const std::vector & constant_expressions, + const std::vector & _mfem_coefficient_names); + void functionParse(const std::string & function_expression, + const std::vector & constant_names, + const std::vector & constant_expressions, + const std::vector & _mfem_coefficient_names, + const std::vector & _mfem_gridfunction_names); + void Init(const hephaestus::GridFunctions & variables, + hephaestus::Coefficients & coefficients) override; + + double Eval(mfem::ElementTransformation & trans, const mfem::IntegrationPoint & ip) override; + + std::shared_ptr getCoefficient() const override + { + return PlatypusUtils::dynamic_const_cast(getSharedPtr()); + } + +protected: + usingFunctionParserUtilsMembers(false); + + // run FPOptimizer on the parsed function + virtual void functionsOptimize(); + + /// The undiffed free energy function parser object. + SymFunctionPtr _func_F; + + /** + * Symbol names used in the expression (depends on the map_mode). + * We distinguish "symbols" i.e. FParser placeholder names from "variables", which + * are MOOSE solution objects + */ + std::vector _symbol_names; + + std::vector _gridfunction_names; + std::vector _gridfunctions; + + std::vector _coefficient_names; + std::vector _coefficients; +}; diff --git a/include/coefficients/MFEMVariableDependentFunctionCoefficient.h b/include/coefficients/MFEMVariableDependentFunctionCoefficient.h new file mode 100644 index 00000000..c7a31a17 --- /dev/null +++ b/include/coefficients/MFEMVariableDependentFunctionCoefficient.h @@ -0,0 +1,28 @@ +#pragma once +#include "MFEMCoefficient.h" +#include "PlatypusUtils.h" +#include "auxsolvers.hpp" + +class MFEMVariableDependentFunctionCoefficient : public MFEMCoefficient, + public hephaestus::CoupledCoefficient +{ +public: + static InputParameters validParams(); + + MFEMVariableDependentFunctionCoefficient(const InputParameters & parameters); + virtual ~MFEMVariableDependentFunctionCoefficient(); + + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + + double Eval(mfem::ElementTransformation & trans, const mfem::IntegrationPoint & ip) override; + + std::shared_ptr getCoefficient() const override + { + return PlatypusUtils::dynamic_const_cast(getSharedPtr()); + } + +private: + const Function & _func; +}; diff --git a/include/coefficients/MFEMVectorCoefficient.h b/include/coefficients/MFEMVectorCoefficient.h new file mode 100644 index 00000000..b3e199e7 --- /dev/null +++ b/include/coefficients/MFEMVectorCoefficient.h @@ -0,0 +1,24 @@ +#pragma once + +#include "GeneralUserObject.h" +#include "coefficients.hpp" +#include "Function.h" + +class MFEMVectorCoefficient : public GeneralUserObject +{ +public: + static InputParameters validParams(); + + MFEMVectorCoefficient(const InputParameters & parameters); + virtual ~MFEMVectorCoefficient(); + + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + + virtual std::shared_ptr getVectorCoefficient() const + { + mooseError("Base class MFEMVectorCoefficient cannot return a valid VectorCoefficient. Use a " + "child class."); + } +}; diff --git a/include/coefficients/MFEMVectorConstantCoefficient.h b/include/coefficients/MFEMVectorConstantCoefficient.h new file mode 100644 index 00000000..fb63d9f9 --- /dev/null +++ b/include/coefficients/MFEMVectorConstantCoefficient.h @@ -0,0 +1,24 @@ +#pragma once +#include "MFEMVectorCoefficient.h" + +class MFEMVectorConstantCoefficient : public MFEMVectorCoefficient +{ +public: + static InputParameters validParams(); + + MFEMVectorConstantCoefficient(const InputParameters & parameters); + virtual ~MFEMVectorConstantCoefficient(); + + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + + virtual std::shared_ptr getVectorCoefficient() const override + { + return _vector_coefficient; + } + +private: + const mfem::Vector _vector; + std::shared_ptr _vector_coefficient{nullptr}; +}; diff --git a/include/coefficients/MFEMVectorFunctionCoefficient.h b/include/coefficients/MFEMVectorFunctionCoefficient.h new file mode 100644 index 00000000..53d77102 --- /dev/null +++ b/include/coefficients/MFEMVectorFunctionCoefficient.h @@ -0,0 +1,24 @@ +#pragma once +#include "MFEMVectorCoefficient.h" + +class MFEMVectorFunctionCoefficient : public MFEMVectorCoefficient +{ +public: + static InputParameters validParams(); + + MFEMVectorFunctionCoefficient(const InputParameters & parameters); + virtual ~MFEMVectorFunctionCoefficient(); + + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + + std::shared_ptr getVectorCoefficient() const override + { + return _vector_coefficient; + } + +private: + const Function & _func; + std::shared_ptr _vector_coefficient{nullptr}; +}; diff --git a/include/fespaces/MFEMFESpace.h b/include/fespaces/MFEMFESpace.h new file mode 100644 index 00000000..0e01ae91 --- /dev/null +++ b/include/fespaces/MFEMFESpace.h @@ -0,0 +1,23 @@ +#pragma once + +#include "GeneralUserObject.h" +#include "inputs.hpp" +#include "gridfunctions.hpp" + +class MFEMFESpace : public GeneralUserObject +{ +public: + static InputParameters validParams(); + + MFEMFESpace(const InputParameters & parameters); + virtual ~MFEMFESpace(); + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + + static const std::string createFECName(const std::string & fespace_type, const int order); + const int order; + const int vdim; + const std::string fespace_type; + const std::string fec_name; +}; diff --git a/include/formulations/CustomFormulation.h b/include/formulations/CustomFormulation.h new file mode 100644 index 00000000..b23197b9 --- /dev/null +++ b/include/formulations/CustomFormulation.h @@ -0,0 +1,22 @@ +#pragma once + +#include "MFEMFormulation.h" +#include "factory.hpp" + +class CustomFormulation : public MFEMFormulation +{ +public: + static InputParameters validParams(); + + CustomFormulation(const InputParameters & parameters); + virtual ~CustomFormulation(); + + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + + std::shared_ptr getProblemBuilder() override { return formulation; } + +private: + std::shared_ptr formulation{nullptr}; +}; diff --git a/include/formulations/MFEMFormulation.h b/include/formulations/MFEMFormulation.h new file mode 100644 index 00000000..b46dfd13 --- /dev/null +++ b/include/formulations/MFEMFormulation.h @@ -0,0 +1,23 @@ +#pragma once + +#include "GeneralUserObject.h" +#include "factory.hpp" + +class MFEMFormulation : public GeneralUserObject +{ +public: + static InputParameters validParams(); + + MFEMFormulation(const InputParameters & parameters); + virtual ~MFEMFormulation(); + + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + + virtual std::shared_ptr getProblemBuilder() + { + mooseError( + "Base class MFEMFormulation cannot return a valid ProblemBuilder. Use a child class."); + } +}; diff --git a/include/kernels/MFEMBilinearFormKernel.h b/include/kernels/MFEMBilinearFormKernel.h new file mode 100644 index 00000000..dff10307 --- /dev/null +++ b/include/kernels/MFEMBilinearFormKernel.h @@ -0,0 +1,20 @@ +#pragma once + +#include "GeneralUserObject.h" +#include "kernels.hpp" +#include "gridfunctions.hpp" + +class MFEMBilinearFormKernel : public GeneralUserObject +{ +public: + static InputParameters validParams(); + + MFEMBilinearFormKernel(const InputParameters & parameters); + virtual ~MFEMBilinearFormKernel() {} + + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + + virtual std::shared_ptr> getKernel() { return nullptr; } +}; diff --git a/include/kernels/MFEMDiffusionKernel.h b/include/kernels/MFEMDiffusionKernel.h new file mode 100644 index 00000000..4d75fd62 --- /dev/null +++ b/include/kernels/MFEMDiffusionKernel.h @@ -0,0 +1,25 @@ +#pragma once +#include "MFEMBilinearFormKernel.h" +#include "kernels.hpp" + +class MFEMDiffusionKernel : public MFEMBilinearFormKernel +{ +public: + static InputParameters validParams(); + + MFEMDiffusionKernel(const InputParameters & parameters); + ~MFEMDiffusionKernel() override {} + + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + + std::shared_ptr> getKernel() override + { + return _kernel; + } + +protected: + hephaestus::InputParameters _kernel_params; + std::shared_ptr _kernel{nullptr}; +}; diff --git a/include/kernels/MFEMLinearFormKernel.h b/include/kernels/MFEMLinearFormKernel.h new file mode 100644 index 00000000..494dd1c1 --- /dev/null +++ b/include/kernels/MFEMLinearFormKernel.h @@ -0,0 +1,20 @@ +#pragma once + +#include "GeneralUserObject.h" +#include "kernels.hpp" +#include "gridfunctions.hpp" + +class MFEMLinearFormKernel : public GeneralUserObject +{ +public: + static InputParameters validParams(); + + MFEMLinearFormKernel(const InputParameters & parameters); + virtual ~MFEMLinearFormKernel(); + + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + + virtual std::shared_ptr> getKernel() { return nullptr; } +}; diff --git a/include/materials/MFEMMaterial.h b/include/materials/MFEMMaterial.h new file mode 100644 index 00000000..efadda0c --- /dev/null +++ b/include/materials/MFEMMaterial.h @@ -0,0 +1,22 @@ +#pragma once + +#include "GeneralUserObject.h" +#include "MFEMCoefficient.h" +#include "coefficients.hpp" + +class MFEMMaterial : public GeneralUserObject +{ +public: + static InputParameters validParams(); + + MFEMMaterial(const InputParameters & parameters); + virtual ~MFEMMaterial(); + + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + + virtual void storeCoefficients(hephaestus::Subdomain & subdomain) {} + + std::vector blocks; +}; diff --git a/include/mesh/CoupledMFEMMesh.h b/include/mesh/CoupledMFEMMesh.h new file mode 100644 index 00000000..5740bb66 --- /dev/null +++ b/include/mesh/CoupledMFEMMesh.h @@ -0,0 +1,174 @@ +//* This file is part of the MOOSE framework +//* https://www.mooseframework.org +//* +//* All rights reserved, see COPYRIGHT for full restrictions +//* https://github.com/idaholab/moose/blob/master/COPYRIGHT +//* +//* Licensed under LGPL 2.1, please see LICENSE for details +//* https://www.gnu.org/licenses/lgpl-2.1.html + +#pragma once +#include "ExclusiveMFEMMesh.h" +#include "CubitElementInfo.h" +#include "libmesh/face_quad4.h" + +/** + * CoupledMFEMMesh + */ +class CoupledMFEMMesh : public ExclusiveMFEMMesh +{ +public: + static InputParameters validParams(); + + CoupledMFEMMesh(const InputParameters & parameters); + + virtual ~CoupledMFEMMesh(); + + std::unique_ptr safeClone() const override; + + /** + * Builds only the MOOSE mesh from the file. + */ + void buildMesh() override; + + /** + * Override method in ExclusiveMFEMMesh. + */ + inline int getLocalMFEMNodeId(const int libmesh_global_node_id) const override + { + return _mfem_local_node_id_for_libmesh_global_node_id.at(libmesh_global_node_id); + } + + inline int getLibmeshGlobalNodeId(const int mfem_local_node_id) const override + { + return _libmesh_global_node_id_for_mfem_local_node_id.at(mfem_local_node_id); + } + +protected: + /** + * An internal method used to create maps from each boundary ID to vectors of side IDs + * and element IDs. + */ + void buildBoundaryInfo(std::map> & element_ids_for_boundary_id, + std::map> & side_ids_for_boundary_id); + + /** + * Create a mapping from each boundary ID to a vector of vectors containing the global node + * IDs of nodes that lie on the faces of elements that fall on the boundary. + */ + void buildBoundaryNodeIDs( + const std::vector & unique_side_boundary_ids, + const std::map> & element_ids_for_boundary_id, + const std::map> & side_ids_for_boundary_id, + std::map>> & node_ids_for_boundary_id); + + /** + * Builds two maps: + * 1. Mapping from each block ID --> vector containing all element IDs for block. + * 2. Mapping from each element --> vector containing all global node IDs for element. + */ + void buildElementAndNodeIDs(const std::vector & unique_block_ids, + std::map> & element_ids_for_block_id, + std::map> & node_ids_for_element_id); + + /** + * Iterates through each block to find the elements in the block. For each + * element in a block, it runs through the nodes in the block and adds only + * the corner nodes to a vector. This is then sorted and only unique global + * node IDs are retained. + */ + void buildUniqueCornerNodeIDs(std::vector & unique_corner_node_ids, + const std::vector & unique_block_ids, + const std::map> & element_ids_for_block_id, + const std::map> & node_ids_for_element_id); + + /** + * Required for converting an MFEMMesh to an MFEMParMesh. This method updates the two-way mappings + * so that the libMesh global node IDs now correctly map to the LOCAL MFEM dofs for the + * MFEMParMesh. This method is called internally after creating an MFEMParMesh from an MFEMMesh. + * NB: failure to call this method will result in the synchronization steps failing. + */ + void convertSerialDofMappingsToParallel(const MFEMMesh & serial_mesh, + const MFEMParMesh & parallel_mesh); + + /** + * Add block elements to _block_info. + */ + void buildCubitBlockInfo(const std::vector & unique_block_ids); + + /** + * Blocks/subdomains are separate subsets of the mesh that could have different + * material properties etc. This method returns a vector containing the unique + * IDs of each block in the mesh. This will be passed to the MFEMMesh constructor + * which sets the attribute of each element to the ID of the block that it is a + * part of. + */ + std::vector getLibmeshBlockIDs() const; + + /** + * Returns a vector containing the IDs of all boundaries. + */ + std::vector getSideBoundaryIDs() const; + + /** + * Maps from the element ID to the block ID. + */ + std::map + getBlockIDForElementID(const std::map> & element_ids_for_block_id) const; + + /** + * Maps from the boundary ID to a vector containing the block IDs of all elements that lie on + * the boundary. + */ + std::map> getBlockIDsForBoundaryID( + const std::map> & element_ids_for_block_id, + const std::map> & element_ids_for_boundary_id) const; + + /** + * Returns the libMesh partitioning. The "raw" pointer is wrapped up in a unique + * pointer. + */ + std::unique_ptr getMeshPartitioning(); + + /** + * Returns true if mesh is split between two or more processors. + */ + bool isDistributedMesh() const; + + /** + * Override methods in Exclusive MFEMMesh. + */ + void buildMFEMMesh() override; + void buildMFEMParMesh() override; + + /** + * Returns a constant reference to the block info. + */ + inline const CubitBlockInfo & blockInfo() const { return _block_info; } + + /** + * Returns a non-const reference to the block info. + */ + inline CubitBlockInfo & blockInfo() { return _block_info; } + + /** + * Returns a const reference to the block element. + */ + inline const CubitElementInfo & blockElement(int block_id) + { + return blockInfo().blockElement(block_id); + } + +private: + /** + * Stores the element info for each block in the mesh. + */ + CubitBlockInfo _block_info; + + /** + * Maps from a libMesh global node ID to the MFEM LOCAL node ID (dof) on the processor. NB: this + * is NOT the same as LOCAL TRUE dof. + */ + std::map _libmesh_global_node_id_for_mfem_local_node_id; + std::map _mfem_local_node_id_for_libmesh_global_node_id; +}; diff --git a/include/mesh/CubitElementInfo.h b/include/mesh/CubitElementInfo.h new file mode 100644 index 00000000..8ece6efa --- /dev/null +++ b/include/mesh/CubitElementInfo.h @@ -0,0 +1,215 @@ +#pragma once +#include +#include "MooseError.h" + +/** + * CubitFaceInfo + * + * Stores information about a particular element face. + */ +class CubitFaceInfo +{ +public: + CubitFaceInfo() = delete; + ~CubitFaceInfo() = default; + + enum CubitFaceType + { + FACE_EDGE2, + FACE_EDGE3, + FACE_TRI3, + FACE_TRI6, + FACE_QUAD4, + FACE_QUAD8, // order = 2. + FACE_QUAD9 // order = 2. Center node. + }; + + /** + * Default initializer. + */ + CubitFaceInfo(CubitFaceType face_type); + + inline uint8_t order() const { return _order; }; + inline uint8_t numFaceNodes() const { return _num_face_nodes; }; + inline uint8_t numFaceCornerNodes() const { return _num_face_corner_nodes; }; + inline CubitFaceType faceType() const { return _face_type; } + +protected: + void buildCubitFaceInfo(); + +private: + /** + * Type of face. + */ + CubitFaceType _face_type; + + /** + * Total number of nodes and number of corner nodes ("vertices"). + */ + uint8_t _num_face_nodes; + uint8_t _num_face_corner_nodes; + + /** + * Order of face. + */ + uint8_t _order; +}; + +/** + * CubitElementInfo + * + * Stores information about a particular element. + */ +class CubitElementInfo +{ +public: + CubitElementInfo() = default; + ~CubitElementInfo() = default; + + CubitElementInfo(int num_nodes_per_element, int dimension = 3); + + enum CubitElementType + { + ELEMENT_TRI3, + ELEMENT_TRI6, + ELEMENT_QUAD4, + ELEMENT_QUAD9, + ELEMENT_TET4, + ELEMENT_TET10, + ELEMENT_HEX8, + ELEMENT_HEX27, + ELEMENT_WEDGE6, + ELEMENT_WEDGE18, + ELEMENT_PYRAMID5, + ELEMENT_PYRAMID14 + }; + + inline CubitElementType elementType() const { return _element_type; } + + /** + * Returns info for a particular face. + */ + const CubitFaceInfo & face(int iface = 0) const; + + inline uint8_t numFaces() const { return _num_faces; } + + inline uint8_t numNodes() const { return _num_nodes; } + inline uint8_t numCornerNodes() const { return _num_corner_nodes; } + + inline uint8_t order() const { return _order; } + inline uint8_t dimension() const { return _dimension; } + +protected: + void buildCubit2DElementInfo(int num_nodes_per_element); + void buildCubit3DElementInfo(int num_nodes_per_element); + + /** + * Sets the _face_info vector. + */ + std::vector getWedge6FaceInfo() const; + std::vector getWedge18FaceInfo() const; + + std::vector getPyramid5FaceInfo() const; + std::vector getPyramid14FaceInfo() const; + +private: + /** + * Stores the element type. + */ + CubitElementType _element_type; + + /** + * NB: first-order elements have only nodes on the "corners". Second-order have + * additional nodes between "corner" nodes. + */ + uint8_t _order; + uint8_t _dimension; + + /** + * NB: "corner nodes" refer to MOOSE nodes at the corners of an element. In + * MFEM this is referred to as "vertices". + */ + uint8_t _num_nodes; + uint8_t _num_corner_nodes; + + /** + * Stores info about the face types. + */ + uint8_t _num_faces; + std::vector _face_info; +}; + +/** + * CubitBlockInfo + * + * Stores the information about each block in a mesh. Each block can contain a different + * element type (although all element types must be of the same order and dimension). + */ +class CubitBlockInfo +{ +public: + CubitBlockInfo() = delete; + ~CubitBlockInfo() = default; + + /** + * Default initializer. + */ + CubitBlockInfo(int dimension); + + /** + * Returns a constant reference to the element info for a particular block. + */ + const CubitElementInfo & blockElement(int block_id) const; + + /** + * Call to add each block individually. + */ + void addBlockElement(int block_id, int num_nodes_per_element); + + /** + * Accessors. + */ + uint8_t order() const; + inline uint8_t dimension() const { return _dimension; } + + inline std::size_t numBlocks() const { return blockIDs().size(); } + inline bool hasBlocks() const { return !blockIDs().empty(); } + +protected: + /** + * Checks that the order of a new block element matches the order of existing blocks. Called + * internally in mehtod "addBlockElement". + */ + void checkElementBlockIsCompatible(const CubitElementInfo & new_block_element) const; + + /** + * Reset all block elements. Called internally in initializer. + */ + void clearBlockElements(); + + /** + * Helper methods. + */ + inline const std::set & blockIDs() const { return _block_ids; } + + bool hasBlockID(int block_id) const; + bool validBlockID(int block_id) const; + bool validDimension(int dimension) const; + +private: + /** + * Stores all block IDs. + */ + std::set _block_ids; + + /** + * Maps from block ID to element. + */ + std::map _block_element_for_block_id; + + /** + * Dimension and order of block elements. + */ + uint8_t _dimension; + uint8_t _order; +}; diff --git a/include/mesh/ExclusiveMFEMMesh.h b/include/mesh/ExclusiveMFEMMesh.h new file mode 100644 index 00000000..d84ad692 --- /dev/null +++ b/include/mesh/ExclusiveMFEMMesh.h @@ -0,0 +1,95 @@ +//* This file is part of the MOOSE framework +//* https://www.mooseframework.org +//* +//* All rights reserved, see COPYRIGHT for full restrictions +//* https://github.com/idaholab/moose/blob/master/COPYRIGHT +//* +//* Licensed under LGPL 2.1, please see LICENSE for details +//* https://www.gnu.org/licenses/lgpl-2.1.html + +#pragma once +#include "FileMesh.h" +#include "MFEMMesh.h" +#include "MFEMParMesh.h" +#include "memory" +#include "libmesh/elem.h" +#include "libmesh/enum_io_package.h" +#include "libmesh/equation_systems.h" +#include "libmesh/face_quad4.h" +#include "libmesh/ignore_warnings.h" +#include "libmesh/libmesh_config.h" +#include "libmesh/mesh_base.h" +#include "libmesh/mesh_input.h" +#include "libmesh/node.h" +#include "libmesh/numeric_vector.h" +#include "libmesh/system.h" +#include "libmesh/vtk_io.h" +#include "mfem.hpp" + +/** + * ExclusiveMFEMMesh + * + * ExclusiveMFEMMesh inherits a MOOSE mesh class which allows us to work with + * other MOOSE objects. It contains pointers to an MFEM serial and MFEM parallel + * mesh. + */ +class ExclusiveMFEMMesh : public FileMesh +{ +public: + static InputParameters validParams(); + + ExclusiveMFEMMesh(const InputParameters & parameters); + + virtual ~ExclusiveMFEMMesh(); + + std::unique_ptr safeClone() const override; + + /** + * Accessors for the _mfem_mesh and _mfem_par_mesh objects. If the objects have + * not been build, the methods will call the appropriate protected methods to + * build them. + */ + MFEMMesh & getMFEMMesh(); + MFEMParMesh & getMFEMParMesh(); + + /** + * Calls buildDummyMesh. + */ + void buildMesh() override; + + /** + * Override in derived classes. + */ + virtual inline int getLocalMFEMNodeId(const int libmesh_global_node_id) const + { + mooseError("Not implemented."); + } + + virtual inline int getLibmeshGlobalNodeId(const int mfem_local_node_id) const + { + mooseError("Not implemented."); + } + +protected: + /** + * Builds a placeholder mesh when no MOOSE mesh is required. + */ + void buildDummyMesh(); + + /** + * Builds an MFEMMesh object from a file. Override in derived classes. + */ + virtual void buildMFEMMesh(); + + /** + * Builds an MFEMParMesh object from a file. Override in derived classes. + */ + virtual void buildMFEMParMesh(); + + /** + * Smart pointers to MFEMMesh and MFEMParMesh objects. Do not access directly. + * Use the accessors instead. + */ + std::shared_ptr _mfem_mesh; + std::shared_ptr _mfem_par_mesh; +}; diff --git a/include/mesh/MFEMMesh.h b/include/mesh/MFEMMesh.h new file mode 100644 index 00000000..ab0d553e --- /dev/null +++ b/include/mesh/MFEMMesh.h @@ -0,0 +1,162 @@ +#pragma once + +#include "libmesh/elem.h" +#include "libmesh/enum_io_package.h" +#include "libmesh/exodusII_io.h" +#include "libmesh/nemesis_io.h" +#include "libmesh/node.h" +#include "libmesh/parallel_mesh.h" +#include "CubitElementInfo.h" +#include "mfem.hpp" +#include "MooseError.h" + +/** + * MFEMMesh + * + * MFEMMesh wraps an mfem::Mesh object. + */ +class MFEMMesh : public mfem::Mesh +{ +public: + /** + * Initializer for 1st order elements. + */ + MFEMMesh(const int num_elements_in_mesh, + const CubitBlockInfo & block_info, + const std::vector & unique_block_ids, + const std::vector & unique_side_boundary_ids, + const std::vector & unique_libmesh_corner_node_ids, + const std::map> & libmesh_element_ids_for_block_id, + const std::map> & libmesh_node_ids_for_element_id, + const std::map>> & + libmesh_node_ids_for_boundary_id, + const std::map> & libmesh_side_ids_for_boundary_id, + const std::map> & libmesh_block_ids_for_boundary_id, + const std::map> & coordinates_for_libmesh_node_id); + + /** + * Initializer for 2nd order elements. + */ + MFEMMesh(const int num_elements_in_mesh, + const CubitBlockInfo & block_info, + const std::vector & unique_block_ids, + const std::vector & unique_side_boundary_ids, + const std::vector & unique_libmesh_corner_node_ids, + const std::map> & libmesh_element_ids_for_block_id, + const std::map> & libmesh_node_ids_for_element_id, + const std::map>> & + libmesh_node_ids_for_boundary_id, + const std::map> & libmesh_side_ids_for_boundary_id, + const std::map> & libmesh_block_ids_for_boundary_id, + const std::map> & coordinates_for_libmesh_node_id, + std::map & libmesh_node_id_for_mfem_node_id, + std::map & mfem_node_id_for_libmesh_node_id); + + MFEMMesh(std::string mesh_fname, + int generate_edges = 0, + int refine = 1, + bool fix_orientation = true); + +protected: + /** + * Calls buildMFEMVertices, buildMFEMElements, buildMFEMBoundaryElements methods + * to construct the mesh. NB: - additional methods should be called after this + * to handle second-order elements. The Finalize() method must be called at the + * end. + */ + void buildMFEMVerticesAndElements( + const int num_elements_in_mesh, + const CubitBlockInfo & block_info, + const std::vector & unique_block_ids, + const std::vector & unique_side_boundary_ids, + const std::vector & unique_libmesh_corner_node_ids, + const std::map> & libmesh_element_ids_for_block_id, + const std::map> & libmesh_node_ids_for_element_id, + const std::map>> & + libmesh_node_ids_for_boundary_id, + const std::map> & libmesh_side_ids_for_boundary_id, + const std::map> & libmesh_block_ids_for_boundary_id, + const std::map> & coordinates_for_libmesh_node_id); + + /** + * Sets the protected variable array using the provided vector of corner node + * IDs from MOOSE. Note that the vertices (named "nodes" in MOOSE) are ONLY + * at the corners of elements. These are referred to as "corner nodes" in MOOSE. + */ + void + buildMFEMVertices(const std::vector & unique_libmesh_corner_node_ids, + const std::map> & coordinates_for_libmesh_node_id); + + /** + * Construct the MFEM elements array. + */ + void buildMFEMElements(const int num_elements_in_mesh, + const CubitBlockInfo & block_info, + const std::vector & unique_block_ids, + const std::map> & libmesh_element_ids_for_block_id, + const std::map> & libmesh_node_ids_for_element_id); + + /** + * Construct the boundary array of elements. + */ + void buildMFEMBoundaryElements( + const CubitBlockInfo & block_info, + const std::vector & unique_side_boundary_ids, + const std::map>> & + libmesh_node_ids_for_boundary_id, + const std::map> & libmesh_side_ids_for_boundary_id, + const std::map> & libmesh_block_ids_for_boundary_ids); + + /** + * Returns a pointer to an mfem::Element. + */ + mfem::Element * + buildMFEMElement(const int element_type, const int * vertex_ids, const int block_id); + + /** + * Returns an pointer to an mfem::Element (for faces only). + */ + mfem::Element * + buildMFEMFaceElement(const int face_type, const int * vertex_ids, const int boundary_id); + + /** + * Called internally in constructor if the element is second-order. + */ + void handleQuadraticFESpace( + const CubitBlockInfo & block_info, + const std::vector & unique_block_ids, + const std::map> & libmesh_element_ids_for_block_id, + const std::map> & libmesh_node_ids_for_element_id, + const std::map> & coordinates_for_libmesh_node_id, + std::map & libmesh_node_id_for_mfem_node_id, + std::map & mfem_node_id_for_libmesh_node_id); + + /** + * Verifies whether the libmesh and mfem node ids have a unique mapping. All + * coordinates should match and every mfem node id should have a corresponding + * libmesh node id. Any left-over node ids will be detected. + */ + void verifyUniqueMappingBetweenLibmeshAndMFEMNodes( + const std::vector & unique_block_ids, + const std::map> & libmesh_element_ids_for_block_id, + const std::map> & libmesh_node_ids_for_element_id, + const std::map> & coordinates_for_libmesh_node_id, + const std::map & libmesh_node_id_for_mfem_node_id); + + /** + * Accessors. + */ + inline int getMFEMElementID(int libmesh_element_id) const + { + return _mfem_element_id_for_libmesh_element_id.at(libmesh_element_id); + } + + inline int getMFEMVertexIndex(int libmesh_corner_node_id) const + { + return _mfem_vertex_index_for_libmesh_corner_node_id.at(libmesh_corner_node_id); + } + +private: + std::map _mfem_element_id_for_libmesh_element_id; + std::map _mfem_vertex_index_for_libmesh_corner_node_id; +}; diff --git a/include/mesh/MFEMParMesh.h b/include/mesh/MFEMParMesh.h new file mode 100644 index 00000000..e0ad486a --- /dev/null +++ b/include/mesh/MFEMParMesh.h @@ -0,0 +1,17 @@ +#pragma once + +#include "mfem.hpp" +#include "MFEMMesh.h" + +/** + * MFEMParMesh + * + * MFEMParMesh is a wrapper for the mfem::ParMesh object. + */ +class MFEMParMesh : public mfem::ParMesh +{ +public: + MFEMParMesh(MPI_Comm comm, MFEMMesh & mesh, int * partitioning = nullptr, int part_method = 1); + + // TODO: - add implementation. +}; diff --git a/include/outputs/MFEMDataCollection.h b/include/outputs/MFEMDataCollection.h new file mode 100644 index 00000000..d13eeda9 --- /dev/null +++ b/include/outputs/MFEMDataCollection.h @@ -0,0 +1,20 @@ +#pragma once +#include "FileOutput.h" +#include "mfem.hpp" + +/** + * Class for output information saved in MFEM DataCollections + */ +class MFEMDataCollection : public FileOutput +{ +public: + static InputParameters validParams(); + + MFEMDataCollection(const InputParameters & parameters); + + virtual std::shared_ptr + createDataCollection(const std::string & collection_name) const; + +protected: + void output() override {} +}; diff --git a/include/outputs/MFEMParaViewDataCollection.h b/include/outputs/MFEMParaViewDataCollection.h new file mode 100644 index 00000000..b1a6477c --- /dev/null +++ b/include/outputs/MFEMParaViewDataCollection.h @@ -0,0 +1,21 @@ +#pragma once +#include "MFEMDataCollection.h" +#include "mfem.hpp" + +/** + * Class for output information saved in MFEM ParaViewDataCollections + */ +class MFEMParaViewDataCollection : public MFEMDataCollection +{ +public: + static InputParameters validParams(); + + MFEMParaViewDataCollection(const InputParameters & parameters); + + std::shared_ptr + createDataCollection(const std::string & collection_name) const override; + +protected: + bool _high_order_output; + unsigned int _refinements; +}; diff --git a/include/outputs/MFEMVisItDataCollection.h b/include/outputs/MFEMVisItDataCollection.h new file mode 100644 index 00000000..e733d8da --- /dev/null +++ b/include/outputs/MFEMVisItDataCollection.h @@ -0,0 +1,21 @@ +#pragma once +#include "MFEMDataCollection.h" +#include "mfem.hpp" + +/** + * Class for output information saved in MFEM VisItDataCollections + */ +class MFEMVisItDataCollection : public MFEMDataCollection +{ +public: + static InputParameters validParams(); + + MFEMVisItDataCollection(const InputParameters & parameters); + + std::shared_ptr + createDataCollection(const std::string & collection_name) const override; + +protected: + bool _high_order_output; + unsigned int _refinements; +}; diff --git a/include/postprocessors/ElementVectorL2Difference.h b/include/postprocessors/ElementVectorL2Difference.h new file mode 100644 index 00000000..55d916b3 --- /dev/null +++ b/include/postprocessors/ElementVectorL2Difference.h @@ -0,0 +1,24 @@ +#include "ElementIntegralPostprocessor.h" + +/** + * Computes the L2-Norm difference between two solution vector fields. + */ +class ElementVectorL2Difference : public ElementIntegralPostprocessor +{ +public: + static InputParameters validParams(); + + ElementVectorL2Difference(const InputParameters & parameters); + + using Postprocessor::getValue; + virtual Real getValue() const override; + +protected: + virtual Real computeQpIntegral() override; + + const VectorVariableValue & _vector_variable; + const VectorVariableValue & _other_vector_variable; + +private: + void checkVectorVariables() const; +}; diff --git a/include/problem/MFEMProblem.h b/include/problem/MFEMProblem.h new file mode 100644 index 00000000..dee49f69 --- /dev/null +++ b/include/problem/MFEMProblem.h @@ -0,0 +1,182 @@ +#pragma once +#include "AuxiliarySystem.h" +#include "DisplacedProblem.h" +#include "ExternalProblem.h" +#include "ExclusiveMFEMMesh.h" +#include "CoupledMFEMMesh.h" +#include "MFEMMesh.h" +#include "MFEMCoefficient.h" +#include "MFEMVectorCoefficient.h" +#include "MFEMMaterial.h" +#include "MFEMVariable.h" +#include "MFEMScalarDirichletBC.h" +#include "MFEMConstantCoefficient.h" +#include "MFEMBoundaryCondition.h" +#include "MFEMBilinearFormKernel.h" +#include "MFEMLinearFormKernel.h" +#include "MFEMFormulation.h" +#include "MFEMAuxSolver.h" +#include "MFEMDataCollection.h" +#include "MFEMFESpace.h" +#include "Function.h" +#include "MooseEnum.h" +#include "SystemBase.h" +#include "Transient.h" +#include "Steady.h" +#include "hephaestus.hpp" +#include "libmesh/string_to_enum.h" +#include "libmesh/point.h" + +class MFEMProblem : public ExternalProblem +{ +public: + static InputParameters validParams(); + + MFEMProblem(const InputParameters & params); + virtual ~MFEMProblem(); + + virtual void init() override; + virtual void initialSetup() override; + virtual void externalSolve() override; + virtual void outputStep(ExecFlagType type) override; + + virtual bool nlConverged(const unsigned int nl_sys_num) override { return true; }; + + virtual void syncSolutions(Direction direction) override; + + /** + * Overwritten mesh() method from base MooseMesh to retrieve the correct mesh type, in this case + * ExclusiveMFEMMesh. + */ + virtual ExclusiveMFEMMesh & mesh() override; + + /** + * Returns all the variable names from the auxiliary system base. This is helpful in the + * syncSolutions() method when transferring variable data. + */ + virtual std::vector getAuxVariableNames(); + + void addBoundaryCondition(const std::string & bc_name, + const std::string & name, + InputParameters & parameters) override; + + void addMaterial(const std::string & kernel_name, + const std::string & name, + InputParameters & parameters); + + /** + * Add an MFEM coefficient to the problem. + */ + void addCoefficient(const std::string & user_object_name, + const std::string & name, + InputParameters & parameters); + + /** + * Add an MFEM vector coefficient to the problem. + */ + void addVectorCoefficient(const std::string & user_object_name, + const std::string & name, + InputParameters & parameters); + /** + * Add an MFEM FESpace to the problem. + */ + void addFESpace(const std::string & user_object_name, + const std::string & name, + InputParameters & parameters); + /** + * Override of ExternalProblem::addUserObject. Uses ExternalProblem::addUserObject to set the + * Moose user objects, and contains additional code to create MFEM specific user objects. + */ + void setFormulation(const std::string & user_object_name, + const std::string & name, + InputParameters & parameters); + + /** + * Override of ExternalProblem::addAuxVariable. Uses ExternalProblem::addAuxVariable to set the + * Moose aux var, and contains additional code to create a corresponding MFEM grid function to be + * used in the MFEM solve. + */ + void addAuxVariable(const std::string & var_type, + const std::string & var_name, + InputParameters & parameters) override; + + /** + * Override of ExternalProblem::addKernel. Uses ExternalProblem::addKernel to create a + * GeneralUserObject representing the kernel in MOOSE, and creates corresponding MFEM kernel + * to be used in the MFEM solve. + */ + void addKernel(const std::string & kernel_name, + const std::string & name, + InputParameters & parameters) override; + /** + * Override of ExternalProblem::addAuxKernel. Uses ExternalProblem::addAuxKernel to create a + * GeneralUserObject representing the auxkernel in MOOSE, and creates corresponding MFEM auxsolver + * to be used in the MFEM solve. + */ + void addAuxKernel(const std::string & kernel_name, + const std::string & name, + InputParameters & parameters) override; + + /** + * setMFEMVarData and setMOOSEVarData have very similar uses. They are both used to retrieve + * data from one of the variable types (either Moose AuxVar or MFEM grid function), and + * transfer it to the other. For example if you solve for temperature in MOOSE, you would use + * setMFEMVarData to get this temperature data into an MFEM grid function. + */ + void setMFEMVarData(const std::string & var_name); + void setMOOSEVarData(const std::string & var_name); + + /** + * Method used to get an mfem FEC depending on the variable family specified in the input file. + * This method is used in addAuxVariable to help create the MFEM grid function that corresponds to + * a given MOOSE aux-variable. + */ + InputParameters addMFEMFESpaceFromMOOSEVariable(InputParameters & moosevar_params); + +protected: + /** + * Called internally by setMFEMVarData. + */ + void setMFEMNodalVarData(MooseVariableFieldBase & moose_variable); + void setMFEMElementalVarData(MooseVariableFieldBase & moose_variable); + + /** + * Called internally by setMOOSEVarData. + */ + void setMOOSENodalVarData(MooseVariableFieldBase & moose_variable); + void setMOOSEElementalVarData(MooseVariableFieldBase & moose_variable); + + /** + * Template method for adding kernels. We can only add kernels using equation system problem builders. + */ + template + void addKernel(std::string var_name, std::shared_ptr> kernel) + { + using namespace hephaestus; + + EquationSystemProblemBuilderInterface * eqn_system_problem_builder{nullptr}; + + if ((eqn_system_problem_builder = dynamic_cast(mfem_problem_builder.get()))) + { + eqn_system_problem_builder->AddKernel(std::move(var_name), std::move(kernel)); + } + else + { + mooseError("Cannot add kernel with name '" + var_name + "' because there is no equation system."); + } + } + + std::string _input_mesh; + std::string _formulation_name; + int _order; + + hephaestus::Coefficients _coefficients; + hephaestus::InputParameters _solver_options; + hephaestus::Outputs _outputs; + hephaestus::InputParameters _exec_params; + + std::shared_ptr mfem_problem_builder{nullptr}; + + std::unique_ptr mfem_problem{nullptr}; + std::unique_ptr executioner{nullptr}; +}; diff --git a/include/utils/PlatypusUtils.h b/include/utils/PlatypusUtils.h new file mode 100644 index 00000000..bf8f8bd3 --- /dev/null +++ b/include/utils/PlatypusUtils.h @@ -0,0 +1,32 @@ +#pragma once + +#include +#include +#include + +namespace PlatypusUtils +{ + +template +std::shared_ptr +dynamic_const_cast(std::shared_ptr source_pointer) +{ + if constexpr (!std::is_const_v) + { + auto source_remove_const = + std::const_pointer_cast::type>(source_pointer); + auto destination_pointer = std::dynamic_pointer_cast(source_remove_const); + if (!destination_pointer) + throw std::bad_cast(); + return destination_pointer; + } + else + { + auto destination_pointer = std::dynamic_pointer_cast(source_pointer); + if (!destination_pointer) + throw std::bad_cast(); + return destination_pointer; + } +} + +} // namespace PlatypusUtils diff --git a/include/variables/MFEMVariable.h b/include/variables/MFEMVariable.h new file mode 100644 index 00000000..c997717d --- /dev/null +++ b/include/variables/MFEMVariable.h @@ -0,0 +1,20 @@ +#pragma once + +#include "MFEMFESpace.h" +#include "inputs.hpp" +#include "gridfunctions.hpp" + +class MFEMVariable : public GeneralUserObject +{ +public: + static InputParameters validParams(); + + MFEMVariable(const InputParameters & parameters); + virtual ~MFEMVariable(); + virtual void execute() override {} + virtual void initialize() override {} + virtual void finalize() override {} + + const MFEMFESpace & fespace; + unsigned int components; +}; diff --git a/platypus.mk b/platypus.mk new file mode 100644 index 00000000..cf4b7ec5 --- /dev/null +++ b/platypus.mk @@ -0,0 +1,4 @@ +# +# Check the existence of the contrib submodules and build accordingly +# +include $(APPLICATION_DIR)/contrib/hephaestus.mk diff --git a/platypus.yaml b/platypus.yaml new file mode 100644 index 00000000..ff87e7db --- /dev/null +++ b/platypus.yaml @@ -0,0 +1,9 @@ +DMETHOD: opt +Werror: reorder +compiler_type: gcc +documentation: true +installation_type: in_tree +registered_apps: +- WASPAPP +- PLATYPUSAPP +- PLATYPUSTESTAPP diff --git a/run_tests b/run_tests new file mode 100755 index 00000000..bf5d1f2a --- /dev/null +++ b/run_tests @@ -0,0 +1,12 @@ +#!/usr/bin/env python +import sys, os + +MOOSE_DIR = os.path.abspath(os.environ.get('MOOSE_DIR', os.path.join(os.path.dirname(__file__), '..', 'moose'))) +if os.path.exists(os.path.abspath(os.path.join('moose', 'framework', 'Makefile'))): + MOOSE_DIR = os.path.abspath('moose') +MOOSE_DIR = os.environ.get('MOOSE_DIR', MOOSE_DIR) + +sys.path.append(os.path.join(MOOSE_DIR, 'python')) + +from TestHarness import TestHarness +TestHarness.buildAndRun(sys.argv, 'platypus', MOOSE_DIR) diff --git a/scripts/build-platypus-csd3-cclake.sh b/scripts/build-platypus-csd3-cclake.sh new file mode 100644 index 00000000..8dd20206 --- /dev/null +++ b/scripts/build-platypus-csd3-cclake.sh @@ -0,0 +1,165 @@ +#!/bin/bash +#set -ue + +export STACK_SRC=`mktemp -d /tmp/moose_stack_src.XXXXXX` +export WORKDIR=`pwd` +export compile_cores=32 +export OMPI_MCA_mca_base_component_show_load_errors=0 + +function load_modules() { + module purge + module load rhel7/global dot slurm cmake-3.19.7-gcc-5.4-5gbsejo + module load hdf5/openmpi/gcc/9.3/openmpi-4.0.4/1.12.0 + module load python/3.8 +} + +function build_petsc() { + cd $WORKDIR + curl -LJO https://github.com/xiaoyeli/superlu_dist/archive/refs/tags/v8.1.0.tar.gz + if [ -d "$WORKDIR/petsc" ] ; then + return + fi + mkdir petsc + cd petsc + curl -L -O http://ftp.mcs.anl.gov/pub/petsc/release-snapshots/petsc-3.19.3.tar.gz + tar -xf petsc-3.19.3.tar.gz -C . + cd petsc-3.19.3 + ./configure \ + --prefix=$WORKDIR/petsc \ + CXXOPTFLAGS='-O3 -march=cascadelake -funroll-loops' COPTFLAGS='-O3 -march=cascadelake -funroll-loops' FOPTFLAGS='-O3 -march=cascadelake' \ + --with-debugging=0 \ + --with-ssl=0 \ + --with-pic=1 \ + --with-openmp=1 \ + --with-mpi=1 \ + --with-shared-libraries=1 \ + --with-fortran-bindings=0 \ + --with-sowing=0 \ + --download-hypre=1 \ + --download-fblaslapack=1 \ + --download-metis=1 \ + --download-ptscotch=1 \ + --download-parmetis=1 \ + --download-superlu_dist=$WORKDIR/superlu_dist-8.1.0.tar.gz \ + --download-scalapack=1 \ + --download-mumps=1 \ + --download-slepc=1 \ + --with-64-bit-indices=1 \ + --with-mpi-dir=/usr/local/Cluster-Apps/openmpi/gcc/9.3/4.0.4 \ + PETSC_DIR=`pwd` PETSC_ARCH=arch-linux-c-opt + make + make PETSC_DIR=$WORKDIR/petsc/petsc-3.19.3 PETSC_ARCH=arch-linux-c-opt install + make PETSC_DIR=$WORKDIR/petsc PETSC_ARCH="" check + cd .. + cd .. + export PETSC_DIR=$WORKDIR/petsc +} + +function build_moose() { + export MOOSE_JOBS=32 + cd $WORKDIR + if [ -d "$WORKDIR/moose" ] ; then + return + fi +# _build_mpich33 + load_modules + #build_vtk_git + cd $WORKDIR + git clone https://github.com/idaholab/moose + cd moose + git checkout master + if [ ! -f "$WORKDIR/petsc/lib/libpetsc.so" ] ; then + echo "PETSc Install Unsuccessful" + return + fi + + export PETSC_DIR=$WORKDIR/petsc + export PETSC_ARCH=arch-linux-c-opt + export CC=mpicc + export CXX=mpicxx + export F90=mpif90 + export F77=mpif77 + export FC=mpif90 + if [ -d "$WORKDIR/vtk" ] ; then + echo "building libmesh with VTK" + METHODS='opt' ./scripts/update_and_rebuild_libmesh.sh --with-mpi --with-cxx-std=2017 --with-vtk-include=$WORKDIR/vtk/include/vtk-9.1 --with-vtk-lib=$WORKDIR/vtk/lib64 + else + echo "Building libmesh withOUT VTK" + METHODS='opt' ./scripts/update_and_rebuild_libmesh.sh --with-mpi + fi + ./configure --with-derivative-size=200 --with-ad-indexing-type=global + METHODS='opt' ./scripts/update_and_rebuild_wasp.sh + cd framework + METHOD=opt make -j32 + cd .. + cd modules + METHOD=opt make -j32 + cd .. + cd test + METHOD=opt make -j32 + ./run_tests -j32 + cd .. + cd .. +} + +function build_mfem() { + cd $WORKDIR + if [ -d "$WORKDIR/mfem" ] ; then + return + fi + git clone https://github.com/Heinrich-BR/mfem.git + cd mfem + git checkout SubmeshBoundary + sed -i "s|list|# list|g" $WORKDIR/mfem/config/cmake/modules/FindNetCDF.cmake + mkdir build + cd build + echo "Building MFEM" + cmake .. \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_CXX_FLAGS_RELEASE=-fPIC \ + -DMFEM_SHARED=YES \ + -DMFEM_USE_OPENMP=YES \ + -DMFEM_THREAD_SAFE=NO \ + -DHYPRE_DIR=/$WORKDIR/petsc/ \ + -DBLAS_LIBRARIES=/$WORKDIR/petsc/lib/libfblas.a \ + -DLAPACK_LIBRARIES=/$WORKDIR/petsc/lib/libflapack.a \ + -DMFEM_USE_MPI=YES \ + -DMFEM_USE_METIS_5=YES \ + -DMETIS_DIR=/$WORKDIR/petsc/ \ + -DParMETIS_DIR=/$WORKDIR/petsc/ \ + -DMFEM_USE_SUPERLU=YES \ + -DSuperLUDist_DIR=/$WORKDIR/petsc/ \ + -DMFEM_USE_NETCDF=YES \ + -DNETCDF_LIBRARIES=$WORKDIR/moose/libmesh/installed/lib/libnetcdf.so \ + -DNETCDF_INCLUDE_DIRS=$WORKDIR/moose/libmesh/contrib/netcdf/netcdf-c-4.6.2/include \ + -DHDF5_DIR=/usr/local/Cluster-Apps/hdf5/openmpi/gcc/9.3/1.12.0 \ + -DCMAKE_POLICY_DEFAULT_CMP0057=NEW + make -j"$compile_cores" + cd miniapps/common + make -j"$compile_cores" +} + +function build_platypus() { + cd $WORKDIR + if [ -d "$WORKDIR/platypus" ] ; then + return + fi + + git clone https://github.com/aurora-multiphysics/platypus.git + cd platypus + git checkout master + git submodule update --init --recursive + cd contrib/hephaestus/ + mkdir build + cd build + cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release -DMFEM_DIR=/$WORKDIR/mfem/build -DMFEM_COMMON_INCLUDES=/$WORKDIR/mfem/miniapps/common .. + make -j1 + cd /$WORKDIR/platypus + make -j"$compile_cores" +} + +load_modules +build_petsc +build_moose +build_mfem +build_platypus diff --git a/scripts/build-platypus-csd3-sapphire.sh b/scripts/build-platypus-csd3-sapphire.sh new file mode 100644 index 00000000..c3d14427 --- /dev/null +++ b/scripts/build-platypus-csd3-sapphire.sh @@ -0,0 +1,287 @@ +#!/bin/bash +#SBATCH --nodes=1 +#SBATCH --ntasks=20 +#SBATCH --time=04:00:00 +#SBATCH --mail-type=none +#SBATCH -p sapphire +#SBATCH -A UKAEA-AP001-CPU +#SBATCH --cpus-per-task=1 +#SBATCH -o out_%j_%A_%a +#SBATCH --exclusive +. /etc/profile.d/modules.sh + +#TODO: +# - Remove xdr requirement from moose/scripts/configure_libmesh +# - Resolve yaml and hit failures in MOOSE test builds +# - Resolve build errors linking hephaestus tests when using intel compilers +# - Split SuperLU_dist build out into separate method + +function load_modules() { + module purge + module load rhel8/default-icl cmake + module load intel-oneapi-mkl/2022.1.0/intel/mngj3ad6 + module load gcc/11 + module load curl + module load python/3.8 + module load ninja + + export STACK_SRC=`mktemp -d /tmp/moose_stack_src.XXXXXX` + export WORKDIR=`pwd` + export compile_cores=8 + export OMPI_MCA_mca_base_component_show_load_errors=0 + + USER=`whoami` + BUILD_DIR_NAME=${WORKDIR} + + ROOT_PATH=/home/${USER}/rds/rds-ukaea-ap001/${USER} + BUILD_PATH=${ROOT_PATH}/${BUILD_DIR_NAME} + USR_PATH=${BUILD_PATH}/usr + + HDF5_MAJ_VER=1.10 + HDF5_MIN_VER=10 + HDF5_DIR_NAME=hdf5 + HDF5_INSTALL_PATH=${WORKDIR}/${HDF5_DIR_NAME} + + PETSC_COMMIT=38aca504f6ea08cc814f159b2c9bcf837a5876f3 + PETSC_DIR_NAME=petsc + PETSC_INSTALL_DIR=${BUILD_PATH}/petsc + + MOOSE_COMMIT=4e99faf9804480e7be302895ff9b8ded5b9944ea + + PLATYPUS_COMMIT=6d3f2edd1792e0538490231de12935b4b5d4ff24 + + export PATH=${BUILD_PATH}:${PATH} + + cd ${WORKDIR} + + #Need to set some compiler flags via config file" + echo "-std=c++17" >> icpx.cfg + echo "-Wno-tautological-constant-compare" >> icpx.cfg + export ICPXCFG=${WORKDIR}/icpx.cfg + + export CC=mpiicc + export CXX=mpiicpc + export FC=mpiifort + export F77=mpiifort + + export I_MPI_CC=icx + export I_MPI_CXX=icpx + export I_MPI_F90=ifx + export I_MPI_FC=ifx + export I_MPI_F77=ifx +} + +function _build_hdf5() { + cd ${WORKDIR} + mkdir -p ${HDF5_DIR_NAME} || { echo "Failed to create ${HDF5_DIR_NAME}" ; exit 1 ; } + + HDF5_MAJ_VER=1.10 + HDF5_MIN_VER=10 + HDF5_VER=${HDF5_MAJ_VER}.${HDF5_MIN_VER} + echo "Downloading HDF5" + curl -kLJO \ + https://support.hdfgroup.org/ftp/HDF5/releases/hdf5-${HDF5_MAJ_VER}/hdf5-${HDF5_VER}/src/hdf5-${HDF5_VER}.tar.gz \ + || { echo "Failed to download hdf5" ; exit 1 ; } + tar -xf hdf5-${HDF5_VER}.tar.gz + + cd hdf5-${HDF5_VER} + make clean + ./configure --prefix=${HDF5_INSTALL_PATH} --enable-cxx --enable-fortran --enable-build-mode=production + make install -j ${compile_cores} + if [ $? -eq 2 ]; then + echo "HDF5 Build failed" + exit 1 + fi + echo "HDF5 built" +} + +function _build_petsc() { + cd $WORKDIR + # echo "Downloading SuperLU_dist" + # curl -kLJO https://github.com/xiaoyeli/superlu_dist/archive/refs/tags/v8.1.0.tar.gz + # curl -kLJO https://github.com/xiaoyeli/superlu_dist/archive/refs/tags/v8.1.0.tar.gz + # if [ -d "$WORKDIR/petsc" ] ; then + # return + # fi + mkdir -p petsc + cd petsc + curl -kL -O http://ftp.mcs.anl.gov/pub/petsc/release-snapshots/petsc-3.19.3.tar.gz + tar -xf petsc-3.19.3.tar.gz -C . + cd petsc-3.19.3 + ./configure \ + --with-cc=$CC --with-cxx=$CXX --with-fc=$FC -CXXPP=cpp \ + --prefix=${WORKDIR}/${PETSC_DIR_NAME} \ + --download-hypre=1 \ + --with-shared-libraries \ + --with-debugging=no \ + --with-hdf5-dir=${WORKDIR}/${HDF5_DIR_NAME} \ + --with-blaslapack-dir=${MKLROOT} \ + --download-metis=1 \ + --download-parmetis=1 \ + --download-ptscotch=1 \ + --download-mumps=1 \ + --download-superlu_dist=${WORKDIR}/superlu_dist-8.1.0.tar.gz \ + --download-scalapack=1 \ + --download-slepc=1 \ + --with-mpi=1 \ + --with-cxx-dialect=C++17 \ + --with-fortran-bindings=0 \ + --with-sowing=0 \ + --with-64-bit-indices \ + --with-make-np=${SLURM_NTASKS} \ + COPTFLAGS='-O3 -fno-slp-vectorize' \ + CXXOPTFLAGS='-O3 -fno-slp-vectorize' \ + FOPTFLAGS='-O3 -fno-slp-vectorize' \ + PETSC_DIR=`pwd` PETSC_ARCH=arch-linux-c-opt + make + make PETSC_DIR=${WORKDIR}/${PETSC_DIR_NAME}/petsc-3.19.3 PETSC_ARCH=arch-linux-c-opt install \ + || { echo "Failed to build petsc" ; exit 1 ; } + cd .. + cd .. + export PETSC_DIR=$WORKDIR/petsc +} + +function build_moose() { + export MOOSE_JOBS=32 + cd $WORKDIR + # if [ -d "$WORKDIR/moose" ] ; then + # return + # fi + cd $WORKDIR + git clone https://github.com/idaholab/moose + cd moose + git checkout ${MOOSE_COMMIT} || { echo "Checkout failed" ; exit 1 ; } + if [ ! -f "$WORKDIR/petsc/lib/libpetsc.so" ] ; then + echo "PETSc Install Unsuccessful" + return + fi + export PETSC_DIR=$WORKDIR/petsc + export PETSC_ARCH=arch-linux-c-opt + + #libmesh configure fails with the llvm compilers so we set these back here + export I_MPI_CXX=icpc + export I_MPI_FC=ifort + export I_MPI_F90=ifort + export I_MPI_F77=ifort + export I_MPI_C=icc + + # echo "diff --git a/scripts/update_and_rebuild_libmesh.sh b/scripts/update_and_rebuild_libmesh.sh + # index e49933bb68..b4d4159843 100755 + # --- a/scripts/update_and_rebuild_libmesh.sh + # +++ b/scripts/update_and_rebuild_libmesh.sh + # @@ -157,6 +157,11 @@ if [ -z \"\$go_fast\" ]; then + # SRC_DIR=\${SCRIPT_DIR}/../libmesh configure_libmesh \$DISABLE_TIMESTAMPS \\ + # \$VTK_OPTIONS \\ + # \$* | tee -a \"\$SCRIPT_DIR/\$DIAGNOSTIC_LOG\" || exit 1 + # + export I_MPI_CXX=icpx + # + export I_MPI_FC=ifx + # + export I_MPI_F90=ifx + # + export I_MPI_F77=ifx + # + export I_MPI_C=icx + # else + # # The build directory must already exist: you can't do --fast for + # # an initial build." > moose.patch + + # git apply moose.patch || { echo "Patch failed" ; exit 1 ; } + + ./scripts/update_and_rebuild_libmesh.sh \ + --with-cxx-std=2017 \ + --with-cc=$CC \ + --with-cxx=$CXX \ + --with-fc=$FC + + export I_MPI_CXX=icpx + export I_MPI_FC=ifx + export I_MPI_F90=ifx + export I_MPI_F77=ifx + export I_MPI_C=icx + + ./configure --with-derivative-size=200 --with-ad-indexing-type=global + METHODS='opt' ./scripts/update_and_rebuild_wasp.sh + cd framework + METHOD=opt make -j"$compile_cores" + cd .. + cd modules + METHOD=opt make -j"$compile_cores" + cd .. + cd test + METHOD=opt make -j"$compile_cores" + ./run_tests -j"$compile_cores" + cd .. + cd .. +} + +function build_gslib() { + cd $WORKDIR + if [ -d "$WORKDIR/gslb" ] ; then + return + fi + git clone https://github.com/Nek5000/gslib.git + cd gslib + make CFLAGS='-O2 -fPIC' +} + +function build_mfem() { + cd $WORKDIR + # if [ -d "$WORKDIR/mfem" ] ; then + # return + # fi + git clone https://github.com/Heinrich-BR/mfem.git + cd mfem + git checkout SubmeshBoundary + sed -i "s|list|# list|g" $WORKDIR/mfem/config/cmake/modules/FindNetCDF.cmake + mkdir build + cd build + echo "Building MFEM" + cmake .. \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_POSITION_INDEPENDENT_CODE=YES \ + -DMFEM_USE_OPENMP=NO \ + -DMFEM_THREAD_SAFE=NO \ + -DHYPRE_DIR=/$WORKDIR/petsc/ \ + -DMFEM_USE_LAPACK=YES \ + -DMFEM_USE_MPI=YES \ + -DMFEM_USE_METIS_5=YES \ + -DMETIS_DIR=/$WORKDIR/petsc/ \ + -DParMETIS_DIR=/$WORKDIR/petsc/ \ + -DMFEM_USE_SUPERLU=YES \ + -DSuperLUDist_DIR=/$WORKDIR/petsc/ \ + -DSuperLUDist_VERSION_OK=YES \ + -DMFEM_USE_NETCDF=YES \ + -DNETCDF_LIBRARIES=$WORKDIR/moose/libmesh/installed/lib/libnetcdf.so \ + -DNETCDF_INCLUDE_DIRS=$WORKDIR/moose/libmesh/contrib/netcdf/netcdf-c-4.6.2/include \ + -DHDF5_DIR=/$WORKDIR/${HDF5_DIR_NAME}/ \ + -DMFEM_USE_GSLIB=YES \ + -DGSLIB_DIR=/$WORKDIR/gslib/build + make -j"$compile_cores" + cd miniapps/common + make -j"$compile_cores" +} + +function build_platypus() { + cd $WORKDIR + # if [ -d "$WORKDIR/platypus" ] ; then + # return + # fi + + git clone https://github.com/aurora-multiphysics/platypus.git + cd platypus + git checkout ${PLATYPUS_COMMIT} + git submodule update --init --recursive + cd contrib/hephaestus/ + # git checkout master + mkdir build + cd build + cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DMFEM_DIR=/$WORKDIR/mfem/build .. + ninja + cd /$WORKDIR/platypus + make -j"$compile_cores" +} + +load_modules +_build_hdf5 +_build_petsc +build_moose +build_gslib +build_mfem +build_platypus diff --git a/scripts/install-format-hook.sh b/scripts/install-format-hook.sh new file mode 100755 index 00000000..44a2037a --- /dev/null +++ b/scripts/install-format-hook.sh @@ -0,0 +1,26 @@ +#!/bin/bash + +REPO_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )/../" +hookfile="$REPO_DIR/.git/hooks/pre-commit" + +if [[ -f $hookfile ]]; then + echo "'$hookfile' already exists - aborting" 1>&2 + exit 1 +fi + +echo '#!/bin/bash +patch=$(git clang-format --diff -- $(git diff --staged --name-only -- src include tests unit)) +if [[ "$patch" =~ "no modified files to format" || "$patch" =~ "clang-format did not modify any files" ]]; then + echo "" > /dev/null +else + echo "" + echo "Your code is not properly formatted." >&2 + echo "Run 'git clang-format' to resolve the following issues:" >&2 + echo "" + echo "$patch" + exit 1 +fi +' > $hookfile + +chmod a+x $hookfile + diff --git a/src/actions/AddCoefficientAction.C b/src/actions/AddCoefficientAction.C new file mode 100644 index 00000000..2af5c381 --- /dev/null +++ b/src/actions/AddCoefficientAction.C @@ -0,0 +1,24 @@ +#include "AddCoefficientAction.h" + +registerMooseAction("PlatypusApp", AddCoefficientAction, "add_mfem_coefficients"); + +InputParameters +AddCoefficientAction::validParams() +{ + InputParameters params = MooseObjectAction::validParams(); + params.addClassDescription("Add a MFEM Coefficient object to the simulation."); + return params; +} + +AddCoefficientAction::AddCoefficientAction(const InputParameters & parameters) + : MooseObjectAction(parameters) +{ +} + +void +AddCoefficientAction::act() +{ + MFEMProblem * mfem_problem = dynamic_cast(_problem.get()); + if (mfem_problem) + mfem_problem->addCoefficient(_type, _name, _moose_object_pars); +} diff --git a/src/actions/AddFESpaceAction.C b/src/actions/AddFESpaceAction.C new file mode 100644 index 00000000..6ff6b9e7 --- /dev/null +++ b/src/actions/AddFESpaceAction.C @@ -0,0 +1,24 @@ +#include "AddFESpaceAction.h" + +registerMooseAction("PlatypusApp", AddFESpaceAction, "add_mfem_fespaces"); + +InputParameters +AddFESpaceAction::validParams() +{ + InputParameters params = MooseObjectAction::validParams(); + params.addClassDescription("Add a MFEM FESpace object to the simulation."); + return params; +} + +AddFESpaceAction::AddFESpaceAction(const InputParameters & parameters) + : MooseObjectAction(parameters) +{ +} + +void +AddFESpaceAction::act() +{ + MFEMProblem * mfem_problem = dynamic_cast(_problem.get()); + if (mfem_problem) + mfem_problem->addFESpace(_type, _name, _moose_object_pars); +} diff --git a/src/actions/AddFormulationAction.C b/src/actions/AddFormulationAction.C new file mode 100644 index 00000000..f9897881 --- /dev/null +++ b/src/actions/AddFormulationAction.C @@ -0,0 +1,24 @@ +#include "AddFormulationAction.h" + +registerMooseAction("PlatypusApp", AddFormulationAction, "add_mfem_formulation"); + +InputParameters +AddFormulationAction::validParams() +{ + InputParameters params = MooseObjectAction::validParams(); + params.addClassDescription("Set the Hephaestus formulation to solve in the simulation."); + return params; +} + +AddFormulationAction::AddFormulationAction(const InputParameters & parameters) + : MooseObjectAction(parameters) +{ +} + +void +AddFormulationAction::act() +{ + MFEMProblem * mfem_problem = dynamic_cast(_problem.get()); + if (mfem_problem) + mfem_problem->setFormulation(_type, _name, _moose_object_pars); +} diff --git a/src/actions/AddVectorCoefficientAction.C b/src/actions/AddVectorCoefficientAction.C new file mode 100644 index 00000000..6abea3d7 --- /dev/null +++ b/src/actions/AddVectorCoefficientAction.C @@ -0,0 +1,24 @@ +#include "AddVectorCoefficientAction.h" + +registerMooseAction("PlatypusApp", AddVectorCoefficientAction, "add_mfem_coefficients"); + +InputParameters +AddVectorCoefficientAction::validParams() +{ + InputParameters params = MooseObjectAction::validParams(); + params.addClassDescription("Add a MFEM VectorCoefficient object to the simulation."); + return params; +} + +AddVectorCoefficientAction::AddVectorCoefficientAction(const InputParameters & parameters) + : MooseObjectAction(parameters) +{ +} + +void +AddVectorCoefficientAction::act() +{ + MFEMProblem * mfem_problem = dynamic_cast(_problem.get()); + if (mfem_problem) + mfem_problem->addVectorCoefficient(_type, _name, _moose_object_pars); +} diff --git a/src/auxkernels/MFEMAuxSolver.C b/src/auxkernels/MFEMAuxSolver.C new file mode 100644 index 00000000..b781feb4 --- /dev/null +++ b/src/auxkernels/MFEMAuxSolver.C @@ -0,0 +1,19 @@ +#include "MFEMAuxSolver.h" + +registerMooseObject("PlatypusApp", MFEMAuxSolver); + +InputParameters +MFEMAuxSolver::validParams() +{ + InputParameters params = GeneralUserObject::validParams(); + + // NB: register as base. MFEM auxkernels should be derived from this base class. This allows the + // same AuxKernel block to be used to setup both MFEM auxsolvers and MOOSE auxkernels. + params.registerBase("MFEMAuxKernel"); + + return params; +} + +MFEMAuxSolver::MFEMAuxSolver(const InputParameters & parameters) : GeneralUserObject(parameters) {} + +MFEMAuxSolver::~MFEMAuxSolver() {} diff --git a/src/auxkernels/MFEMJouleHeatingAux.C b/src/auxkernels/MFEMJouleHeatingAux.C new file mode 100644 index 00000000..053dc08c --- /dev/null +++ b/src/auxkernels/MFEMJouleHeatingAux.C @@ -0,0 +1,28 @@ +#include "MFEMJouleHeatingAux.h" + +registerMooseObject("PlatypusApp", MFEMJouleHeatingAux); + +InputParameters +MFEMJouleHeatingAux::validParams() +{ + InputParameters params = MFEMAuxSolver::validParams(); + + return params; +} + +MFEMJouleHeatingAux::MFEMJouleHeatingAux(const InputParameters & parameters) + : MFEMAuxSolver(parameters), + joule_heating_params({{"CoupledVariableName", std::string("electric_field")}, + {"ConductivityCoefName", std::string("electrical_conductivity")}, + {"JouleHeatingVarName", std::string("joule_heating")}}), + joule_heating_aux{std::make_shared(joule_heating_params)} +{ +} + +void +MFEMJouleHeatingAux::storeCoefficients(hephaestus::Coefficients & coefficients) +{ + coefficients._scalars.Register("JouleHeating", joule_heating_aux); +} + +MFEMJouleHeatingAux::~MFEMJouleHeatingAux() {} diff --git a/src/auxkernels/VectorVariableFromComponentsAux.C b/src/auxkernels/VectorVariableFromComponentsAux.C new file mode 100644 index 00000000..05febe92 --- /dev/null +++ b/src/auxkernels/VectorVariableFromComponentsAux.C @@ -0,0 +1,80 @@ +#include "VectorVariableFromComponentsAux.h" + +registerMooseObject("MooseApp", VectorVariableFromComponentsAux); + +InputParameters +VectorVariableFromComponentsAux::validParams() +{ + InputParameters params = WritableVectorAuxKernel::validParams(); + + params.addRequiredCoupledVar("component_x", "The x-component of the vector variable."); + params.addRequiredCoupledVar("component_y", "The y-component of the vector variable."); + params.addRequiredCoupledVar("component_z", "The z-component of the vector variable."); + + params.addClassDescription("Combine three standard variables into a vector variable."); + + return params; +} + +VectorVariableFromComponentsAux::VectorVariableFromComponentsAux(const InputParameters & parameters) + : WritableVectorAuxKernel(parameters), + _component_x(writableVariable("component_x")), + _component_y(writableVariable("component_y")), + _component_z(writableVariable("component_z")), + _vector_order(_var.order()), + _vector_family(_var.feType().family) +{ + checkVectorVariable(); + checkVectorComponents(); +} + +void +VectorVariableFromComponentsAux::compute() +{ + _variable->setDofValue(_component_x.dofValues()[0], 0); + _variable->setDofValue(_component_y.dofValues()[0], 1); + _variable->setDofValue(_component_z.dofValues()[0], 2); +} + +void +VectorVariableFromComponentsAux::checkVectorVariable() const +{ + if (_vector_family != LAGRANGE_VEC && _vector_family != MONOMIAL_VEC) + { + mooseError("Only Lagrange and Monomial vectors are supported."); + } + + if (_vector_family == MONOMIAL_VEC && _vector_order != CONSTANT) + { + mooseError("Monomial vectors are supported only for constant order."); + } +} + +void +VectorVariableFromComponentsAux::checkVectorComponents() const +{ + checkVectorComponent(_component_x); + checkVectorComponent(_component_y); + checkVectorComponent(_component_z); +} + +void +VectorVariableFromComponentsAux::checkVectorComponent( + const MooseVariable & component_variable) const +{ + auto component_order = component_variable.order(); + auto component_family = component_variable.feType().family; + + bool correct_family = ((component_family == LAGRANGE && _vector_family == LAGRANGE_VEC) || + (component_family == MONOMIAL && _vector_family == MONOMIAL_VEC)); + if (!correct_family) + { + mooseError("Component '", component_variable.name(), "' is of the incorrect family."); + } + + bool correct_order = (component_order == _vector_order); + if (!correct_order) + { + mooseError("Component '", component_variable.name(), "' has a different order to the vector."); + } +} \ No newline at end of file diff --git a/src/auxkernels/VectorVariableToComponentsAux.C b/src/auxkernels/VectorVariableToComponentsAux.C new file mode 100644 index 00000000..5b09fd86 --- /dev/null +++ b/src/auxkernels/VectorVariableToComponentsAux.C @@ -0,0 +1,30 @@ +#include "VectorVariableToComponentsAux.h" + +registerMooseObject("MooseApp", VectorVariableToComponentsAux); + +InputParameters +VectorVariableToComponentsAux::validParams() +{ + InputParameters params = VectorVariableFromComponentsAux::validParams(); + + params.addClassDescription("Extract the components of a vector."); + + return params; +} + +VectorVariableToComponentsAux::VectorVariableToComponentsAux(const InputParameters & parameters) + : VectorVariableFromComponentsAux(parameters) +{ +} + +void +VectorVariableToComponentsAux::compute() +{ + Real value_x = _variable->dofValues()[0]; + Real value_y = _variable->dofValues()[1]; + Real value_z = _variable->dofValues()[2]; + + _component_x.setNodalValue(value_x, 0); + _component_y.setNodalValue(value_y, 0); + _component_z.setNodalValue(value_z, 0); +} diff --git a/src/auxkernels/WritableVectorAuxKernel.C b/src/auxkernels/WritableVectorAuxKernel.C new file mode 100644 index 00000000..8fafacba --- /dev/null +++ b/src/auxkernels/WritableVectorAuxKernel.C @@ -0,0 +1,14 @@ +#include "WritableVectorAuxKernel.h" + +registerMooseObject("MooseApp", WritableVectorAuxKernel); + +MooseVariable & +WritableVectorAuxKernel::writableVariable(const std::string & var_name, unsigned int comp) +{ + auto * var = dynamic_cast(getVar(var_name, comp)); + + // Make sure only one object can access a variable. + checkWritableVar(var); + + return *var; +} diff --git a/src/base/PlatypusApp.C b/src/base/PlatypusApp.C new file mode 100644 index 00000000..8236d969 --- /dev/null +++ b/src/base/PlatypusApp.C @@ -0,0 +1,96 @@ +#include "PlatypusApp.h" +#include "Moose.h" +#include "AppFactory.h" +#include "ModulesApp.h" +#include "MooseSyntax.h" + +InputParameters +PlatypusApp::validParams() +{ + InputParameters params = MooseApp::validParams(); + params.set("use_legacy_material_output") = false; + return params; +} + +PlatypusApp::PlatypusApp(InputParameters parameters) : MooseApp(parameters) +{ + PlatypusApp::registerAll(_factory, _action_factory, _syntax); +} + +PlatypusApp::~PlatypusApp() {} + +static void +associateSyntaxInner(Syntax & syntax, ActionFactory & /*action_factory*/) +{ + // add base formulation + registerMooseObjectTask("add_mfem_formulation", MFEMFormulation, true); + registerSyntaxTask("AddFormulationAction", "Formulation", "add_mfem_formulation"); + addTaskDependency("add_mfem_formulation", "init_mesh"); + addTaskDependency("add_variable", "add_mfem_formulation"); + addTaskDependency("add_aux_variable", "add_mfem_formulation"); + addTaskDependency("add_elemental_field_variable", "add_mfem_formulation"); + addTaskDependency("add_kernel", "add_mfem_formulation"); + + // add MFEM auxkernel base + appendMooseObjectTask("add_aux_kernel", MFEMAuxKernel); + + // add coefficients + registerMooseObjectTask("add_mfem_coefficients", MFEMCoefficient, false); + registerSyntaxTask("AddCoefficientAction", "Coefficients/*", "add_mfem_coefficients"); + addTaskDependency("add_material", "add_mfem_coefficients"); + addTaskDependency("add_mfem_coefficients", "add_variable"); + addTaskDependency("add_mfem_coefficients", "add_aux_variable"); + addTaskDependency("add_mfem_coefficients", "add_ic"); + + // add vector coefficients + registerMooseObjectTask("add_mfem_vector_coefficients", MFEMVectorCoefficient, false); + registerSyntaxTask( + "AddVectorCoefficientAction", "VectorCoefficients/*", "add_mfem_vector_coefficients"); + addTaskDependency("add_material", "add_mfem_vector_coefficients"); + + // add sources + registerMooseObjectTask("add_mfem_sources", MFEMSource, false); + registerSyntaxTask("AddSourceAction", "Sources/*", "add_mfem_sources"); + addTaskDependency("add_mfem_sources", "add_material"); + addTaskDependency("add_mfem_sources", "add_variable"); + addTaskDependency("add_mfem_sources", "add_aux_variable"); + + // add FESpaces + registerMooseObjectTask("add_mfem_fespaces", MFEMFESpace, false); + registerSyntaxTask("AddFESpaceAction", "FESpaces/*", "add_mfem_fespaces"); + addTaskDependency("add_variable", "add_mfem_fespaces"); + addTaskDependency("add_aux_variable", "add_mfem_fespaces"); + addTaskDependency("add_elemental_field_variable", "add_mfem_fespaces"); + addTaskDependency("add_kernel", "add_mfem_fespaces"); + addTaskDependency("add_mfem_sources", "add_mfem_fespaces"); +} + +void +PlatypusApp::registerAll(Factory & f, ActionFactory & af, Syntax & s) +{ + ModulesApp::registerAll(f, af, s); + Registry::registerObjectsTo(f, {"PlatypusApp"}); + Registry::registerActionsTo(af, {"PlatypusApp"}); + /* register custom execute flags, action syntax, etc. here */ + associateSyntaxInner(s, af); +} + +void +PlatypusApp::registerApps() +{ + registerApp(PlatypusApp); +} + +/*************************************************************************************************** + *********************** Dynamic Library Entry Points - DO NOT MODIFY ****************************** + **************************************************************************************************/ +extern "C" void +PlatypusApp__registerAll(Factory & f, ActionFactory & af, Syntax & s) +{ + PlatypusApp::registerAll(f, af, s); +} +extern "C" void +PlatypusApp__registerApps() +{ + PlatypusApp::registerApps(); +} diff --git a/src/bcs/MFEMBoundaryCondition.C b/src/bcs/MFEMBoundaryCondition.C new file mode 100644 index 00000000..6d596296 --- /dev/null +++ b/src/bcs/MFEMBoundaryCondition.C @@ -0,0 +1,31 @@ +#include "MFEMBoundaryCondition.h" + +registerMooseObject("PlatypusApp", MFEMBoundaryCondition); + +InputParameters +MFEMBoundaryCondition::validParams() +{ + InputParameters params = GeneralUserObject::validParams(); + + params.registerBase("BoundaryCondition"); + + // Create user-facing 'boundary' input for restricting inheriting object to boundaries + params.addParam>( + "boundary", + "The list of boundaries (ids or names) from the mesh where this boundary condition applies"); + params.addParam("variable", "Variable on which to apply the boundary condition"); + return params; +} + +MFEMBoundaryCondition::MFEMBoundaryCondition(const InputParameters & parameters) + : GeneralUserObject(parameters), + _boundary_names(getParam>("boundary")), + bdr_attr(_boundary_names.size()) +{ + for (unsigned int i = 0; i < _boundary_names.size(); ++i) + { + bdr_attr[i] = std::stoi(_boundary_names[i]); + } + _boundary_condition = + std::make_shared(getParam("variable"), bdr_attr); +} diff --git a/src/bcs/MFEMComplexVectorDirichletBC.C b/src/bcs/MFEMComplexVectorDirichletBC.C new file mode 100644 index 00000000..ed9e8cc3 --- /dev/null +++ b/src/bcs/MFEMComplexVectorDirichletBC.C @@ -0,0 +1,33 @@ +#include "MFEMComplexVectorDirichletBC.h" + +registerMooseObject("PlatypusApp", MFEMComplexVectorDirichletBC); + +InputParameters +MFEMComplexVectorDirichletBC::validParams() +{ + InputParameters params = MFEMBoundaryCondition::validParams(); + params.addRequiredParam( + "real_vector_coefficient", + "The vector MFEM coefficient representing the real component of the variable on which the " + "Dirichlet condition is being applied"); + params.addRequiredParam("imag_vector_coefficient", + "The vector MFEM coefficient representing the imaginary " + "component of the variable on which the " + "Dirichlet condition is being applied"); + return params; +} + +// TODO: Currently assumes the vector function coefficient is 3D +MFEMComplexVectorDirichletBC::MFEMComplexVectorDirichletBC(const InputParameters & parameters) + : MFEMBoundaryCondition(parameters), + _vec_coef_re(const_cast( + &getUserObject("real_vector_coefficient"))), + _vec_coef_im(const_cast( + &getUserObject("imag_vector_coefficient"))) +{ + _boundary_condition = + std::make_shared(getParam("variable"), + bdr_attr, + _vec_coef_re->getVectorCoefficient().get(), + _vec_coef_im->getVectorCoefficient().get()); +} diff --git a/src/bcs/MFEMScalarDirichletBC.C b/src/bcs/MFEMScalarDirichletBC.C new file mode 100644 index 00000000..90d68e61 --- /dev/null +++ b/src/bcs/MFEMScalarDirichletBC.C @@ -0,0 +1,20 @@ +#include "MFEMScalarDirichletBC.h" + +registerMooseObject("PlatypusApp", MFEMScalarDirichletBC); + +InputParameters +MFEMScalarDirichletBC::validParams() +{ + InputParameters params = MFEMBoundaryCondition::validParams(); + params.addRequiredParam( + "coefficient", "The scalar MFEM coefficient to use in the Dirichlet condition"); + return params; +} + +MFEMScalarDirichletBC::MFEMScalarDirichletBC(const InputParameters & parameters) + : MFEMBoundaryCondition(parameters), + _coef(const_cast(&getUserObject("coefficient"))) +{ + _boundary_condition = std::make_shared( + getParam("variable"), bdr_attr, _coef->getCoefficient().get()); +} diff --git a/src/bcs/MFEMVectorDirichletBC.C b/src/bcs/MFEMVectorDirichletBC.C new file mode 100644 index 00000000..496a1aa1 --- /dev/null +++ b/src/bcs/MFEMVectorDirichletBC.C @@ -0,0 +1,22 @@ +#include "MFEMVectorDirichletBC.h" + +registerMooseObject("PlatypusApp", MFEMVectorDirichletBC); + +InputParameters +MFEMVectorDirichletBC::validParams() +{ + InputParameters params = MFEMBoundaryCondition::validParams(); + params.addRequiredParam( + "vector_coefficient", "The vector MFEM coefficient to use in the Dirichlet condition"); + return params; +} + +// TODO: Currently assumes the vector function coefficient is 3D +MFEMVectorDirichletBC::MFEMVectorDirichletBC(const InputParameters & parameters) + : MFEMBoundaryCondition(parameters), + _vec_coef(const_cast( + &getUserObject("vector_coefficient"))) +{ + _boundary_condition = std::make_shared( + getParam("variable"), bdr_attr, _vec_coef->getVectorCoefficient().get()); +} diff --git a/src/bcs/MFEMVectorNormalIntegratedBC.C b/src/bcs/MFEMVectorNormalIntegratedBC.C new file mode 100644 index 00000000..8c4e1fe9 --- /dev/null +++ b/src/bcs/MFEMVectorNormalIntegratedBC.C @@ -0,0 +1,26 @@ +#include "MFEMVectorNormalIntegratedBC.h" + +registerMooseObject("PlatypusApp", MFEMVectorNormalIntegratedBC); + +InputParameters +MFEMVectorNormalIntegratedBC::validParams() +{ + InputParameters params = MFEMBoundaryCondition::validParams(); + params.addRequiredParam( + "vector_coefficient", + "The vector MFEM coefficient whose normal component will be used in the integrated BC"); + return params; +} + +// TODO: Currently assumes the vector function coefficient is 3D +MFEMVectorNormalIntegratedBC::MFEMVectorNormalIntegratedBC(const InputParameters & parameters) + : MFEMBoundaryCondition(parameters), + _vec_coef(const_cast( + &getUserObject("vector_coefficient"))) +{ + + _boundary_condition = std::make_shared( + getParam("variable"), + bdr_attr, + std::make_unique(*_vec_coef->getVectorCoefficient())); +} diff --git a/src/coefficients/MFEMCoefficient.C b/src/coefficients/MFEMCoefficient.C new file mode 100644 index 00000000..4b159666 --- /dev/null +++ b/src/coefficients/MFEMCoefficient.C @@ -0,0 +1,23 @@ +#include "MFEMCoefficient.h" + +registerMooseObject("PlatypusApp", MFEMCoefficient); + +libMesh::Point +PointFromMFEMVector(const mfem::Vector & vec) +{ + return libMesh::Point(vec.Elem(0), vec.Elem(1), vec.Elem(2)); +} + +InputParameters +MFEMCoefficient::validParams() +{ + InputParameters params = GeneralUserObject::validParams(); + params.registerBase("MFEMCoefficient"); + return params; +} + +MFEMCoefficient::MFEMCoefficient(const InputParameters & parameters) : GeneralUserObject(parameters) +{ +} + +MFEMCoefficient::~MFEMCoefficient() {} diff --git a/src/coefficients/MFEMConstantCoefficient.C b/src/coefficients/MFEMConstantCoefficient.C new file mode 100644 index 00000000..18a360dc --- /dev/null +++ b/src/coefficients/MFEMConstantCoefficient.C @@ -0,0 +1,19 @@ +#include "MFEMConstantCoefficient.h" + +registerMooseObject("PlatypusApp", MFEMConstantCoefficient); + +InputParameters +MFEMConstantCoefficient::validParams() +{ + InputParameters params = MFEMCoefficient::validParams(); + params.addRequiredParam("value", "Value for the ConstantCoefficient"); + return params; +} + +MFEMConstantCoefficient::MFEMConstantCoefficient(const InputParameters & parameters) + : MFEMCoefficient(parameters), + coefficient{std::make_shared(getParam("value"))} +{ +} + +MFEMConstantCoefficient::~MFEMConstantCoefficient() {} diff --git a/src/coefficients/MFEMFunctionCoefficient.C b/src/coefficients/MFEMFunctionCoefficient.C new file mode 100644 index 00000000..bcbd4dcc --- /dev/null +++ b/src/coefficients/MFEMFunctionCoefficient.C @@ -0,0 +1,21 @@ +#include "MFEMFunctionCoefficient.h" + +registerMooseObject("PlatypusApp", MFEMFunctionCoefficient); + +InputParameters +MFEMFunctionCoefficient::validParams() +{ + InputParameters params = MFEMCoefficient::validParams(); + params.addParam("function", 0, "The function to associated with the Dirichlet BC"); + return params; +} + +MFEMFunctionCoefficient::MFEMFunctionCoefficient(const InputParameters & parameters) + : MFEMCoefficient(parameters), + _func(getFunction("function")), + _coefficient(std::make_shared( + [&](const mfem::Vector & p, double t) { return _func.value(t, PointFromMFEMVector(p)); })) +{ +} + +MFEMFunctionCoefficient::~MFEMFunctionCoefficient() {} diff --git a/src/coefficients/MFEMParsedCoefficient.C b/src/coefficients/MFEMParsedCoefficient.C new file mode 100644 index 00000000..4e5a461e --- /dev/null +++ b/src/coefficients/MFEMParsedCoefficient.C @@ -0,0 +1,24 @@ +#include "MFEMParsedCoefficient.h" + +registerMooseObject("MooseApp", MFEMParsedCoefficient); + +InputParameters +MFEMParsedCoefficient::validParams() +{ + InputParameters params = MFEMParsedCoefficientHelper::validParams(); + params += MFEMParsedCoefficientBase::validParams(); + params.addClassDescription("MFEM Parsed Function Coefficient."); + return params; +} + +MFEMParsedCoefficient::MFEMParsedCoefficient(const InputParameters & parameters) + : MFEMParsedCoefficientHelper(parameters, VariableNameMappingMode::USE_MOOSE_NAMES), + MFEMParsedCoefficientBase(parameters) +{ + // Build function and optimize + functionParse(_function, + _constant_names, + _constant_expressions, + getParam>("mfem_coefficient_names"), + getParam>("mfem_gridfunction_names")); +} diff --git a/src/coefficients/MFEMParsedCoefficientBase.C b/src/coefficients/MFEMParsedCoefficientBase.C new file mode 100644 index 00000000..7f644aaf --- /dev/null +++ b/src/coefficients/MFEMParsedCoefficientBase.C @@ -0,0 +1,50 @@ +#include "MFEMParsedCoefficientBase.h" + +InputParameters +MFEMParsedCoefficientBase::validParams() +{ + InputParameters params = emptyInputParameters(); + params.addCoupledVar("args", "Arguments of F() - use vector coupling"); + + // Constants and their values + params.addParam>( + "constant_names", + std::vector(), + "Vector of constants used in the parsed function (use this for kB etc.)"); + params.addParam>( + "constant_expressions", + std::vector(), + "Vector of values for the constants in constant_names (can be an FParser expression)"); + + // Material properties + params.addParam>( + "mfem_gridfunction_names", + std::vector(), + "Vector of MFEM gridfunctions names used in the parsed function"); + + // Postprocessors + params.addParam>( + "mfem_coefficient_names", + std::vector(), + "Vector of MFEM coefficient names used in the parsed function"); + + // Function expression + params.addRequiredCustomTypeParam( + "function", "FunctionExpression", "FParser function expression for the parsed material"); + + return params; +} + +MFEMParsedCoefficientBase::MFEMParsedCoefficientBase(const InputParameters & parameters) +{ + // get function expression + _function = parameters.get("function"); + + // get constant vectors + _constant_names = parameters.get>("constant_names"); + _constant_expressions = parameters.get>("constant_expressions"); + + // get mfem object names + _mfem_coefficient_names = parameters.get>("mfem_coefficient_names"); + _mfem_gridfunction_names = parameters.get>("mfem_gridfunction_names"); +} diff --git a/src/coefficients/MFEMParsedCoefficientHelper.C b/src/coefficients/MFEMParsedCoefficientHelper.C new file mode 100644 index 00000000..4b32496b --- /dev/null +++ b/src/coefficients/MFEMParsedCoefficientHelper.C @@ -0,0 +1,163 @@ +#include "MFEMParsedCoefficientHelper.h" + +InputParameters +MFEMParsedCoefficientHelper::validParams() +{ + InputParameters params = MFEMCoefficient::validParams(); + params += FunctionParserUtils::validParams(); + params.addClassDescription( + "Class to create mfem::Coefficients which evaluate to a provided parsed function."); + return params; +} + +MFEMParsedCoefficientHelper::MFEMParsedCoefficientHelper(const InputParameters & parameters, + VariableNameMappingMode map_mode) + : MFEMCoefficient(parameters), + hephaestus::CoupledCoefficient(hephaestus::InputParameters( + std::map({{"CoupledVariableName", std::string("dummy_variable")}}))), + FunctionParserUtils(parameters), + _symbol_names(0), + _coefficient_names(0) +{ +} + +void +MFEMParsedCoefficientHelper::functionParse(const std::string & function_expression) +{ + const std::vector empty_string_vector; + functionParse(function_expression, empty_string_vector, empty_string_vector); +} + +void +MFEMParsedCoefficientHelper::functionParse(const std::string & function_expression, + const std::vector & constant_names, + const std::vector & constant_expressions) +{ + const std::vector empty_string_vector; + const std::vector empty_real_vector; + functionParse(function_expression, constant_names, constant_expressions, empty_string_vector); +} + +void +MFEMParsedCoefficientHelper::functionParse(const std::string & function_expression, + const std::vector & constant_names, + const std::vector & constant_expressions, + const std::vector & mfem_coefficient_names) +{ + const std::vector empty_string_vector; + functionParse(function_expression, + constant_names, + constant_expressions, + mfem_coefficient_names, + empty_string_vector); +} + +void +MFEMParsedCoefficientHelper::functionParse(const std::string & function_expression, + const std::vector & constant_names, + const std::vector & constant_expressions, + const std::vector & mfem_coefficient_names, + const std::vector & mfem_gridfunction_names) +{ + // build base function object + _func_F = std::make_shared(); + + // set FParser internal feature flags + setParserFeatureFlags(_func_F); + + // initialize constants + addFParserConstants(_func_F, constant_names, constant_expressions); + + // Store all MFEM gridfunction names + unsigned int nmfem_gfs = mfem_gridfunction_names.size(); + _gridfunctions.resize(nmfem_gfs); + for (const auto & gfname : mfem_gridfunction_names) + { + _gridfunction_names.push_back(gfname); + _symbol_names.push_back(gfname); + } + + // Store all MFEM coefficient names + unsigned int nmfem_coefs = mfem_coefficient_names.size(); + _coefficients.resize(nmfem_coefs); + for (const auto & coefname : mfem_coefficient_names) + { + _coefficient_names.push_back(coefname); + _symbol_names.push_back(coefname); + } + + // build 'variables' argument for fparser + std::string variables = Moose::stringify(_symbol_names); + + // build the base function + if (_func_F->Parse(function_expression, variables) >= 0) + mooseError("Invalid function\n", + function_expression, + '\n', + variables, + "\nin MFEMParsedCoefficientHelper.\n", + _func_F->ErrorMsg()); + + // create parameter passing buffer + _func_params.resize(nmfem_coefs + nmfem_gfs); + + // optimise function + functionsOptimize(); +} + +void +MFEMParsedCoefficientHelper::functionsOptimize() +{ + // base function + if (!_disable_fpoptimizer) + _func_F->Optimize(); + if (_enable_jit && !_func_F->JITCompile()) + mooseInfo("Failed to JIT compile expression, falling back to byte code interpretation."); +} + +void +MFEMParsedCoefficientHelper::Init(const hephaestus::GridFunctions & variables, + hephaestus::Coefficients & coefficients) +{ + auto nmfem_gfs = _gridfunction_names.size(); + for (MooseIndex(_gridfunction_names) i = 0; i < nmfem_gfs; ++i) + { + if (variables.Has(_gridfunction_names[i])) + { + _gridfunctions[i] = variables.Get(_gridfunction_names[i]); + } + else + { + mooseError("Invalid gridfunction\n", + _gridfunction_names[i], + "\n", + "not found in variables when\n" + "creating MFEMParsedCoefficient\n", + "in MFEMParsedCoefficientHelper.\n"); + } + } + + auto nmfem_coefs = _coefficient_names.size(); + for (MooseIndex(_coefficient_names) i = 0; i < nmfem_coefs; ++i) + { + _coefficients[i] = coefficients._scalars.Get(_coefficient_names[i]); + } +} + +double +MFEMParsedCoefficientHelper::Eval(mfem::ElementTransformation & trans, + const mfem::IntegrationPoint & ip) +{ + // insert coefficient values + auto nmfem_coefs = _coefficient_names.size(); + for (MooseIndex(_coefficient_names) i = 0; i < nmfem_coefs; ++i) + _func_params[i] = _coefficients[i]->Eval(trans, ip); + + // insert gridfunction values + auto nmfem_gfs = _gridfunction_names.size(); + for (MooseIndex(_gridfunction_names) i = 0; i < nmfem_gfs; ++i) + _func_params[i + nmfem_coefs] = _gridfunctions[i]->GetValue(trans, ip); + + // set function value + return evaluate(_func_F, _name); +} diff --git a/src/coefficients/MFEMVariableDependentFunctionCoefficient.C b/src/coefficients/MFEMVariableDependentFunctionCoefficient.C new file mode 100644 index 00000000..0298f5b6 --- /dev/null +++ b/src/coefficients/MFEMVariableDependentFunctionCoefficient.C @@ -0,0 +1,33 @@ +#include "MFEMVariableDependentFunctionCoefficient.h" + +registerMooseObject("PlatypusApp", MFEMVariableDependentFunctionCoefficient); + +InputParameters +MFEMVariableDependentFunctionCoefficient::validParams() +{ + InputParameters params = MFEMCoefficient::validParams(); + params.addParam( + "function", 1, "The function acting on the MFEM variable to return the coefficient"); + + params.addParam("coupled_variable", "The MFEMVariable the coefficient depends on."); + return params; +} + +MFEMVariableDependentFunctionCoefficient::MFEMVariableDependentFunctionCoefficient( + const InputParameters & parameters) + : MFEMCoefficient(parameters), + hephaestus::CoupledCoefficient(hephaestus::InputParameters( + {{"CoupledVariableName", getParam("coupled_variable")}})), + _func(getFunction("function")) +{ +} + +double +MFEMVariableDependentFunctionCoefficient::Eval(mfem::ElementTransformation & trans, + const mfem::IntegrationPoint & ip) +{ + auto gf_value{hephaestus::CoupledCoefficient::Eval(trans, ip)}; + return _func.value(gf_value); +}; + +MFEMVariableDependentFunctionCoefficient::~MFEMVariableDependentFunctionCoefficient() {} diff --git a/src/coefficients/MFEMVectorCoefficient.C b/src/coefficients/MFEMVectorCoefficient.C new file mode 100644 index 00000000..5ff0b05c --- /dev/null +++ b/src/coefficients/MFEMVectorCoefficient.C @@ -0,0 +1,18 @@ +#include "MFEMVectorCoefficient.h" + +registerMooseObject("PlatypusApp", MFEMVectorCoefficient); + +InputParameters +MFEMVectorCoefficient::validParams() +{ + InputParameters params = GeneralUserObject::validParams(); + params.registerBase("MFEMVectorCoefficient"); + return params; +} + +MFEMVectorCoefficient::MFEMVectorCoefficient(const InputParameters & parameters) + : GeneralUserObject(parameters) +{ +} + +MFEMVectorCoefficient::~MFEMVectorCoefficient() {} diff --git a/src/coefficients/MFEMVectorConstantCoefficient.C b/src/coefficients/MFEMVectorConstantCoefficient.C new file mode 100644 index 00000000..628a6086 --- /dev/null +++ b/src/coefficients/MFEMVectorConstantCoefficient.C @@ -0,0 +1,23 @@ +#include "MFEMVectorConstantCoefficient.h" + +registerMooseObject("PlatypusApp", MFEMVectorConstantCoefficient); + +InputParameters +MFEMVectorConstantCoefficient::validParams() +{ + InputParameters params = MFEMVectorCoefficient::validParams(); + params.addRequiredParam("value_x", "x component of the VectorConstantCoefficient"); + params.addRequiredParam("value_y", "y component of the VectorConstantCoefficient"); + params.addRequiredParam("value_z", "z component of the VectorConstantCoefficient"); + return params; +} + +MFEMVectorConstantCoefficient::MFEMVectorConstantCoefficient(const InputParameters & parameters) + : MFEMVectorCoefficient(parameters), + _vector( + {getParam("value_x"), getParam("value_y"), getParam("value_z")}), + _vector_coefficient{std::make_shared(_vector)} +{ +} + +MFEMVectorConstantCoefficient::~MFEMVectorConstantCoefficient() {} diff --git a/src/coefficients/MFEMVectorFunctionCoefficient.C b/src/coefficients/MFEMVectorFunctionCoefficient.C new file mode 100644 index 00000000..f09668fd --- /dev/null +++ b/src/coefficients/MFEMVectorFunctionCoefficient.C @@ -0,0 +1,28 @@ +#include "MFEMVectorFunctionCoefficient.h" + +registerMooseObject("PlatypusApp", MFEMVectorFunctionCoefficient); + +InputParameters +MFEMVectorFunctionCoefficient::validParams() +{ + InputParameters params = MFEMVectorCoefficient::validParams(); + params.addParam("function", 0, "The function to associated with the Dirichlet BC"); + return params; +} + +MFEMVectorFunctionCoefficient::MFEMVectorFunctionCoefficient(const InputParameters & parameters) + : MFEMVectorCoefficient(parameters), + _func(getFunction("function")), + _vector_coefficient(std::make_shared( + 3, + [&](const mfem::Vector & p, double t, mfem::Vector & u) + { + libMesh::RealVectorValue vector_value = _func.vectorValue(t, PointFromMFEMVector(p)); + u[0] = vector_value(0); + u[1] = vector_value(1); + u[2] = vector_value(2); + })) +{ +} + +MFEMVectorFunctionCoefficient::~MFEMVectorFunctionCoefficient() {} diff --git a/src/fespaces/MFEMFESpace.C b/src/fespaces/MFEMFESpace.C new file mode 100644 index 00000000..260dbb75 --- /dev/null +++ b/src/fespaces/MFEMFESpace.C @@ -0,0 +1,48 @@ +#include "MFEMFESpace.h" + +registerMooseObject("PlatypusApp", MFEMFESpace); + +InputParameters +MFEMFESpace::validParams() +{ + InputParameters params = GeneralUserObject::validParams(); + params.registerBase("MFEMFESpace"); + MooseEnum fespace_types("H1 ND RT L2", "H1", true); + params.addParam( + "fespace_type", + fespace_types, + "Specifies the family of FE shape functions (FE space) to use for this variable."); + MooseEnum order( + "CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH" + "THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH " + "TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH " + "TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH " + "THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST" + "FORTYSECOND FORTYTHIRD", + "FIRST", + true); + params.addParam("order", + order, + "Order of the FE shape function to use for this variable (additional" + "orders not listed here are allowed," + "depending on the family."); + params.addParam("vdim", 1, "Dimension of degrees of freedom"); + return params; +} + +MFEMFESpace::MFEMFESpace(const InputParameters & parameters) + : GeneralUserObject(parameters), + order(parameters.get("order")), + vdim(parameters.get("vdim")), + fespace_type(parameters.get("fespace_type")), + fec_name(createFECName(fespace_type, order)) +{ +} + +const std::string +MFEMFESpace::createFECName(const std::string & fespace_type, const int order) +{ + return fespace_type + "_3D_P" + std::to_string(order); +} + +MFEMFESpace::~MFEMFESpace() {} diff --git a/src/formulations/CustomFormulation.C b/src/formulations/CustomFormulation.C new file mode 100644 index 00000000..3d647b0b --- /dev/null +++ b/src/formulations/CustomFormulation.C @@ -0,0 +1,18 @@ +#include "CustomFormulation.h" + +registerMooseObject("PlatypusApp", CustomFormulation); + +InputParameters +CustomFormulation::validParams() +{ + InputParameters params = MFEMFormulation::validParams(); + return params; +} + +CustomFormulation::CustomFormulation(const InputParameters & parameters) + : MFEMFormulation(parameters) +{ + formulation = std::make_shared(); +} + +CustomFormulation::~CustomFormulation() {} diff --git a/src/formulations/MFEMFormulation.C b/src/formulations/MFEMFormulation.C new file mode 100644 index 00000000..f1ef4897 --- /dev/null +++ b/src/formulations/MFEMFormulation.C @@ -0,0 +1,17 @@ +#include "MFEMFormulation.h" + +registerMooseObject("PlatypusApp", MFEMFormulation); + +InputParameters +MFEMFormulation::validParams() +{ + InputParameters params = GeneralUserObject::validParams(); + params.registerBase("MFEMFormulation"); + return params; +} + +MFEMFormulation::MFEMFormulation(const InputParameters & parameters) : GeneralUserObject(parameters) +{ +} + +MFEMFormulation::~MFEMFormulation() {} diff --git a/src/kernels/MFEMBilinearFormKernel.C b/src/kernels/MFEMBilinearFormKernel.C new file mode 100644 index 00000000..1b53e535 --- /dev/null +++ b/src/kernels/MFEMBilinearFormKernel.C @@ -0,0 +1,19 @@ +#include "MFEMBilinearFormKernel.h" + +registerMooseObject("PlatypusApp", MFEMBilinearFormKernel); + +InputParameters +MFEMBilinearFormKernel::validParams() +{ + InputParameters params = GeneralUserObject::validParams(); + + params.registerBase("Kernel"); + params.addParam("variable", "Variable on which to apply the kernel"); + + return params; +} + +MFEMBilinearFormKernel::MFEMBilinearFormKernel(const InputParameters & parameters) + : GeneralUserObject(parameters) +{ +} diff --git a/src/kernels/MFEMDiffusionKernel.C b/src/kernels/MFEMDiffusionKernel.C new file mode 100644 index 00000000..bdd2ee3f --- /dev/null +++ b/src/kernels/MFEMDiffusionKernel.C @@ -0,0 +1,25 @@ +#include "MFEMDiffusionKernel.h" + +registerMooseObject("PlatypusApp", MFEMDiffusionKernel); + +InputParameters +MFEMDiffusionKernel::validParams() +{ + InputParameters params = MFEMBilinearFormKernel::validParams(); + params.addClassDescription( + "The Laplacian operator ($-k\\nabla \\cdot \\nabla u$), with the weak " + "form of $ (k\\nabla \\phi_i, \\nabla u_h), to be added to an MFEM problem"); + + params.addParam("coefficient", + "Name of MFEM coefficient k to multiply the Laplacian by"); + + return params; +} + +MFEMDiffusionKernel::MFEMDiffusionKernel(const InputParameters & parameters) + : MFEMBilinearFormKernel(parameters), + _kernel_params{{{"VariableName", getParam("variable")}, + {"CoefficientName", getParam("coefficient")}}}, + _kernel{std::make_shared(_kernel_params)} +{ +} diff --git a/src/kernels/MFEMLinearFormKernel.C b/src/kernels/MFEMLinearFormKernel.C new file mode 100644 index 00000000..1fa281af --- /dev/null +++ b/src/kernels/MFEMLinearFormKernel.C @@ -0,0 +1,21 @@ +#include "MFEMLinearFormKernel.h" + +registerMooseObject("PlatypusApp", MFEMLinearFormKernel); + +InputParameters +MFEMLinearFormKernel::validParams() +{ + InputParameters params = GeneralUserObject::validParams(); + + params.registerBase("Kernel"); + params.addParam("variable", "Variable on which to apply the kernel"); + + return params; +} + +MFEMLinearFormKernel::MFEMLinearFormKernel(const InputParameters & parameters) + : GeneralUserObject(parameters) +{ +} + +MFEMLinearFormKernel::~MFEMLinearFormKernel() {} diff --git a/src/main.C b/src/main.C new file mode 100644 index 00000000..bbd5b61b --- /dev/null +++ b/src/main.C @@ -0,0 +1,27 @@ +#include "PlatypusTestApp.h" +#include "MooseInit.h" +#include "Moose.h" +#include "MooseApp.h" +#include "AppFactory.h" + +// Create a performance log +PerfLog Moose::perf_log("Platypus"); + +// Begin the main program. +int +main(int argc, char * argv[]) +{ + // Initialize MPI, solvers and MOOSE + MooseInit init(argc, argv); + + // Register this application's MooseApp and any it depends on + PlatypusTestApp::registerApps(); + + // Create an instance of the application and store it in a smart pointer for easy cleanup + std::shared_ptr app = AppFactory::createAppShared("PlatypusTestApp", argc, argv); + + // Execute the application + app->run(); + + return 0; +} diff --git a/src/materials/MFEMMaterial.C b/src/materials/MFEMMaterial.C new file mode 100644 index 00000000..a687185b --- /dev/null +++ b/src/materials/MFEMMaterial.C @@ -0,0 +1,24 @@ +#include "MFEMMaterial.h" + +registerMooseObject("PlatypusApp", MFEMMaterial); + +InputParameters +MFEMMaterial::validParams() +{ + InputParameters params = GeneralUserObject::validParams(); + + params.set("_moose_base") = "MaterialBase"; + params.addPrivateParam("_neighbor", false); + params.addPrivateParam("_interface", false); + + params.addParam>( + "block", "The list of blocks (ids or names) that this object will be applied"); + return params; +} + +MFEMMaterial::MFEMMaterial(const InputParameters & parameters) + : GeneralUserObject(parameters), blocks(getParam>("block")) +{ +} + +MFEMMaterial::~MFEMMaterial() {} diff --git a/src/mesh/CoupledMFEMMesh.C b/src/mesh/CoupledMFEMMesh.C new file mode 100644 index 00000000..da3920ab --- /dev/null +++ b/src/mesh/CoupledMFEMMesh.C @@ -0,0 +1,566 @@ +//* This file is part of the MOOSE framework +//* https://www.mooseframework.org +//* +//* All rights reserved, see COPYRIGHT for full restrictions +//* https://github.com/idaholab/moose/blob/master/COPYRIGHT +//* +//* Licensed under LGPL 2.1, please see LICENSE for details +//* https://www.gnu.org/licenses/lgpl-2.1.html + +#include "CoupledMFEMMesh.h" + +registerMooseObject("PlatypusApp", CoupledMFEMMesh); + +InputParameters +CoupledMFEMMesh::validParams() +{ + InputParameters params = ExclusiveMFEMMesh::validParams(); + return params; +} + +CoupledMFEMMesh::CoupledMFEMMesh(const InputParameters & parameters) + : ExclusiveMFEMMesh(parameters), _block_info(_dim) +{ +} + +CoupledMFEMMesh::~CoupledMFEMMesh() {} + +void +CoupledMFEMMesh::buildMesh() +{ + // Use method from file mesh to build MOOSE mesh from Exodus file. + FileMesh::buildMesh(); +} + +std::unique_ptr +CoupledMFEMMesh::safeClone() const +{ + return std::make_unique(*this); +} + +void +CoupledMFEMMesh::buildBoundaryInfo(std::map> & element_ids_for_boundary_id, + std::map> & side_ids_for_boundary_id) +{ + buildBndElemList(); + + struct BoundaryElementAndSideIDs + { + std::vector element_ids; // Element ids for a boundary id. + std::vector side_ids; // Side ids for a boundary id. + + BoundaryElementAndSideIDs() : element_ids{}, side_ids{} {} + }; + + std::vector unique_boundary_ids; + std::map boundary_ids_map; + + // Iterate over elements on the boundary to build the map that allows us to go + // from a boundary id to a vector of element id/side ids. + for (auto boundary_element : _bnd_elems) + { + auto boundary_id = boundary_element->_bnd_id; + + bool is_new_boundary_id = (boundary_ids_map.count(boundary_id) == 0); + + if (is_new_boundary_id) // Initialize new struct. + { + boundary_ids_map[boundary_id] = BoundaryElementAndSideIDs(); + unique_boundary_ids.push_back(boundary_id); + } + + auto element_id = boundary_element->_elem->id(); // ID of element on boundary. + auto side_id = boundary_element->_side; // ID of side that element is on. + + boundary_ids_map[boundary_id].element_ids.push_back(element_id); + boundary_ids_map[boundary_id].side_ids.push_back(side_id); + } + + // Sort. + std::sort(unique_boundary_ids.begin(), unique_boundary_ids.end()); + + // Run through the (key, value) pairs in the boundary_ids_map map. + for (const auto & key_value_pair : boundary_ids_map) + { + auto boundary_id = key_value_pair.first; + + auto element_ids = key_value_pair.second.element_ids; + auto side_ids = key_value_pair.second.side_ids; + + element_ids_for_boundary_id[boundary_id] = std::move(element_ids); + side_ids_for_boundary_id[boundary_id] = std::move(side_ids); + } +} + +std::vector +CoupledMFEMMesh::getSideBoundaryIDs() const +{ + const libMesh::BoundaryInfo & boundary_info = getMesh().get_boundary_info(); + const std::set & side_boundary_ids_set = boundary_info.get_side_boundary_ids(); + + std::vector side_boundary_ids(side_boundary_ids_set.size()); + + int counter = 0; + for (auto side_boundary_id : side_boundary_ids_set) + { + side_boundary_ids[counter++] = side_boundary_id; + } + + std::sort(side_boundary_ids.begin(), side_boundary_ids.end()); + + return side_boundary_ids; +} + +bool +CoupledMFEMMesh::isDistributedMesh() const +{ + return (!getMesh().is_replicated() && n_processors() > 1); +} + +void +CoupledMFEMMesh::buildCubitBlockInfo(const std::vector & unique_block_ids) +{ + /** + * Iterate over the block_ids. Note that we only need to extract the first element from + * each block since only a single element type can be specified per block. + */ + for (int block_id : unique_block_ids) + { + auto element_range = getMesh().active_subdomain_elements_ptr_range(block_id); + if (element_range.begin() == element_range.end()) + { + mooseError("Block '", block_id, "' contains no elements."); + } + + auto first_element_ptr = *element_range.begin(); + + blockInfo().addBlockElement(block_id, first_element_ptr->n_nodes()); + } +} + +std::vector +CoupledMFEMMesh::getLibmeshBlockIDs() const +{ + auto & libmesh = getMesh(); + + // Identify all subdomains (blocks) in the entire mesh (global == true). + std::set block_ids_set; + libmesh.subdomain_ids(block_ids_set, true); + + std::vector unique_block_ids(block_ids_set.size()); + + int counter = 0; + for (auto block_id : block_ids_set) + { + unique_block_ids[counter++] = block_id; + } + + return unique_block_ids; +} + +void +CoupledMFEMMesh::buildElementAndNodeIDs(const std::vector & unique_block_ids, + std::map> & element_ids_for_block_id, + std::map> & node_ids_for_element_id) +{ + for (int block_id : unique_block_ids) + { + auto & element_info = blockElement(block_id); + + std::vector elements_in_block; + + auto active_block_elements_begin = getMesh().active_subdomain_elements_begin(block_id); + auto active_block_elements_end = getMesh().active_subdomain_elements_end(block_id); + + for (auto element_iterator = active_block_elements_begin; + element_iterator != active_block_elements_end; + element_iterator++) + { + auto element_ptr = *element_iterator; + + const int element_id = element_ptr->id(); + + std::vector element_node_ids(element_info.numNodes()); + + elements_in_block.push_back(element_id); + + for (int node_counter = 0; node_counter < element_info.numNodes(); node_counter++) + { + element_node_ids[node_counter] = element_ptr->node_id(node_counter); + } + + node_ids_for_element_id[element_id] = std::move(element_node_ids); + } + + elements_in_block.shrink_to_fit(); + + // Add to map. + element_ids_for_block_id[block_id] = std::move(elements_in_block); + } +} + +void +CoupledMFEMMesh::buildUniqueCornerNodeIDs( + std::vector & unique_corner_node_ids, + const std::vector & unique_block_ids, + const std::map> & element_ids_for_block_id, + const std::map> & node_ids_for_element_id) +{ + // Iterate through all nodes (on edge of each element) and add their global IDs + // to the unique_corner_node_ids vector. + for (int block_id : unique_block_ids) + { + auto & block_element = blockElement(block_id); + + auto & element_ids = element_ids_for_block_id.at(block_id); + + for (int element_id : element_ids) + { + auto & node_ids = node_ids_for_element_id.at(element_id); + + // Only use the nodes on the edge of the element! + for (int knode = 0; knode < block_element.numCornerNodes(); knode++) + { + unique_corner_node_ids.push_back(node_ids[knode]); + } + } + } + + // Sort unique_vertex_ids in ascending order and remove duplicate node IDs. + std::sort(unique_corner_node_ids.begin(), unique_corner_node_ids.end()); + + auto new_end = std::unique(unique_corner_node_ids.begin(), unique_corner_node_ids.end()); + + unique_corner_node_ids.resize(std::distance(unique_corner_node_ids.begin(), new_end)); +} + +void +CoupledMFEMMesh::buildMFEMMesh() +{ + // 1. If the mesh is distributed and split between more than one processor, + // we need to call allgather on each processor. This will gather the nodes + // and elements onto each processor. + if (isDistributedMesh()) + { + getMesh().allgather(); + } + + // 2. Get the unique libmesh IDs of each block in the mesh. + std::vector unique_block_ids = getLibmeshBlockIDs(); + + // 3. Retrieve information about the elements used within the mesh. + buildCubitBlockInfo(unique_block_ids); + + // 4. Build maps: + // Map from block ID --> vector of element IDs. + // Map from element ID --> vector of global node IDs. + std::map> element_ids_for_block_id; + std::map> node_ids_for_element_id; + + buildElementAndNodeIDs(unique_block_ids, element_ids_for_block_id, node_ids_for_element_id); + + // 5. Create vector containing the IDs of all nodes that are on the corners of + // elements. MFEM only requires the corner nodes. + std::vector unique_corner_node_ids; + + buildUniqueCornerNodeIDs( + unique_corner_node_ids, unique_block_ids, element_ids_for_block_id, node_ids_for_element_id); + + // 6. Create a map to hold the x, y, z coordinates for each unique node. + std::map> coordinates_for_node_id; + + for (auto node_ptr : getMesh().node_ptr_range()) + { + auto & node = *node_ptr; + + std::array coordinates = {node(0), node(1), node(2)}; + + coordinates_for_node_id[node.id()] = std::move(coordinates); + } + + // 7. + // element_ids_for_boundary_id stores the ids of each element on each boundary. + // side_ids_for_boundary_id stores the sides of those elements that are on each boundary. + std::map> element_ids_for_boundary_id; + std::map> side_ids_for_boundary_id; + + buildBoundaryInfo(element_ids_for_boundary_id, side_ids_for_boundary_id); + + // 8. Get a vector containing all boundary IDs on sides of semi-local elements. + std::vector unique_side_boundary_ids = getSideBoundaryIDs(); + + // 9. + // node_ids_for_boundary_id maps from the boundary ID to a vector of vectors containing + // the nodes of each element on the boundary that correspond to the face of the boundary. + std::map>> node_ids_for_boundary_id; + + buildBoundaryNodeIDs(unique_side_boundary_ids, + element_ids_for_boundary_id, + side_ids_for_boundary_id, + node_ids_for_boundary_id); + + // 10. Create mapping from the boundary ID to a vector containing the block IDs of all elements + // that lie on the boundary. This is required for in MFEM mesh for multiple-element types. + auto block_ids_for_boundary_id = + getBlockIDsForBoundaryID(element_ids_for_block_id, element_ids_for_boundary_id); + + // 11. + // Call the correct initializer. + switch (blockInfo().order()) + { + case 1: + { + _mfem_mesh = std::make_shared(nElem(), + blockInfo(), + unique_block_ids, + unique_side_boundary_ids, + unique_corner_node_ids, + element_ids_for_block_id, + node_ids_for_element_id, + node_ids_for_boundary_id, + side_ids_for_boundary_id, + block_ids_for_boundary_id, + coordinates_for_node_id); + break; + } + case 2: + { + _mfem_mesh = std::make_shared(nElem(), + blockInfo(), + unique_block_ids, + unique_side_boundary_ids, + unique_corner_node_ids, + element_ids_for_block_id, + node_ids_for_element_id, + node_ids_for_boundary_id, + side_ids_for_boundary_id, + block_ids_for_boundary_id, + coordinates_for_node_id, + _libmesh_global_node_id_for_mfem_local_node_id, + _mfem_local_node_id_for_libmesh_global_node_id); + break; + } + default: + { + mooseError("Unsupported element type of order ", blockInfo().order(), "."); + break; + } + } +} + +std::map +CoupledMFEMMesh::getBlockIDForElementID( + const std::map> & element_ids_for_block_id) const +{ + std::map block_id_for_element_id; + + for (const auto & key_value : element_ids_for_block_id) + { + auto block_id = key_value.first; + auto & element_ids = key_value.second; + + for (const auto & element_id : element_ids) + { + block_id_for_element_id[element_id] = block_id; + } + } + + return block_id_for_element_id; +} + +std::map> +CoupledMFEMMesh::getBlockIDsForBoundaryID( + const std::map> & element_ids_for_block_id, + const std::map> & element_ids_for_boundary_id) const +{ + auto block_id_for_element_id = getBlockIDForElementID(element_ids_for_block_id); + + std::map> block_ids_for_boundary_id; + + for (const auto & key_value : element_ids_for_boundary_id) + { + auto boundary_id = key_value.first; + auto & element_ids = key_value.second; + + std::vector block_ids(element_ids.size()); + + int ielement = 0; + for (const auto & element_id : element_ids) + { + block_ids[ielement++] = block_id_for_element_id.at(element_id); + } + + block_ids_for_boundary_id[boundary_id] = std::move(block_ids); + } + + return block_ids_for_boundary_id; +} + +std::unique_ptr +CoupledMFEMMesh::getMeshPartitioning() +{ + // Call allgather because we need all element information on each processor. + getMesh().allgather(); + + const MeshBase & lib_mesh = getMesh(); + + const int num_elements = lib_mesh.n_elem(); + if (num_elements < 1) + { + return nullptr; + } + + int * mesh_partitioning = new int[num_elements]; + + for (auto element : lib_mesh.element_ptr_range()) + { + int element_id = element->id(); + + mesh_partitioning[element_id] = element->processor_id(); + } + + // Wrap-up in a unique pointer. + return std::unique_ptr(mesh_partitioning); +} + +void +CoupledMFEMMesh::buildMFEMParMesh() +{ + auto partitioning = getMeshPartitioning(); + + int * partitioning_raw_ptr = partitioning ? partitioning.get() : nullptr; + + _mfem_par_mesh = + std::make_shared(MPI_COMM_WORLD, getMFEMMesh(), partitioning_raw_ptr); + + // If we have a higher-order mesh then we need to figure-out the mapping from the libMesh node ID + // to the MFEM node ID since this will have changed. + convertSerialDofMappingsToParallel(*_mfem_mesh.get(), *_mfem_par_mesh.get()); + + _mfem_mesh.reset(); // Lower reference count of serial mesh since no longer needed. +} + +void +CoupledMFEMMesh::convertSerialDofMappingsToParallel(const MFEMMesh & serial_mesh, + const MFEMParMesh & parallel_mesh) +{ + // No need to change dof mappings if running on a single processor or if a first order element. + if (n_processors() < 2 || blockInfo().order() == 1) + { + return; + } + + // Get the FE spaces. + const auto * serial_fespace = serial_mesh.GetNodalFESpace(); + const auto * parallel_fespace = parallel_mesh.GetNodalFESpace(); + + mooseAssert(serial_fespace != nullptr && parallel_fespace != nullptr, "Nodal FESpace is NULL!"); + + // Important notes: + // 1. LibMesh: node id is unique even across multiple processors. + // 2. MFEM: "local dof": belongs to the processor. + // 3. MFEM: "local true dof": unique nodes on a processor. i.e. if local nodes 1, 2 both + // correspond to the same coordinates on a processor they will map to a single true dof. + std::map libmesh_global_node_id_for_mfem_local_node_id; + std::map mfem_local_node_id_for_libmesh_global_node_id; + + // Match-up the libMesh elements on the processor with the MFEM elements on the ParMesh. + int counter = 0; + for (auto element_ptr : getMesh().local_element_ptr_range()) + { + const auto global_element_id = element_ptr->id(); + const auto local_element_id = counter++; + + // Get the LOCAL dofs of the element for both the serial and ParMesh for this element. + mfem::Array serial_local_dofs; + serial_fespace->GetElementDofs(global_element_id, serial_local_dofs); + + mfem::Array parallel_local_dofs; + parallel_fespace->GetElementDofs(local_element_id, parallel_local_dofs); + + // Verify that the number of LOCAL dofs match. + mooseAssert(serial_local_dofs.Size() == parallel_local_dofs.Size(), + "Serial and parallel dofs sizes do not match for element."); + + const auto num_local_dofs = serial_local_dofs.Size(); + + std::map serial_dof_for_parallel_dof; + std::map parallel_dof_for_serial_dof; + + for (int i = 0; i < num_local_dofs; i++) + { + auto parallel_dof = parallel_local_dofs[i]; + auto serial_dof = serial_local_dofs[i]; + + serial_dof_for_parallel_dof[parallel_dof] = serial_dof; + parallel_dof_for_serial_dof[serial_dof] = parallel_dof; + } + + // Iterate over serial local dofs and update mappings. + for (auto dof : serial_local_dofs) + { + const auto parallel_local_dof = parallel_dof_for_serial_dof[dof]; + + // Pair the libmesh node formerly associated with the serial node with this node. + auto libmesh_node_id = getLibmeshGlobalNodeId(dof); + + // Update two-way mappings. + libmesh_global_node_id_for_mfem_local_node_id[parallel_local_dof] = libmesh_node_id; + mfem_local_node_id_for_libmesh_global_node_id[libmesh_node_id] = parallel_local_dof; + } + } + + // Set two-way mappings. + _libmesh_global_node_id_for_mfem_local_node_id = libmesh_global_node_id_for_mfem_local_node_id; + _mfem_local_node_id_for_libmesh_global_node_id = mfem_local_node_id_for_libmesh_global_node_id; +} + +void +CoupledMFEMMesh::buildBoundaryNodeIDs( + const std::vector & unique_side_boundary_ids, + const std::map> & element_ids_for_boundary_id, + const std::map> & side_ids_for_boundary_id, + std::map>> & node_ids_for_boundary_id) +{ + node_ids_for_boundary_id.clear(); + + // Iterate over all boundary IDs. + for (int boundary_id : unique_side_boundary_ids) + { + // Get element IDs of element on boundary (and their sides that are on boundary). + auto & boundary_element_ids = element_ids_for_boundary_id.at(boundary_id); + auto & boundary_element_sides = side_ids_for_boundary_id.at(boundary_id); + + // Create vector to store the node ids of all boundary nodes. + std::vector> boundary_node_ids(boundary_element_ids.size()); + + // Iterate over elements on boundary. + for (int jelement = 0; jelement < (int)boundary_element_ids.size(); jelement++) + { + // Get element ID and the boundary side. + const int boundary_element_global_id = boundary_element_ids[jelement]; + const int boundary_element_side = boundary_element_sides[jelement]; + + Elem * element_ptr = elemPtr(boundary_element_global_id); + + // Get vector of local node IDs on boundary side of element. + auto nodes_of_element_on_side = element_ptr->nodes_on_side(boundary_element_side); + + // Replace local IDs with global IDs. + for (int knode = 0; knode < (int)nodes_of_element_on_side.size(); knode++) + { + // Get the global node ID of each node. + const int local_node_id = nodes_of_element_on_side[knode]; + const int global_node_id = element_ptr->node_id(local_node_id); + + nodes_of_element_on_side[knode] = global_node_id; + } + + // Add to vector. + boundary_node_ids[jelement] = std::move(nodes_of_element_on_side); + } + + // Add to the map. + node_ids_for_boundary_id[boundary_id] = std::move(boundary_node_ids); + } +} diff --git a/src/mesh/CubitElementInfo.C b/src/mesh/CubitElementInfo.C new file mode 100644 index 00000000..63839f10 --- /dev/null +++ b/src/mesh/CubitElementInfo.C @@ -0,0 +1,419 @@ +#include "CubitElementInfo.h" + +/** + * CubitFaceInfo + */ +CubitFaceInfo::CubitFaceInfo(CubitFaceType face_type) : _face_type(face_type) +{ + buildCubitFaceInfo(); +} + +void +CubitFaceInfo::buildCubitFaceInfo() +{ + switch (_face_type) + { + /** + * 2D + */ + case (FACE_EDGE2): + { + _num_face_nodes = 2; + _num_face_corner_nodes = 2; + break; + } + case (FACE_EDGE3): + { + _num_face_nodes = 3; + _num_face_corner_nodes = 2; + break; + } + /** + * 3D + */ + case (FACE_TRI3): + { + _num_face_nodes = 3; + _num_face_corner_nodes = 3; + break; + } + case (FACE_TRI6): + { + _num_face_nodes = 6; + _num_face_corner_nodes = 3; + break; + } + case (FACE_QUAD4): + { + _num_face_nodes = 4; + _num_face_corner_nodes = 4; + break; + } + case (FACE_QUAD8): + { + _num_face_nodes = 8; + _num_face_corner_nodes = 4; + break; + } + case (FACE_QUAD9): + { + _num_face_nodes = 9; // Includes center node. + _num_face_corner_nodes = 4; + break; + } + default: + { + mooseError("Unsupported face type '", _face_type, "'."); + break; + } + } +} + +/** + * CubitElementInfo + */ +CubitElementInfo::CubitElementInfo(int num_nodes_per_element, int dimension) +{ + switch (dimension) + { + case 2: + { + buildCubit2DElementInfo(num_nodes_per_element); + break; + } + case 3: + { + buildCubit3DElementInfo(num_nodes_per_element); + break; + } + default: + { + mooseError("Unsupported element dimension ", dimension, "."); + break; + } + } +} + +void +CubitElementInfo::buildCubit2DElementInfo(int num_nodes_per_element) +{ + _dimension = 2; + _num_nodes = num_nodes_per_element; + + switch (num_nodes_per_element) + { + case 3: + { + _element_type = ELEMENT_TRI3; + _order = 1; + _num_corner_nodes = 3; + _num_faces = 3; + _face_info = {CubitFaceInfo(CubitFaceInfo::FACE_EDGE2)}; + break; + } + case 6: + { + _element_type = ELEMENT_TRI6; + _order = 2; + _num_corner_nodes = 3; + _num_faces = 3; + _face_info = {CubitFaceInfo(CubitFaceInfo::FACE_EDGE3)}; + break; + } + case 4: + { + _element_type = ELEMENT_QUAD4; + _order = 1; + _num_corner_nodes = 4; + _num_faces = 4; + _face_info = {CubitFaceInfo(CubitFaceInfo::FACE_EDGE2)}; + break; + } + case 9: + { + _element_type = ELEMENT_QUAD9; + _order = 2; + _num_corner_nodes = 4; + _num_faces = 4; + _face_info = {CubitFaceInfo(CubitFaceInfo::FACE_EDGE3)}; + break; + } + default: + { + mooseError("Unsupported 2D element with ", num_nodes_per_element, " nodes per element."); + break; + } + } +} + +void +CubitElementInfo::buildCubit3DElementInfo(int num_nodes_per_element) +{ + _dimension = 3; + _num_nodes = num_nodes_per_element; + + switch (num_nodes_per_element) + { + case 4: + { + _element_type = ELEMENT_TET4; + _order = 1; + _num_corner_nodes = 4; + _num_faces = 4; + _face_info = {CubitFaceInfo(CubitFaceInfo::FACE_TRI3)}; + break; + } + case 10: + { + _element_type = ELEMENT_TET10; + _order = 2; + _num_corner_nodes = 4; + _num_faces = 4; + _face_info = {CubitFaceInfo(CubitFaceInfo::FACE_TRI6)}; + break; + } + case 8: + { + _element_type = ELEMENT_HEX8; + _order = 1; + _num_corner_nodes = 8; + _num_faces = 6; + _face_info = {CubitFaceInfo(CubitFaceInfo::FACE_QUAD4)}; + break; + } + case 27: + { + _element_type = ELEMENT_HEX27; + _order = 2; + _num_corner_nodes = 8; + _num_faces = 6; + _face_info = {CubitFaceInfo(CubitFaceInfo::FACE_QUAD9)}; + break; + } + case 6: + { + _element_type = ELEMENT_WEDGE6; + _order = 1; + _num_corner_nodes = 6; + _num_faces = 5; + _face_info = getWedge6FaceInfo(); + break; + } + case 18: + { + _element_type = ELEMENT_WEDGE18; + _order = 2; + _num_corner_nodes = 6; + _num_faces = 5; + _face_info = getWedge18FaceInfo(); + break; + } + case 5: + { + _element_type = ELEMENT_PYRAMID5; + _order = 1; + _num_corner_nodes = 5; + _num_faces = 5; + _face_info = getPyramid5FaceInfo(); + break; + } + case 14: + { + _element_type = ELEMENT_PYRAMID14; + _order = 2; + _num_corner_nodes = 5; + _num_faces = 5; + _face_info = getPyramid14FaceInfo(); + _num_corner_nodes = 5; + break; + } + default: + { + mooseError("Unsupported 3D element with ", num_nodes_per_element, " nodes per element."); + break; + } + } +} + +std::vector +CubitElementInfo::getWedge6FaceInfo() const +{ + // Refer to "cell_prism.C" line 127. + // We are using the same side ordering as used in LibMesh. + CubitFaceInfo tri3 = CubitFaceInfo(CubitFaceInfo::FACE_TRI3); // Faces 0, 4 (LibMesh) + CubitFaceInfo quad4 = CubitFaceInfo(CubitFaceInfo::FACE_QUAD4); // Faces 1, 2, 3 (LibMesh) + + return {tri3, quad4, quad4, quad4, tri3}; +} + +std::vector +CubitElementInfo::getWedge18FaceInfo() const +{ + CubitFaceInfo tri6 = CubitFaceInfo(CubitFaceInfo::FACE_TRI6); + CubitFaceInfo quad9 = CubitFaceInfo(CubitFaceInfo::FACE_QUAD9); + + return {tri6, quad9, quad9, quad9, tri6}; +} + +std::vector +CubitElementInfo::getPyramid5FaceInfo() const +{ + // Refer to "cell_pyramid5.C" line 134. + // We are using the same side ordering as used in LibMesh. + CubitFaceInfo tri3 = CubitFaceInfo(CubitFaceInfo::FACE_TRI3); + CubitFaceInfo quad4 = CubitFaceInfo(CubitFaceInfo::FACE_QUAD4); + + return {tri3, tri3, tri3, tri3, quad4}; +} + +std::vector +CubitElementInfo::getPyramid14FaceInfo() const +{ + // Refer to "cell_pyramid14.h" + // Define Pyramid14: Quad9 base and 4 x Tri6. + CubitFaceInfo tri6 = CubitFaceInfo(CubitFaceInfo::FACE_TRI6); + CubitFaceInfo quad9 = CubitFaceInfo(CubitFaceInfo::FACE_QUAD9); + + // Use same ordering as LibMesh ("cell_pyramid14.c"; line 44) + // front, right, back, left, base (different in MFEM!). + return {tri6, tri6, tri6, tri6, quad9}; +} + +const CubitFaceInfo & +CubitElementInfo::face(int iface) const +{ + /** + * Check _face_info initialized. + */ + if (_face_info.empty()) + { + mooseError("_face_info is empty."); + } + + /** + * Check valid face index. + */ + bool is_valid_face_index = (iface >= 0 && iface < _num_faces); + if (!is_valid_face_index) + { + mooseError("Face index '", iface, "' is invalid."); + } + + /** + * Case 1: single face type --> only store a single face. + * Case 2: multiple face types --> store each face. Return face at index. + */ + bool is_single_face_type = (_face_info.size() == 1); + + /** + * Check vector size matches _num_Faces for multiple face types. + */ + if (!is_single_face_type && _face_info.size() != _num_faces) + { + mooseError("_face_info.size() != _num_faces."); + } + + return is_single_face_type ? _face_info.front() : _face_info[iface]; +}; + +/** + * CubitBlockInfo + */ +CubitBlockInfo::CubitBlockInfo(int dimension) +{ + if (!validDimension(dimension)) + { + mooseError("Invalid dimension '", dimension, "' specified."); + } + + _dimension = dimension; + + clearBlockElements(); +} + +void +CubitBlockInfo::addBlockElement(int block_id, int num_nodes_per_element) +{ + if (hasBlockID(block_id)) + mooseError("Block with ID '", block_id, "' has already been added."); + else if (!validBlockID(block_id)) + mooseError("Illegal block ID '", block_id, "'."); + + auto block_element = CubitElementInfo(num_nodes_per_element, _dimension); + + /** + * Check element is compatible with existing element blocks. + */ + checkElementBlockIsCompatible(block_element); + + if (!hasBlocks()) // Set order of elements. + { + _order = block_element.order(); + } + + _block_ids.insert(block_id); + _block_element_for_block_id[block_id] = block_element; +} + +uint8_t +CubitBlockInfo::order() const +{ + if (!hasBlocks()) + { + mooseError("No elements have been added."); + } + + return _order; +} + +void +CubitBlockInfo::clearBlockElements() +{ + _order = 0; + _block_ids.clear(); + _block_element_for_block_id.clear(); +} + +bool +CubitBlockInfo::hasBlockID(int block_id) const +{ + return (_block_ids.count(block_id) > 0); +} + +bool +CubitBlockInfo::validBlockID(int block_id) const +{ + return (block_id > 0); // 1-based indexing. +} + +bool +CubitBlockInfo::validDimension(int dimension) const +{ + return (dimension == 2 || dimension == 3); +} + +const CubitElementInfo & +CubitBlockInfo::blockElement(int block_id) const +{ + if (!hasBlockID(block_id)) + { + mooseError("No element info for block ID '", block_id, "'."); + } + + return _block_element_for_block_id.at(block_id); +} + +void +CubitBlockInfo::checkElementBlockIsCompatible(const CubitElementInfo & new_block_element) const +{ + if (!hasBlocks()) + { + return; + } + + // Enforce block orders to be the same for now. + if (order() != new_block_element.order()) + { + mooseError("All block elements must be of the same order."); + } +} diff --git a/src/mesh/ExclusiveMFEMMesh.C b/src/mesh/ExclusiveMFEMMesh.C new file mode 100644 index 00000000..95f6e4b6 --- /dev/null +++ b/src/mesh/ExclusiveMFEMMesh.C @@ -0,0 +1,93 @@ +//* This file is part of the MOOSE framework +//* https://www.mooseframework.org +//* +//* All rights reserved, see COPYRIGHT for full restrictions +//* https://github.com/idaholab/moose/blob/master/COPYRIGHT +//* +//* Licensed under LGPL 2.1, please see LICENSE for details +//* https://www.gnu.org/licenses/lgpl-2.1.html + +#include "ExclusiveMFEMMesh.h" + +registerMooseObject("MooseApp", ExclusiveMFEMMesh); + +InputParameters +ExclusiveMFEMMesh::validParams() +{ + InputParameters params = FileMesh::validParams(); + return params; +} + +ExclusiveMFEMMesh::ExclusiveMFEMMesh(const InputParameters & parameters) : FileMesh(parameters) {} + +ExclusiveMFEMMesh::~ExclusiveMFEMMesh() {} + +void +ExclusiveMFEMMesh::buildMesh() +{ + // Build a dummy MOOSE mesh to enable this class to work with other MOOSE classes. + buildDummyMesh(); +} + +void +ExclusiveMFEMMesh::buildDummyMesh() +{ + auto element = new Quad4; + element->set_id() = 1; + element->processor_id() = 0; + + _mesh->add_elem(element); + + Point pt1(0.0, 0.0, 0.0); + Point pt2(1.0, 0.0, 0.0); + Point pt3(1.0, 1.0, 0.0); + Point pt4(0.0, 1.0, 0.0); + + element->set_node(0) = _mesh->add_point(pt1); + element->set_node(1) = _mesh->add_point(pt2); + element->set_node(2) = _mesh->add_point(pt3); + element->set_node(3) = _mesh->add_point(pt4); + + _mesh->prepare_for_use(); +} + +void +ExclusiveMFEMMesh::buildMFEMMesh() +{ + _mfem_mesh = std::make_shared(getFileName()); +} + +void +ExclusiveMFEMMesh::buildMFEMParMesh() +{ + _mfem_par_mesh = std::make_shared(MPI_COMM_WORLD, getMFEMMesh()); + _mfem_mesh.reset(); // Lower reference count of serial mesh since no longer needed. +} + +MFEMMesh & +ExclusiveMFEMMesh::getMFEMMesh() +{ + if (!_mfem_mesh) + { + buildMFEMMesh(); + } + + return *_mfem_mesh; +} + +MFEMParMesh & +ExclusiveMFEMMesh::getMFEMParMesh() +{ + if (!_mfem_par_mesh) + { + buildMFEMParMesh(); + } + + return *_mfem_par_mesh; +} + +std::unique_ptr +ExclusiveMFEMMesh::safeClone() const +{ + return std::make_unique(*this); +} diff --git a/src/mesh/MFEMMesh.C b/src/mesh/MFEMMesh.C new file mode 100644 index 00000000..114f14db --- /dev/null +++ b/src/mesh/MFEMMesh.C @@ -0,0 +1,624 @@ +#pragma once +#include "MFEMMesh.h" + +// Function prototypes: +static bool +coordinatesMatch(const double * primary, const double * secondary, const double tolerance = 0.01); + +/** + * Initializer for 1st order elements. + */ +MFEMMesh::MFEMMesh( + const int num_elements_in_mesh, + const CubitBlockInfo & block_info, + const std::vector & unique_block_ids, + const std::vector & unique_side_boundary_ids, + const std::vector & unique_libmesh_corner_node_ids, + const std::map> & libmesh_element_ids_for_block_id, + const std::map> & libmesh_node_ids_for_element_id, + const std::map>> & libmesh_node_ids_for_boundary_id, + const std::map> & libmesh_side_ids_for_boundary_id, + const std::map> & libmesh_block_ids_for_boundary_id, + const std::map> & coordinates_for_libmesh_node_id) +{ + if (block_info.order() != 1) + { + mooseError("1st order initializer called for order ", block_info.order(), "."); + } + + buildMFEMVerticesAndElements(num_elements_in_mesh, + block_info, + unique_block_ids, + unique_side_boundary_ids, + unique_libmesh_corner_node_ids, + libmesh_element_ids_for_block_id, + libmesh_node_ids_for_element_id, + libmesh_node_ids_for_boundary_id, + libmesh_side_ids_for_boundary_id, + libmesh_block_ids_for_boundary_id, + coordinates_for_libmesh_node_id); + + // Finalize mesh method is needed to fully finish constructing the mesh. + FinalizeMesh(); +} + +/** + * Initializer for 2nd order elements. + */ +MFEMMesh::MFEMMesh( + const int num_elements_in_mesh, + const CubitBlockInfo & block_info, + const std::vector & unique_block_ids, + const std::vector & unique_side_boundary_ids, + const std::vector & unique_libmesh_corner_node_ids, + const std::map> & libmesh_element_ids_for_block_id, + const std::map> & libmesh_node_ids_for_element_id, + const std::map>> & libmesh_node_ids_for_boundary_id, + const std::map> & libmesh_side_ids_for_boundary_id, + const std::map> & libmesh_block_ids_for_boundary_id, + const std::map> & coordinates_for_libmesh_node_id, + std::map & libmesh_node_id_for_mfem_node_id, + std::map & mfem_node_id_for_libmesh_node_id) +{ + if (block_info.order() != 2) + { + mooseError("2nd order initializer called for order ", block_info.order(), "."); + } + + buildMFEMVerticesAndElements(num_elements_in_mesh, + block_info, + unique_block_ids, + unique_side_boundary_ids, + unique_libmesh_corner_node_ids, + libmesh_element_ids_for_block_id, + libmesh_node_ids_for_element_id, + libmesh_node_ids_for_boundary_id, + libmesh_side_ids_for_boundary_id, + libmesh_block_ids_for_boundary_id, + coordinates_for_libmesh_node_id); + + handleQuadraticFESpace(block_info, + unique_block_ids, + libmesh_element_ids_for_block_id, + libmesh_node_ids_for_element_id, + coordinates_for_libmesh_node_id, + libmesh_node_id_for_mfem_node_id, + mfem_node_id_for_libmesh_node_id); + + FinalizeMesh(); +} + +MFEMMesh::MFEMMesh(std::string mesh_fname, int generate_edges, int refine, bool fix_orientation) + : _mfem_element_id_for_libmesh_element_id{}, _mfem_vertex_index_for_libmesh_corner_node_id{} +{ + SetEmpty(); + + mfem::named_ifgzstream mesh_fstream(mesh_fname); + if (!mesh_fstream) // TODO: - can this be nullptr? + { + mooseError("Failed to read '" + mesh_fname + "'\n"); + } + else + { + Load(mesh_fstream, generate_edges, refine, fix_orientation); + } +} + +void +MFEMMesh::buildMFEMVerticesAndElements( + const int num_elements_in_mesh, + const CubitBlockInfo & block_info, + const std::vector & unique_block_ids, + const std::vector & unique_side_boundary_ids, + const std::vector & unique_libmesh_corner_node_ids, + const std::map> & libmesh_element_ids_for_block_id, + const std::map> & libmesh_node_ids_for_element_id, + const std::map>> & libmesh_node_ids_for_boundary_id, + const std::map> & libmesh_side_ids_for_boundary_id, + const std::map> & libmesh_block_ids_for_boundary_id, + const std::map> & coordinates_for_libmesh_node_id) +{ + // Set dimensions. + Dim = spaceDim = block_info.dimension(); + + // Create the vertices. + buildMFEMVertices(unique_libmesh_corner_node_ids, coordinates_for_libmesh_node_id); + + // Create the mesh elements. + buildMFEMElements(num_elements_in_mesh, + block_info, + unique_block_ids, + libmesh_element_ids_for_block_id, + libmesh_node_ids_for_element_id); + + // Create the boundary elements. + buildMFEMBoundaryElements(block_info, + unique_side_boundary_ids, + libmesh_node_ids_for_boundary_id, + libmesh_side_ids_for_boundary_id, + libmesh_block_ids_for_boundary_id); +} + +void +MFEMMesh::buildMFEMVertices( + const std::vector & unique_libmesh_corner_node_ids, + const std::map> & coordinates_for_libmesh_node_id) +{ + _mfem_vertex_index_for_libmesh_corner_node_id.clear(); + + NumOfVertices = unique_libmesh_corner_node_ids.size(); + vertices.SetSize(NumOfVertices); + + // Iterate over the global IDs of each unqiue corner node from the MOOSE mesh. + const bool use_z_component = (Dim == 3); + + int ivertex = 0; + for (int libmesh_node_id : unique_libmesh_corner_node_ids) + { + // Get the xyz coordinates associated with the libmesh corner node. + auto & coordinates = coordinates_for_libmesh_node_id.at(libmesh_node_id); + + // Set xyz components. + vertices[ivertex](0) = coordinates[0]; + vertices[ivertex](1) = coordinates[1]; + + if (use_z_component) + { + vertices[ivertex](2) = coordinates[2]; + } + + _mfem_vertex_index_for_libmesh_corner_node_id[libmesh_node_id] = ivertex; + + ivertex++; + } +} + +void +MFEMMesh::buildMFEMElements(const int num_elements_in_mesh, + const CubitBlockInfo & block_info, + const std::vector & unique_block_ids, + const std::map> & element_ids_for_block_id, + const std::map> & node_ids_for_element_id) +{ + _mfem_element_id_for_libmesh_element_id.clear(); + + // Set mesh elements. + NumOfElements = num_elements_in_mesh; + elements.SetSize(num_elements_in_mesh); + + int ielement = 0; + for (int block_id : unique_block_ids) + { + // Get the element type associated with the block. + auto & block_element = block_info.blockElement(block_id); + + std::vector renumbered_vertex_ids(block_element.numCornerNodes()); + + auto & element_ids = element_ids_for_block_id.at(block_id); + + for (int element_id : element_ids) // Iterate over elements in block. + { + auto & libmesh_node_ids = node_ids_for_element_id.at(element_id); + + // Iterate over ONLY the corner nodes in the element. + for (int ivertex = 0; ivertex < block_element.numCornerNodes(); ivertex++) + { + const int libmesh_node_id = libmesh_node_ids[ivertex]; + + // Map from the corner libmesh node --> corresponding mfem vertex. + renumbered_vertex_ids[ivertex] = getMFEMVertexIndex(libmesh_node_id); + } + + // Map from mfem element id to libmesh element id. + _mfem_element_id_for_libmesh_element_id[element_id] = ielement; + + elements[ielement++] = + buildMFEMElement(block_element.elementType(), renumbered_vertex_ids.data(), block_id); + } + } +} + +void +MFEMMesh::buildMFEMBoundaryElements( + const CubitBlockInfo & block_info, + const std::vector & unique_side_boundary_ids, + const std::map>> & libmesh_node_ids_for_boundary_id, + const std::map> & libmesh_side_ids_for_boundary_id, + const std::map> & libmesh_block_ids_for_boundary_id) +{ + // Find total number of boundary elements. + NumOfBdrElements = 0; + + if (unique_side_boundary_ids.empty()) + { + boundary.SetSize(0); + return; + } + + for (int boundary_id : unique_side_boundary_ids) + { + NumOfBdrElements += libmesh_node_ids_for_boundary_id.at(boundary_id).size(); + } + + boundary.SetSize(NumOfBdrElements); + + // Iterate over boundary ids. + int iboundary = 0; + for (int boundary_id : unique_side_boundary_ids) + { + auto & all_boundary_node_ids = libmesh_node_ids_for_boundary_id.at(boundary_id); + auto & all_boundary_side_ids = libmesh_side_ids_for_boundary_id.at(boundary_id); + auto & all_boundary_block_ids = libmesh_block_ids_for_boundary_id.at(boundary_id); + + // Iterate over all elements on boundary. + for (int jelement = 0; jelement < (int)all_boundary_node_ids.size(); jelement++) + { + // Extract the boundary node ids and face id for this boundary element. + auto & boundary_node_ids = all_boundary_node_ids[jelement]; + auto boundary_face_id = all_boundary_side_ids[jelement]; + auto boundary_block_id = all_boundary_block_ids[jelement]; + + // Get the element type and face info. + auto & block_element = block_info.blockElement(boundary_block_id); + auto & boundary_face_info = block_element.face(boundary_face_id); + + // Iterate only over the corner nodes and renumber. + std::vector renumbered_vertex_ids(boundary_face_info.numFaceCornerNodes()); + + for (int knode = 0; knode < boundary_face_info.numFaceCornerNodes(); knode++) + { + const int libmesh_node_id = boundary_node_ids[knode]; + + // Renumber vertex ("node") IDs so they're contiguous and start from 0. + renumbered_vertex_ids[knode] = getMFEMVertexIndex(libmesh_node_id); + } + + boundary[iboundary++] = buildMFEMFaceElement( + boundary_face_info.faceType(), renumbered_vertex_ids.data(), boundary_id); + } + } +} + +mfem::Element * +MFEMMesh::buildMFEMElement(const int element_type, const int * vertex_ids, const int block_id) +{ + mfem::Element * new_element = nullptr; + + switch (element_type) + { + case CubitElementInfo::ELEMENT_TRI3: + case CubitElementInfo::ELEMENT_TRI6: + { + new_element = new mfem::Triangle(vertex_ids, block_id); + break; + } + case CubitElementInfo::ELEMENT_QUAD4: + case CubitElementInfo::ELEMENT_QUAD9: + { + new_element = new mfem::Quadrilateral(vertex_ids, block_id); + break; + } + case CubitElementInfo::ELEMENT_TET4: + case CubitElementInfo::ELEMENT_TET10: + { +#ifdef MFEM_USE_MEMALLOC + new_element = TetMemory.Alloc(); + new_element->SetVertices(vertex_ids); + new_element->SetAttribute(block_id); +#else + new_element = new mfem::Tetrahedron(vertex_ids, block_id); +#endif + break; + } + case CubitElementInfo::ELEMENT_HEX8: + case CubitElementInfo::ELEMENT_HEX27: + { + new_element = new mfem::Hexahedron(vertex_ids, block_id); + break; + } + case CubitElementInfo::ELEMENT_WEDGE6: + case CubitElementInfo::ELEMENT_WEDGE18: + { + new_element = new mfem::Wedge(vertex_ids, block_id); + break; + } + case CubitElementInfo::ELEMENT_PYRAMID5: + case CubitElementInfo::ELEMENT_PYRAMID14: + { + new_element = new mfem::Pyramid(vertex_ids, block_id); + break; + } + default: + { + mooseError("Unsupported element type specified.\n"); + break; + } + } + + return new_element; +} + +mfem::Element * +MFEMMesh::buildMFEMFaceElement(const int face_type, const int * vertex_ids, const int boundary_id) +{ + mfem::Element * new_face = nullptr; + + switch (face_type) + { + case CubitFaceInfo::FACE_EDGE2: + case CubitFaceInfo::FACE_EDGE3: + { + new_face = new mfem::Segment(vertex_ids, boundary_id); + break; + } + case CubitFaceInfo::FACE_TRI3: + case CubitFaceInfo::FACE_TRI6: + { + new_face = new mfem::Triangle(vertex_ids, boundary_id); + break; + } + case CubitFaceInfo::FACE_QUAD4: + case CubitFaceInfo::FACE_QUAD8: + case CubitFaceInfo::FACE_QUAD9: + { + new_face = new mfem::Quadrilateral(vertex_ids, boundary_id); + break; + } + default: + { + mooseError("Unsupported face type encountered.\n"); + break; + } + } + + return new_face; +} + +void +MFEMMesh::handleQuadraticFESpace( + const CubitBlockInfo & block_info, + const std::vector & unique_block_ids, + const std::map> & libmesh_element_ids_for_block_id, + const std::map> & libmesh_node_ids_for_element_id, + const std::map> & coordinates_for_libmesh_node_id, + std::map & libmesh_node_id_for_mfem_node_id, + std::map & mfem_node_id_for_libmesh_node_id) +{ + // Verify that this is indeed a second-order element. + if (block_info.order() != 2) + { + return; + } + + // Add a warning for 2D second-order elements but proceed. + if (block_info.dimension() == 2) + { + mooseWarning("'", __func__, "' has not been tested with second-order 2D elements."); + } + + // Clear second order maps. + libmesh_node_id_for_mfem_node_id.clear(); + mfem_node_id_for_libmesh_node_id.clear(); + + // Call FinalizeTopology. If we call this then we must call Finalize later after + // we've defined the mesh nodes. + FinalizeTopology(); + + // Define quadratic FE space. + mfem::FiniteElementCollection * finite_element_collection = new mfem::H1_FECollection(2, Dim); + + // NB: the specified ordering is byVDIM. + // byVDim: XYZ, XYZ, XYZ, XYZ,... + // byNode: XXX..., YYY..., ZZZ... + mfem::FiniteElementSpace * finite_element_space = + new mfem::FiniteElementSpace(this, finite_element_collection, spaceDim); + + Nodes = new mfem::GridFunction(finite_element_space); + Nodes->MakeOwner(finite_element_collection); // Nodes will destroy 'finite_element_collection' + own_nodes = 1; // and 'finite_element_space' + + // 2D maps: + const int mfem_to_libmesh_tri6[] = {1, 2, 3, 4, 5, 6}; + const int mfem_to_libmesh_quad9[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; + + // 3D maps: + const int mfem_to_libmesh_tet10[] = {1, 2, 3, 4, 5, 7, 8, 6, 9, 10}; + + // const int mfem_to_libmesh_pyramid14[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}; + + const int mfem_to_libmesh_wedge18[] = { + 1, 2, 3, 4, 5, 6, 7, 8, 9, 13, 14, 15, 10, 11, 12, 16, 17, 18}; + + // NB: different map used for hex27 to ReadCubit. LibMesh uses a different node + // ordering to the Exodus/Genesis format. + const int mfem_to_libmesh_hex27[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 17, 18, + 19, 20, 13, 14, 15, 16, 21, 22, 23, 24, 25, 26, 27}; + + // Iterate over blocks and libmesh elements. + for (auto block_id : unique_block_ids) + { + auto & libmesh_element_ids = libmesh_element_ids_for_block_id.at(block_id); + + // Find the element type. + auto & block_element = block_info.blockElement(block_id); + + // Get the correct mapping. + int * mfem_to_libmesh_map = nullptr; + + switch (block_element.elementType()) + { + case CubitElementInfo::ELEMENT_TRI6: + { + mfem_to_libmesh_map = (int *)mfem_to_libmesh_tri6; + break; + } + case CubitElementInfo::ELEMENT_QUAD9: + { + mfem_to_libmesh_map = (int *)mfem_to_libmesh_quad9; + break; + } + case CubitElementInfo::ELEMENT_TET10: + { + mfem_to_libmesh_map = (int *)mfem_to_libmesh_tet10; + break; + } + case CubitElementInfo::ELEMENT_HEX27: + { + mfem_to_libmesh_map = (int *)mfem_to_libmesh_hex27; + break; + } + case CubitElementInfo::ELEMENT_WEDGE18: + { + mfem_to_libmesh_map = (int *)mfem_to_libmesh_wedge18; + break; + } + case CubitElementInfo::ELEMENT_PYRAMID14: + { + mooseError("H1_FECollection does not currently support Pyramid14."); + break; + } + default: + { + mooseError("No second-order map available for element type ", + block_element.elementType(), + " with dimension ", + block_element.dimension(), + "."); + break; + } + } + + // Iterate over elements in the block. + for (auto libmesh_element_id : libmesh_element_ids) + { + auto mfem_element_id = getMFEMElementID(libmesh_element_id); + + // Get vector containing ALL node global IDs for element. + auto & libmesh_node_ids = libmesh_node_ids_for_element_id.at(libmesh_element_id); + + // Sets DOF array for element. Higher-order (second-order) elements contain + // additional nodes between corner nodes. + mfem::Array dofs; + finite_element_space->GetElementDofs(mfem_element_id, dofs); + + // Iterate over dofs array. + for (int j = 0; j < dofs.Size(); j++) + { + const int mfem_node_id = dofs[j]; + + // Find the libmesh node ID: + // NB: the map is 1-based to we need to subtract 1. + const int libmesh_node_index = mfem_to_libmesh_map[j] - 1; + const int libmesh_node_id = libmesh_node_ids[libmesh_node_index]; + + // Update two-way map: + libmesh_node_id_for_mfem_node_id[mfem_node_id] = libmesh_node_id; + mfem_node_id_for_libmesh_node_id[libmesh_node_id] = mfem_node_id; + + // Extract node's coordinates: + auto & coordinates = coordinates_for_libmesh_node_id.at(libmesh_node_id); + + SetNode(dofs[j], coordinates.data()); + } + } + } + + /** + * Ensure that there is a one-to-one mapping between libmesh and mfem node ids. + * All coordinates should match. If this does not occur then it suggests that + * there is a problem with the higher-order transfer. + */ + verifyUniqueMappingBetweenLibmeshAndMFEMNodes(unique_block_ids, + libmesh_element_ids_for_block_id, + libmesh_node_ids_for_element_id, + coordinates_for_libmesh_node_id, + libmesh_node_id_for_mfem_node_id); +} + +void +MFEMMesh::verifyUniqueMappingBetweenLibmeshAndMFEMNodes( + const std::vector & unique_block_ids, + const std::map> & libmesh_element_ids_for_block_id, + const std::map> & libmesh_node_ids_for_element_id, + const std::map> & coordinates_for_libmesh_node_id, + const std::map & libmesh_node_id_for_mfem_node_id) +{ + const auto * finite_element_space = GetNodalFESpace(); + if (!finite_element_space) + { + mooseError("No nodal FE space."); + } + + // Create a set of all unique libmesh node ids. + std::set libmesh_node_ids; + + for (auto & key_value : libmesh_node_ids_for_element_id) + { + const std::vector & libmesh_node_ids_for_element = key_value.second; + + for (int libmesh_node_id : libmesh_node_ids_for_element) + { + libmesh_node_ids.insert(libmesh_node_id); + } + } + + double mfem_coordinates[3]; + + for (int ielement = 0; ielement < NumOfElements; ielement++) + { + mfem::Array mfem_dofs; + finite_element_space->GetElementDofs(ielement, mfem_dofs); + + for (int mfem_dof : mfem_dofs) + { + GetNode(mfem_dof, mfem_coordinates); + + const int libmesh_node_id = libmesh_node_id_for_mfem_node_id.at(mfem_dof); + + // Remove from set. + libmesh_node_ids.erase(libmesh_node_id); + + auto & libmesh_coordinates = coordinates_for_libmesh_node_id.at(libmesh_node_id); + + if (!coordinatesMatch(libmesh_coordinates.data(), mfem_coordinates)) + { + mooseError("Non-matching coordinates detected for libmesh node ", + libmesh_node_id, + " and MFEM node ", + mfem_dof, + " for MFEM element ", + ielement, + "."); + } + } + } + + // Check how many elements remain in set of libmesh element ids. Ideally, + // there should be none left indicating that we've referenced every single + // element in the set. + if (libmesh_node_ids.size() != 0) + { + mooseError("There are ", + libmesh_node_ids.size(), + " unpaired libmesh node ids. No one-to-one mapping exists!"); + } +} + +static bool +coordinatesMatch(const double * primary, const double * secondary, const double tolerance) +{ + if (!primary || !secondary || tolerance < 0.0) + { + return false; + } + + for (int i = 0; i < 3; i++) + { + if (fabs(primary[i] - secondary[i]) > tolerance) + { + return false; + } + } + + return true; +} diff --git a/src/mesh/MFEMParMesh.C b/src/mesh/MFEMParMesh.C new file mode 100644 index 00000000..b32c1a47 --- /dev/null +++ b/src/mesh/MFEMParMesh.C @@ -0,0 +1,9 @@ +#pragma once +#include "MFEMParMesh.h" + +// This is a temporary initializer and will be replaced once this class has been +// completed. +MFEMParMesh::MFEMParMesh(MPI_Comm comm, MFEMMesh & mesh, int * partitioning, int part_method) + : mfem::ParMesh(comm, dynamic_cast(mesh), partitioning, part_method) +{ +} diff --git a/src/outputs/MFEMDataCollection.C b/src/outputs/MFEMDataCollection.C new file mode 100644 index 00000000..1164d5d1 --- /dev/null +++ b/src/outputs/MFEMDataCollection.C @@ -0,0 +1,21 @@ +#include "MFEMDataCollection.h" + +registerMooseObject("PlatypusApp", MFEMDataCollection); + +InputParameters +MFEMDataCollection::validParams() +{ + InputParameters params = FileOutput::validParams(); + params.addClassDescription("Output for controlling MFEMDataCollection inherited data."); + return params; +} + +MFEMDataCollection::MFEMDataCollection(const InputParameters & parameters) : FileOutput(parameters) +{ +} + +std::shared_ptr +MFEMDataCollection::createDataCollection(const std::string & collection_name) const +{ + return std::make_shared(collection_name); +} \ No newline at end of file diff --git a/src/outputs/MFEMParaViewDataCollection.C b/src/outputs/MFEMParaViewDataCollection.C new file mode 100644 index 00000000..2af64c09 --- /dev/null +++ b/src/outputs/MFEMParaViewDataCollection.C @@ -0,0 +1,41 @@ +#include "MFEMParaViewDataCollection.h" + +registerMooseObject("PlatypusApp", MFEMParaViewDataCollection); + +InputParameters +MFEMParaViewDataCollection::validParams() +{ + InputParameters params = MFEMDataCollection::validParams(); + params.addClassDescription("Output for controlling MFEMParaViewDataCollection inherited data."); + params.addParam("refinements", + 0, + "Number of uniform refinements for oversampling " + "(refinement levels beyond any uniform " + "refinements)"); + params.addParam("high_order_output", + false, + "Sets whether or not to output the data as " + "high-order elements (false by default)." + "Reading high-order data requires ParaView" + "5.5 or later."); + return params; +} + +MFEMParaViewDataCollection::MFEMParaViewDataCollection(const InputParameters & parameters) + : MFEMDataCollection(parameters), + _high_order_output(getParam("high_order_output")), + _refinements(getParam("refinements")) +{ +} + +std::shared_ptr +MFEMParaViewDataCollection::createDataCollection(const std::string & collection_name) const +{ + auto pv_dc = std::make_shared(_file_base.c_str() + collection_name); + + pv_dc->SetPrecision(9); + pv_dc->SetHighOrderOutput(_high_order_output); + pv_dc->SetLevelsOfDetail(_refinements + 1); + + return pv_dc; +} \ No newline at end of file diff --git a/src/outputs/MFEMVisItDataCollection.C b/src/outputs/MFEMVisItDataCollection.C new file mode 100644 index 00000000..4019c543 --- /dev/null +++ b/src/outputs/MFEMVisItDataCollection.C @@ -0,0 +1,30 @@ +#include "MFEMVisItDataCollection.h" + +registerMooseObject("PlatypusApp", MFEMVisItDataCollection); + +InputParameters +MFEMVisItDataCollection::validParams() +{ + InputParameters params = MFEMDataCollection::validParams(); + params.addClassDescription("Output for controlling MFEMVisItDataCollection inherited data."); + params.addParam("refinements", + 0, + "Number of uniform refinements for oversampling " + "(refinement levels beyond any uniform " + "refinements)"); + return params; +} + +MFEMVisItDataCollection::MFEMVisItDataCollection(const InputParameters & parameters) + : MFEMDataCollection(parameters), _refinements(getParam("refinements")) +{ +} + +std::shared_ptr +MFEMVisItDataCollection::createDataCollection(const std::string & collection_name) const +{ + auto visit_dc = std::make_shared(_file_base.c_str() + collection_name); + visit_dc->SetLevelsOfDetail(_refinements + 1); + + return visit_dc; +} \ No newline at end of file diff --git a/src/postprocessors/ElementVectorL2Difference.C b/src/postprocessors/ElementVectorL2Difference.C new file mode 100644 index 00000000..a2b70acb --- /dev/null +++ b/src/postprocessors/ElementVectorL2Difference.C @@ -0,0 +1,76 @@ +#include "ElementVectorL2Difference.h" + +registerMooseObject("MooseApp", ElementVectorL2Difference); + +InputParameters +ElementVectorL2Difference::validParams() +{ + InputParameters params = ElementIntegralPostprocessor::validParams(); + + params.addRequiredCoupledVar("variable", "The name of the vector variable."); + params.addRequiredCoupledVar("other_variable", + "The name of the other vector variable to compare against."); + + params.addClassDescription( + "Computes the element-wise L2 difference between two coupled vector fields."); + return params; +} + +ElementVectorL2Difference::ElementVectorL2Difference(const InputParameters & parameters) + : ElementIntegralPostprocessor(parameters), + _vector_variable(coupledVectorValue("variable")), + _other_vector_variable(coupledVectorValue("other_variable")) +{ + checkVectorVariables(); +} + +Real +ElementVectorL2Difference::getValue() const +{ + return std::sqrt(ElementIntegralPostprocessor::getValue()); +} + +Real +ElementVectorL2Difference::computeQpIntegral() +{ + RealVectorValue solution_value(0.0, 0.0, 0.0); + RealVectorValue other_value(0.0, 0.0, 0.0); + + for (int icomponent = 0; icomponent < 3; icomponent++) + { + solution_value(icomponent) = _vector_variable[_qp](icomponent); + other_value(icomponent) = _other_vector_variable[_qp](icomponent); + } + + RealVectorValue difference_vector = (solution_value - other_value); + + return difference_vector.norm_sq(); // dot product of difference vector. +} + +void ElementVectorL2Difference::checkVectorVariables() const +{ + auto & coupled_vector_variables = getCoupledVectorMooseVars(); + + if (coupled_vector_variables.size() != 2) + { + mooseError("There are ", coupled_vector_variables.size(), " coupled vector variables. Expected 2."); + } + + auto first = coupled_vector_variables[0]; + auto second = coupled_vector_variables[1]; + + if (!first || !second) + { + mooseError("Coupled vector variable is nullptr."); + } + + if (first->feType().family != second->feType().family) + { + mooseError("The families of the vector variables must match."); + } + + if (first->order() != second->order()) + { + mooseError("The order of the vector variables must match."); + } +} diff --git a/src/problem/MFEMProblem.C b/src/problem/MFEMProblem.C new file mode 100644 index 00000000..5de8121f --- /dev/null +++ b/src/problem/MFEMProblem.C @@ -0,0 +1,632 @@ +#include "MFEMProblem.h" + +registerMooseObject("PlatypusApp", MFEMProblem); + +InputParameters +MFEMProblem::validParams() +{ + InputParameters params = ExternalProblem::validParams(); + params.addParam( + "vis_steps", + 1, + "Number of timesteps between successive write outs of data collections to file."); + params.addParam( + "use_glvis", false, "Attempt to open GLVis ports to display variables during simulation"); + + return params; +} + +MFEMProblem::MFEMProblem(const InputParameters & params) + : ExternalProblem(params), + _input_mesh(_mesh.parameters().get("file")), + _coefficients(), + _outputs(), + _exec_params() +{ + hephaestus::logger.set_level(spdlog::level::info); +} + +MFEMProblem::~MFEMProblem() {} + +void +MFEMProblem::outputStep(ExecFlagType type) +{ + // Needed to ensure outputs from successive runs when using MultiApps are stored in + // directories with iterated names + if (type == EXEC_INITIAL) + { + std::vector mfem_data_collections = + _app.getOutputWarehouse().getOutputNames(); + for (const auto & name : mfem_data_collections) + { + auto dc = _app.getOutputWarehouse().getOutput(name); + int filenum(dc->getFileNumber()); + std::string filename("/Run" + std::to_string(filenum)); + + mfem_problem->_outputs.Register(name, dc->createDataCollection(filename)); + mfem_problem->_outputs.Reset(); + dc->setFileNumber(filenum + 1); + } + } + FEProblemBase::outputStep(type); +} + +void +MFEMProblem::initialSetup() +{ + FEProblemBase::initialSetup(); + EquationSystems & es = FEProblemBase::es(); + _solver_options.SetParam("Tolerance", float(es.parameters.get("linear solver tolerance"))); + _solver_options.SetParam("AbsTolerance", + float(es.parameters.get("linear solver absolute tolerance"))); + _solver_options.SetParam("MaxIter", + es.parameters.get("linear solver maximum iterations")); + _coefficients.AddGlobalCoefficientsFromSubdomains(); + + mfem_problem_builder->SetCoefficients(_coefficients); + mfem_problem_builder->SetSolverOptions(_solver_options); + + // NB: set to false to avoid reconstructing problem operator. + mfem_problem_builder->FinalizeProblem(false); + + hephaestus::InputParameters exec_params; + + Transient * _moose_executioner = dynamic_cast(_app.getExecutioner()); + if (_moose_executioner != nullptr) + { + auto mfem_transient_problem_builder = + std::dynamic_pointer_cast(mfem_problem_builder); + if (mfem_transient_problem_builder == nullptr) + { + mooseError("Specified formulation does not support Transient executioners"); + } + + mfem_problem = mfem_transient_problem_builder->ReturnProblem(); + + exec_params.SetParam("StartTime", float(_moose_executioner->getStartTime())); + exec_params.SetParam("TimeStep", float(dt())); + exec_params.SetParam("EndTime", float(_moose_executioner->endTime())); + exec_params.SetParam("VisualisationSteps", getParam("vis_steps")); + exec_params.SetParam("Problem", + static_cast(mfem_problem.get())); + + executioner = std::make_unique(exec_params); + } + else if (dynamic_cast(_app.getExecutioner())) + { + auto mfem_steady_problem_builder = + std::dynamic_pointer_cast(mfem_problem_builder); + if (mfem_steady_problem_builder == nullptr) + { + mooseError("Specified formulation does not support Steady executioners"); + } + + mfem_problem = mfem_steady_problem_builder->ReturnProblem(); + + exec_params.SetParam("Problem", + static_cast(mfem_problem.get())); + + executioner = std::make_unique(exec_params); + } + else + { + mooseError("Executioner used that is not currently supported by MFEMProblem"); + } + + mfem_problem->_outputs.EnableGLVis(getParam("use_glvis")); +} + +void +MFEMProblem::init() +{ + FEProblemBase::init(); +} + +void +MFEMProblem::externalSolve() +{ + if (!_solve) + { + return; + } + + auto * transient_mfem_exec = dynamic_cast(executioner.get()); + if (transient_mfem_exec != nullptr) + { + transient_mfem_exec->_t_step = dt(); + } + executioner->Solve(); +} + +void +MFEMProblem::setFormulation(const std::string & user_object_name, + const std::string & name, + InputParameters & parameters) +{ + mfem::ParMesh & mfem_par_mesh = mesh().getMFEMParMesh(); + FEProblemBase::addUserObject(user_object_name, name, parameters); + MFEMFormulation * mfem_formulation(&getUserObject(name)); + + mfem_problem_builder = mfem_formulation->getProblemBuilder(); + + mfem_problem_builder->SetMesh(std::make_shared(mfem_par_mesh)); + mfem_problem_builder->ConstructOperator(); +} + +void +MFEMProblem::addBoundaryCondition(const std::string & bc_name, + const std::string & name, + InputParameters & parameters) +{ + FEProblemBase::addUserObject(bc_name, name, parameters); + MFEMBoundaryCondition * mfem_bc(&getUserObject(name)); + mfem_problem_builder->AddBoundaryCondition(name, mfem_bc->getBC()); +} + +void +MFEMProblem::addMaterial(const std::string & kernel_name, + const std::string & name, + InputParameters & parameters) +{ + FEProblemBase::addUserObject(kernel_name, name, parameters); + MFEMMaterial & mfem_material(getUserObject(name)); + + for (unsigned int bid = 0; bid < mfem_material.blocks.size(); ++bid) + { + int block = std::stoi(mfem_material.blocks[bid]); + hephaestus::Subdomain mfem_subdomain(name, block); + mfem_material.storeCoefficients(mfem_subdomain); + _coefficients._subdomains.push_back(mfem_subdomain); + } +} + +void +MFEMProblem::addCoefficient(const std::string & user_object_name, + const std::string & name, + InputParameters & parameters) +{ + FEProblemBase::addUserObject(user_object_name, name, parameters); + MFEMCoefficient * mfem_coef(&getUserObject(name)); + _coefficients._scalars.Register(name, mfem_coef->getCoefficient()); + + // Add associated auxsolvers for CoupledCoefficients + auto coupled_coef = std::dynamic_pointer_cast( + _coefficients._scalars.GetShared(name)); + if (coupled_coef != nullptr) + { + mfem_problem_builder->AddAuxSolver(name, std::move(coupled_coef)); + } +} + +void +MFEMProblem::addVectorCoefficient(const std::string & user_object_name, + const std::string & name, + InputParameters & parameters) +{ + FEProblemBase::addUserObject(user_object_name, name, parameters); + MFEMVectorCoefficient * mfem_vec_coef(&getUserObject(name)); + _coefficients._vectors.Register(name, mfem_vec_coef->getVectorCoefficient()); +} + +void +MFEMProblem::addFESpace(const std::string & user_object_name, + const std::string & name, + InputParameters & parameters) +{ + FEProblemBase::addUserObject(user_object_name, name, parameters); + MFEMFESpace & mfem_fespace(getUserObject(name)); + + mfem_problem_builder->AddFESpace(name, mfem_fespace.fec_name, mfem_fespace.vdim); +} + +void +MFEMProblem::addAuxVariable(const std::string & var_type, + const std::string & var_name, + InputParameters & parameters) +{ + if (var_type == "MFEMVariable") + { + FEProblemBase::addUserObject(var_type, var_name, parameters); + } + else + { + ExternalProblem::addAuxVariable(var_type, var_name, parameters); + + InputParameters mfem_var_params(addMFEMFESpaceFromMOOSEVariable(parameters)); + FEProblemBase::addUserObject("MFEMVariable", var_name, mfem_var_params); + } + + MFEMVariable & var(getUserObject(var_name)); + + mfem_problem_builder->AddGridFunction(var_name, var.fespace.name()); +} + +void +MFEMProblem::addKernel(const std::string & kernel_name, + const std::string & name, + InputParameters & parameters) +{ + FEProblemBase::addUserObject(kernel_name, name, parameters); + const UserObject * kernel = &(getUserObjectBase(name)); + + if (dynamic_cast(kernel) != nullptr) + { + MFEMLinearFormKernel * lf_kernel(&getUserObject(name)); + addKernel(parameters.get("variable"), lf_kernel->getKernel()); + } + else if (dynamic_cast(kernel) != nullptr) + { + MFEMBilinearFormKernel * blf_kernel(&getUserObject(name)); + addKernel(parameters.get("variable"), + blf_kernel->getKernel()); + } + else + { + mooseError("Unsupported kernel of type '", kernel_name, "' and name '", name, "' detected."); + } +} + +void +MFEMProblem::addAuxKernel(const std::string & kernel_name, + const std::string & name, + InputParameters & parameters) +{ + std::string base_auxkernel = parameters.get("_moose_base"); + + if (base_auxkernel == "MFEMAuxKernel") // MFEM auxsolver. + { + FEProblemBase::addUserObject(kernel_name, name, parameters); + MFEMAuxSolver * mfem_auxsolver(&getUserObject(name)); + + mfem_problem_builder->AddPostprocessor(name, mfem_auxsolver->getAuxSolver()); + mfem_auxsolver->storeCoefficients(_coefficients); + } + else if (base_auxkernel == "AuxKernel" || base_auxkernel == "VectorAuxKernel" || + base_auxkernel == "ArrayAuxKernel") // MOOSE auxkernels. + { + FEProblemBase::addAuxKernel(kernel_name, name, parameters); + } + else + { + mooseError("Unrecognized auxkernel base class '", base_auxkernel, "' detected."); + } +} + +void +MFEMProblem::setMFEMVarData(const std::string & var_name) +{ + auto & moose_var_ref = getVariable(0, var_name); + + if (moose_var_ref.isNodal()) + setMFEMNodalVarData(moose_var_ref); + else + setMFEMElementalVarData(moose_var_ref); +} + +void +MFEMProblem::setMOOSEVarData(const std::string & var_name) +{ + auto & moose_var_ref = getVariable(0, var_name); + + if (moose_var_ref.isNodal()) + setMOOSENodalVarData(moose_var_ref); + else + setMOOSEElementalVarData(moose_var_ref); +} + +void +MFEMProblem::setMFEMNodalVarData(MooseVariableFieldBase & moose_var_ref) +{ + // Sanity check: + mooseAssert(moose_var_ref.isNodal() == true, + "Attempted to call 'setMFEMNodalVarData' on a non-nodal MOOSE variable."); + + auto order = (unsigned int)moose_var_ref.order(); + + auto & libmesh_base = mesh().getMesh(); + auto & temp_solution_vector = moose_var_ref.sys().solution(); + auto pgf = mfem_problem->_gridfunctions.Get(moose_var_ref.name()); + + const auto * par_fespace = order > 1 ? pgf->ParFESpace() : nullptr; + + // Count number of true local dofs. + unsigned int true_local_dofs_count = 0; + + for (const auto * node : libmesh_base.local_node_ptr_range()) + { + bool has_dofs = (node->n_dofs(moose_var_ref.sys().number(), moose_var_ref.number()) > 0); + if (!has_dofs) + continue; + + auto n_comp = node->n_comp(moose_var_ref.sys().number(), moose_var_ref.number()); + true_local_dofs_count += n_comp; + } + + mfem::Vector mfem_true_local_dofs(true_local_dofs_count); + + // Set MFEM true local dofs. + unsigned int dof_index = 0; + + for (const auto * node : libmesh_base.local_node_ptr_range()) + { + bool has_dofs = (node->n_dofs(moose_var_ref.sys().number(), moose_var_ref.number()) > 0); + if (!has_dofs) + { + continue; + } + + auto n_comp = node->n_comp(moose_var_ref.sys().number(), moose_var_ref.number()); + + for (decltype(n_comp) i = 0; i < n_comp; i++) + { + auto dof = node->dof_number(moose_var_ref.sys().number(), moose_var_ref.number(), i); + + if (order == 1) + { + mfem_true_local_dofs[dof_index++] = temp_solution_vector(dof); + } + else + { + // Get the local dof: + auto mfem_local_dof = mesh().getLocalMFEMNodeId(node->id()); + + // Convert to TRUE LOCAL dof. Removes duplicated. No longer 1:1 mapping. + auto mfem_true_local_dof = par_fespace->GetLocalTDofNumber(mfem_local_dof); + + // Not on this processor? --> skip. + if (mfem_true_local_dof == -1) + { + continue; + } + + // Catch dodgy local true dofs. + mooseAssert(mfem_true_local_dof >= 0 && mfem_true_local_dof < mfem_true_local_dofs.Size(), + "local-true dof out-of-bounds."); + + mfem_true_local_dofs[mfem_true_local_dof] = temp_solution_vector(dof); + } + } + } + + pgf->SetFromTrueDofs(mfem_true_local_dofs); + + moose_var_ref.sys().solution().close(); + moose_var_ref.sys().update(); +} + +void +MFEMProblem::setMFEMElementalVarData(MooseVariableFieldBase & moose_var_ref) +{ + // Sanity check: + mooseAssert(moose_var_ref.isNodal() == false, + "Attempted to call 'setMFEMElementalVarData' on a nodal MOOSE variable."); + + auto order = (unsigned int)moose_var_ref.order(); + mooseAssert((n_processors() == 1) || (n_processors() > 1 && order == CONSTANT), + "Currently, only constant-order elemental variables can be synced in parallel."); + + auto & libmesh_base = mesh().getMesh(); + auto & temp_solution_vector = moose_var_ref.sys().solution(); + auto pgf = (mfem_problem->_gridfunctions.Get(moose_var_ref.name())); + + // Count number of true local dofs. + unsigned int true_local_dofs_count = 0; + + for (const auto * elem : libmesh_base.local_element_ptr_range()) + { + auto n_comp = elem->n_comp(moose_var_ref.sys().number(), moose_var_ref.number()); + true_local_dofs_count += n_comp; + } + + mfem::Vector mfem_true_local_dofs(true_local_dofs_count); + + // Set MFEM true local dofs. + unsigned int dof_index = 0; + + for (const auto * elem : libmesh_base.local_element_ptr_range()) + { + auto n_comp = elem->n_comp(moose_var_ref.sys().number(), moose_var_ref.number()); + + for (decltype(n_comp) i = 0; i < n_comp; i++) + { + dof_id_type dof = elem->dof_number(moose_var_ref.sys().number(), moose_var_ref.number(), i); + + mfem_true_local_dofs[dof_index++] = temp_solution_vector(dof); + } + } + + pgf->SetFromTrueDofs(mfem_true_local_dofs); + + moose_var_ref.sys().solution().close(); + moose_var_ref.sys().update(); +} + +void +MFEMProblem::setMOOSENodalVarData(MooseVariableFieldBase & moose_var_ref) +{ + mooseAssert(moose_var_ref.isNodal() == true, + "Attempted to call 'setMOOSENodalVarData' on a non-nodal MOOSE variable."); + + auto order = (unsigned int)moose_var_ref.order(); + + auto & libmesh_base = mesh().getMesh(); + auto pgf = (mfem_problem->_gridfunctions.Get(moose_var_ref.name())); + + const auto * par_fespace = (order > 1) ? pgf->ParFESpace() : nullptr; + + auto * mfem_true_local_dofs = pgf->GetTrueDofs(); // Must delete. + + unsigned int dof_index = 0; + + for (const auto * node : libmesh_base.local_node_ptr_range()) + { + auto n_comp = node->n_comp(moose_var_ref.sys().number(), moose_var_ref.number()); + + for (decltype(n_comp) i = 0; i < n_comp; i++) + { + auto dof = node->dof_number(moose_var_ref.sys().number(), moose_var_ref.number(), i); + + if (order == 1) + { + moose_var_ref.sys().solution().set(dof, (*mfem_true_local_dofs)[dof_index++]); + } + else + { + // Local dof # 1:1 correspondance with MOOSE nodes. + auto mfem_local_dof = mesh().getLocalMFEMNodeId(node->id()); + + // No 1:1 correspondance with MOOSE nodes. #local true dofs <= #local dofs. + // Removes multiple local nodes that refer to same coordinate. + auto mfem_true_local_dof = par_fespace->GetLocalTDofNumber(mfem_local_dof); + + // Skip dof if it isn't on this processor. + if (mfem_true_local_dof == -1) + { + continue; + } + + mooseAssert(mfem_true_local_dof >= 0 && mfem_true_local_dof < mfem_true_local_dofs->Size(), + "local-true dof out-of-bounds."); + + moose_var_ref.sys().solution().set(dof, (*mfem_true_local_dofs)[mfem_true_local_dof]); + } + } + } + + moose_var_ref.sys().solution().close(); + moose_var_ref.sys().update(); + + delete mfem_true_local_dofs; +} + +void +MFEMProblem::setMOOSEElementalVarData(MooseVariableFieldBase & moose_var_ref) +{ + mooseAssert(moose_var_ref.isNodal() == false, + "Attempted to call 'setMOOSEElementalVarData' on a nodal MOOSE variable."); + + auto order = (unsigned int)moose_var_ref.order(); + mooseAssert((n_processors() == 1) || (n_processors() > 1 && order == CONSTANT), + "Currently, only constant-order elemental variables can be synced in parallel."); + + auto & libmesh_base = mesh().getMesh(); + auto pgf = (mfem_problem->_gridfunctions.Get(moose_var_ref.name())); + + auto * mfem_local_elems = pgf->GetTrueDofs(); // Must delete. + + unsigned int dof_index = 0; + + for (const auto * elem : libmesh_base.local_element_ptr_range()) + { + auto n_comp = elem->n_comp(moose_var_ref.sys().number(), moose_var_ref.number()); + + for (decltype(n_comp) i = 0; i < n_comp; i++) + { + dof_id_type dof = elem->dof_number(moose_var_ref.sys().number(), moose_var_ref.number(), i); + moose_var_ref.sys().solution().set(dof, (*mfem_local_elems)[dof_index++]); + } + } + + moose_var_ref.sys().solution().close(); + moose_var_ref.sys().update(); + + delete mfem_local_elems; +} + +InputParameters +MFEMProblem::addMFEMFESpaceFromMOOSEVariable(InputParameters & moosevar_params) +{ + InputParameters mfem_fespace_params(_factory.getValidParams("MFEMFESpace")); + InputParameters mfem_var_params(_factory.getValidParams("MFEMVariable")); + + const FEFamily var_family = + Utility::string_to_enum(moosevar_params.get("family")); + switch (var_family) + { + case FEFamily::LAGRANGE: + mfem_fespace_params.set("fespace_type") = std::string("H1"); + break; + case FEFamily::LAGRANGE_VEC: + mfem_fespace_params.set("fespace_type") = std::string("H1"); + mfem_fespace_params.set("vdim") = 3; + break; + case FEFamily::MONOMIAL: + mfem_fespace_params.set("fespace_type") = std::string("L2"); + break; + case FEFamily::MONOMIAL_VEC: + mfem_fespace_params.set("fespace_type") = + std::string("L2"); // Create L2 only for now. + mfem_fespace_params.set("vdim") = 3; + break; + default: + mooseError("Unable to set MFEM FESpace for MOOSE variable"); + break; + } + mfem_fespace_params.setParameters("order", moosevar_params.get("order")); + int order(moosevar_params.get("order")); + std::string fec_name( + MFEMFESpace::createFECName(mfem_fespace_params.get("fespace_type"), order)); + std::string fespace_name(Utility::enum_to_string(var_family) + "_" + fec_name); + + if (!hasUserObject(fespace_name)) + { + addFESpace("MFEMFESpace", fespace_name, mfem_fespace_params); + } + + mfem_var_params.set("fespace") = fespace_name; + + return mfem_var_params; +} + +std::vector +MFEMProblem::getAuxVariableNames() +{ + return systemBaseAuxiliary().getVariableNames(); +} + +void +MFEMProblem::syncSolutions(Direction direction) +{ + // Only sync solutions if MOOSE and MFEM meshes are coupled. + if (ExternalProblem::mesh().type() != "CoupledMFEMMesh") + { + return; + } + + void (MFEMProblem::*setVarDataFuncPtr)(const std::string &); + + switch (direction) + { + case Direction::TO_EXTERNAL_APP: + setVarDataFuncPtr = + &MFEMProblem::setMFEMVarData; // If data is being sent from the master app. + break; + case Direction::FROM_EXTERNAL_APP: + setVarDataFuncPtr = + &MFEMProblem::setMOOSEVarData; // If data is being sent back to the master app. + break; + default: + setVarDataFuncPtr = nullptr; + break; + } + + if (!setVarDataFuncPtr) + { + mooseError("Invalid syncSolutions direction specified."); + } + + for (std::string & name : getAuxVariableNames()) + { + (this->*setVarDataFuncPtr)(name); + } +} + +ExclusiveMFEMMesh & +MFEMProblem::mesh() +{ + mooseAssert(ExternalProblem::mesh().type() == "ExclusiveMFEMMesh" || + ExternalProblem::mesh().type() == "CoupledMFEMMesh", + "Please choose a valid mesh type for an MFEMProblem\n(Either CoupledMFEMMesh or " + "ExclusiveMFEMMesh)"); + return (ExclusiveMFEMMesh &)_mesh; +} diff --git a/src/variables/MFEMVariable.C b/src/variables/MFEMVariable.C new file mode 100644 index 00000000..451085f0 --- /dev/null +++ b/src/variables/MFEMVariable.C @@ -0,0 +1,44 @@ +#include "MFEMVariable.h" + +registerMooseObject("PlatypusApp", MFEMVariable); + +InputParameters +MFEMVariable::validParams() +{ + InputParameters params = GeneralUserObject::validParams(); + + params.registerBase("MooseVariableBase"); + + // Create user-facing 'boundary' input for restricting inheriting object to boundaries + + params.addRequiredParam("fespace", + "The finite element space this variable is defined on."); + + // Remaining params are for compatibility with MOOSE AuxVariable interface + params.addRangeCheckedParam( + "components", 3, "components>0", "Number of components for an array variable"); + + params.addParam>("scaling", + "Specifies a scaling factor to apply to this variable"); + params.addParam("eigen", false, "True to make this variable an eigen variable"); + params.addParam("fv", false, "True to make this variable a finite volume variable"); + params.addParam("array", + false, + "True to make this variable a array variable regardless of number of " + "components. If 'components' > 1, this will automatically be set to" + "true."); + params.addParamNamesToGroup("scaling eigen", "Advanced"); + + params.addParam("use_dual", false, "True to use dual basis for Lagrange multipliers"); + + return params; +} + +MFEMVariable::MFEMVariable(const InputParameters & parameters) + : GeneralUserObject(parameters), + fespace(getUserObject("fespace")), + components(parameters.get("components")) +{ +} + +MFEMVariable::~MFEMVariable() {} diff --git a/syntax.yaml b/syntax.yaml new file mode 100644 index 00000000..122b3798 --- /dev/null +++ b/syntax.yaml @@ -0,0 +1,77039 @@ + +**START YAML DATA** +- name: /Adaptivity + description: | + + parameters: + - name: cycles_per_step + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + The number of adaptive steps to use when on each timestep during a Transient simulation. + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: initial_marker + required: No + default: !!str + cpp_type: MarkerName + group_name: + description: | + The name of the Marker to use to adapt the mesh during initial refinement. + - name: initial_steps + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The number of adaptive steps to do based on the initial condition. + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + The number of time steps betweeen each adaptivity phase + - name: marker + required: No + default: !!str + cpp_type: MarkerName + group_name: + description: | + The name of the Marker to use to actually adapt the mesh. + - name: max_h_level + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + Maximum number of times a single element can be refined. If 0 then infinite. + - name: recompute_markers_during_cycles + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Recompute markers during adaptivity cycles + - name: start_time + required: No + default: !!str -1.79769e+308 + cpp_type: double + group_name: + description: | + The time that adaptivity will be active after. + - name: steps + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The number of adaptive steps to use when doing a Steady simulation. + - name: stop_time + required: No + default: !!str 1.79769e+308 + cpp_type: double + group_name: + description: | + The time after which adaptivity will no longer be active. + subblocks: + - name: /Adaptivity/Indicators + description: | + + parameters: + subblocks: + - name: /Adaptivity/Indicators/* + description: | + + parameters: + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH + description: | + Specifies the order of the FE shape function to use for this variable (additional orders not listed are allowed) + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /Adaptivity/Indicators/AnalyticalIndicator + description: | + + parameters: + - name: block + required: No + default: !!str ANY_BLOCK_ID + cpp_type: std::vector > + group_name: + description: | + block ID or name where the object works + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The analytic solution to compare against + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str AnalyticalIndicator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The name of the variable that this Indicator operates on + subblocks: + - name: /Adaptivity/Indicators/ArrayMooseVariable + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str ArrayMooseVariable + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /Adaptivity/Indicators/GradientJumpIndicator + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scale_by_flux_faces + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to scale the error values by the number of flux faces. This attempts to not penalize elements on boundaries for having less neighbors. + - name: type + required: No + default: !!str GradientJumpIndicator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The name of the variable that this side indicator applies to + subblocks: + - name: /Adaptivity/Indicators/LaplacianJumpIndicator + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scale_by_flux_faces + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to scale the error values by the number of flux faces. This attempts to not penalize elements on boundaries for having less neighbors. + - name: type + required: No + default: !!str LaplacianJumpIndicator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The name of the variable that this side indicator applies to + subblocks: + - name: /Adaptivity/Indicators/MooseVariable + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str MooseVariable + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /Adaptivity/Indicators/MooseVariableBase + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str MooseVariableBase + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /Adaptivity/Indicators/MooseVariableConstMonomial + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str MONOMIAL + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str CONSTANT + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str MooseVariableConstMonomial + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /Adaptivity/Indicators/MooseVariableFVReal + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str MooseVariableFVReal + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /Adaptivity/Indicators/MooseVariableScalar + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str SCALAR + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str MooseVariableScalar + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /Adaptivity/Indicators/ValueJumpIndicator + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scale_by_flux_faces + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to scale the error values by the number of flux faces. This attempts to not penalize elements on boundaries for having less neighbors. + - name: type + required: No + default: !!str ValueJumpIndicator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The name of the variable that this side indicator applies to + subblocks: + - name: /Adaptivity/Indicators/VectorMooseVariable + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str VectorMooseVariable + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /Adaptivity/Markers + description: | + + parameters: + subblocks: + - name: /Adaptivity/Markers/* + description: | + + parameters: + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH + description: | + Specifies the order of the FE shape function to use for this variable (additional orders not listed are allowed) + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /Adaptivity/Markers/ArrayMooseVariable + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str ArrayMooseVariable + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /Adaptivity/Markers/BoxMarker + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: bottom_left + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The bottom left point (in x,y,z with spaces in-between). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: inside + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: DONT_MARK COARSEN DO_NOTHING REFINE + description: | + How to mark elements inside the box. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: outside + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: DONT_MARK COARSEN DO_NOTHING REFINE + description: | + How to mark elements outside the box. + - name: top_right + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The bottom left point (in x,y,z with spaces in-between). + - name: type + required: No + default: !!str BoxMarker + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Adaptivity/Markers/ComboMarker + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: markers + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + A list of marker names to combine into a single marker. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str ComboMarker + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Adaptivity/Markers/ErrorFractionMarker + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: clear_extremes + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether or not to clear the extremes during each error calculation. Changing this to `false` will result in the global extremes ever encountered during the run to be used as the min and max error. + - name: coarsen + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Elements within this percentage of the min error will be coarsened. Must be between 0 and 1! + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: indicator + required: Yes + default: !!str + cpp_type: IndicatorName + group_name: + description: | + The name of the Indicator that this Marker uses. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: refine + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Elements within this percentage of the max error will be refined. Must be between 0 and 1! + - name: type + required: No + default: !!str ErrorFractionMarker + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Adaptivity/Markers/ErrorToleranceMarker + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: coarsen + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Elements with error less than this will be coarsened. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: indicator + required: Yes + default: !!str + cpp_type: IndicatorName + group_name: + description: | + The name of the Indicator that this Marker uses. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: refine + required: No + default: !!str 1.79769e+308 + cpp_type: double + group_name: + description: | + Elements with error more than this will be refined. + - name: type + required: No + default: !!str ErrorToleranceMarker + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Adaptivity/Markers/MooseVariable + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str MooseVariable + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /Adaptivity/Markers/MooseVariableBase + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str MooseVariableBase + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /Adaptivity/Markers/MooseVariableConstMonomial + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str MONOMIAL + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str CONSTANT + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str MooseVariableConstMonomial + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /Adaptivity/Markers/MooseVariableFVReal + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str MooseVariableFVReal + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /Adaptivity/Markers/MooseVariableScalar + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str SCALAR + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str MooseVariableScalar + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /Adaptivity/Markers/OrientedBoxMarker + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: center + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + The center (many people spell this 'center') of the box. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: height + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The height of the box + - name: inside + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: DONT_MARK COARSEN DO_NOTHING REFINE + description: | + How to mark elements inside the box. + - name: length + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The length of the box + - name: length_direction + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The direction along which the length is oriented (must be perpendicular to width_direction). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: outside + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: DONT_MARK COARSEN DO_NOTHING REFINE + description: | + How to mark elements outside the box. + - name: type + required: No + default: !!str OrientedBoxMarker + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: width + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The width of the box + - name: width_direction + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The direction along which the width is oriented. + subblocks: + - name: /Adaptivity/Markers/UniformMarker + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: mark + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: DONT_MARK COARSEN DO_NOTHING REFINE + description: | + How to mark elements. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str UniformMarker + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Adaptivity/Markers/ValueRangeMarker + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: buffer_size + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + A buffer zone value added to both ends of the range where a third_state marker can be returned. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: invert + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If this is true then values _below_ 'refine' will be refined and _above_ 'coarsen' will be coarsened. + - name: lower_bound + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The lower bound value for the range. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: third_state + required: No + default: !!str DONT_MARK + cpp_type: MooseEnum + group_name: + options: DONT_MARK COARSEN DO_NOTHING REFINE + description: | + The Marker state to apply to values falling in-between the coarsen and refine thresholds. + - name: type + required: No + default: !!str ValueRangeMarker + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: upper_bound + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The upper bound value for the range. + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The values of this variable will be compared to 'refine' and 'coarsen' to see what should be done with the element + subblocks: + - name: /Adaptivity/Markers/ValueThresholdMarker + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: coarsen + required: No + default: !!str + cpp_type: double + group_name: + description: | + The threshold value for coarsening. Elements with variable values beyond this will be marked for coarsening. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: invert + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If this is true then values _below_ 'refine' will be refined and _above_ 'coarsen' will be coarsened. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: refine + required: No + default: !!str + cpp_type: double + group_name: + description: | + The threshold value for refinement. Elements with variable values beyond this will be marked for refinement. + - name: third_state + required: No + default: !!str DONT_MARK + cpp_type: MooseEnum + group_name: + options: DONT_MARK COARSEN DO_NOTHING REFINE + description: | + The Marker state to apply to values falling in-between the coarsen and refine thresholds. + - name: type + required: No + default: !!str ValueThresholdMarker + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The values of this variable will be compared to 'refine' and 'coarsen' to see what should be done with the element + subblocks: + - name: /Adaptivity/Markers/VectorMooseVariable + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str VectorMooseVariable + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: +- name: /AuxKernels + description: | + + parameters: + subblocks: + - name: /AuxKernels/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /AuxKernels/ADMaterialRankTwoTensorAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: i + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The index i of ij for the tensor to output + - name: j + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The index j of ij for the tensor to output + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADMaterialRankTwoTensorAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/ADMaterialRealAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADMaterialRealAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/ADMaterialRealVectorValueAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: component + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The vector component to consider for this kernel + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADMaterialRealVectorValueAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/ADVectorMaterialRealVectorValueAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: offset + required: No + default: !!str 0 0 0 + cpp_type: libMesh::VectorValue + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADVectorMaterialRealVectorValueAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/ArrayVariableComponent + description: | + + parameters: + - name: array_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the array variable + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: component + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + Component of the array variable to be extracted + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ArrayVariableComponent + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/ConstantAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ConstantAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Some constant value that can be read from the input file + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/ConstantBoundsAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: bound_type + required: No + default: !!str upper + cpp_type: MooseEnum + group_name: + options: upper lower + description: | + Type of bound. 'upper' refers to the upper bound. 'lower' refers to the lower value. + - name: bound_value + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The value of bound for the variable + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: bounded_variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The variable to be bounded + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ConstantBoundsAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/DebugResidualAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: debug_variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The variable that is being debugged. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str DebugResidualAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/DiffusionFluxAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: component + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z + description: | + The desired component of flux. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diffusion_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable + - name: diffusivity + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the diffusivity material property that will be used in the flux computation. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str DiffusionFluxAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/ElemExtraIDAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: extra_id_name + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The extra ID name in the mesh + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElemExtraIDAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/ElementH1ErrorFunctionAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: coupled_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable to compute the norm of. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + Function representing the exact solution + - name: p + required: No + default: !!str 2 + cpp_type: double + group_name: + description: | + The exponent used in the norm. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementH1ErrorFunctionAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/ElementIntegerAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: integer_names + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Element integers to be retrieved + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementIntegerAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/ElementL2ErrorFunctionAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: coupled_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable to compute the norm of. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + Function representing the exact solution + - name: p + required: No + default: !!str 2 + cpp_type: double + group_name: + description: | + The exponent used in the norm. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementL2ErrorFunctionAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/ElementLengthAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: method + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: min max + description: | + The size calculation to perform ('min' or 'max'). + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementLengthAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/ElementLpNormAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: coupled_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable to compute the norm of. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: p + required: No + default: !!str 2 + cpp_type: double + group_name: + description: | + The exponent used in the norm. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementLpNormAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/ElementQualityAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: metric + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: ASPECT_RATIO SKEW SHEAR SHAPE MAX_ANGLE MIN_ANGLE CONDITION DISTORTION TAPER WARP STRETCH DIAGONAL ASPECT_RATIO_BETA ASPECT_RATIO_GAMMA SIZE JACOBIAN + description: | + The quality metric to use. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementQualityAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/FunctionAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The function to use as the value + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str FunctionAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/GapValueAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: normal_smoothing_distance + required: No + default: !!str + cpp_type: double + group_name: + description: | + Distance from edge in parametric coordinates over which to smooth contact normal + - name: normal_smoothing_method + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Method to use to smooth normals (edge_based|nodal_normal_based) + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: FIRST SECOND THIRD FOURTH + description: | + The finite element order + - name: paired_boundary + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The boundary on the other side of a gap. + - name: paired_variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable to get the value of. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: tangential_tolerance + required: No + default: !!str + cpp_type: double + group_name: + description: | + Tangential distance to extend edges of contact surfaces + - name: type + required: No + default: !!str GapValueAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + - name: warnings + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether to output warning messages concerning nodes not being found + subblocks: + - name: /AuxKernels/GhostingAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: functor_type + required: No + default: !!str geometric + cpp_type: MooseEnum + group_name: + options: geometric algebraic + description: | + The type of ghosting functor to use + - name: ghost_uo + required: Yes + default: !!str + cpp_type: UserObjectName + group_name: + description: | + The GhostUserObject from which to obtain ghosting information from. + - name: include_local_elements + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to include local elements as part of the ghosting set + - name: pid + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The PID to see the ghosting for + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str GhostingAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/HardwareIDAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str HardwareIDAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/InterfaceValueUserObjectAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: interface_uo_name + required: Yes + default: !!str + cpp_type: UserObjectName + group_name: + description: | + The name of the interface user object to use + - name: return_side_average + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true returns the elment side average rather than a single qp value + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str InterfaceValueUserObjectAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/MaterialRankFourTensorAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: i + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The index i of ijkl for the tensor to output + - name: j + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The index j of ijkl for the tensor to output + - name: k + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The index k of ijkl for the tensor to output + - name: l + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The index l of ijkl for the tensor to output + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MaterialRankFourTensorAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/MaterialRankTwoTensorAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: i + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The index i of ij for the tensor to output + - name: j + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The index j of ij for the tensor to output + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MaterialRankTwoTensorAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/MaterialRealAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MaterialRealAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/MaterialRealDenseMatrixAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: column + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The column component to consider for this kernel + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: row + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The row component to consider for this kernel + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MaterialRealDenseMatrixAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/MaterialRealTensorValueAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: column + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The column component to consider for this kernel + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: row + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The row component to consider for this kernel + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MaterialRealTensorValueAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/MaterialRealVectorValueAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: component + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The vector component to consider for this kernel + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MaterialRealVectorValueAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/MaterialStdVectorAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: index + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The index to consider for this kernel + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: selected_qp + required: No + default: !!str + cpp_type: unsigned int + group_name: 'Advanced' + description: | + Evaluate the std::vector at this quadpoint. This only needs to be used if you are interested in a particular quadpoint in each element: otherwise do not include this parameter in your input file + - name: type + required: No + default: !!str MaterialStdVectorAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/MaterialStdVectorRealGradientAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: component + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The gradient component to be extracted for this kernel + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: index + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The index to consider for this kernel + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MaterialStdVectorRealGradientAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/NearestNodeDistanceAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: paired_boundary + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The boundary to find the distance to. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NearestNodeDistanceAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/NearestNodeValueAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: paired_boundary + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The boundary to get the value from. + - name: paired_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable to get the value of. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NearestNodeValueAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/NormalizationAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: normal_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The normalization factor + - name: normalization + required: No + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The postprocessor on the source + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: shift + required: No + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The postprocessor to shift the source + - name: source_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable to be normalized + - name: type + required: No + default: !!str NormalizationAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/ParsedAux + description: | + + parameters: + - name: args + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + coupled variables + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: constant_expressions + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of values for the constants in constant_names (can be an FParser expression) + - name: constant_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of constants used in the parsed function (use this for kB etc.) + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: disable_fpoptimizer + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Disable the function parser algebraic optimizer + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: enable_ad_cache + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable cacheing of function derivatives for faster startup time + - name: enable_auto_optimize + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable automatic immediate optimization of derivatives + - name: enable_jit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable just-in-time compilation of function expressions for faster evaluation + - name: evalerror_behavior + required: No + default: !!str nan + cpp_type: MooseEnum + group_name: 'Advanced' + options: nan nan_warning error exception + description: | + What to do if evaluation error occurs. Options are to pass a nan, pass a nan with a warning, throw a error, or throw an exception + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: fail_on_evalerror + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Fail fatally if a function evaluation returns an error code (otherwise just pass on NaN) + - name: function + required: Yes + default: !!str + cpp_type: FunctionExpression + group_name: + description: | + function expression + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ParsedAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/PenetrationAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: normal_smoothing_distance + required: No + default: !!str + cpp_type: double + group_name: + description: | + Distance from edge in parametric coordinates over which to smooth contact normal + - name: normal_smoothing_method + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Method to use to smooth normals (edge_based|nodal_normal_based) + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: FIRST SECOND THIRD FOURTH + description: | + The finite element order + - name: paired_boundary + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The boundary to be penetrated + - name: quantity + required: No + default: !!str distance + cpp_type: MooseEnum + group_name: + options: distance tangential_distance normal_x normal_y normal_z closest_point_x closest_point_y closest_point_z element_id side incremental_slip_magnitude incremental_slip_x incremental_slip_y incremental_slip_z accumulated_slip force_x force_y force_z normal_force_magnitude normal_force_x normal_force_y normal_force_z tangential_force_magnitude tangential_force_x tangential_force_y tangential_force_z frictional_energy lagrange_multiplier mechanical_status + description: | + The quantity to recover from the available penetration information + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: tangential_tolerance + required: No + default: !!str + cpp_type: double + group_name: + description: | + Tangential distance to extend edges of contact surfaces + - name: type + required: No + default: !!str PenetrationAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/ProcessorIDAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ProcessorIDAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/QuotientAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: denominator + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The downstairs of the quotient variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: numerator + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The upstairs of the quotient variable + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str QuotientAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/SelfAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str SelfAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/SolutionAux + description: | + + parameters: + - name: add_factor + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Add this value (b) to the solution (x): ax+b, where a is the 'scale_factor' + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: direct + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true the meshes must be the same and then the values are simply copied over. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: from_variable + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name of the variable to extract from the file + - name: scale_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Scale factor (a) to be applied to the solution (x): ax+b, where b is the 'add_factor' + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: solution + required: Yes + default: !!str + cpp_type: UserObjectName + group_name: + description: | + The name of the SolutionUserObject + - name: type + required: No + default: !!str SolutionAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/SpatialUserObjectAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str SpatialUserObjectAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: user_object + required: Yes + default: !!str + cpp_type: UserObjectName + group_name: + description: | + The UserObject UserObject to get values from. Note that the UserObject _must_ implement the spatialValue() virtual function! + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/TagMatrixAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: matrix_tag + required: No + default: !!str TagName + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Tag Name this Aux works on + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str TagMatrixAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The coupled variable whose components are coupled to AuxVariable + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/TagVectorAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str TagVectorAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The coupled variable whose components are coupled to AuxVariable + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + - name: vector_tag + required: No + default: !!str TagName + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Tag Name this Aux works on + subblocks: + - name: /AuxKernels/VariableGradientComponent + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: component + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z + description: | + The gradient component to compute + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: gradient_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable from which to compute the gradient component + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VariableGradientComponent + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/VariableOldValueBoundsAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: bound_type + required: No + default: !!str upper + cpp_type: MooseEnum + group_name: + options: upper lower + description: | + Type of bound. 'upper' refers to the upper bound. 'lower' refers to the lower value. + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: bounded_variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The variable to be bounded + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VariableOldValueBoundsAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/VariableTimeIntegrationAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: coefficient + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + A simple coefficient + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: order + required: No + default: !!str 2 + cpp_type: unsigned int + group_name: + description: | + The order of global truncation error: midpoint=1, trapazoidal=2, Simpson=3 + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VariableTimeIntegrationAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + - name: variable_to_integrate + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable to be integrated + subblocks: + - name: /AuxKernels/VectorFunctionAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The function to use as the value. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VectorFunctionAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/VectorMagnitudeAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VectorMagnitudeAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + - name: x + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + x-component of the vector + - name: y + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + y-component of the vector + - name: z + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + z-component of the vector + subblocks: + - name: /AuxKernels/VectorMaterialRealVectorValueAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: offset + required: No + default: !!str 0 0 0 + cpp_type: libMesh::VectorValue + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VectorMaterialRealVectorValueAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /AuxKernels/VectorPostprocessorVisualizationAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VectorPostprocessorVisualizationAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_broadcast + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Causes this AuxKernel to use a broadcasted version of the vector instead of a scattered version of the vector (the default). This is slower - but is useful for debugging and testing + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + - name: vector_name + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name of the vector to use from the VectorPostprocessor + - name: vpp + required: Yes + default: !!str + cpp_type: VectorPostprocessorName + group_name: + description: | + The name of the VectorPostprocessor to pull the data from. + subblocks: + - name: /AuxKernels/VectorVariableComponentAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: component + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z + description: | + The component to compute + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VectorVariableComponentAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + - name: vector_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable from which to compute the component + subblocks: +- name: /AuxScalarKernels + description: | + + parameters: + subblocks: + - name: /AuxScalarKernels/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /AuxScalarKernels/ConstantScalarAux + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: type + required: No + default: !!str ConstantScalarAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The value to be set to the scalar variable. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this kernel operates on + subblocks: + - name: /AuxScalarKernels/FunctionScalarAux + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: function + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The functions to set the scalar variable components. + - name: type + required: No + default: !!str FunctionScalarAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this kernel operates on + subblocks: + - name: /AuxScalarKernels/QuotientScalarAux + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: denominator + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The downstairs of the quotient variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: numerator + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The upstairs of the quotient variable + - name: type + required: No + default: !!str QuotientScalarAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this kernel operates on + subblocks: + - name: /AuxScalarKernels/ScalarTagMatrixAux + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: matrix_tag + required: No + default: !!str TagName + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Tag Name this Aux works on + - name: type + required: No + default: !!str ScalarTagMatrixAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The coupled variable whose components are coupled to AuxVariable + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this kernel operates on + subblocks: + - name: /AuxScalarKernels/ScalarTagVectorAux + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: type + required: No + default: !!str ScalarTagVectorAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The coupled variable whose components are coupled to AuxVariable + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this kernel operates on + - name: vector_tag + required: No + default: !!str TagName + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Tag Name this Aux works on + subblocks: + - name: /AuxScalarKernels/SolutionScalarAux + description: | + + parameters: + - name: add_factor + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Add this value (b) to the solution (x): ax+b, where a is the 'scale_factor' + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: from_variable + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name of the variable to extract from the file + - name: scale_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Scale factor (a) to be applied to the solution (x): ax+b, where b is the 'add_factor' + - name: solution + required: Yes + default: !!str + cpp_type: UserObjectName + group_name: + description: | + The name of the SolutionUserObject + - name: type + required: No + default: !!str SolutionScalarAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this kernel operates on + subblocks: +- name: /AuxVariables + description: | + + parameters: + subblocks: + - name: /AuxVariables/* + description: | + + parameters: + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH + description: | + Specifies the order of the FE shape function to use for this variable (additional orders not listed are allowed) + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: Yes + default: !!str MooseVariableBase + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + - name: initial_from_file_timestep + required: No + default: !!str LATEST + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: 'Initial From File' + description: | + Gives the timestep (or "LATEST") for which to read a solution from a file for a given variable. (Default: LATEST) + - name: initial_from_file_var + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: 'Initial From File' + description: | + Gives the name of a variable for which to read an initial condition from a mesh file + subblocks: + - name: /AuxVariables/*/InitialCondition + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /AuxVariables/*/InitialCondition/ + description: | + + parameters: + subblocks: + - name: /AuxVariables/*/InitialCondition//ArrayConstantIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: type + required: No + default: !!str ArrayConstantIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: value + required: Yes + default: !!str + cpp_type: Eigen::Matrix + group_name: + description: | + The values to be set in IC + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /AuxVariables/*/InitialCondition//ArrayFunctionIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: function + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The initial condition functions. + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: type + required: No + default: !!str ArrayFunctionIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /AuxVariables/*/InitialCondition//BoundingBoxIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: inside + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The value of the variable inside the box + - name: int_width + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The width of the diffuse interface. Set to 0 for sharp interface. + - name: outside + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The value of the variable outside the box + - name: type + required: No + default: !!str BoundingBoxIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + - name: x1 + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The x coordinate of the lower left-hand corner of the box + - name: x2 + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The x coordinate of the upper right-hand corner of the box + - name: y1 + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The y coordinate of the lower left-hand corner of the box + - name: y2 + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The y coordinate of the upper right-hand corner of the box + - name: z1 + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The z coordinate of the lower left-hand corner of the box + - name: z2 + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The z coordinate of the upper right-hand corner of the box + subblocks: + - name: /AuxVariables/*/InitialCondition//ConstantIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: type + required: No + default: !!str ConstantIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: value + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The value to be set in IC + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /AuxVariables/*/InitialCondition//FunctionIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The initial condition function. + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: type + required: No + default: !!str FunctionIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /AuxVariables/*/InitialCondition//FunctionScalarIC + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: function + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The initial condition function. + - name: type + required: No + default: !!str FunctionScalarIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: No + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /AuxVariables/*/InitialCondition//RandomIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: distribution + required: No + default: !!str + cpp_type: DistributionName + group_name: + description: | + Name of distribution defining distribution of randomly generated values + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: legacy_generator + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Determines whether or not the legacy generator (deprecated) should be used. + - name: max + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper bound of uniformly distributed randomly generated values + - name: min + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower bound of uniformly distributed randomly generated values + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + Seed value for the random number generator + - name: type + required: No + default: !!str RandomIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /AuxVariables/*/InitialCondition//ScalarComponentIC + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str ScalarComponentIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: values + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + Initial values to initialize the scalar variable. + - name: variable + required: No + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /AuxVariables/*/InitialCondition//ScalarConstantIC + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str ScalarConstantIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + + - name: variable + required: No + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /AuxVariables/*/InitialCondition//VectorConstantIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: type + required: No + default: !!str VectorConstantIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + - name: x_value + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The x value to be set in IC + - name: y_value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The y value to be set in IC + - name: z_value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The z value to be set in IC + subblocks: + - name: /AuxVariables/*/InitialCondition//VectorFunctionIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: function + required: No + default: !!str + cpp_type: FunctionName + group_name: + description: | + The initial condition vector function. This cannot be supplied with the component parameters. + - name: function_x + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + A function that describes the x-component of the initial condition + - name: function_y + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + A function that describes the y-component of the initial condition + - name: function_z + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + A function that describes the z-component of the initial condition + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: type + required: No + default: !!str VectorFunctionIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /AuxVariables/ArrayMooseVariable + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str ArrayMooseVariable + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /AuxVariables/MooseVariable + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str MooseVariable + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /AuxVariables/MooseVariableBase + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str MooseVariableBase + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /AuxVariables/MooseVariableConstMonomial + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str MONOMIAL + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str CONSTANT + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str MooseVariableConstMonomial + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /AuxVariables/MooseVariableFVReal + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str MooseVariableFVReal + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /AuxVariables/MooseVariableScalar + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str SCALAR + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str MooseVariableScalar + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /AuxVariables/VectorMooseVariable + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str VectorMooseVariable + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: +- name: /BCs + description: | + + parameters: + subblocks: + - name: /BCs/* + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/ADDirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: preset + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether or not to preset the BC (apply the value before the solve begins). Note that the default value of this parameter is handled by the use_legacy_dirichlet_bc parameter on the MooseApp. + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: set_x_comp + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to set the x-component of the variable + - name: set_y_comp + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to set the y-component of the variable + - name: set_z_comp + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to set the z-component of the variable + - name: type + required: No + default: !!str ADDirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Value of the BC + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str residual + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time residual + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/ADFunctionDirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: function + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The function describing the Dirichlet condition + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: preset + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether or not to preset the BC (apply the value before the solve begins). Note that the default value of this parameter is handled by the use_legacy_dirichlet_bc parameter on the MooseApp. + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: set_x_comp + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to set the x-component of the variable + - name: set_y_comp + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to set the y-component of the variable + - name: set_z_comp + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to set the z-component of the variable + - name: type + required: No + default: !!str ADFunctionDirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str residual + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time residual + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/ADFunctionNeumannBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The function. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADFunctionNeumannBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/ADFunctionPenaltyDirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + Forcing function + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: penalty + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Penalty scalar + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADFunctionPenaltyDirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/ADFunctionPresetBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The forcing function. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: set_x_comp + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to set the x-component of the variable + - name: set_y_comp + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to set the y-component of the variable + - name: set_z_comp + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to set the z-component of the variable + - name: type + required: No + default: !!str ADFunctionPresetBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str residual + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time residual + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/ADNeumannBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADNeumannBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: Yes + default: !!str 0 + cpp_type: double + group_name: + description: | + The value of the gradient on the boundary. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/ADPenaltyDirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: penalty + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Penalty scalar + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADPenaltyDirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Boundary value of the variable + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/ADPresetBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: set_x_comp + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to set the x-component of the variable + - name: set_y_comp + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to set the y-component of the variable + - name: set_z_comp + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to set the z-component of the variable + - name: type + required: No + default: !!str ADPresetBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Value of the BC + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str residual + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time residual + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/ADVectorFunctionDirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: function + required: No + default: !!str + cpp_type: FunctionName + group_name: + description: | + The boundary condition vector function. This cannot be supplied with the component parameters. + - name: function_x + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The function for the x component + - name: function_y + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The function for the y component + - name: function_z + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The function for the z component + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: set_x_comp + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to set the x-component of the variable + - name: set_y_comp + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to set the y-component of the variable + - name: set_z_comp + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to set the z-component of the variable + - name: type + required: No + default: !!str ADVectorFunctionDirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str residual + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time residual + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/ADVectorMatchedValueBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: set_x_comp + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to set the x-component of the variable + - name: set_y_comp + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to set the y-component of the variable + - name: set_z_comp + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to set the z-component of the variable + - name: type + required: No + default: !!str ADVectorMatchedValueBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable whose value we are to match. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str residual + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time residual + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/ArrayDirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ArrayDirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: values + required: Yes + default: !!str + cpp_type: Eigen::Matrix + group_name: + description: | + The values the components must take on the boundary + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str residual + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time residual + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/ArrayPenaltyDirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: penalty + required: No + default: !!str 4 + cpp_type: double + group_name: + description: | + Penalty scalar + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ArrayPenaltyDirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: Yes + default: !!str + cpp_type: Eigen::Matrix + group_name: + description: | + Boundary value of the array variable + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/ArrayVacuumBC + description: | + + parameters: + - name: alpha + required: No + default: !!str + cpp_type: Eigen::Matrix + group_name: + description: | + Ratio between directional gradient and solution + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ArrayVacuumBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/ConvectiveFluxBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: duration + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: final + required: No + default: !!str 500 + cpp_type: double + group_name: + description: | + + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: initial + required: No + default: !!str 500 + cpp_type: double + group_name: + description: | + + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: rate + required: No + default: !!str 7500 + cpp_type: double + group_name: + description: | + + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ConvectiveFluxBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/CoupledVarNeumannBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: coef + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Coefficent ($\sigma$) multiplier for the coupled force term. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str CoupledVarNeumannBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + Coupled variable setting the gradient on the boundary. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/DGFunctionDiffusionDirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: diff + required: No + default: !!str 1 + cpp_type: MaterialPropertyName + group_name: + description: | + The diffusion (or thermal electrical_conductivity or viscosity) coefficient. + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: epsilon + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Epsilon + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The forcing function. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: sigma + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Sigma + - name: type + required: No + default: !!str DGFunctionDiffusionDirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The value the variable should have on the boundary + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/DiffusionFluxBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str DiffusionFluxBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/DirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: preset + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether or not to preset the BC (apply the value before the solve begins). Note that the default value of this parameter is handled by the use_legacy_dirichlet_bc parameter on the MooseApp. + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str DirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Value of the BC + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str residual + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time residual + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/EigenArrayDirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str eigen + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time eigen + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str EigenArrayDirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str eigen + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time residual eigen + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/EigenDirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str eigen + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time eigen + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str EigenDirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str eigen + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time residual eigen + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/FunctionDirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The forcing function. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: preset + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether or not to preset the BC (apply the value before the solve begins). Note that the default value of this parameter is handled by the use_legacy_dirichlet_bc parameter on the MooseApp. + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str FunctionDirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str residual + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time residual + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/FunctionGradientNeumannBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: coeff + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The diffusion, thermal electrical_conductivity, etc. coefficient + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: exact_solution + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The exact solution. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str FunctionGradientNeumannBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/FunctionNeumannBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The function. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str FunctionNeumannBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/FunctionPenaltyDirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + Forcing function + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: penalty + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Penalty scalar + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str FunctionPenaltyDirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/FunctionPresetBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The forcing function. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str FunctionPresetBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str residual + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time residual + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/LagrangeVecDirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str LagrangeVecDirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: values + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The values the components must take on the boundary + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str residual + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time residual + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/LagrangeVecFunctionDirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: function + required: No + default: !!str + cpp_type: FunctionName + group_name: + description: | + The boundary condition vector function. This cannot be supplied with the component parameters. + - name: function_x + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The function for the x component + - name: function_y + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The function for the y component + - name: function_z + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The function for the z component + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str LagrangeVecFunctionDirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str residual + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time residual + description: | + The tag for the vectors this Kernel should fill + - name: x_exact_soln + required: No + default: !!str + cpp_type: FunctionName + group_name: + description: | + The exact solution for the x component + - name: y_exact_soln + required: No + default: !!str + cpp_type: FunctionName + group_name: + description: | + The exact solution for the y component + - name: z_exact_soln + required: No + default: !!str + cpp_type: FunctionName + group_name: + description: | + The exact solution for the z component + subblocks: + - name: /BCs/MatchedValueBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MatchedValueBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable whose value we are to match. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str residual + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time residual + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/NeumannBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NeumannBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The value of the gradient on the boundary. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/OneDEqualValueConstraintBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: component + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + Component of the Lagrange multiplier + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: lambda + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + Lagrange multiplier + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str OneDEqualValueConstraintBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + - name: vg + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Variation of the constraint g wrt this surface (+1 or -1). Note: g = value1 - value2 = 0 + subblocks: + - name: /BCs/PenaltyDirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: penalty + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Penalty scalar + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str PenaltyDirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Boundary value of the variable + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/Periodic + description: | + + parameters: + subblocks: + - name: /BCs/Periodic/* + description: | + + parameters: + - name: auto_direction + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If using a generated mesh, you can specifiy just the dimension(s) you want to mark as periodic + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: inv_transform_func + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Functions that specify the inverse transformation + - name: primary + required: No + default: !!str + cpp_type: BoundaryName + group_name: + description: | + Boundary ID associated with the primary boundary. + - name: secondary + required: No + default: !!str + cpp_type: BoundaryName + group_name: + description: | + Boundary ID associated with the secondary boundary. + - name: transform_func + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Functions that specify the transformation + - name: translation + required: No + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + Vector that translates coordinates on the primary boundary to coordinates on the secondary boundary. + - name: variable + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Variable for the periodic boundary + subblocks: + - name: /BCs/PostprocessorDirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: postprocessor + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The postprocessor to set the value to on the boundary. + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str PostprocessorDirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str residual + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time residual + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/PostprocessorNeumannBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: postprocessor + required: No + default: !!str 0 + cpp_type: PostprocessorName + group_name: + description: | + The postprocessor to use for value of the gradient on the boundary. + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str PostprocessorNeumannBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/PresetBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str PresetBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Value of the BC + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str residual + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time residual + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/SinDirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: duration + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: final + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: initial + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str SinDirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str residual + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time residual + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/SinNeumannBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: duration + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The duration of the ramp + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: final + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The final value of the gradient on the boundary + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: initial + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The initial value of the gradient on the boundary + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str SinNeumannBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/VacuumBC + description: | + + parameters: + - name: alpha + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + No idea. + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VacuumBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/VectorCurlBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: curl_value + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + Value of field curl on the boundary. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VectorCurlBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/VectorTangentialPenaltyDirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: function_x + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The function for the x component + - name: function_y + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The function for the y component + - name: function_z + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The function for the z component + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: penalty + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The penalty coefficient + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VectorTangentialPenaltyDirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + - name: x_exact_soln + required: No + default: !!str + cpp_type: FunctionName + group_name: + description: | + The exact solution for the x component + - name: y_exact_soln + required: No + default: !!str + cpp_type: FunctionName + group_name: + description: | + The exact solution for the y component + - name: z_exact_soln + required: No + default: !!str + cpp_type: FunctionName + group_name: + description: | + The exact solution for the z component + subblocks: + - name: /BCs/VectorDirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VectorDirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: values + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The values the components must take on the boundary + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str residual + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time residual + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /BCs/VectorFunctionDirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: function + required: No + default: !!str + cpp_type: FunctionName + group_name: + description: | + The boundary condition vector function. This cannot be supplied with the component parameters. + - name: function_x + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The function for the x component + - name: function_y + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The function for the y component + - name: function_z + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The function for the z component + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VectorFunctionDirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str residual + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time residual + description: | + The tag for the vectors this Kernel should fill + - name: x_exact_soln + required: No + default: !!str + cpp_type: FunctionName + group_name: + description: | + The exact solution for the x component + - name: y_exact_soln + required: No + default: !!str + cpp_type: FunctionName + group_name: + description: | + The exact solution for the y component + - name: z_exact_soln + required: No + default: !!str + cpp_type: FunctionName + group_name: + description: | + The exact solution for the z component + subblocks: + - name: /BCs/VectorNeumannBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VectorNeumannBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + - name: vector_value + required: No + default: !!str 0 0 0 + cpp_type: libMesh::VectorValue + group_name: + description: | + vector this BC should act in + subblocks: + - name: /BCs/WeakGradientBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str WeakGradientBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: +- name: /Bounds + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + subblocks: + - name: /Bounds/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /Bounds/ADMaterialRankTwoTensorAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: i + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The index i of ij for the tensor to output + - name: j + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The index j of ij for the tensor to output + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADMaterialRankTwoTensorAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/ADMaterialRealAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADMaterialRealAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/ADMaterialRealVectorValueAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: component + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The vector component to consider for this kernel + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADMaterialRealVectorValueAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/ADVectorMaterialRealVectorValueAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: offset + required: No + default: !!str 0 0 0 + cpp_type: libMesh::VectorValue + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADVectorMaterialRealVectorValueAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/ArrayVariableComponent + description: | + + parameters: + - name: array_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the array variable + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: component + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + Component of the array variable to be extracted + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ArrayVariableComponent + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/ConstantAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ConstantAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Some constant value that can be read from the input file + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/ConstantBoundsAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: bound_type + required: No + default: !!str upper + cpp_type: MooseEnum + group_name: + options: upper lower + description: | + Type of bound. 'upper' refers to the upper bound. 'lower' refers to the lower value. + - name: bound_value + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The value of bound for the variable + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: bounded_variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The variable to be bounded + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ConstantBoundsAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/DebugResidualAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: debug_variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The variable that is being debugged. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str DebugResidualAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/DiffusionFluxAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: component + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z + description: | + The desired component of flux. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diffusion_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable + - name: diffusivity + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the diffusivity material property that will be used in the flux computation. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str DiffusionFluxAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/ElemExtraIDAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: extra_id_name + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The extra ID name in the mesh + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElemExtraIDAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/ElementH1ErrorFunctionAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: coupled_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable to compute the norm of. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + Function representing the exact solution + - name: p + required: No + default: !!str 2 + cpp_type: double + group_name: + description: | + The exponent used in the norm. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementH1ErrorFunctionAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/ElementIntegerAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: integer_names + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Element integers to be retrieved + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementIntegerAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/ElementL2ErrorFunctionAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: coupled_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable to compute the norm of. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + Function representing the exact solution + - name: p + required: No + default: !!str 2 + cpp_type: double + group_name: + description: | + The exponent used in the norm. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementL2ErrorFunctionAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/ElementLengthAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: method + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: min max + description: | + The size calculation to perform ('min' or 'max'). + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementLengthAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/ElementLpNormAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: coupled_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable to compute the norm of. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: p + required: No + default: !!str 2 + cpp_type: double + group_name: + description: | + The exponent used in the norm. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementLpNormAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/ElementQualityAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: metric + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: ASPECT_RATIO SKEW SHEAR SHAPE MAX_ANGLE MIN_ANGLE CONDITION DISTORTION TAPER WARP STRETCH DIAGONAL ASPECT_RATIO_BETA ASPECT_RATIO_GAMMA SIZE JACOBIAN + description: | + The quality metric to use. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementQualityAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/FunctionAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The function to use as the value + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str FunctionAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/GapValueAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: normal_smoothing_distance + required: No + default: !!str + cpp_type: double + group_name: + description: | + Distance from edge in parametric coordinates over which to smooth contact normal + - name: normal_smoothing_method + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Method to use to smooth normals (edge_based|nodal_normal_based) + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: FIRST SECOND THIRD FOURTH + description: | + The finite element order + - name: paired_boundary + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The boundary on the other side of a gap. + - name: paired_variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable to get the value of. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: tangential_tolerance + required: No + default: !!str + cpp_type: double + group_name: + description: | + Tangential distance to extend edges of contact surfaces + - name: type + required: No + default: !!str GapValueAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + - name: warnings + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether to output warning messages concerning nodes not being found + subblocks: + - name: /Bounds/GhostingAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: functor_type + required: No + default: !!str geometric + cpp_type: MooseEnum + group_name: + options: geometric algebraic + description: | + The type of ghosting functor to use + - name: ghost_uo + required: Yes + default: !!str + cpp_type: UserObjectName + group_name: + description: | + The GhostUserObject from which to obtain ghosting information from. + - name: include_local_elements + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to include local elements as part of the ghosting set + - name: pid + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The PID to see the ghosting for + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str GhostingAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/HardwareIDAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str HardwareIDAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/InterfaceValueUserObjectAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: interface_uo_name + required: Yes + default: !!str + cpp_type: UserObjectName + group_name: + description: | + The name of the interface user object to use + - name: return_side_average + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true returns the elment side average rather than a single qp value + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str InterfaceValueUserObjectAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/MaterialRankFourTensorAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: i + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The index i of ijkl for the tensor to output + - name: j + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The index j of ijkl for the tensor to output + - name: k + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The index k of ijkl for the tensor to output + - name: l + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The index l of ijkl for the tensor to output + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MaterialRankFourTensorAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/MaterialRankTwoTensorAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: i + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The index i of ij for the tensor to output + - name: j + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The index j of ij for the tensor to output + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MaterialRankTwoTensorAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/MaterialRealAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MaterialRealAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/MaterialRealDenseMatrixAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: column + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The column component to consider for this kernel + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: row + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The row component to consider for this kernel + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MaterialRealDenseMatrixAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/MaterialRealTensorValueAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: column + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The column component to consider for this kernel + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: row + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The row component to consider for this kernel + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MaterialRealTensorValueAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/MaterialRealVectorValueAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: component + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The vector component to consider for this kernel + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MaterialRealVectorValueAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/MaterialStdVectorAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: index + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The index to consider for this kernel + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: selected_qp + required: No + default: !!str + cpp_type: unsigned int + group_name: 'Advanced' + description: | + Evaluate the std::vector at this quadpoint. This only needs to be used if you are interested in a particular quadpoint in each element: otherwise do not include this parameter in your input file + - name: type + required: No + default: !!str MaterialStdVectorAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/MaterialStdVectorRealGradientAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: component + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The gradient component to be extracted for this kernel + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: index + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The index to consider for this kernel + - name: offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MaterialStdVectorRealGradientAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/NearestNodeDistanceAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: paired_boundary + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The boundary to find the distance to. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NearestNodeDistanceAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/NearestNodeValueAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: paired_boundary + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The boundary to get the value from. + - name: paired_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable to get the value of. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NearestNodeValueAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/NormalizationAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: normal_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The normalization factor + - name: normalization + required: No + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The postprocessor on the source + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: shift + required: No + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The postprocessor to shift the source + - name: source_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable to be normalized + - name: type + required: No + default: !!str NormalizationAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/ParsedAux + description: | + + parameters: + - name: args + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + coupled variables + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: constant_expressions + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of values for the constants in constant_names (can be an FParser expression) + - name: constant_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of constants used in the parsed function (use this for kB etc.) + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: disable_fpoptimizer + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Disable the function parser algebraic optimizer + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: enable_ad_cache + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable cacheing of function derivatives for faster startup time + - name: enable_auto_optimize + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable automatic immediate optimization of derivatives + - name: enable_jit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable just-in-time compilation of function expressions for faster evaluation + - name: evalerror_behavior + required: No + default: !!str nan + cpp_type: MooseEnum + group_name: 'Advanced' + options: nan nan_warning error exception + description: | + What to do if evaluation error occurs. Options are to pass a nan, pass a nan with a warning, throw a error, or throw an exception + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: fail_on_evalerror + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Fail fatally if a function evaluation returns an error code (otherwise just pass on NaN) + - name: function + required: Yes + default: !!str + cpp_type: FunctionExpression + group_name: + description: | + function expression + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ParsedAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/PenetrationAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: normal_smoothing_distance + required: No + default: !!str + cpp_type: double + group_name: + description: | + Distance from edge in parametric coordinates over which to smooth contact normal + - name: normal_smoothing_method + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Method to use to smooth normals (edge_based|nodal_normal_based) + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: FIRST SECOND THIRD FOURTH + description: | + The finite element order + - name: paired_boundary + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The boundary to be penetrated + - name: quantity + required: No + default: !!str distance + cpp_type: MooseEnum + group_name: + options: distance tangential_distance normal_x normal_y normal_z closest_point_x closest_point_y closest_point_z element_id side incremental_slip_magnitude incremental_slip_x incremental_slip_y incremental_slip_z accumulated_slip force_x force_y force_z normal_force_magnitude normal_force_x normal_force_y normal_force_z tangential_force_magnitude tangential_force_x tangential_force_y tangential_force_z frictional_energy lagrange_multiplier mechanical_status + description: | + The quantity to recover from the available penetration information + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: tangential_tolerance + required: No + default: !!str + cpp_type: double + group_name: + description: | + Tangential distance to extend edges of contact surfaces + - name: type + required: No + default: !!str PenetrationAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/ProcessorIDAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ProcessorIDAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/QuotientAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: denominator + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The downstairs of the quotient variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: numerator + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The upstairs of the quotient variable + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str QuotientAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/SelfAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str SelfAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/SolutionAux + description: | + + parameters: + - name: add_factor + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Add this value (b) to the solution (x): ax+b, where a is the 'scale_factor' + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: direct + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true the meshes must be the same and then the values are simply copied over. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: from_variable + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name of the variable to extract from the file + - name: scale_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Scale factor (a) to be applied to the solution (x): ax+b, where b is the 'add_factor' + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: solution + required: Yes + default: !!str + cpp_type: UserObjectName + group_name: + description: | + The name of the SolutionUserObject + - name: type + required: No + default: !!str SolutionAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/SpatialUserObjectAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str SpatialUserObjectAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: user_object + required: Yes + default: !!str + cpp_type: UserObjectName + group_name: + description: | + The UserObject UserObject to get values from. Note that the UserObject _must_ implement the spatialValue() virtual function! + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/TagMatrixAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: matrix_tag + required: No + default: !!str TagName + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Tag Name this Aux works on + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str TagMatrixAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The coupled variable whose components are coupled to AuxVariable + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/TagVectorAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str TagVectorAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The coupled variable whose components are coupled to AuxVariable + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + - name: vector_tag + required: No + default: !!str TagName + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Tag Name this Aux works on + subblocks: + - name: /Bounds/VariableGradientComponent + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: component + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z + description: | + The gradient component to compute + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: gradient_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable from which to compute the gradient component + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VariableGradientComponent + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/VariableOldValueBoundsAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: bound_type + required: No + default: !!str upper + cpp_type: MooseEnum + group_name: + options: upper lower + description: | + Type of bound. 'upper' refers to the upper bound. 'lower' refers to the lower value. + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: bounded_variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The variable to be bounded + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VariableOldValueBoundsAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/VariableTimeIntegrationAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: coefficient + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + A simple coefficient + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: order + required: No + default: !!str 2 + cpp_type: unsigned int + group_name: + description: | + The order of global truncation error: midpoint=1, trapazoidal=2, Simpson=3 + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VariableTimeIntegrationAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + - name: variable_to_integrate + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable to be integrated + subblocks: + - name: /Bounds/VectorFunctionAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The function to use as the value. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VectorFunctionAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/VectorMagnitudeAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VectorMagnitudeAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + - name: x + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + x-component of the vector + - name: y + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + y-component of the vector + - name: z + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + z-component of the vector + subblocks: + - name: /Bounds/VectorMaterialRealVectorValueAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The factor by which to multiply your material property for visualization + - name: offset + required: No + default: !!str 0 0 0 + cpp_type: libMesh::VectorValue + group_name: + description: | + The offset to add to your material property for visualization + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The scalar material property name + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VectorMaterialRealVectorValueAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + subblocks: + - name: /Bounds/VectorPostprocessorVisualizationAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VectorPostprocessorVisualizationAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_broadcast + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Causes this AuxKernel to use a broadcasted version of the vector instead of a scattered version of the vector (the default). This is slower - but is useful for debugging and testing + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + - name: vector_name + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name of the vector to use from the VectorPostprocessor + - name: vpp + required: Yes + default: !!str + cpp_type: VectorPostprocessorName + group_name: + description: | + The name of the VectorPostprocessor to pull the data from. + subblocks: + - name: /Bounds/VectorVariableComponentAux + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: component + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z + description: | + The component to compute + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VectorVariableComponentAux + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The name of the variable that this object applies to + - name: vector_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable from which to compute the component + subblocks: +- name: /Constraints + description: | + + parameters: + subblocks: + - name: /Constraints/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /Constraints/CoupledTiedValueConstraint + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: master + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The boundary ID associated with the master side + - name: master_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable on the master side of the domain + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: normal_smoothing_distance + required: No + default: !!str + cpp_type: double + group_name: + description: | + Distance from edge in parametric coordinates over which to smooth contact normal + - name: normal_smoothing_method + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Method to use to smooth normals (edge_based|nodal_normal_based) + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: FIRST SECOND THIRD FOURTH + description: | + The finite element order used for projections + - name: scaling + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + scaling factor to be applied to constraint equations + - name: slave + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The boundary ID associated with the slave side + - name: tangential_tolerance + required: No + default: !!str + cpp_type: double + group_name: + description: | + Tangential distance to extend edges of contact surfaces + - name: type + required: No + default: !!str CoupledTiedValueConstraint + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this constraint is applied to. + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Constraints/EqualGradientConstraint + description: | + + parameters: + - name: component + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + Gradient component to constrain + - name: compute_lm_residuals + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to compute Lagrange Multiplier residuals + - name: compute_primal_residuals + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to compute residuals for the primal variable. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: master_boundary + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The name of the master boundary sideset. + - name: master_subdomain + required: Yes + default: !!str + cpp_type: SubdomainName + group_name: + description: | + The name of the master subdomain. + - name: master_variable + required: No + default: !!str + cpp_type: VariableName + group_name: + description: | + Primal variable on master surface. If this parameter is not provided then the master variable will be initialized to the slave variable + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: periodic + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether this constraint is going to be used to enforce a periodic condition. This has the effect of changing the normals vector for projection from outward to inward facing + - name: slave_boundary + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The name of the slave boundary sideset. + - name: slave_subdomain + required: Yes + default: !!str + cpp_type: SubdomainName + group_name: + description: | + The name of the slave subdomain. + - name: slave_variable + required: No + default: !!str + cpp_type: VariableName + group_name: + description: | + Primal variable on slave surface. + - name: type + required: No + default: !!str EqualGradientConstraint + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: No + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the lagrange multiplier variable that this constraint is applied to. This parameter may not be supplied in the case of using penalty methods for example + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Constraints/EqualValueBoundaryConstraint + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: formulation + required: No + default: !!str penalty + cpp_type: MooseEnum + group_name: + options: penalty kinematic + description: | + Formulation used to calculate constraint - penalty or kinematic. + - name: master + required: No + default: !!str 4294967295 + cpp_type: unsigned int + group_name: + description: | + The ID of the master node. If no ID is provided, first node of slave set is chosen. + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: penalty + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The penalty used for the boundary term + - name: slave + required: No + default: !!str NaN + cpp_type: BoundaryName + group_name: + description: | + The boundary ID associated with the slave side + - name: slave_node_ids + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The IDs of the slave node + - name: type + required: No + default: !!str EqualValueBoundaryConstraint + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this constraint is applied to. + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Constraints/EqualValueConstraint + description: | + + parameters: + - name: compute_lm_residuals + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to compute Lagrange Multiplier residuals + - name: compute_primal_residuals + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to compute residuals for the primal variable. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: master_boundary + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The name of the master boundary sideset. + - name: master_subdomain + required: Yes + default: !!str + cpp_type: SubdomainName + group_name: + description: | + The name of the master subdomain. + - name: master_variable + required: No + default: !!str + cpp_type: VariableName + group_name: + description: | + Primal variable on master surface. If this parameter is not provided then the master variable will be initialized to the slave variable + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: periodic + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether this constraint is going to be used to enforce a periodic condition. This has the effect of changing the normals vector for projection from outward to inward facing + - name: slave_boundary + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The name of the slave boundary sideset. + - name: slave_subdomain + required: Yes + default: !!str + cpp_type: SubdomainName + group_name: + description: | + The name of the slave subdomain. + - name: slave_variable + required: No + default: !!str + cpp_type: VariableName + group_name: + description: | + Primal variable on slave surface. + - name: type + required: No + default: !!str EqualValueConstraint + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: No + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the lagrange multiplier variable that this constraint is applied to. This parameter may not be supplied in the case of using penalty methods for example + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Constraints/EqualValueEmbeddedConstraint + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: formulation + required: No + default: !!str kinematic + cpp_type: MooseEnum + group_name: + options: kinematic penalty + description: | + Formulation used to enforce the constraint + - name: master + required: Yes + default: !!str + cpp_type: SubdomainName + group_name: + description: | + master block id + - name: master_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable on the master side of the domain + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: penalty + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Penalty parameter used in constraint enforcement for kinematic and penalty formulations. + - name: slave + required: Yes + default: !!str + cpp_type: SubdomainName + group_name: + description: | + slave block id + - name: type + required: No + default: !!str EqualValueEmbeddedConstraint + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this constraint is applied to. + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Constraints/LinearNodalConstraint + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: formulation + required: No + default: !!str penalty + cpp_type: MooseEnum + group_name: + options: penalty kinematic + description: | + Formulation used to calculate constraint - penalty or kinematic. + - name: master + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The master node IDs. + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: penalty + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The penalty used for the boundary term + - name: slave_node_ids + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of slave node ids + - name: slave_node_set + required: No + default: !!str NaN + cpp_type: BoundaryName + group_name: + description: | + The boundary ID associated with the slave side + - name: type + required: No + default: !!str LinearNodalConstraint + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this constraint is applied to. + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + - name: weights + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The weights associated with the master node ids. Must be of the same size as master nodes + subblocks: + - name: /Constraints/OldEqualValueConstraint + description: | + + parameters: + - name: compute_lm_residuals + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to compute Lagrange Multiplier residuals + - name: compute_primal_residuals + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether to compute residuals for the primal variable. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: master_boundary + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The name of the master boundary sideset. + - name: master_subdomain + required: Yes + default: !!str + cpp_type: SubdomainName + group_name: + description: | + The name of the master subdomain. + - name: master_variable + required: No + default: !!str + cpp_type: VariableName + group_name: + description: | + Primal variable on master surface. If this parameter is not provided then the master variable will be initialized to the slave variable + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: periodic + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether this constraint is going to be used to enforce a periodic condition. This has the effect of changing the normals vector for projection from outward to inward facing + - name: slave_boundary + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The name of the slave boundary sideset. + - name: slave_subdomain + required: Yes + default: !!str + cpp_type: SubdomainName + group_name: + description: | + The name of the slave subdomain. + - name: slave_variable + required: No + default: !!str + cpp_type: VariableName + group_name: + description: | + Primal variable on slave surface. + - name: type + required: No + default: !!str OldEqualValueConstraint + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: No + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the lagrange multiplier variable that this constraint is applied to. This parameter may not be supplied in the case of using penalty methods for example + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Constraints/TiedValueConstraint + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str LINEAR + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: master + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The boundary ID associated with the master side + - name: master_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable on the master side of the domain + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: normal_smoothing_distance + required: No + default: !!str + cpp_type: double + group_name: + description: | + Distance from edge in parametric coordinates over which to smooth contact normal + - name: normal_smoothing_method + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Method to use to smooth normals (edge_based|nodal_normal_based) + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: FIRST SECOND THIRD FOURTH + description: | + The finite element order used for projections + - name: scaling + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + scaling factor to be applied to constraint equations + - name: slave + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The boundary ID associated with the slave side + - name: tangential_tolerance + required: No + default: !!str + cpp_type: double + group_name: + description: | + Tangential distance to extend edges of contact surfaces + - name: type + required: No + default: !!str TiedValueConstraint + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this constraint is applied to. + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: +- name: /Controls + description: | + + parameters: + subblocks: + - name: /Controls/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /Controls/BoolFunctionControl + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The Controls that this control relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The function to use for controlling the specified parameter. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: parameter + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The input parameter(s) to control. Specify a single parameter name and all parameters in all objects matching the name will be updated + - name: type + required: No + default: !!str BoolFunctionControl + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Controls/ConditionalFunctionEnableControl + description: | + + parameters: + - name: conditional_function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The function to give a true or false value + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The Controls that this control relies upon (i.e. must execute before this one) + - name: disable_objects + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + A list of object tags to disable. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: enable_objects + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + A list of object tags to enable. + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: reverse_on_false + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When true, the disable/enable lists are set to opposite values when the specified condition is false. + - name: type + required: No + default: !!str ConditionalFunctionEnableControl + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Controls/RealFunctionControl + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The Controls that this control relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The function to use for controlling the specified parameter. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: parameter + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The input parameter(s) to control. Specify a single parameter name and all parameters in all objects matching the name will be updated + - name: type + required: No + default: !!str RealFunctionControl + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Controls/TimePeriod + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The Controls that this control relies upon (i.e. must execute before this one) + - name: disable_objects + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + A list of object tags to disable. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: enable_objects + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + A list of object tags to enable. + - name: end_time + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The time at which the objects are to be enable/disabled. + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: reverse_on_false + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When true, the disable/enable lists are set to opposite values when the specified condition is false. + - name: set_sync_times + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set the start and end time as execute sync times. + - name: start_time + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The time at which the objects are to be enabled/disabled. + - name: type + required: No + default: !!str TimePeriod + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: +- name: /DGKernels + description: | + + parameters: + subblocks: + - name: /DGKernels/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /DGKernels/ADDGDiffusion + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: diff + required: No + default: !!str 1 + cpp_type: MaterialPropertyName + group_name: + description: | + The diffusion (or thermal electrical_conductivity or viscosity) coefficient. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: epsilon + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + epsilon + - name: exclude_boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The internal side sets to be excluded from this kernel. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: sigma + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + sigma + - name: type + required: No + default: !!str ADDGDiffusion + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /DGKernels/ArrayDGDiffusion + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: diff + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The diffusion (or thermal electrical_conductivity or viscosity) coefficient. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: epsilon + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + epsilon + - name: exclude_boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The internal side sets to be excluded from this kernel. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: sigma + required: No + default: !!str 4 + cpp_type: double + group_name: + description: | + sigma + - name: type + required: No + default: !!str ArrayDGDiffusion + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /DGKernels/DGConvection + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: exclude_boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The internal side sets to be excluded from this kernel. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: type + required: No + default: !!str DGConvection + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + - name: velocity + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + Velocity vector + subblocks: + - name: /DGKernels/DGDiffusion + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: diff + required: No + default: !!str 1 + cpp_type: MaterialPropertyName + group_name: + description: | + The diffusion (or thermal electrical_conductivity or viscosity) coefficient. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: epsilon + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + epsilon + - name: exclude_boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The internal side sets to be excluded from this kernel. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: sigma + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + sigma + - name: type + required: No + default: !!str DGDiffusion + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: +- name: /Dampers + description: | + + parameters: + subblocks: + - name: /Dampers/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /Dampers/BoundingValueElementDamper + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: max_value + required: No + default: !!str 1.79769e+308 + cpp_type: double + group_name: + description: | + The maximum permissible iterative value for the variable. + - name: min_damping + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Minimum value of computed damping. Damping lower than this will result in an exception being thrown and cutting the time step + - name: min_value + required: No + default: !!str -1.79769e+308 + cpp_type: double + group_name: + description: | + The minimum permissible iterative value for the variable. + - name: type + required: No + default: !!str BoundingValueElementDamper + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this damper operates on + subblocks: + - name: /Dampers/BoundingValueNodalDamper + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: max_value + required: No + default: !!str 1.79769e+308 + cpp_type: double + group_name: + description: | + The maximum permissible iterative value for the variable. + - name: min_damping + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Minimum value of computed damping. Damping lower than this will result in an exception being thrown and cutting the time step + - name: min_value + required: No + default: !!str -1.79769e+308 + cpp_type: double + group_name: + description: | + The minimum permissible iterative value for the variable. + - name: type + required: No + default: !!str BoundingValueNodalDamper + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this damper operates on + subblocks: + - name: /Dampers/ConstantDamper + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: damping + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The percentage (between 0 and 1) of the newton update to take. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: min_damping + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Minimum value of computed damping. Damping lower than this will result in an exception being thrown and cutting the time step + - name: type + required: No + default: !!str ConstantDamper + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Dampers/MaxIncrement + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: increment_type + required: No + default: !!str absolute + cpp_type: MooseEnum + group_name: + options: absolute fractional + description: | + Type of increment to compare against max_increment. 'absolute': use variable increment. 'fractional': use variable increment divided by the variable value. + - name: max_increment + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The maximum newton increment for the variable. + - name: min_damping + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Minimum value of computed damping. Damping lower than this will result in an exception being thrown and cutting the time step + - name: type + required: No + default: !!str MaxIncrement + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this damper operates on + subblocks: +- name: /Debug + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: show_actions + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Print out the actions being executed + - name: show_material_props + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Print out the material properties supplied for each block, face, neighbor, and/or sideset + - name: show_parser + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Shows parser block extraction and debugging information + - name: show_top_residuals + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The number of top residuals to print out (0 = no output) + - name: show_var_residual_norms + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Print the residual norms of the individual solution variables at each nonlinear iteration + - name: show_var_residual + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Variables for which residuals will be sent to the output file. + subblocks: + - name: /Debug/MaterialDerivativeTest + description: | + + parameters: + subblocks: + - name: /Debug/MaterialDerivativeTest/* + description: | + + parameters: + - name: args + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Variables the tested material property depends on. + - name: derivative_order + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + Highest order derivative to test derivatives of. + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: prop_name + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + Name of the material property to test the derivatives of. + - name: prop_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: Real RankTwoTensor RankFourTensor + description: | + Type of the material property to test the derivatives of. + subblocks: +- name: /DeprecatedBlock + description: | + + parameters: + - name: DEPRECATED + required: No + default: !!str + cpp_type: bool + group_name: + description: | + *** WARNING: This block is deprecated - DO NOT USE *** + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + subblocks: +- name: /DiracKernels + description: | + + parameters: + subblocks: + - name: /DiracKernels/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /DiracKernels/ConstantPointSource + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: drop_duplicate_points + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + By default points added to a DiracKernel are dropped if a point at the same locationhas been added before. If this option is set to false duplicate points are retainedand contribute to residual and Jacobian. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: point + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The x,y,z coordinates of the point + - name: type + required: No + default: !!str ConstantPointSource + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The value of the point source + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /DiracKernels/FunctionDiracSource + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: drop_duplicate_points + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + By default points added to a DiracKernel are dropped if a point at the same locationhas been added before. If this option is set to false duplicate points are retainedand contribute to residual and Jacobian. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The function to use for controlling the specified dirac source. + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: point + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + The x,y,z coordinates of the point + - name: type + required: No + default: !!str FunctionDiracSource + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: +- name: /Distributions + description: | + + parameters: + subblocks: + - name: /Distributions/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: +- name: /Executioner + description: | + + parameters: + - name: auto_preconditioning + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When true and a [Preconditioning] block does not exist, the application will attempt to use the correct preconditioning given the Executioner settings. + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /Executioner/ + description: | + + parameters: + subblocks: + - name: /Executioner//Eigenvalue + description: | + + parameters: + - name: accept_on_max_picard_iteration + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Picard' + description: | + True to treat reaching the maximum number of Picard iterations as converged. + - name: automatic_scaling + required: No + default: !!str + cpp_type: bool + group_name: 'Solver' + description: | + Whether to use automatic scaling for the variables. + - name: compute_initial_residual_before_preset_bcs + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Solver' + description: | + Use the residual norm computed *before* preset BCs are imposed in relative convergence check + - name: compute_scaling_once + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Solver' + description: | + Whether the scaling factors should only be computed once at the beginning of the simulation through an extra Jacobian evaluation. If this is set to false, then the scaling factors will be computed during an extra Jacobian evaluation at the beginning of every time step. + - name: contact_line_search_allowed_lambda_cuts + required: No + default: !!str 2 + cpp_type: unsigned int + group_name: + description: | + The number of times lambda is allowed to be cut in half in the contact line search. We recommend this number be roughly bounded by 0 <= allowed_lambda_cuts <= 3 + - name: contact_line_search_ltol + required: No + default: !!str + cpp_type: double + group_name: + description: | + The linear relative tolerance to be used while the contact state is changing between non-linear iterations. We recommend that this tolerance be looser than the standard linear tolerance + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: custom_abs_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: + description: | + The absolute nonlinear residual to shoot for during Picard iterations. This check is performed based on postprocessor defined by picard_custom_pp residual. + - name: custom_rel_tol + required: No + default: !!str 1e-08 + cpp_type: double + group_name: + description: | + The relative nonlinear residual drop to shoot for during Picard iterations. This check is performed based on postprocessor defined by picard_custom_pp residual. + - name: direct_pp_value + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use direct postprocessor value (scaled by value on first iteration). False (default) to use difference in postprocessor value between picard iterations. + - name: disable_picard_residual_norm_check + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Picard' + description: | + Disable the Picard residual norm evaluation thus the three parameters picard_rel_tol, picard_abs_tol and picard_force_norms. + - name: eigen_max_its + required: No + default: !!str 10000 + cpp_type: unsigned int + group_name: + description: | + Max Iterations for Eigen Solver + - name: eigen_problem_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: HERMITIAN NON_HERMITIAN GEN_HERMITIAN GEN_NON_HERMITIAN GEN_INDEFINITE POS_GEN_NON_HERMITIAN SLEPC_DEFAULT + description: | + Type of the eigenvalue problem we are solving HERMITIAN: Hermitian NON_HERMITIAN: Non-Hermitian GEN_HERMITIAN: Generalized Hermitian GEN_NON_HERMITIAN: Generalized Non-Hermitian GEN_INDEFINITE: Generalized indefinite Hermitian POS_GEN_NON_HERMITIAN: Generalized Non-Hermitian with positive (semi-)definite B SLEPC_DEFAULT: Use whatever SLEPC has by default + - name: eigen_tol + required: No + default: !!str 0.0001 + cpp_type: double + group_name: + description: | + Relative Tolerance for Eigen Solver + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: free_power_iterations + required: No + default: !!str 4 + cpp_type: unsigned int + group_name: + description: | + The number of free power iterations + - name: l_abs_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: + description: | + Absolute Tolerances for Linear Solver + - name: l_max_its + required: No + default: !!str 10000 + cpp_type: unsigned int + group_name: 'Solver' + description: | + Max Linear Iterations + - name: l_tol + required: No + default: !!str 0.01 + cpp_type: double + group_name: 'Solver' + description: | + Linear Tolerance + - name: line_search + required: No + default: !!str default + cpp_type: MooseEnum + group_name: + options: basic bt contact cp default l2 none project shell + description: | + Specifies the line search type (Note: none = basic) + - name: line_search_package + required: No + default: !!str petsc + cpp_type: MooseEnum + group_name: + options: petsc moose + description: | + The solver package to use to conduct the line-search + - name: matrix_free + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use a matrix free fashion to form operators. If true, shell matrices will be used and meanwhile a preconditioning matrixmay be formed as well. + - name: max_xfem_update + required: No + default: !!str 4294967295 + cpp_type: unsigned int + group_name: + description: | + Maximum number of times to update XFEM crack topology in a step due to evolving cracks + - name: mffd_type + required: No + default: !!str wp + cpp_type: MooseEnum + group_name: + options: wp ds + description: | + Specifies the finite differencing type for Jacobian-free solve types. Note that the default is wp (for Walker and Pernice). + - name: n_basis_vectors + required: No + default: !!str 3 + cpp_type: unsigned int + group_name: + description: | + The dimension of eigen subspaces + - name: n_eigen_pairs + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + The number of eigen pairs + - name: nl_abs_step_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Solver' + description: | + Nonlinear Absolute step Tolerance + - name: nl_abs_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Solver' + description: | + Nonlinear Absolute Tolerance + - name: nl_div_tol + required: No + default: !!str -1 + cpp_type: double + group_name: + description: | + Nonlinear Divergence Tolerance + - name: nl_max_funcs + required: No + default: !!str 10000 + cpp_type: unsigned int + group_name: 'Solver' + description: | + Max Nonlinear solver function evaluations + - name: nl_max_its + required: No + default: !!str 50 + cpp_type: unsigned int + group_name: 'Solver' + description: | + Max Nonlinear Iterations + - name: nl_rel_step_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Solver' + description: | + Nonlinear Relative step Tolerance + - name: nl_rel_tol + required: No + default: !!str 1e-08 + cpp_type: double + group_name: 'Solver' + description: | + Nonlinear Relative Tolerance + - name: normal_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Normalize eigenvector to make a defined norm equal to this factor + - name: normalization + required: No + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + Postprocessor evaluating norm of eigenvector for normalization + - name: num_grids + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Solver' + description: | + The number of grids to use for a grid sequencing algorithm. This includes the final grid, so num_grids = 1 indicates just one solve in a time-step + - name: petsc_options + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: -dm_moose_print_embedding -dm_view -ksp_converged_reason -ksp_gmres_modifiedgramschmidt -ksp_monitor -ksp_monitor_snes_lg-snes_ksp_ew -ksp_snes_ew -snes_converged_reason -snes_ksp -snes_ksp_ew -snes_linesearch_monitor -snes_mf -snes_mf_operator -snes_monitor -snes_test_display -snes_view + description: | + Singleton PETSc options + - name: petsc_options_iname + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: -ksp_atol -ksp_gmres_restart -ksp_max_it -ksp_pc_side -ksp_rtol -ksp_type -mat_fd_coloring_err -mat_fd_type -mat_mffd_type -pc_asm_overlap -pc_factor_levels -pc_factor_mat_ordering_type -pc_hypre_boomeramg_grid_sweeps_all -pc_hypre_boomeramg_max_iter -pc_hypre_boomeramg_strong_threshold -pc_hypre_type -pc_type -snes_atol -snes_linesearch_type -snes_ls -snes_max_it -snes_rtol -snes_divergence_tolerance -snes_type -sub_ksp_type -sub_pc_type + description: | + Names of PETSc name/value pairs + - name: petsc_options_value + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Values of PETSc name/value pairs (must correspond with "petsc_options_iname" + - name: picard_abs_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Picard' + description: | + The absolute nonlinear residual to shoot for during Picard iterations. This check is performed based on the Master app's nonlinear residual. + - name: picard_custom_pp + required: No + default: !!str + cpp_type: PostprocessorName + group_name: 'Picard' + description: | + Postprocessor for custom picard convergence check. + - name: picard_force_norms + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Picard' + description: | + Force the evaluation of both the TIMESTEP_BEGIN and TIMESTEP_END norms regardless of the existance of active MultiApps with those execute_on flags, default: false. + - name: picard_max_its + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Picard' + description: | + Specifies the maximum number of Picard iterations. Mainly used when wanting to do Picard iterations with MultiApps that are set to execute_on timestep_end or timestep_begin. Setting this parameter to 1 turns off the Picard iterations. + - name: picard_rel_tol + required: No + default: !!str 1e-08 + cpp_type: double + group_name: 'Picard' + description: | + The relative nonlinear residual drop to shoot for during Picard iterations. This check is performed based on the Master app's nonlinear residual. + - name: precond_matrix_free + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use a matrix free fashion for forming the preconditioning matrix. If true, a shell matrix will be used for preconditioner. + - name: precond_matrix_includes_eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to include eigen kernels in the preconditioning matrix. If true, the preconditioning matrix will include eigen kernels. + - name: relaxation_factor + required: No + default: !!str 1 + cpp_type: double + group_name: 'Picard' + description: | + Fraction of newly computed value to keep.Set between 0 and 2. + - name: relaxed_variables + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Picard' + description: | + List of variables to relax during Picard Iteration + - name: resid_vs_jac_scaling_param + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + A parameter that indicates the weighting of the residual vs the Jacobian in determining variable scaling parameters. A value of 1 indicates pure residual-based scaling. A value of 0 indicates pure Jacobian-based scaling + - name: restart_file_base + required: No + default: !!str + cpp_type: FileNameNoExtension + group_name: 'Restart' + description: | + File base name used for restart + - name: scaling_group_variables + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > >, std::allocator, std::allocator >, std::allocator, std::allocator > > > > > + group_name: + description: | + Name of variables that are grouped together to for determing scale factors. (Multiple groups can be provided, separated by semicolon) + - name: skip_exception_check + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether or not to skip exception check + - name: snesmf_reuse_base + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Solver' + description: | + Specifies whether or not to reuse the base vector for matrix-free calculation + - name: solve_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: POWER ARNOLDI KRYLOVSCHUR JACOBI_DAVIDSON NONLINEAR_POWER NEWTON + description: | + POWER: Power / Inverse / RQI ARNOLDI: Arnoldi KRYLOVSCHUR: Krylov-Schur JACOBI_DAVIDSON: Jacobi-Davidson NONLINEAR_POWER: Nonlinear Power NEWTON: Newton + - name: splitting + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Top-level splitting defining a hierarchical decomposition into subsystems to help the solver. + - name: time + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + System time + - name: type + required: No + default: !!str Eigenvalue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: update_xfem_at_timestep_begin + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Should XFEM update the mesh at the beginning of the timestep + - name: verbose + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true to print additional information + - name: which_eigen_pairs + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: LARGEST_MAGNITUDE SMALLEST_MAGNITUDE LARGEST_REAL SMALLEST_REAL LARGEST_IMAGINARY SMALLEST_IMAGINARY TARGET_MAGNITUDE TARGET_REAL TARGET_IMAGINARY ALL_EIGENVALUES SLEPC_DEFAULT + description: | + Which eigenvalue pairs to obtain from the solution LARGEST_MAGNITUDE SMALLEST_MAGNITUDE LARGEST_REAL SMALLEST_REAL LARGEST_IMAGINARY SMALLEST_IMAGINARY TARGET_MAGNITUDE TARGET_REAL TARGET_IMAGINARY ALL_EIGENVALUES SLEPC_DEFAULT + subblocks: + - name: /Executioner//InversePowerMethod + description: | + + parameters: + - name: Chebyshev_acceleration_on + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If Chebyshev acceleration is turned on + - name: accept_on_max_picard_iteration + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Picard' + description: | + True to treat reaching the maximum number of Picard iterations as converged. + - name: auto_initialization + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + True to ask the solver to set initial + - name: automatic_scaling + required: No + default: !!str + cpp_type: bool + group_name: 'Solver' + description: | + Whether to use automatic scaling for the variables. + - name: bx_norm + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + To evaluate |Bx| for the eigenvalue + - name: compute_initial_residual_before_preset_bcs + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Solver' + description: | + Use the residual norm computed *before* preset BCs are imposed in relative convergence check + - name: compute_scaling_once + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Solver' + description: | + Whether the scaling factors should only be computed once at the beginning of the simulation through an extra Jacobian evaluation. If this is set to false, then the scaling factors will be computed during an extra Jacobian evaluation at the beginning of every time step. + - name: contact_line_search_allowed_lambda_cuts + required: No + default: !!str 2 + cpp_type: unsigned int + group_name: + description: | + The number of times lambda is allowed to be cut in half in the contact line search. We recommend this number be roughly bounded by 0 <= allowed_lambda_cuts <= 3 + - name: contact_line_search_ltol + required: No + default: !!str + cpp_type: double + group_name: + description: | + The linear relative tolerance to be used while the contact state is changing between non-linear iterations. We recommend that this tolerance be looser than the standard linear tolerance + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: custom_abs_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: + description: | + The absolute nonlinear residual to shoot for during Picard iterations. This check is performed based on postprocessor defined by picard_custom_pp residual. + - name: custom_rel_tol + required: No + default: !!str 1e-08 + cpp_type: double + group_name: + description: | + The relative nonlinear residual drop to shoot for during Picard iterations. This check is performed based on postprocessor defined by picard_custom_pp residual. + - name: direct_pp_value + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use direct postprocessor value (scaled by value on first iteration). False (default) to use difference in postprocessor value between picard iterations. + - name: disable_picard_residual_norm_check + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Picard' + description: | + Disable the Picard residual norm evaluation thus the three parameters picard_rel_tol, picard_abs_tol and picard_force_norms. + - name: eig_check_tol + required: No + default: !!str 1e-06 + cpp_type: double + group_name: + description: | + Eigenvalue convergence tolerance + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: k0 + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Initial guess of the eigenvalue + - name: l_abs_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Solver' + description: | + Linear Absolute Tolerance + - name: l_max_its + required: No + default: !!str 10000 + cpp_type: unsigned int + group_name: 'Solver' + description: | + Max Linear Iterations + - name: l_tol + required: No + default: !!str 0.01 + cpp_type: double + group_name: 'Solver' + description: | + Linear Tolerance + - name: line_search + required: No + default: !!str default + cpp_type: MooseEnum + group_name: + options: basic bt contact cp default l2 none project shell + description: | + Specifies the line search type (Note: none = basic) + - name: line_search_package + required: No + default: !!str petsc + cpp_type: MooseEnum + group_name: + options: petsc moose + description: | + The solver package to use to conduct the line-search + - name: max_power_iterations + required: No + default: !!str 300 + cpp_type: unsigned int + group_name: + description: | + The maximum number of power iterations + - name: max_xfem_update + required: No + default: !!str 4294967295 + cpp_type: unsigned int + group_name: + description: | + Maximum number of times to update XFEM crack topology in a step due to evolving cracks + - name: mffd_type + required: No + default: !!str wp + cpp_type: MooseEnum + group_name: + options: wp ds + description: | + Specifies the finite differencing type for Jacobian-free solve types. Note that the default is wp (for Walker and Pernice). + - name: min_power_iterations + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Minimum number of power iterations + - name: nl_abs_step_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Solver' + description: | + Nonlinear Absolute step Tolerance + - name: nl_abs_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Solver' + description: | + Nonlinear Absolute Tolerance + - name: nl_div_tol + required: No + default: !!str -1 + cpp_type: double + group_name: + description: | + Nonlinear Divergence Tolerance + - name: nl_max_funcs + required: No + default: !!str 10000 + cpp_type: unsigned int + group_name: 'Solver' + description: | + Max Nonlinear solver function evaluations + - name: nl_max_its + required: No + default: !!str 50 + cpp_type: unsigned int + group_name: 'Solver' + description: | + Max Nonlinear Iterations + - name: nl_rel_step_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Solver' + description: | + Nonlinear Relative step Tolerance + - name: nl_rel_tol + required: No + default: !!str 1e-08 + cpp_type: double + group_name: 'Solver' + description: | + Nonlinear Relative Tolerance + - name: normal_factor + required: No + default: !!str + cpp_type: double + group_name: 'Normalization' + description: | + Normalize x to make |x| equal to this factor + - name: normalization + required: No + default: !!str + cpp_type: PostprocessorName + group_name: 'Normalization' + description: | + To evaluate |x| for normalization + - name: num_grids + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Solver' + description: | + The number of grids to use for a grid sequencing algorithm. This includes the final grid, so num_grids = 1 indicates just one solve in a time-step + - name: output_before_normalization + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Normalization' + description: | + True to output a step before normalization + - name: petsc_options + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: -dm_moose_print_embedding -dm_view -ksp_converged_reason -ksp_gmres_modifiedgramschmidt -ksp_monitor -ksp_monitor_snes_lg-snes_ksp_ew -ksp_snes_ew -snes_converged_reason -snes_ksp -snes_ksp_ew -snes_linesearch_monitor -snes_mf -snes_mf_operator -snes_monitor -snes_test_display -snes_view + description: | + Singleton PETSc options + - name: petsc_options_iname + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: -ksp_atol -ksp_gmres_restart -ksp_max_it -ksp_pc_side -ksp_rtol -ksp_type -mat_fd_coloring_err -mat_fd_type -mat_mffd_type -pc_asm_overlap -pc_factor_levels -pc_factor_mat_ordering_type -pc_hypre_boomeramg_grid_sweeps_all -pc_hypre_boomeramg_max_iter -pc_hypre_boomeramg_strong_threshold -pc_hypre_type -pc_type -snes_atol -snes_linesearch_type -snes_ls -snes_max_it -snes_rtol -snes_divergence_tolerance -snes_type -sub_ksp_type -sub_pc_type + description: | + Names of PETSc name/value pairs + - name: petsc_options_value + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Values of PETSc name/value pairs (must correspond with "petsc_options_iname" + - name: picard_abs_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Picard' + description: | + The absolute nonlinear residual to shoot for during Picard iterations. This check is performed based on the Master app's nonlinear residual. + - name: picard_custom_pp + required: No + default: !!str + cpp_type: PostprocessorName + group_name: 'Picard' + description: | + Postprocessor for custom picard convergence check. + - name: picard_force_norms + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Picard' + description: | + Force the evaluation of both the TIMESTEP_BEGIN and TIMESTEP_END norms regardless of the existance of active MultiApps with those execute_on flags, default: false. + - name: picard_max_its + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Picard' + description: | + Specifies the maximum number of Picard iterations. Mainly used when wanting to do Picard iterations with MultiApps that are set to execute_on timestep_end or timestep_begin. Setting this parameter to 1 turns off the Picard iterations. + - name: picard_rel_tol + required: No + default: !!str 1e-08 + cpp_type: double + group_name: 'Picard' + description: | + The relative nonlinear residual drop to shoot for during Picard iterations. This check is performed based on the Master app's nonlinear residual. + - name: relaxation_factor + required: No + default: !!str 1 + cpp_type: double + group_name: 'Picard' + description: | + Fraction of newly computed value to keep.Set between 0 and 2. + - name: relaxed_variables + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Picard' + description: | + List of variables to relax during Picard Iteration + - name: resid_vs_jac_scaling_param + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + A parameter that indicates the weighting of the residual vs the Jacobian in determining variable scaling parameters. A value of 1 indicates pure residual-based scaling. A value of 0 indicates pure Jacobian-based scaling + - name: restart_file_base + required: No + default: !!str + cpp_type: FileNameNoExtension + group_name: 'Restart' + description: | + File base name used for restart + - name: scaling_group_variables + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > >, std::allocator, std::allocator >, std::allocator, std::allocator > > > > > + group_name: + description: | + Name of variables that are grouped together to for determing scale factors. (Multiple groups can be provided, separated by semicolon) + - name: skip_exception_check + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether or not to skip exception check + - name: snesmf_reuse_base + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Solver' + description: | + Specifies whether or not to reuse the base vector for matrix-free calculation + - name: sol_check_tol + required: No + default: !!str 1.79769e+308 + cpp_type: double + group_name: + description: | + Convergence tolerance on |x-x_previous| when provided + - name: solve_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: PJFNK JFNK NEWTON FD LINEAR + description: | + PJFNK: Preconditioned Jacobian-Free Newton Krylov JFNK: Jacobian-Free Newton Krylov NEWTON: Full Newton Solve FD: Use finite differences to compute Jacobian LINEAR: Solving a linear problem + - name: splitting + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Top-level splitting defining a hierarchical decomposition into subsystems to help the solver. + - name: time + required: No + default: !!str 0 + cpp_type: double + group_name: 'Advanced' + description: | + System time + - name: type + required: No + default: !!str InversePowerMethod + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: update_xfem_at_timestep_begin + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Should XFEM update the mesh at the beginning of the timestep + - name: verbose + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true to print additional information + - name: xdiff + required: No + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + To evaluate |x-x_previous| for power iterations + subblocks: + - name: /Executioner//NonlinearEigen + description: | + + parameters: + - name: accept_on_max_picard_iteration + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Picard' + description: | + True to treat reaching the maximum number of Picard iterations as converged. + - name: auto_initialization + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + True to ask the solver to set initial + - name: automatic_scaling + required: No + default: !!str + cpp_type: bool + group_name: 'Solver' + description: | + Whether to use automatic scaling for the variables. + - name: bx_norm + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + To evaluate |Bx| for the eigenvalue + - name: compute_initial_residual_before_preset_bcs + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Solver' + description: | + Use the residual norm computed *before* preset BCs are imposed in relative convergence check + - name: compute_scaling_once + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Solver' + description: | + Whether the scaling factors should only be computed once at the beginning of the simulation through an extra Jacobian evaluation. If this is set to false, then the scaling factors will be computed during an extra Jacobian evaluation at the beginning of every time step. + - name: contact_line_search_allowed_lambda_cuts + required: No + default: !!str 2 + cpp_type: unsigned int + group_name: + description: | + The number of times lambda is allowed to be cut in half in the contact line search. We recommend this number be roughly bounded by 0 <= allowed_lambda_cuts <= 3 + - name: contact_line_search_ltol + required: No + default: !!str + cpp_type: double + group_name: + description: | + The linear relative tolerance to be used while the contact state is changing between non-linear iterations. We recommend that this tolerance be looser than the standard linear tolerance + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: custom_abs_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: + description: | + The absolute nonlinear residual to shoot for during Picard iterations. This check is performed based on postprocessor defined by picard_custom_pp residual. + - name: custom_rel_tol + required: No + default: !!str 1e-08 + cpp_type: double + group_name: + description: | + The relative nonlinear residual drop to shoot for during Picard iterations. This check is performed based on postprocessor defined by picard_custom_pp residual. + - name: direct_pp_value + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use direct postprocessor value (scaled by value on first iteration). False (default) to use difference in postprocessor value between picard iterations. + - name: disable_picard_residual_norm_check + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Picard' + description: | + Disable the Picard residual norm evaluation thus the three parameters picard_rel_tol, picard_abs_tol and picard_force_norms. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: free_l_tol + required: No + default: !!str 0.01 + cpp_type: double + group_name: + description: | + Relative linear tolerance in free power iteration + - name: free_power_iterations + required: No + default: !!str 4 + cpp_type: unsigned int + group_name: + description: | + The number of free power iterations + - name: k0 + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Initial guess of the eigenvalue + - name: l_abs_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Solver' + description: | + Linear Absolute Tolerance + - name: l_max_its + required: No + default: !!str 10000 + cpp_type: unsigned int + group_name: 'Solver' + description: | + Max Linear Iterations + - name: l_tol + required: No + default: !!str 0.01 + cpp_type: double + group_name: 'Solver' + description: | + Linear Tolerance + - name: line_search + required: No + default: !!str default + cpp_type: MooseEnum + group_name: + options: basic bt contact cp default l2 none project shell + description: | + Specifies the line search type (Note: none = basic) + - name: line_search_package + required: No + default: !!str petsc + cpp_type: MooseEnum + group_name: + options: petsc moose + description: | + The solver package to use to conduct the line-search + - name: max_xfem_update + required: No + default: !!str 4294967295 + cpp_type: unsigned int + group_name: + description: | + Maximum number of times to update XFEM crack topology in a step due to evolving cracks + - name: mffd_type + required: No + default: !!str wp + cpp_type: MooseEnum + group_name: + options: wp ds + description: | + Specifies the finite differencing type for Jacobian-free solve types. Note that the default is wp (for Walker and Pernice). + - name: nl_abs_step_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Solver' + description: | + Nonlinear Absolute step Tolerance + - name: nl_abs_tol + required: No + default: !!str 1e-06 + cpp_type: double + group_name: 'Solver' + description: | + Nonlinear Absolute Tolerance + - name: nl_div_tol + required: No + default: !!str -1 + cpp_type: double + group_name: + description: | + Nonlinear Divergence Tolerance + - name: nl_max_funcs + required: No + default: !!str 10000 + cpp_type: unsigned int + group_name: 'Solver' + description: | + Max Nonlinear solver function evaluations + - name: nl_max_its + required: No + default: !!str 50 + cpp_type: unsigned int + group_name: 'Solver' + description: | + Max Nonlinear Iterations + - name: nl_rel_step_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Solver' + description: | + Nonlinear Relative step Tolerance + - name: nl_rel_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Solver' + description: | + Nonlinear Relative Tolerance + - name: normal_factor + required: No + default: !!str + cpp_type: double + group_name: 'Normalization' + description: | + Normalize x to make |x| equal to this factor + - name: normalization + required: No + default: !!str + cpp_type: PostprocessorName + group_name: 'Normalization' + description: | + To evaluate |x| for normalization + - name: num_grids + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Solver' + description: | + The number of grids to use for a grid sequencing algorithm. This includes the final grid, so num_grids = 1 indicates just one solve in a time-step + - name: output_after_power_iterations + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + True to output solution after free power iterations + - name: output_before_normalization + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Normalization' + description: | + True to output a step before normalization + - name: petsc_options + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: -dm_moose_print_embedding -dm_view -ksp_converged_reason -ksp_gmres_modifiedgramschmidt -ksp_monitor -ksp_monitor_snes_lg-snes_ksp_ew -ksp_snes_ew -snes_converged_reason -snes_ksp -snes_ksp_ew -snes_linesearch_monitor -snes_mf -snes_mf_operator -snes_monitor -snes_test_display -snes_view + description: | + Singleton PETSc options + - name: petsc_options_iname + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: -ksp_atol -ksp_gmres_restart -ksp_max_it -ksp_pc_side -ksp_rtol -ksp_type -mat_fd_coloring_err -mat_fd_type -mat_mffd_type -pc_asm_overlap -pc_factor_levels -pc_factor_mat_ordering_type -pc_hypre_boomeramg_grid_sweeps_all -pc_hypre_boomeramg_max_iter -pc_hypre_boomeramg_strong_threshold -pc_hypre_type -pc_type -snes_atol -snes_linesearch_type -snes_ls -snes_max_it -snes_rtol -snes_divergence_tolerance -snes_type -sub_ksp_type -sub_pc_type + description: | + Names of PETSc name/value pairs + - name: petsc_options_value + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Values of PETSc name/value pairs (must correspond with "petsc_options_iname" + - name: picard_abs_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Picard' + description: | + The absolute nonlinear residual to shoot for during Picard iterations. This check is performed based on the Master app's nonlinear residual. + - name: picard_custom_pp + required: No + default: !!str + cpp_type: PostprocessorName + group_name: 'Picard' + description: | + Postprocessor for custom picard convergence check. + - name: picard_force_norms + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Picard' + description: | + Force the evaluation of both the TIMESTEP_BEGIN and TIMESTEP_END norms regardless of the existance of active MultiApps with those execute_on flags, default: false. + - name: picard_max_its + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Picard' + description: | + Specifies the maximum number of Picard iterations. Mainly used when wanting to do Picard iterations with MultiApps that are set to execute_on timestep_end or timestep_begin. Setting this parameter to 1 turns off the Picard iterations. + - name: picard_rel_tol + required: No + default: !!str 1e-08 + cpp_type: double + group_name: 'Picard' + description: | + The relative nonlinear residual drop to shoot for during Picard iterations. This check is performed based on the Master app's nonlinear residual. + - name: relaxation_factor + required: No + default: !!str 1 + cpp_type: double + group_name: 'Picard' + description: | + Fraction of newly computed value to keep.Set between 0 and 2. + - name: relaxed_variables + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Picard' + description: | + List of variables to relax during Picard Iteration + - name: resid_vs_jac_scaling_param + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + A parameter that indicates the weighting of the residual vs the Jacobian in determining variable scaling parameters. A value of 1 indicates pure residual-based scaling. A value of 0 indicates pure Jacobian-based scaling + - name: restart_file_base + required: No + default: !!str + cpp_type: FileNameNoExtension + group_name: 'Restart' + description: | + File base name used for restart + - name: scaling_group_variables + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > >, std::allocator, std::allocator >, std::allocator, std::allocator > > > > > + group_name: + description: | + Name of variables that are grouped together to for determing scale factors. (Multiple groups can be provided, separated by semicolon) + - name: skip_exception_check + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether or not to skip exception check + - name: snesmf_reuse_base + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Solver' + description: | + Specifies whether or not to reuse the base vector for matrix-free calculation + - name: solve_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: PJFNK JFNK NEWTON FD LINEAR + description: | + PJFNK: Preconditioned Jacobian-Free Newton Krylov JFNK: Jacobian-Free Newton Krylov NEWTON: Full Newton Solve FD: Use finite differences to compute Jacobian LINEAR: Solving a linear problem + - name: splitting + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Top-level splitting defining a hierarchical decomposition into subsystems to help the solver. + - name: time + required: No + default: !!str 0 + cpp_type: double + group_name: 'Advanced' + description: | + System time + - name: type + required: No + default: !!str NonlinearEigen + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: update_xfem_at_timestep_begin + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Should XFEM update the mesh at the beginning of the timestep + - name: verbose + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true to print additional information + subblocks: + - name: /Executioner//Steady + description: | + + parameters: + - name: accept_on_max_picard_iteration + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Picard' + description: | + True to treat reaching the maximum number of Picard iterations as converged. + - name: automatic_scaling + required: No + default: !!str + cpp_type: bool + group_name: 'Solver' + description: | + Whether to use automatic scaling for the variables. + - name: compute_initial_residual_before_preset_bcs + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Solver' + description: | + Use the residual norm computed *before* preset BCs are imposed in relative convergence check + - name: compute_scaling_once + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Solver' + description: | + Whether the scaling factors should only be computed once at the beginning of the simulation through an extra Jacobian evaluation. If this is set to false, then the scaling factors will be computed during an extra Jacobian evaluation at the beginning of every time step. + - name: contact_line_search_allowed_lambda_cuts + required: No + default: !!str 2 + cpp_type: unsigned int + group_name: + description: | + The number of times lambda is allowed to be cut in half in the contact line search. We recommend this number be roughly bounded by 0 <= allowed_lambda_cuts <= 3 + - name: contact_line_search_ltol + required: No + default: !!str + cpp_type: double + group_name: + description: | + The linear relative tolerance to be used while the contact state is changing between non-linear iterations. We recommend that this tolerance be looser than the standard linear tolerance + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: custom_abs_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: + description: | + The absolute nonlinear residual to shoot for during Picard iterations. This check is performed based on postprocessor defined by picard_custom_pp residual. + - name: custom_rel_tol + required: No + default: !!str 1e-08 + cpp_type: double + group_name: + description: | + The relative nonlinear residual drop to shoot for during Picard iterations. This check is performed based on postprocessor defined by picard_custom_pp residual. + - name: direct_pp_value + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use direct postprocessor value (scaled by value on first iteration). False (default) to use difference in postprocessor value between picard iterations. + - name: disable_picard_residual_norm_check + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Picard' + description: | + Disable the Picard residual norm evaluation thus the three parameters picard_rel_tol, picard_abs_tol and picard_force_norms. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: l_abs_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Solver' + description: | + Linear Absolute Tolerance + - name: l_max_its + required: No + default: !!str 10000 + cpp_type: unsigned int + group_name: 'Solver' + description: | + Max Linear Iterations + - name: l_tol + required: No + default: !!str 1e-05 + cpp_type: double + group_name: 'Solver' + description: | + Linear Tolerance + - name: line_search + required: No + default: !!str default + cpp_type: MooseEnum + group_name: + options: basic bt contact cp default l2 none project shell + description: | + Specifies the line search type (Note: none = basic) + - name: line_search_package + required: No + default: !!str petsc + cpp_type: MooseEnum + group_name: + options: petsc moose + description: | + The solver package to use to conduct the line-search + - name: max_xfem_update + required: No + default: !!str 4294967295 + cpp_type: unsigned int + group_name: + description: | + Maximum number of times to update XFEM crack topology in a step due to evolving cracks + - name: mffd_type + required: No + default: !!str wp + cpp_type: MooseEnum + group_name: + options: wp ds + description: | + Specifies the finite differencing type for Jacobian-free solve types. Note that the default is wp (for Walker and Pernice). + - name: nl_abs_step_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Solver' + description: | + Nonlinear Absolute step Tolerance + - name: nl_abs_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Solver' + description: | + Nonlinear Absolute Tolerance + - name: nl_div_tol + required: No + default: !!str -1 + cpp_type: double + group_name: + description: | + Nonlinear Divergence Tolerance + - name: nl_max_funcs + required: No + default: !!str 10000 + cpp_type: unsigned int + group_name: 'Solver' + description: | + Max Nonlinear solver function evaluations + - name: nl_max_its + required: No + default: !!str 50 + cpp_type: unsigned int + group_name: 'Solver' + description: | + Max Nonlinear Iterations + - name: nl_rel_step_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Solver' + description: | + Nonlinear Relative step Tolerance + - name: nl_rel_tol + required: No + default: !!str 1e-08 + cpp_type: double + group_name: 'Solver' + description: | + Nonlinear Relative Tolerance + - name: num_grids + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Solver' + description: | + The number of grids to use for a grid sequencing algorithm. This includes the final grid, so num_grids = 1 indicates just one solve in a time-step + - name: petsc_options + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: -dm_moose_print_embedding -dm_view -ksp_converged_reason -ksp_gmres_modifiedgramschmidt -ksp_monitor -ksp_monitor_snes_lg-snes_ksp_ew -ksp_snes_ew -snes_converged_reason -snes_ksp -snes_ksp_ew -snes_linesearch_monitor -snes_mf -snes_mf_operator -snes_monitor -snes_test_display -snes_view + description: | + Singleton PETSc options + - name: petsc_options_iname + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: -ksp_atol -ksp_gmres_restart -ksp_max_it -ksp_pc_side -ksp_rtol -ksp_type -mat_fd_coloring_err -mat_fd_type -mat_mffd_type -pc_asm_overlap -pc_factor_levels -pc_factor_mat_ordering_type -pc_hypre_boomeramg_grid_sweeps_all -pc_hypre_boomeramg_max_iter -pc_hypre_boomeramg_strong_threshold -pc_hypre_type -pc_type -snes_atol -snes_linesearch_type -snes_ls -snes_max_it -snes_rtol -snes_divergence_tolerance -snes_type -sub_ksp_type -sub_pc_type + description: | + Names of PETSc name/value pairs + - name: petsc_options_value + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Values of PETSc name/value pairs (must correspond with "petsc_options_iname" + - name: picard_abs_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Picard' + description: | + The absolute nonlinear residual to shoot for during Picard iterations. This check is performed based on the Master app's nonlinear residual. + - name: picard_custom_pp + required: No + default: !!str + cpp_type: PostprocessorName + group_name: 'Picard' + description: | + Postprocessor for custom picard convergence check. + - name: picard_force_norms + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Picard' + description: | + Force the evaluation of both the TIMESTEP_BEGIN and TIMESTEP_END norms regardless of the existance of active MultiApps with those execute_on flags, default: false. + - name: picard_max_its + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Picard' + description: | + Specifies the maximum number of Picard iterations. Mainly used when wanting to do Picard iterations with MultiApps that are set to execute_on timestep_end or timestep_begin. Setting this parameter to 1 turns off the Picard iterations. + - name: picard_rel_tol + required: No + default: !!str 1e-08 + cpp_type: double + group_name: 'Picard' + description: | + The relative nonlinear residual drop to shoot for during Picard iterations. This check is performed based on the Master app's nonlinear residual. + - name: relaxation_factor + required: No + default: !!str 1 + cpp_type: double + group_name: 'Picard' + description: | + Fraction of newly computed value to keep.Set between 0 and 2. + - name: relaxed_variables + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Picard' + description: | + List of variables to relax during Picard Iteration + - name: resid_vs_jac_scaling_param + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + A parameter that indicates the weighting of the residual vs the Jacobian in determining variable scaling parameters. A value of 1 indicates pure residual-based scaling. A value of 0 indicates pure Jacobian-based scaling + - name: restart_file_base + required: No + default: !!str + cpp_type: FileNameNoExtension + group_name: 'Restart' + description: | + File base name used for restart + - name: scaling_group_variables + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > >, std::allocator, std::allocator >, std::allocator, std::allocator > > > > > + group_name: + description: | + Name of variables that are grouped together to for determing scale factors. (Multiple groups can be provided, separated by semicolon) + - name: skip_exception_check + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether or not to skip exception check + - name: snesmf_reuse_base + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Solver' + description: | + Specifies whether or not to reuse the base vector for matrix-free calculation + - name: solve_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: PJFNK JFNK NEWTON FD LINEAR + description: | + PJFNK: Preconditioned Jacobian-Free Newton Krylov JFNK: Jacobian-Free Newton Krylov NEWTON: Full Newton Solve FD: Use finite differences to compute Jacobian LINEAR: Solving a linear problem + - name: splitting + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Top-level splitting defining a hierarchical decomposition into subsystems to help the solver. + - name: time + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + System time + - name: type + required: No + default: !!str Steady + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: update_xfem_at_timestep_begin + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Should XFEM update the mesh at the beginning of the timestep + - name: verbose + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true to print additional information + subblocks: + - name: /Executioner//Transient + description: | + + parameters: + - name: abort_on_solve_fail + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + abort if solve not converged rather than cut timestep + - name: accept_on_max_picard_iteration + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Picard' + description: | + True to treat reaching the maximum number of Picard iterations as converged. + - name: automatic_scaling + required: No + default: !!str + cpp_type: bool + group_name: 'Solver' + description: | + Whether to use automatic scaling for the variables. + - name: compute_initial_residual_before_preset_bcs + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Solver' + description: | + Use the residual norm computed *before* preset BCs are imposed in relative convergence check + - name: compute_scaling_once + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Solver' + description: | + Whether the scaling factors should only be computed once at the beginning of the simulation through an extra Jacobian evaluation. If this is set to false, then the scaling factors will be computed during an extra Jacobian evaluation at the beginning of every time step. + - name: contact_line_search_allowed_lambda_cuts + required: No + default: !!str 2 + cpp_type: unsigned int + group_name: + description: | + The number of times lambda is allowed to be cut in half in the contact line search. We recommend this number be roughly bounded by 0 <= allowed_lambda_cuts <= 3 + - name: contact_line_search_ltol + required: No + default: !!str + cpp_type: double + group_name: + description: | + The linear relative tolerance to be used while the contact state is changing between non-linear iterations. We recommend that this tolerance be looser than the standard linear tolerance + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: custom_abs_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: + description: | + The absolute nonlinear residual to shoot for during Picard iterations. This check is performed based on postprocessor defined by picard_custom_pp residual. + - name: custom_rel_tol + required: No + default: !!str 1e-08 + cpp_type: double + group_name: + description: | + The relative nonlinear residual drop to shoot for during Picard iterations. This check is performed based on postprocessor defined by picard_custom_pp residual. + - name: direct_pp_value + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use direct postprocessor value (scaled by value on first iteration). False (default) to use difference in postprocessor value between picard iterations. + - name: disable_picard_residual_norm_check + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Picard' + description: | + Disable the Picard residual norm evaluation thus the three parameters picard_rel_tol, picard_abs_tol and picard_force_norms. + - name: dt + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The timestep size between solves + - name: dtmax + required: No + default: !!str 1e+30 + cpp_type: double + group_name: 'Advanced' + description: | + The maximum timestep size in an adaptive run + - name: dtmin + required: No + default: !!str 2e-14 + cpp_type: double + group_name: 'Advanced' + description: | + The minimum timestep size in an adaptive run + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_time + required: No + default: !!str 1e+30 + cpp_type: double + group_name: + description: | + The end time of the simulation + - name: l_abs_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Solver' + description: | + Linear Absolute Tolerance + - name: l_max_its + required: No + default: !!str 10000 + cpp_type: unsigned int + group_name: 'Solver' + description: | + Max Linear Iterations + - name: l_tol + required: No + default: !!str 1e-05 + cpp_type: double + group_name: 'Solver' + description: | + Linear Tolerance + - name: line_search + required: No + default: !!str default + cpp_type: MooseEnum + group_name: + options: basic bt contact cp default l2 none project shell + description: | + Specifies the line search type (Note: none = basic) + - name: line_search_package + required: No + default: !!str petsc + cpp_type: MooseEnum + group_name: + options: petsc moose + description: | + The solver package to use to conduct the line-search + - name: max_xfem_update + required: No + default: !!str 4294967295 + cpp_type: unsigned int + group_name: + description: | + Maximum number of times to update XFEM crack topology in a step due to evolving cracks + - name: mffd_type + required: No + default: !!str wp + cpp_type: MooseEnum + group_name: + options: wp ds + description: | + Specifies the finite differencing type for Jacobian-free solve types. Note that the default is wp (for Walker and Pernice). + - name: n_startup_steps + required: No + default: !!str 0 + cpp_type: int + group_name: 'Advanced' + description: | + The number of timesteps during startup + - name: nl_abs_step_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Solver' + description: | + Nonlinear Absolute step Tolerance + - name: nl_abs_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Solver' + description: | + Nonlinear Absolute Tolerance + - name: nl_div_tol + required: No + default: !!str -1 + cpp_type: double + group_name: + description: | + Nonlinear Divergence Tolerance + - name: nl_max_funcs + required: No + default: !!str 10000 + cpp_type: unsigned int + group_name: 'Solver' + description: | + Max Nonlinear solver function evaluations + - name: nl_max_its + required: No + default: !!str 50 + cpp_type: unsigned int + group_name: 'Solver' + description: | + Max Nonlinear Iterations + - name: nl_rel_step_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Solver' + description: | + Nonlinear Relative step Tolerance + - name: nl_rel_tol + required: No + default: !!str 1e-08 + cpp_type: double + group_name: 'Solver' + description: | + Nonlinear Relative Tolerance + - name: num_grids + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Solver' + description: | + The number of grids to use for a grid sequencing algorithm. This includes the final grid, so num_grids = 1 indicates just one solve in a time-step + - name: num_steps + required: No + default: !!str 4294967295 + cpp_type: unsigned int + group_name: + description: | + The number of timesteps in a transient run + - name: petsc_options + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: -dm_moose_print_embedding -dm_view -ksp_converged_reason -ksp_gmres_modifiedgramschmidt -ksp_monitor -ksp_monitor_snes_lg-snes_ksp_ew -ksp_snes_ew -snes_converged_reason -snes_ksp -snes_ksp_ew -snes_linesearch_monitor -snes_mf -snes_mf_operator -snes_monitor -snes_test_display -snes_view + description: | + Singleton PETSc options + - name: petsc_options_iname + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: -ksp_atol -ksp_gmres_restart -ksp_max_it -ksp_pc_side -ksp_rtol -ksp_type -mat_fd_coloring_err -mat_fd_type -mat_mffd_type -pc_asm_overlap -pc_factor_levels -pc_factor_mat_ordering_type -pc_hypre_boomeramg_grid_sweeps_all -pc_hypre_boomeramg_max_iter -pc_hypre_boomeramg_strong_threshold -pc_hypre_type -pc_type -snes_atol -snes_linesearch_type -snes_ls -snes_max_it -snes_rtol -snes_divergence_tolerance -snes_type -sub_ksp_type -sub_pc_type + description: | + Names of PETSc name/value pairs + - name: petsc_options_value + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Values of PETSc name/value pairs (must correspond with "petsc_options_iname" + - name: picard_abs_tol + required: No + default: !!str 1e-50 + cpp_type: double + group_name: 'Picard' + description: | + The absolute nonlinear residual to shoot for during Picard iterations. This check is performed based on the Master app's nonlinear residual. + - name: picard_custom_pp + required: No + default: !!str + cpp_type: PostprocessorName + group_name: 'Picard' + description: | + Postprocessor for custom picard convergence check. + - name: picard_force_norms + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Picard' + description: | + Force the evaluation of both the TIMESTEP_BEGIN and TIMESTEP_END norms regardless of the existance of active MultiApps with those execute_on flags, default: false. + - name: picard_max_its + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Picard' + description: | + Specifies the maximum number of Picard iterations. Mainly used when wanting to do Picard iterations with MultiApps that are set to execute_on timestep_end or timestep_begin. Setting this parameter to 1 turns off the Picard iterations. + - name: picard_rel_tol + required: No + default: !!str 1e-08 + cpp_type: double + group_name: 'Picard' + description: | + The relative nonlinear residual drop to shoot for during Picard iterations. This check is performed based on the Master app's nonlinear residual. + - name: relaxation_factor + required: No + default: !!str 1 + cpp_type: double + group_name: 'Picard' + description: | + Fraction of newly computed value to keep.Set between 0 and 2. + - name: relaxed_variables + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Picard' + description: | + List of variables to relax during Picard Iteration + - name: reset_dt + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Use when restarting a calculation to force a change in dt. + - name: resid_vs_jac_scaling_param + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + A parameter that indicates the weighting of the residual vs the Jacobian in determining variable scaling parameters. A value of 1 indicates pure residual-based scaling. A value of 0 indicates pure Jacobian-based scaling + - name: restart_file_base + required: No + default: !!str + cpp_type: FileNameNoExtension + group_name: 'Restart' + description: | + File base name used for restart + - name: scaling_group_variables + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > >, std::allocator, std::allocator >, std::allocator, std::allocator > > > > > + group_name: + description: | + Name of variables that are grouped together to for determing scale factors. (Multiple groups can be provided, separated by semicolon) + - name: scheme + required: No + default: !!str implicit-euler + cpp_type: MooseEnum + group_name: + options: implicit-euler explicit-euler crank-nicolson bdf2 explicit-midpoint dirk explicit-tvd-rk-2 newmark-beta + description: | + Time integration scheme used. + - name: skip_exception_check + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether or not to skip exception check + - name: snesmf_reuse_base + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Solver' + description: | + Specifies whether or not to reuse the base vector for matrix-free calculation + - name: solve_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: PJFNK JFNK NEWTON FD LINEAR + description: | + PJFNK: Preconditioned Jacobian-Free Newton Krylov JFNK: Jacobian-Free Newton Krylov NEWTON: Full Newton Solve FD: Use finite differences to compute Jacobian LINEAR: Solving a linear problem + - name: splitting + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Top-level splitting defining a hierarchical decomposition into subsystems to help the solver. + - name: ss_check_tol + required: No + default: !!str 1e-08 + cpp_type: double + group_name: 'Advanced' + description: | + Whenever the relative residual changes by less than this the solution will be considered to be at steady state. + - name: ss_tmin + required: No + default: !!str 0 + cpp_type: double + group_name: 'Advanced' + description: | + Minimum amount of time to run before checking for steady state conditions. + - name: start_time + required: No + default: !!str 0 + cpp_type: double + group_name: 'Advanced' + description: | + The start time of the simulation + - name: steady_state_detection + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Steady State Detection' + description: | + Whether or not to check for steady state conditions + - name: steady_state_start_time + required: No + default: !!str 0 + cpp_type: double + group_name: 'Steady State Detection' + description: | + Minimum amount of time to run before checking for steady state conditions. + - name: steady_state_tolerance + required: No + default: !!str 1e-08 + cpp_type: double + group_name: 'Steady State Detection' + description: | + Whenever the relative residual changes by less than this the solution will be considered to be at steady state. + - name: time_period_ends + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Time Periods' + description: | + The end times of time periods + - name: time_period_starts + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Time Periods' + description: | + The start times of time periods + - name: time_periods + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Time Periods' + description: | + The names of periods + - name: timestep_tolerance + required: No + default: !!str 2e-14 + cpp_type: double + group_name: 'Advanced' + description: | + the tolerance setting for final timestep size and sync times + - name: trans_ss_check + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Whether or not to check for steady state conditions + - name: type + required: No + default: !!str Transient + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: update_xfem_at_timestep_begin + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Should XFEM update the mesh at the beginning of the timestep + - name: use_multiapp_dt + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + If true then the dt for the simulation will be chosen by the MultiApps. If false (the default) then the minimum over the master dt and the MultiApps is used + - name: verbose + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true to print additional information + subblocks: + - name: /Executioner/Adaptivity + description: | + + parameters: + - name: coarsen_fraction + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The fraction of elements or error to coarsen. Should be between 0 and 1. + - name: cycles_per_step + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + The number of adaptivity cycles per step + - name: error_estimator + required: No + default: !!str KellyErrorEstimator + cpp_type: MooseEnum + group_name: + options: KellyErrorEstimator LaplacianErrorEstimator PatchRecoveryErrorEstimator + description: | + The class name of the error estimator you want to use. + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: initial_adaptivity + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The number of adaptivity steps to perform using the initial conditions + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + The number of time steps betweeen each adaptivity phase + - name: max_h_level + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + Maximum number of times a single element can be refined. If 0 then infinite. + - name: print_changed_info + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Determines whether information about the mesh is printed when adaptivity occurs + - name: recompute_markers_during_cycles + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Recompute markers during adaptivity cycles + - name: refine_fraction + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The fraction of elements or error to refine. Should be between 0 and 1. + - name: show_initial_progress + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Show the progress of the initial adaptivity + - name: start_time + required: No + default: !!str -1.79769e+308 + cpp_type: double + group_name: + description: | + The time that adaptivity will be active after. + - name: steps + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The number of adaptivity steps to perform at any one time for steady state + - name: stop_time + required: No + default: !!str 1.79769e+308 + cpp_type: double + group_name: + description: | + The time after which adaptivity will no longer be active. + - name: weight_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + List of names of variables that will be associated with weight_values + - name: weight_values + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + List of values between 0 and 1 to weight the associated weight_names error by + subblocks: + - name: /Executioner/Predictor + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /Executioner/Predictor/ + description: | + + parameters: + subblocks: + - name: /Executioner/Predictor//AdamsPredictor + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: order + required: No + default: !!str 2 + cpp_type: int + group_name: + description: | + The maximum reachable order of the Adams-Bashforth Predictor + - name: scale + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The scale factor for the predictor (can range from 0 to 1) + - name: skip_times + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Skip the predictor if the current solution time is in this list of times + - name: skip_times_old + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Skip the predictor if the previous solution time is in this list of times + - name: type + required: No + default: !!str AdamsPredictor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/Predictor//SimplePredictor + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: scale + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The scale factor for the predictor (can range from 0 to 1) + - name: skip_times + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Skip the predictor if the current solution time is in this list of times + - name: skip_times_old + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Skip the predictor if the previous solution time is in this list of times + - name: type + required: No + default: !!str SimplePredictor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/Quadrature + description: | + + parameters: + - name: element_order + required: No + default: !!str AUTO + cpp_type: MooseEnum + group_name: + options: AUTO CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINTEENTH TWENTIETH + description: | + Order of the quadrature for elements + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: order + required: No + default: !!str AUTO + cpp_type: MooseEnum + group_name: + options: AUTO CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINTEENTH TWENTIETH + description: | + Order of the quadrature + - name: side_order + required: No + default: !!str AUTO + cpp_type: MooseEnum + group_name: + options: AUTO CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINTEENTH TWENTIETH + description: | + Order of the quadrature for sides + - name: type + required: No + default: !!str GAUSS + cpp_type: MooseEnum + group_name: + options: CLOUGH CONICAL GAUSS GRID MONOMIAL SIMPSON TRAP GAUSS_LOBATTO + description: | + Type of the quadrature rule + subblocks: + - name: /Executioner/TimeIntegrator + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /Executioner/TimeIntegrator/ + description: | + + parameters: + subblocks: + - name: /Executioner/TimeIntegrator//AStableDirk4 + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: safe_start + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If true, use LStableDirk4 to bootstrap this method. + - name: type + required: No + default: !!str AStableDirk4 + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeIntegrator//ActuallyExplicitEuler + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: solve_type + required: No + default: !!str consistent + cpp_type: MooseEnum + group_name: + options: consistent lumped lump_preconditioned + description: | + The way to solve the system. A 'consistent' solve uses the full mass matrix and actually needs to use a linear solver to solve the problem. 'lumped' uses a lumped mass matrix with a simple inversion - incredibly fast but may be less accurate. 'lump_preconditioned' uses the lumped mass matrix as a preconditioner for the 'consistent' solve + - name: type + required: No + default: !!str ActuallyExplicitEuler + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeIntegrator//BDF2 + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str BDF2 + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeIntegrator//CentralDifference + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: solve_type + required: No + default: !!str consistent + cpp_type: MooseEnum + group_name: + options: consistent lumped lump_preconditioned + description: | + The way to solve the system. A 'consistent' solve uses the full mass matrix and actually needs to use a linear solver to solve the problem. 'lumped' uses a lumped mass matrix with a simple inversion - incredibly fast but may be less accurate. 'lump_preconditioned' uses the lumped mass matrix as a preconditioner for the 'consistent' solve + - name: type + required: No + default: !!str CentralDifference + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeIntegrator//CrankNicolson + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str CrankNicolson + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeIntegrator//ExplicitEuler + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str ExplicitEuler + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeIntegrator//ExplicitMidpoint + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str ExplicitMidpoint + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeIntegrator//ExplicitSSPRungeKutta + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: order + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: 1 2 3 + description: | + Order of time integration + - name: solve_type + required: No + default: !!str consistent + cpp_type: MooseEnum + group_name: + options: consistent lumped lump_preconditioned + description: | + The way to solve the system. A 'consistent' solve uses the full mass matrix and actually needs to use a linear solver to solve the problem. 'lumped' uses a lumped mass matrix with a simple inversion - incredibly fast but may be less accurate. 'lump_preconditioned' uses the lumped mass matrix as a preconditioner for the 'consistent' solve + - name: type + required: No + default: !!str ExplicitSSPRungeKutta + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeIntegrator//ExplicitTVDRK2 + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str ExplicitTVDRK2 + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeIntegrator//Heun + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str Heun + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeIntegrator//ImplicitEuler + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str ImplicitEuler + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeIntegrator//ImplicitMidpoint + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str ImplicitMidpoint + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeIntegrator//LStableDirk2 + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str LStableDirk2 + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeIntegrator//LStableDirk3 + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str LStableDirk3 + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeIntegrator//LStableDirk4 + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str LStableDirk4 + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeIntegrator//NewmarkBeta + description: | + + parameters: + - name: beta + required: No + default: !!str 0.25 + cpp_type: double + group_name: + description: | + beta value + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: gamma + required: No + default: !!str 0.5 + cpp_type: double + group_name: + description: | + gamma value + - name: type + required: No + default: !!str NewmarkBeta + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeIntegrator//Ralston + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str Ralston + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeStepper + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /Executioner/TimeStepper/ + description: | + + parameters: + subblocks: + - name: /Executioner/TimeStepper//AB2PredictorCorrector + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cutback_factor_at_failure + required: No + default: !!str 0.5 + cpp_type: double + group_name: + description: | + Factor to apply to timestep if it a time step fails to convergence. + - name: dt + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Initial time step size + - name: e_max + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Maximum acceptable error. + - name: e_tol + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Target error tolerance. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: max_increase + required: No + default: !!str 1e+09 + cpp_type: double + group_name: + description: | + Maximum ratio that the time step can increase. + - name: reset_dt + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Use when restarting a calculation to force a change in dt. + - name: scaling_parameter + required: No + default: !!str 0.8 + cpp_type: double + group_name: + description: | + scaling parameter for dt selection + - name: start_adapting + required: No + default: !!str 2 + cpp_type: int + group_name: + description: | + when to start taking adaptive time steps + - name: steps_between_increase + required: No + default: !!str 1 + cpp_type: int + group_name: + description: | + the number of time steps before recalculating dt + - name: type + required: No + default: !!str AB2PredictorCorrector + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeStepper//CSVTimeSequenceStepper + description: | + + parameters: + - name: column_index + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + index of the column which contains the time sequence + - name: column_name + required: No + default: !!str time + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + name of the column which contains the time sequence + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cutback_factor_at_failure + required: No + default: !!str 0.5 + cpp_type: double + group_name: + description: | + Factor to apply to timestep if it a time step fails to convergence. + - name: delimiter + required: No + default: !!str "," + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + delimiter used to parse the file + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: file_name + required: Yes + default: !!str + cpp_type: FileName + group_name: + description: | + name of the file in which the time sequence is read + - name: header + required: No + default: !!str + cpp_type: bool + group_name: + description: | + indicates whether the file contains a header with the column names + - name: reset_dt + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Use when restarting a calculation to force a change in dt. + - name: type + required: No + default: !!str CSVTimeSequenceStepper + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeStepper//ConstantDT + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cutback_factor_at_failure + required: No + default: !!str 0.5 + cpp_type: double + group_name: + description: | + Factor to apply to timestep if it a time step fails to convergence. + - name: dt + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Size of the time step + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: growth_factor + required: No + default: !!str 2 + cpp_type: double + group_name: + description: | + Maximum ratio of new to previous timestep sizes following a step that required the time step to be cut due to a failed solve. + - name: reset_dt + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Use when restarting a calculation to force a change in dt. + - name: type + required: No + default: !!str ConstantDT + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeStepper//DT2 + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cutback_factor_at_failure + required: No + default: !!str 0.5 + cpp_type: double + group_name: + description: | + Factor to apply to timestep if it a time step fails to convergence. + - name: dt + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The initial time step size. + - name: e_max + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Maximum acceptable error. + - name: e_tol + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Target error tolerance. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: max_increase + required: No + default: !!str 1e+09 + cpp_type: double + group_name: + description: | + Maximum ratio that the time step can increase. + - name: reset_dt + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Use when restarting a calculation to force a change in dt. + - name: type + required: No + default: !!str DT2 + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeStepper//ExodusTimeSequenceStepper + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cutback_factor_at_failure + required: No + default: !!str 0.5 + cpp_type: double + group_name: + description: | + Factor to apply to timestep if it a time step fails to convergence. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: mesh + required: Yes + default: !!str + cpp_type: MeshFileName + group_name: + description: | + The name of the mesh file to extract the time sequence from (must be an exodusII file). + - name: reset_dt + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Use when restarting a calculation to force a change in dt. + - name: type + required: No + default: !!str ExodusTimeSequenceStepper + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeStepper//FunctionDT + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cutback_factor_at_failure + required: No + default: !!str 0.5 + cpp_type: double + group_name: + description: | + Factor to apply to timestep if it a time step fails to convergence. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: function + required: No + default: !!str + cpp_type: FunctionName + group_name: + description: | + The name of the time-dependent function that prescribes the time step size. + - name: growth_factor + required: No + default: !!str 1.79769e+308 + cpp_type: double + group_name: + description: | + Maximum ratio of new to previous timestep sizes following a step that required the time step to be cut due to a failed solve. + - name: interpolate + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether or not to interpolate DT between times. This is true by default for historical reasons. + - name: min_dt + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The minimal dt to take. + - name: reset_dt + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Use when restarting a calculation to force a change in dt. + - name: time_dt + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The values of dt + - name: time_t + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The values of t + - name: type + required: No + default: !!str FunctionDT + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeStepper//IterationAdaptiveDT + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cutback_factor + required: No + default: !!str 0.5 + cpp_type: double + group_name: + description: | + Factor to apply to timestep if difficult convergence (if 'optimal_iterations' is specified) or if solution failed + - name: cutback_factor_at_failure + required: No + default: !!str 0.5 + cpp_type: double + group_name: + description: | + Factor to apply to timestep if it a time step fails to convergence. + - name: dt + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The default timestep size between solves + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: force_step_every_function_point + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Forces the timestepper to take a step that is consistent with points defined in the function + - name: growth_factor + required: No + default: !!str 2 + cpp_type: double + group_name: + description: | + Factor to apply to timestep if easy convergence (if 'optimal_iterations' is specified) or if recovering from failed solve + - name: iteration_window + required: No + default: !!str + cpp_type: int + group_name: + description: | + Attempt to grow/shrink timestep if the iteration count is below/above 'optimal_iterations plus/minus iteration_window' (default = optimal_iterations/5). + - name: linear_iteration_ratio + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The ratio of linear to nonlinear iterations to determine target linear iterations and window for adaptive timestepping (default = 25) + - name: max_function_change + required: No + default: !!str + cpp_type: double + group_name: + description: | + The absolute value of the maximum change in timestep_limiting_function over a timestep + - name: optimal_iterations + required: No + default: !!str + cpp_type: int + group_name: + description: | + The target number of nonlinear iterations for adaptive timestepping + - name: reject_large_step + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If 'true', time steps that are too large compared to the ideal time step will be rejected and repeated + - name: reject_large_step_threshold + required: No + default: !!str 0.1 + cpp_type: double + group_name: + description: | + Ratio between the the ideal time step size and the current time step size below which a time step will be rejected if 'reject_large_step' is 'true' + - name: reset_dt + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Use when restarting a calculation to force a change in dt. + - name: time_dt + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The values of dt + - name: time_t + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The values of t + - name: timestep_limiting_function + required: No + default: !!str + cpp_type: FunctionName + group_name: + description: | + A 'PiecewiseBase' type function used to control the timestep by limiting the change in the function over a timestep + - name: timestep_limiting_postprocessor + required: No + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + If specified, the postprocessor value is used as an upper limit for the current time step length + - name: type + required: No + default: !!str IterationAdaptiveDT + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeStepper//LogConstantDT + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cutback_factor_at_failure + required: No + default: !!str 0.5 + cpp_type: double + group_name: + description: | + Factor to apply to timestep if it a time step fails to convergence. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: first_dt + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Initial time step (in absolute time) + - name: growth_factor + required: No + default: !!str 2 + cpp_type: double + group_name: + description: | + Maximum ratio of new to previous timestep sizes following a step that required the time step to be cut due to a failed solve. + - name: log_dt + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Time step in log10(time) + - name: reset_dt + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Use when restarting a calculation to force a change in dt. + - name: type + required: No + default: !!str LogConstantDT + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeStepper//PostprocessorDT + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cutback_factor_at_failure + required: No + default: !!str 0.5 + cpp_type: double + group_name: + description: | + Factor to apply to timestep if it a time step fails to convergence. + - name: dt + required: No + default: !!str + cpp_type: double + group_name: + description: | + Initial value of dt + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: factor + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Add a factor to the supplied postprocessor value. + - name: postprocessor + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The name of the postprocessor that computes the dt + - name: reset_dt + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Use when restarting a calculation to force a change in dt. + - name: scale + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Multiple scale and supplied postprocessor value. + - name: type + required: No + default: !!str PostprocessorDT + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeStepper//SolutionTimeAdaptiveDT + description: | + + parameters: + - name: adapt_log + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Output adaptive time step log + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cutback_factor_at_failure + required: No + default: !!str 0.5 + cpp_type: double + group_name: + description: | + Factor to apply to timestep if it a time step fails to convergence. + - name: dt + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The timestep size between solves + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: initial_direction + required: No + default: !!str 1 + cpp_type: int + group_name: + description: | + Direction for the first step. 1 for up... -1 for down. + - name: percent_change + required: No + default: !!str 0.1 + cpp_type: double + group_name: + description: | + Percentage to change the timestep by. Should be between 0 and 1 + - name: reset_dt + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Use when restarting a calculation to force a change in dt. + - name: type + required: No + default: !!str SolutionTimeAdaptiveDT + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Executioner/TimeStepper//TimeSequenceStepper + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cutback_factor_at_failure + required: No + default: !!str 0.5 + cpp_type: double + group_name: + description: | + Factor to apply to timestep if it a time step fails to convergence. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: reset_dt + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Use when restarting a calculation to force a change in dt. + - name: time_sequence + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The values of t + - name: type + required: No + default: !!str TimeSequenceStepper + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: +- name: /FVBCs + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + subblocks: + - name: /FVBCs/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /FVBCs/FVConstantScalarOutflowBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: type + required: No + default: !!str FVConstantScalarOutflowBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + - name: velocity + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + Constant advection velocity + subblocks: + - name: /FVBCs/FVDirichletBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: type + required: No + default: !!str FVDirichletBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + value to enforce at the boundary face + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /FVBCs/FVMatAdvectionOutflowBC + description: | + + parameters: + - name: advected_quantity + required: No + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + An optional parameter for specifying an advected quantity from a material property. If this is not specified, then the advected quantity will simply be the variable that this object is acting on + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: type + required: No + default: !!str FVMatAdvectionOutflowBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + - name: vel + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + advection velocity + subblocks: + - name: /FVBCs/FVNeumannBC + description: | + + parameters: + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: type + required: No + default: !!str FVNeumannBC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The value of the flux crossing the boundary. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: +- name: /FVKernels + description: | + + parameters: + subblocks: + - name: /FVKernels/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /FVKernels/FVAdvection + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: type + required: No + default: !!str FVAdvection + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the finite volume variable this kernel applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + - name: velocity + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + Constant advection velocity + subblocks: + - name: /FVKernels/FVBodyForce + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: function + required: No + default: !!str 1 + cpp_type: FunctionName + group_name: + description: | + A function that describes the body force + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: postprocessor + required: No + default: !!str 1 + cpp_type: PostprocessorName + group_name: + description: | + A postprocessor whose value is multiplied by the body force + - name: type + required: No + default: !!str FVBodyForce + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Coefficient to multiply by the body force term + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the finite volume variable this kernel applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /FVKernels/FVCoupledForce + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: coef + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Coefficent multiplier for the coupled force term. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: type + required: No + default: !!str FVCoupledForce + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The coupled variable which provides the force + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the finite volume variable this kernel applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /FVKernels/FVDiffusion + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: coeff + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + diffusion coefficient + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: type + required: No + default: !!str FVDiffusion + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the finite volume variable this kernel applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /FVKernels/FVMatAdvection + description: | + + parameters: + - name: advected_quantity + required: No + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + An optional parameter for specifying an advected quantity from a material property. If this is not specified, then the advected quantity will simply be the variable that this object is acting on + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: type + required: No + default: !!str FVMatAdvection + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the finite volume variable this kernel applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + - name: vel + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + advection velocity + subblocks: + - name: /FVKernels/FVReaction + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: type + required: No + default: !!str FVReaction + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the finite volume variable this kernel applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /FVKernels/FVTimeKernel + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: type + required: No + default: !!str FVTimeKernel + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the finite volume variable this kernel applies to + - name: vector_tags + required: No + default: !!str time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: +- name: /Functions + description: | + + parameters: + subblocks: + - name: /Functions/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /Functions/2DXY3DSolutionFunction + description: | + + parameters: + - name: 2d_axis_point1 + required: No + default: !!str 0 0 0 + cpp_type: libMesh::VectorValue + group_name: + description: | + Start point for axis of symmetry for the 2d model + - name: 2d_axis_point2 + required: No + default: !!str 0 1 0 + cpp_type: libMesh::VectorValue + group_name: + description: | + End point for axis of symmetry for the 2d model + - name: 3d_axis_point1 + required: No + default: !!str 0 0 0 + cpp_type: libMesh::VectorValue + group_name: + description: | + Start point for axis of symmetry for the 3d model + - name: 3d_axis_point2 + required: No + default: !!str 0 1 0 + cpp_type: libMesh::VectorValue + group_name: + description: | + End point for axis of symmetry for the 3d model + - name: add_factor + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Add this value (b) to the solution (x): ax+b, where a is the 'scale_factor' + - name: axial_dimension_ratio + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Ratio of the axial dimension in the 3d model to that in the 2d model. Optinally permits the 3d model to be larger than the 2d model in that dimension, and scales vector solutions in that direction by this factor. + - name: component + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + Component of the variable to be computed if it is a vector + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: from_variables + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The names of the variables in the file that are to be extracted, in x, y order if they are vector components + - name: scale_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Scale factor (a) to be applied to the solution (x): ax+b, where b is the 'add_factor' + - name: solution + required: Yes + default: !!str + cpp_type: UserObjectName + group_name: + description: | + The SolutionUserObject to extract data from. + - name: type + required: No + default: !!str 2DXY3DSolutionFunction + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Functions/BicubicSplineFunction + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: normal_component + required: No + default: !!str z + cpp_type: MooseEnum + group_name: + options: x y z + description: | + The component of the geometry that is normal to the spline x1/x2 values + - name: type + required: No + default: !!str BicubicSplineFunction + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: x1 + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The first independent coordinate. + - name: x2 + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The second independent coordinate. + - name: y + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The dependent values + - name: yx1 + required: No + default: !!str 1e30 + cpp_type: FunctionName + group_name: + description: | + The functional form of the derivative with respect to x1. + - name: yx11 + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The values of the derivative wrt x1 on the lower interpolation grid points. + - name: yx1n + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The values of the derivative wrt x1 on the upper interpolation grid points. + - name: yx2 + required: No + default: !!str 1e30 + cpp_type: FunctionName + group_name: + description: | + The functional form of the derivative with respect to x2. + - name: yx21 + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The values of the derivative wrt x2 on the lower interpolation grid points. + - name: yx2n + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The values of the derivative wrt x2 on the upper interpolation grid points. + subblocks: + - name: /Functions/CoarsenedPiecewiseLinear + description: | + + parameters: + - name: axis + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z + description: | + The axis used (x, y, or z) if this is to be a function of position + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: data_file + required: No + default: !!str + cpp_type: FileName + group_name: + description: | + File holding CSV data for use with Piecewise + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: epsilon + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Significant distance in the function below which points are considered removable noise + - name: format + required: No + default: !!str rows + cpp_type: MooseEnum + group_name: + options: columns rows + description: | + Format of csv data file that is in either in columns or rows + - name: scale_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Scale factor to be applied to the ordinate values + - name: type + required: No + default: !!str CoarsenedPiecewiseLinear + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: x + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The abscissa values + - name: x_index_in_file + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The abscissa index in the data file + - name: x_scale + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Scaling factor to apply to the function nodes for the purpose of computing distances in the Douglas-Peucker point reduction algorithm. This permits shifting the weight between x and y-direction distances. + - name: xy_data + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + All function data, supplied in abscissa, ordinate pairs + - name: xy_in_file_only + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If the data file only contains abscissa and ordinate data + - name: y + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The ordinate values + - name: y_index_in_file + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + The ordinate index in the data file + - name: y_scale + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Scaling factor to apply to the function nodes for the purpose of computing distances in the Douglas-Peucker point reduction algorithm. This permits shifting the weight between x and y-direction distances. + subblocks: + - name: /Functions/CompositeFunction + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: functions + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The functions to be multiplied together. + - name: scale_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Scale factor to be applied to the ordinate values + - name: type + required: No + default: !!str CompositeFunction + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Functions/ConstantFunction + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str ConstantFunction + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The constant value + subblocks: + - name: /Functions/ImageFunction + description: | + + parameters: + - name: component + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The image RGB-component to return, leaving this blank will result in a greyscale value for the image to be created. The component number is zero based, i.e. 0 returns the first (RED) component of the image. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dimensions + required: No + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + x,y,z dimensions of the image (defaults to mesh dimensions) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: file + required: No + default: !!str + cpp_type: FileName + group_name: + description: | + Name of single image file to extract mesh parameters from. If provided, a 2D mesh is created. + - name: file_base + required: No + default: !!str + cpp_type: FileNameNoExtension + group_name: + description: | + Image file base to open, use this option when a stack of images must be read (ignored if 'file' is given) + - name: file_range + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Range of images to analyze, used with 'file_base' (ignored if 'file' is given) + - name: file_suffix + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Suffix of the file to open, e.g. 'png' + - name: flip_x + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Flip' + description: | + Flip the image along the x-axis + - name: flip_y + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Flip' + description: | + Flip the image along the y-axis + - name: flip_z + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Flip' + description: | + Flip the image along the z-axis + - name: lower_value + required: No + default: !!str 0 + cpp_type: double + group_name: 'Threshold' + description: | + The value to set for data less than the threshold value + - name: origin + required: No + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + Origin of the image (defaults to mesh origin) + - name: scale + required: No + default: !!str 1 + cpp_type: double + group_name: 'Rescale' + description: | + Multiplier to apply to all pixel values; occurs after shifting + - name: shift + required: No + default: !!str 0 + cpp_type: double + group_name: 'Rescale' + description: | + Value to add to all pixels; occurs prior to scaling + - name: threshold + required: No + default: !!str + cpp_type: double + group_name: 'Threshold' + description: | + The threshold value + - name: type + required: No + default: !!str ImageFunction + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: upper_value + required: No + default: !!str 1 + cpp_type: double + group_name: 'Threshold' + description: | + The value to set for data greater than the threshold value + subblocks: + - name: /Functions/LinearCombinationFunction + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: functions + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + This function will return Sum_over_i(w_i * functions_i) + - name: type + required: No + default: !!str LinearCombinationFunction + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: w + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + This function will return Sum_over_i(w_i * functions_i) + subblocks: + - name: /Functions/ParsedFunction + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str ParsedFunction + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: vals + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Constant numeric values, postprocessor names, or function names for vars. + - name: value + required: Yes + default: !!str + cpp_type: FunctionExpression + group_name: + description: | + The user defined function. + - name: vars + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Variables (excluding t,x,y,z) that are bound to the values provided by the corresponding items in the vals vector. + subblocks: + - name: /Functions/ParsedGradFunction + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: grad_x + required: No + default: !!str 0 + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Partial with respect to x. + - name: grad_y + required: No + default: !!str 0 + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Partial with respect to y. + - name: grad_z + required: No + default: !!str 0 + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Partial with respect to z. + - name: type + required: No + default: !!str ParsedGradFunction + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: vals + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Constant numeric values, postprocessor names, or function names for vars. + - name: value + required: No + default: !!str 0 + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + User defined function. + - name: vars + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Variables (excluding t,x,y,z) that are bound to the values provided by the corresponding items in the vals vector. + subblocks: + - name: /Functions/ParsedVectorFunction + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: curl_x + required: No + default: !!str 0 + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + x-component of curl of function. + - name: curl_y + required: No + default: !!str 0 + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + y-component of curl of function. + - name: curl_z + required: No + default: !!str 0 + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + z-component of curl of function. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str ParsedVectorFunction + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: vals + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Constant numeric values, postprocessor names, or function names for vars. + - name: value_x + required: No + default: !!str 0 + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + x-component of function. + - name: value_y + required: No + default: !!str 0 + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + y-component of function. + - name: value_z + required: No + default: !!str 0 + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + z-component of function. + - name: vars + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Variables (excluding t,x,y,z) that are bound to the values provided by the corresponding items in the vals vector. + subblocks: + - name: /Functions/PiecewiseBilinear + description: | + + parameters: + - name: axis + required: No + default: !!str -1 + cpp_type: int + group_name: + description: | + The axis used (0, 1, or 2 for x, y, or z). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: data_file + required: No + default: !!str + cpp_type: FileName + group_name: + description: | + File holding csv data for use with PiecewiseBilinear + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: radial + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true if you want to interpolate along a radius rather that along a specific axis, and note that you have to define xaxis and yaxis in the input file + - name: scale_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Scale factor to be applied to the axis, yaxis, or xaxis values + - name: type + required: No + default: !!str PiecewiseBilinear + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: x + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The x abscissa values + - name: xaxis + required: No + default: !!str -1 + cpp_type: int + group_name: + description: | + The coordinate used for x-axis data (0, 1, or 2 for x, y, or z). + - name: y + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The y abscissa values + - name: yaxis + required: No + default: !!str -1 + cpp_type: int + group_name: + description: | + The coordinate used for y-axis data (0, 1, or 2 for x, y, or z). + - name: z + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The ordinate values + subblocks: + - name: /Functions/PiecewiseConstant + description: | + + parameters: + - name: axis + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z + description: | + The axis used (x, y, or z) if this is to be a function of position + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: data_file + required: No + default: !!str + cpp_type: FileName + group_name: + description: | + File holding CSV data for use with Piecewise + - name: direction + required: No + default: !!str left + cpp_type: MooseEnum + group_name: + options: left right + description: | + Direction to look to find value: left right + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: format + required: No + default: !!str rows + cpp_type: MooseEnum + group_name: + options: columns rows + description: | + Format of csv data file that is in either in columns or rows + - name: scale_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Scale factor to be applied to the ordinate values + - name: type + required: No + default: !!str PiecewiseConstant + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: x + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The abscissa values + - name: x_index_in_file + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The abscissa index in the data file + - name: xy_data + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + All function data, supplied in abscissa, ordinate pairs + - name: xy_in_file_only + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If the data file only contains abscissa and ordinate data + - name: y + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The ordinate values + - name: y_index_in_file + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + The ordinate index in the data file + subblocks: + - name: /Functions/PiecewiseLinear + description: | + + parameters: + - name: axis + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z + description: | + The axis used (x, y, or z) if this is to be a function of position + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: data_file + required: No + default: !!str + cpp_type: FileName + group_name: + description: | + File holding CSV data for use with Piecewise + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: format + required: No + default: !!str rows + cpp_type: MooseEnum + group_name: + options: columns rows + description: | + Format of csv data file that is in either in columns or rows + - name: scale_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Scale factor to be applied to the ordinate values + - name: type + required: No + default: !!str PiecewiseLinear + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: x + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The abscissa values + - name: x_index_in_file + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The abscissa index in the data file + - name: xy_data + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + All function data, supplied in abscissa, ordinate pairs + - name: xy_in_file_only + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If the data file only contains abscissa and ordinate data + - name: y + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The ordinate values + - name: y_index_in_file + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + The ordinate index in the data file + subblocks: + - name: /Functions/PiecewiseMulticonstant + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: data_file + required: No + default: !!str + cpp_type: FileName + group_name: + description: | + File holding data for use with PiecewiseMultiInterpolation. Format: any empty line and any line beginning with # are ignored, all other lines are assumed to contain relevant information. The file must begin with specification of the grid. This is done through lines containing the keywords: AXIS X; AXIS Y; AXIS Z; or AXIS T. Immediately following the keyword line must be a space-separated line of real numbers which define the grid along the specified axis. These data must be monotonically increasing. After all the axes and their grids have been specified, there must be a line that is DATA. Following that line, function values are given in the correct order (they may be on individual lines, or be space-separated on a number of lines). When the function is evaluated, f[i,j,k,l] corresponds to the i + j*Ni + k*Ni*Nj + l*Ni*Nj*Nk data value. Here i>=0 corresponding to the index along the first AXIS, j>=0 corresponding to the index along the second AXIS, etc, and Ni = number of grid points along the first AXIS, etc. + - name: direction + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: left right + description: | + Direction to look to find value for each interpolation dimension. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str PiecewiseMulticonstant + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Functions/PiecewiseMultilinear + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: data_file + required: No + default: !!str + cpp_type: FileName + group_name: + description: | + File holding data for use with PiecewiseMultiInterpolation. Format: any empty line and any line beginning with # are ignored, all other lines are assumed to contain relevant information. The file must begin with specification of the grid. This is done through lines containing the keywords: AXIS X; AXIS Y; AXIS Z; or AXIS T. Immediately following the keyword line must be a space-separated line of real numbers which define the grid along the specified axis. These data must be monotonically increasing. After all the axes and their grids have been specified, there must be a line that is DATA. Following that line, function values are given in the correct order (they may be on individual lines, or be space-separated on a number of lines). When the function is evaluated, f[i,j,k,l] corresponds to the i + j*Ni + k*Ni*Nj + l*Ni*Nj*Nk data value. Here i>=0 corresponding to the index along the first AXIS, j>=0 corresponding to the index along the second AXIS, etc, and Ni = number of grid points along the first AXIS, etc. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str PiecewiseMultilinear + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Functions/SolutionFunction + description: | + + parameters: + - name: add_factor + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Add this value (b) to the solution (x): ax+b, where a is the 'scale_factor' + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: from_variable + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name of the variable in the file that is to be extracted + - name: scale_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Scale factor (a) to be applied to the solution (x): ax+b, where b is the 'add_factor' + - name: solution + required: Yes + default: !!str + cpp_type: UserObjectName + group_name: + description: | + The SolutionUserObject to extract data from. + - name: type + required: No + default: !!str SolutionFunction + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Functions/SplineFunction + description: | + + parameters: + - name: component + required: No + default: !!str x + cpp_type: MooseEnum + group_name: + options: x y z + description: | + The component of the geometry point to interpolate with + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str SplineFunction + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: x + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The abscissa values + - name: y + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The ordinate values + - name: yp1 + required: No + default: !!str 1e+30 + cpp_type: double + group_name: + description: | + The value of the first derivative of the interpolating function at point 1 + - name: ypn + required: No + default: !!str 1e+30 + cpp_type: double + group_name: + description: | + The value of the first derivative of the interpolating function at point n + subblocks: + - name: /Functions/TestSetupPostprocessorDataActionFunction + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: postprocessor + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + A postprocessor to test against + - name: type + required: No + default: !!str TestSetupPostprocessorDataActionFunction + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Functions/VectorPostprocessorFunction + description: | + + parameters: + - name: argument_column + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + VectorPostprocessor column tabulating the abscissa of the sampled function + - name: component + required: No + default: !!str time + cpp_type: MooseEnum + group_name: + options: x y z time 0 1 2 + description: | + Component of the function evaluation point used to sample the VectorPostprocessor + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str VectorPostprocessorFunction + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: value_column + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + VectorPostprocessor column tabulating the ordinate (function values) of the sampled function + - name: vectorpostprocessor_name + required: Yes + default: !!str + cpp_type: VectorPostprocessorName + group_name: + description: | + The name of the VectorPostprocessor that you want to use + subblocks: +- name: /GlobalParams + description: | + + parameters: + subblocks: +- name: /ICs + description: | + + parameters: + subblocks: + - name: /ICs/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /ICs/ArrayConstantIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: type + required: No + default: !!str ArrayConstantIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: value + required: Yes + default: !!str + cpp_type: Eigen::Matrix + group_name: + description: | + The values to be set in IC + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /ICs/ArrayFunctionIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: function + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The initial condition functions. + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: type + required: No + default: !!str ArrayFunctionIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /ICs/BoundingBoxIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: inside + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The value of the variable inside the box + - name: int_width + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The width of the diffuse interface. Set to 0 for sharp interface. + - name: outside + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The value of the variable outside the box + - name: type + required: No + default: !!str BoundingBoxIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + - name: x1 + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The x coordinate of the lower left-hand corner of the box + - name: x2 + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The x coordinate of the upper right-hand corner of the box + - name: y1 + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The y coordinate of the lower left-hand corner of the box + - name: y2 + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The y coordinate of the upper right-hand corner of the box + - name: z1 + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The z coordinate of the lower left-hand corner of the box + - name: z2 + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The z coordinate of the upper right-hand corner of the box + subblocks: + - name: /ICs/ConstantIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: type + required: No + default: !!str ConstantIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: value + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The value to be set in IC + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /ICs/FunctionIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The initial condition function. + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: type + required: No + default: !!str FunctionIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /ICs/FunctionScalarIC + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: function + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The initial condition function. + - name: type + required: No + default: !!str FunctionScalarIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: No + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /ICs/RandomIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: distribution + required: No + default: !!str + cpp_type: DistributionName + group_name: + description: | + Name of distribution defining distribution of randomly generated values + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: legacy_generator + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Determines whether or not the legacy generator (deprecated) should be used. + - name: max + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper bound of uniformly distributed randomly generated values + - name: min + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower bound of uniformly distributed randomly generated values + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + Seed value for the random number generator + - name: type + required: No + default: !!str RandomIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /ICs/ScalarComponentIC + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str ScalarComponentIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: values + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + Initial values to initialize the scalar variable. + - name: variable + required: No + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /ICs/ScalarConstantIC + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str ScalarConstantIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + + - name: variable + required: No + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /ICs/VectorConstantIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: type + required: No + default: !!str VectorConstantIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + - name: x_value + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The x value to be set in IC + - name: y_value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The y value to be set in IC + - name: z_value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The z value to be set in IC + subblocks: + - name: /ICs/VectorFunctionIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: function + required: No + default: !!str + cpp_type: FunctionName + group_name: + description: | + The initial condition vector function. This cannot be supplied with the component parameters. + - name: function_x + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + A function that describes the x-component of the initial condition + - name: function_y + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + A function that describes the y-component of the initial condition + - name: function_z + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + A function that describes the z-component of the initial condition + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: type + required: No + default: !!str VectorFunctionIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: +- name: /InterfaceKernels + description: | + + parameters: + subblocks: + - name: /InterfaceKernels/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /InterfaceKernels/InterfaceReaction + description: | + + parameters: + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: diag_save_in_var_side + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: m s + description: | + This parameter must exist if diag_save_in variables are specified and must have the same length as diag_save_in. This vector specifies whether the corresponding aux_var should save-in jacobian contributions from the master ('m') or slave side ('s'). + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: kb + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Backward reaction rate coefficient. + - name: kf + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Forward reaction rate coefficient. + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: neighbor_var + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable on the other side of the interface. + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: save_in_var_side + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: m s + description: | + This parameter must exist if save_in variables are specified and must have the same length as save_in. This vector specifies whether the corresponding aux_var should save-in residual contributions from the master ('m') or slave side ('s'). + - name: type + required: No + default: !!str InterfaceReaction + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: +- name: /Kernels + description: | + + parameters: + subblocks: + - name: /Kernels/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /Kernels/ADBodyForce + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: function + required: No + default: !!str 1 + cpp_type: FunctionName + group_name: + description: | + A function that describes the body force + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: postprocessor + required: No + default: !!str 1 + cpp_type: PostprocessorName + group_name: + description: | + A postprocessor whose value is multiplied by the body force + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADBodyForce + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Coefficient to multiply by the body force term + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/ADCoupledTimeDerivative + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADCoupledTimeDerivative + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + Coupled variable + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/ADDiffusion + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADDiffusion + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/ADMatDiffusion + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: diffusivity + required: No + default: !!str D + cpp_type: MaterialPropertyName + group_name: + description: | + The diffusivity value or material property + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADMatDiffusion + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + Coupled concentration variable for kernel to operate on; if this is not specified, the kernel's nonlinear variable will be used as usual + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/ADTimeDerivative + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADTimeDerivative + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/ADVectorDiffusion + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADVectorDiffusion + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/ADVectorTimeDerivative + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADVectorTimeDerivative + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/AnisotropicDiffusion + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: tensor_coeff + required: Yes + default: !!str + cpp_type: libMesh::TensorValue + group_name: + description: | + The Tensor to multiply the Diffusion operator by + - name: type + required: No + default: !!str AnisotropicDiffusion + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/ArrayDiffusion + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: diffusion_coefficient + required: No + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the diffusivity, can be scalar, vector, or matrix. + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ArrayDiffusion + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/ArrayReaction + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: reaction_coefficient + required: No + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the reactivity, can be scalar, vector, or matrix. + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ArrayReaction + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/ArrayTimeDerivative + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: time_derivative_coefficient + required: No + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the time derivative coefficient. Can be scalar, vector, or matrix + - name: type + required: No + default: !!str ArrayTimeDerivative + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/BodyForce + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: function + required: No + default: !!str 1 + cpp_type: FunctionName + group_name: + description: | + A function that describes the body force + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: postprocessor + required: No + default: !!str 1 + cpp_type: PostprocessorName + group_name: + description: | + A postprocessor whose value is multiplied by the body force + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str BodyForce + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Coefficient to multiply by the body force term + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/CoefTimeDerivative + description: | + + parameters: + - name: Coefficient + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The coefficient for the time derivative kernel + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: lumping + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True for mass matrix lumping, false otherwise + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str CoefTimeDerivative + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/ConservativeAdvection + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ConservativeAdvection + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: upwinding_type + required: No + default: !!str none + cpp_type: MooseEnum + group_name: + options: none full + description: | + Type of upwinding used. None: Typically results in overshoots and undershoots, but numerical diffusion is minimized. Full: Overshoots and undershoots are avoided, but numerical diffusion is large + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + - name: velocity + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + Velocity vector + subblocks: + - name: /Kernels/CoupledForce + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: coef + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Coefficent ($\sigma$) multiplier for the coupled force term. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str CoupledForce + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The coupled variable which provides the force + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/CoupledTimeDerivative + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str CoupledTimeDerivative + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + Coupled variable + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/MaxwellHNonlinear + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MaxwellHNonlinear + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + - name: x_forcing_func + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The x forcing function. + - name: y_forcing_func + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The y forcing function. + - name: z_forcing_func + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The z forcing function. + subblocks: + - name: /Kernels/Diffusion + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str Diffusion + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/MassEigenKernel + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: eigen + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Use for eigenvalue problem (true) or source problem (false) + - name: eigen_postprocessor + required: No + default: !!str 1 + cpp_type: PostprocessorName + group_name: + description: | + The name of the postprocessor that provides the eigenvalue. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MassEigenKernel + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/MassLumpedTimeDerivative + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MassLumpedTimeDerivative + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/MatCoupledForce + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: coef + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Coefficents ($\sigma$) multiplier for the coupled force term. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: material_properties + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The coupled material properties. + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MatCoupledForce + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The coupled variables which provide the force + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/MatDiffusion + description: | + + parameters: + - name: D_name + required: No + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the diffusivity + - name: args + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + Optional vector of arguments for the diffusivity. If provided and diffusivity is a derivative parsed material, Jacobian contributions from the diffusivity will be automatically computed + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: conc + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + Deprecated! Use 'v' instead + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: diffusivity + required: No + default: !!str D + cpp_type: MaterialPropertyName + group_name: + description: | + The diffusivity value or material property + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MatDiffusion + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + Coupled concentration variable for kernel to operate on; if this is not specified, the kernel's nonlinear variable will be used as usual + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/MaterialDerivativeRankFourTestKernel + description: | + + parameters: + - name: args + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + List of variables the material property depends on + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: derivative + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Select derivative to test derivatives of (leave empty for checking derivatives of the original material property) + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: i + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + Tensor component + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: j + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + Tensor component + - name: k + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + Tensor component + - name: l + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + Tensor component + - name: material_property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + Name of material property for which derivatives are to be tested. + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MaterialDerivativeRankFourTestKernel + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/MaterialDerivativeRankTwoTestKernel + description: | + + parameters: + - name: args + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + List of variables the material property depends on + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: derivative + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Select derivative to test derivatives of (leave empty for checking derivatives of the original material property) + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: i + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + Tensor component + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: j + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + Tensor component + - name: material_property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + Name of material property for which derivatives are to be tested. + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MaterialDerivativeRankTwoTestKernel + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/MaterialDerivativeTestKernel + description: | + + parameters: + - name: args + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + List of variables the material property depends on + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: derivative + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Select derivative to test derivatives of (leave empty for checking derivatives of the original material property) + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: material_property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + Name of material property for which derivatives are to be tested. + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MaterialDerivativeTestKernel + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/MaterialPropertyValue + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: positive + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If the kernel is positive, this is true, if negative, it is false + - name: prop_name + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + Name of material property to be used in the kernel + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MaterialPropertyValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/NullKernel + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: jacobian_fill + required: No + default: !!str 1e-09 + cpp_type: double + group_name: + description: | + On diagonal Jacobian fill term to retain an invertable matrix for the preconditioner + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NullKernel + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/Reaction + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str Reaction + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/TimeDerivative + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: lumping + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True for mass matrix lumping, false otherwise + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str TimeDerivative + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/UserForcingFunction + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: function + required: No + default: !!str 1 + cpp_type: FunctionName + group_name: + description: | + A function that describes the body force + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: postprocessor + required: No + default: !!str 1 + cpp_type: PostprocessorName + group_name: + description: | + A postprocessor whose value is multiplied by the body force + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str UserForcingFunction + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Coefficient to multiply by the body force term + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/VectorBodyForce + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: function + required: No + default: !!str + cpp_type: FunctionName + group_name: + description: | + A function that defines a vectorValue method. This cannot be supplied with the component parameters. + - name: function_x + required: No + default: !!str 1 + cpp_type: FunctionName + group_name: + description: | + A function that describes the x-component of the body force + - name: function_y + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + A function that describes the y-component of the body force + - name: function_z + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + A function that describes the z-component of the body force + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: postprocessor + required: No + default: !!str 1 + cpp_type: PostprocessorName + group_name: + description: | + A postprocessor whose value is multiplied by the body force + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VectorBodyForce + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Coefficient to multiply by the body force term + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/VectorCoupledTimeDerivative + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VectorCoupledTimeDerivative + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + Coupled vector variable + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/VectorDiffusion + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VectorDiffusion + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /Kernels/VectorFEWave + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VectorFEWave + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + - name: x_forcing_func + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The x forcing function. + - name: y_forcing_func + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The y forcing function. + - name: z_forcing_func + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The z forcing function. + subblocks: + - name: /Kernels/VectorTimeDerivative + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's diagonal Jacobian contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: displacements + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The displacements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: lumping + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True for mass matrix lumping, false otherwise + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + The name of auxiliary variables to save this Kernel's residual contributions to. Everything about that variable must match everything about this variable (the type, what blocks it's on, etc.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VectorTimeDerivative + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this Kernel operates on + - name: vector_tags + required: No + default: !!str time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: +- name: /Materials + description: | + + parameters: + subblocks: + - name: /Materials/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /Materials/ADDerivativeParsedMaterial + description: | + + parameters: + - name: args + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + Arguments of F() - use vector coupling + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: compute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false, MOOSE will not call compute methods on this material. The user must call computeProperties() after retrieving the MaterialBase via MaterialBasePropertyInterface::getMaterialBase(). Non-computed MaterialBases are not sorted for dependencies. + - name: constant_expressions + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of values for the constants in constant_names (can be an FParser expression) + - name: constant_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of constants used in the parsed function (use this for kB etc.) + - name: constant_on + required: No + default: !!str NONE + cpp_type: MooseEnum + group_name: + options: NONE ELEMENT SUBDOMAIN + description: | + When ELEMENT, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps.When SUBDOMAIN, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps. Evaluations on element qps will be skipped + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: derivative_order + required: No + default: !!str 3 + cpp_type: unsigned int + group_name: + description: | + Maximum order of derivatives taken + - name: disable_fpoptimizer + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Disable the function parser algebraic optimizer + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: enable_ad_cache + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable cacheing of function derivatives for faster startup time + - name: enable_auto_optimize + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable automatic immediate optimization of derivatives + - name: enable_jit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable just-in-time compilation of function expressions for faster evaluation + - name: evalerror_behavior + required: No + default: !!str nan + cpp_type: MooseEnum + group_name: 'Advanced' + options: nan nan_warning error exception + description: | + What to do if evaluation error occurs. Options are to pass a nan, pass a nan with a warning, throw a error, or throw an exception + - name: f_name + required: No + default: !!str F + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Base name of the free energy function (used to name the material properties) + - name: fail_on_evalerror + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Fail fatally if a function evaluation returns an error code (otherwise just pass on NaN) + - name: function + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + FParser function expression for the phase free energy + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: material_property_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of material properties used in the parsed function + - name: output_properties + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Outputs' + description: | + List of material properties, from this material, to output (outputs must also be defined to an output type) + - name: outputs + required: No + default: !!str none + cpp_type: std::vector > + group_name: 'Outputs' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: tol_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of variable names to be protected from being 0 or 1 within a tolerance (needed for log(c) and log(1-c) terms) + - name: tol_values + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Vector of tolerance values for the variables in tol_names + - name: type + required: No + default: !!str ADDerivativeParsedMaterial + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Materials/ADGenericConstantMaterial + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: compute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false, MOOSE will not call compute methods on this material. The user must call computeProperties() after retrieving the MaterialBase via MaterialBasePropertyInterface::getMaterialBase(). Non-computed MaterialBases are not sorted for dependencies. + - name: constant_on + required: No + default: !!str SUBDOMAIN + cpp_type: MooseEnum + group_name: + options: NONE ELEMENT SUBDOMAIN + description: | + When ELEMENT, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps.When SUBDOMAIN, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps. Evaluations on element qps will be skipped + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: output_properties + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Outputs' + description: | + List of material properties, from this material, to output (outputs must also be defined to an output type) + - name: outputs + required: No + default: !!str none + cpp_type: std::vector > + group_name: 'Outputs' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: prop_names + required: Yes + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The names of the properties this material will have + - name: prop_values + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The values associated with the named properties + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADGenericConstantMaterial + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Materials/ADGenericFunctionMaterial + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: compute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false, MOOSE will not call compute methods on this material. The user must call computeProperties() after retrieving the MaterialBase via MaterialBasePropertyInterface::getMaterialBase(). Non-computed MaterialBases are not sorted for dependencies. + - name: constant_on + required: No + default: !!str NONE + cpp_type: MooseEnum + group_name: + options: NONE ELEMENT SUBDOMAIN + description: | + When ELEMENT, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps.When SUBDOMAIN, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps. Evaluations on element qps will be skipped + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: enable_stateful + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable the declaration of old and older values + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: output_properties + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Outputs' + description: | + List of material properties, from this material, to output (outputs must also be defined to an output type) + - name: outputs + required: No + default: !!str none + cpp_type: std::vector > + group_name: 'Outputs' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: prop_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The names of the properties this material will have + - name: prop_values + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The corresponding names of the functions that are going to provide the values for the variables + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADGenericFunctionMaterial + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Materials/ADParsedMaterial + description: | + + parameters: + - name: args + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + Arguments of F() - use vector coupling + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: compute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false, MOOSE will not call compute methods on this material. The user must call computeProperties() after retrieving the MaterialBase via MaterialBasePropertyInterface::getMaterialBase(). Non-computed MaterialBases are not sorted for dependencies. + - name: constant_expressions + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of values for the constants in constant_names (can be an FParser expression) + - name: constant_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of constants used in the parsed function (use this for kB etc.) + - name: constant_on + required: No + default: !!str NONE + cpp_type: MooseEnum + group_name: + options: NONE ELEMENT SUBDOMAIN + description: | + When ELEMENT, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps.When SUBDOMAIN, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps. Evaluations on element qps will be skipped + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: disable_fpoptimizer + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Disable the function parser algebraic optimizer + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: enable_ad_cache + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable cacheing of function derivatives for faster startup time + - name: enable_auto_optimize + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable automatic immediate optimization of derivatives + - name: enable_jit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable just-in-time compilation of function expressions for faster evaluation + - name: evalerror_behavior + required: No + default: !!str nan + cpp_type: MooseEnum + group_name: 'Advanced' + options: nan nan_warning error exception + description: | + What to do if evaluation error occurs. Options are to pass a nan, pass a nan with a warning, throw a error, or throw an exception + - name: f_name + required: No + default: !!str F + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Base name of the free energy function (used to name the material properties) + - name: fail_on_evalerror + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Fail fatally if a function evaluation returns an error code (otherwise just pass on NaN) + - name: function + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + FParser function expression for the phase free energy + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: material_property_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of material properties used in the parsed function + - name: output_properties + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Outputs' + description: | + List of material properties, from this material, to output (outputs must also be defined to an output type) + - name: outputs + required: No + default: !!str none + cpp_type: std::vector > + group_name: 'Outputs' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: tol_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of variable names to be protected from being 0 or 1 within a tolerance (needed for log(c) and log(1-c) terms) + - name: tol_values + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Vector of tolerance values for the variables in tol_names + - name: type + required: No + default: !!str ADParsedMaterial + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Materials/ADPiecewiseLinearInterpolationMaterial + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: compute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false, MOOSE will not call compute methods on this material. The user must call computeProperties() after retrieving the MaterialBase via MaterialBasePropertyInterface::getMaterialBase(). Non-computed MaterialBases are not sorted for dependencies. + - name: constant_on + required: No + default: !!str NONE + cpp_type: MooseEnum + group_name: + options: NONE ELEMENT SUBDOMAIN + description: | + When ELEMENT, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps.When SUBDOMAIN, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps. Evaluations on element qps will be skipped + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extrapolation + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Use linear extrapolation to evaluate points that lie outside given data set domain. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: output_properties + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Outputs' + description: | + List of material properties, from this material, to output (outputs must also be defined to an output type) + - name: outputs + required: No + default: !!str none + cpp_type: std::vector > + group_name: 'Outputs' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: property + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name of the property this material will compute + - name: scale_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Scale factor to be applied to the ordinate values + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADPiecewiseLinearInterpolationMaterial + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable whose value is used as the abscissa in the interpolation + - name: x + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The abscissa values + - name: xy_data + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + All function data, supplied in abscissa, ordinate pairs + - name: y + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The ordinate values + subblocks: + - name: /Materials/Conductor + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: compute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false, MOOSE will not call compute methods on this material. The user must call computeProperties() after retrieving the MaterialBase via MaterialBasePropertyInterface::getMaterialBase(). Non-computed MaterialBases are not sorted for dependencies. + - name: constant_on + required: No + default: !!str NONE + cpp_type: MooseEnum + group_name: + options: NONE ELEMENT SUBDOMAIN + description: | + When ELEMENT, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps.When SUBDOMAIN, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps. Evaluations on element qps will be skipped + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: output_properties + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Outputs' + description: | + List of material properties, from this material, to output (outputs must also be defined to an output type) + - name: outputs + required: No + default: !!str none + cpp_type: std::vector > + group_name: 'Outputs' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: resistivity + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The resistivity ($\rho$) of the conductor. Defaults to 1 + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str Conductor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Materials/DerivativeParsedMaterial + description: | + + parameters: + - name: args + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + Arguments of F() - use vector coupling + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: compute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false, MOOSE will not call compute methods on this material. The user must call computeProperties() after retrieving the MaterialBase via MaterialBasePropertyInterface::getMaterialBase(). Non-computed MaterialBases are not sorted for dependencies. + - name: constant_expressions + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of values for the constants in constant_names (can be an FParser expression) + - name: constant_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of constants used in the parsed function (use this for kB etc.) + - name: constant_on + required: No + default: !!str NONE + cpp_type: MooseEnum + group_name: + options: NONE ELEMENT SUBDOMAIN + description: | + When ELEMENT, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps.When SUBDOMAIN, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps. Evaluations on element qps will be skipped + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: derivative_order + required: No + default: !!str 3 + cpp_type: unsigned int + group_name: + description: | + Maximum order of derivatives taken + - name: disable_fpoptimizer + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Disable the function parser algebraic optimizer + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: enable_ad_cache + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable cacheing of function derivatives for faster startup time + - name: enable_auto_optimize + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable automatic immediate optimization of derivatives + - name: enable_jit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable just-in-time compilation of function expressions for faster evaluation + - name: evalerror_behavior + required: No + default: !!str nan + cpp_type: MooseEnum + group_name: 'Advanced' + options: nan nan_warning error exception + description: | + What to do if evaluation error occurs. Options are to pass a nan, pass a nan with a warning, throw a error, or throw an exception + - name: f_name + required: No + default: !!str F + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Base name of the free energy function (used to name the material properties) + - name: fail_on_evalerror + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Fail fatally if a function evaluation returns an error code (otherwise just pass on NaN) + - name: function + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + FParser function expression for the phase free energy + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: material_property_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of material properties used in the parsed function + - name: output_properties + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Outputs' + description: | + List of material properties, from this material, to output (outputs must also be defined to an output type) + - name: outputs + required: No + default: !!str none + cpp_type: std::vector > + group_name: 'Outputs' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: tol_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of variable names to be protected from being 0 or 1 within a tolerance (needed for log(c) and log(1-c) terms) + - name: tol_values + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Vector of tolerance values for the variables in tol_names + - name: type + required: No + default: !!str DerivativeParsedMaterial + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Materials/DerivativeSumMaterial + description: | + + parameters: + - name: args + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + Arguments of the free energy functions being summed - use vector coupling + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: compute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false, MOOSE will not call compute methods on this material. The user must call computeProperties() after retrieving the MaterialBase via MaterialBasePropertyInterface::getMaterialBase(). Non-computed MaterialBases are not sorted for dependencies. + - name: constant + required: No + default: !!str 0 + cpp_type: double + group_name: 'Advanced' + description: | + Constant to be added to the prefactor multiplied sum. + - name: constant_on + required: No + default: !!str NONE + cpp_type: MooseEnum + group_name: + options: NONE ELEMENT SUBDOMAIN + description: | + When ELEMENT, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps.When SUBDOMAIN, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps. Evaluations on element qps will be skipped + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: derivative_order + required: No + default: !!str 3 + cpp_type: unsigned int + group_name: + description: | + Maximum order of derivatives taken (2 or 3) + - name: displacement_gradients + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + Vector of displacement gradient variables (see Modules/PhaseField/DisplacementGradients action) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: f_name + required: No + default: !!str F + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Base name of the free energy function (used to name the material properties) + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: output_properties + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Outputs' + description: | + List of material properties, from this material, to output (outputs must also be defined to an output type) + - name: outputs + required: No + default: !!str none + cpp_type: std::vector > + group_name: 'Outputs' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: prefactor + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Prefactor to multiply the sum term with. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: sum_materials + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Base name of the free energy function (used to name the material properties) + - name: third_derivatives + required: No + default: !!str + cpp_type: bool + group_name: + description: | + Flag to indicate if third derivatives are needed + - name: type + required: No + default: !!str DerivativeSumMaterial + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: validate_coupling + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Check if all variables the specified materials depend on are listed in the `args` parameter. + subblocks: + - name: /Materials/GenericConstant2DArray + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: compute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false, MOOSE will not call compute methods on this material. The user must call computeProperties() after retrieving the MaterialBase via MaterialBasePropertyInterface::getMaterialBase(). Non-computed MaterialBases are not sorted for dependencies. + - name: constant_on + required: No + default: !!str SUBDOMAIN + cpp_type: MooseEnum + group_name: + options: NONE ELEMENT SUBDOMAIN + description: | + When ELEMENT, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps.When SUBDOMAIN, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps. Evaluations on element qps will be skipped + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: output_properties + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Outputs' + description: | + List of material properties, from this material, to output (outputs must also be defined to an output type) + - name: outputs + required: No + default: !!str none + cpp_type: std::vector > + group_name: 'Outputs' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: prop_name + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The names of the properties this material will have + - name: prop_value + required: Yes + default: !!str + cpp_type: Eigen::Matrix + group_name: + description: | + The values associated with the named properties + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str GenericConstant2DArray + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Materials/GenericConstantArray + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: compute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false, MOOSE will not call compute methods on this material. The user must call computeProperties() after retrieving the MaterialBase via MaterialBasePropertyInterface::getMaterialBase(). Non-computed MaterialBases are not sorted for dependencies. + - name: constant_on + required: No + default: !!str SUBDOMAIN + cpp_type: MooseEnum + group_name: + options: NONE ELEMENT SUBDOMAIN + description: | + When ELEMENT, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps.When SUBDOMAIN, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps. Evaluations on element qps will be skipped + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: output_properties + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Outputs' + description: | + List of material properties, from this material, to output (outputs must also be defined to an output type) + - name: outputs + required: No + default: !!str none + cpp_type: std::vector > + group_name: 'Outputs' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: prop_name + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The names of the properties this material will have + - name: prop_value + required: Yes + default: !!str + cpp_type: Eigen::Matrix + group_name: + description: | + The values associated with the named properties + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str GenericConstantArray + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Materials/GenericConstantMaterial + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: compute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false, MOOSE will not call compute methods on this material. The user must call computeProperties() after retrieving the MaterialBase via MaterialBasePropertyInterface::getMaterialBase(). Non-computed MaterialBases are not sorted for dependencies. + - name: constant_on + required: No + default: !!str SUBDOMAIN + cpp_type: MooseEnum + group_name: + options: NONE ELEMENT SUBDOMAIN + description: | + When ELEMENT, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps.When SUBDOMAIN, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps. Evaluations on element qps will be skipped + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: output_properties + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Outputs' + description: | + List of material properties, from this material, to output (outputs must also be defined to an output type) + - name: outputs + required: No + default: !!str none + cpp_type: std::vector > + group_name: 'Outputs' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: prop_names + required: Yes + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The names of the properties this material will have + - name: prop_values + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The values associated with the named properties + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str GenericConstantMaterial + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Materials/GenericConstantRankTwoTensor + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: compute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false, MOOSE will not call compute methods on this material. The user must call computeProperties() after retrieving the MaterialBase via MaterialBasePropertyInterface::getMaterialBase(). Non-computed MaterialBases are not sorted for dependencies. + - name: constant_on + required: No + default: !!str SUBDOMAIN + cpp_type: MooseEnum + group_name: + options: NONE ELEMENT SUBDOMAIN + description: | + When ELEMENT, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps.When SUBDOMAIN, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps. Evaluations on element qps will be skipped + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: output_properties + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Outputs' + description: | + List of material properties, from this material, to output (outputs must also be defined to an output type) + - name: outputs + required: No + default: !!str none + cpp_type: std::vector > + group_name: 'Outputs' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: tensor_name + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + Name of the tensor material property to be created + - name: tensor_values + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + Vector of values defining the constant rank two tensor + - name: type + required: No + default: !!str GenericConstantRankTwoTensor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Materials/GenericFunctionMaterial + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: compute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false, MOOSE will not call compute methods on this material. The user must call computeProperties() after retrieving the MaterialBase via MaterialBasePropertyInterface::getMaterialBase(). Non-computed MaterialBases are not sorted for dependencies. + - name: constant_on + required: No + default: !!str NONE + cpp_type: MooseEnum + group_name: + options: NONE ELEMENT SUBDOMAIN + description: | + When ELEMENT, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps.When SUBDOMAIN, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps. Evaluations on element qps will be skipped + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: enable_stateful + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable the declaration of old and older values + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: output_properties + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Outputs' + description: | + List of material properties, from this material, to output (outputs must also be defined to an output type) + - name: outputs + required: No + default: !!str none + cpp_type: std::vector > + group_name: 'Outputs' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: prop_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The names of the properties this material will have + - name: prop_values + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The corresponding names of the functions that are going to provide the values for the variables + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str GenericFunctionMaterial + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Materials/MaterialConverter + description: | + + parameters: + - name: ad_props_in + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The names of the AD material properties to convert to regular properties + - name: ad_props_out + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The names of the output AD properties + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: compute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false, MOOSE will not call compute methods on this material. The user must call computeProperties() after retrieving the MaterialBase via MaterialBasePropertyInterface::getMaterialBase(). Non-computed MaterialBases are not sorted for dependencies. + - name: constant_on + required: No + default: !!str NONE + cpp_type: MooseEnum + group_name: + options: NONE ELEMENT SUBDOMAIN + description: | + When ELEMENT, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps.When SUBDOMAIN, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps. Evaluations on element qps will be skipped + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: intra_convert + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether to intra convert, e.g. regular->regular, ad->ad + - name: output_properties + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Outputs' + description: | + List of material properties, from this material, to output (outputs must also be defined to an output type) + - name: outputs + required: No + default: !!str none + cpp_type: std::vector > + group_name: 'Outputs' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: reg_props_in + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The names of the regular material properties to convert to AD properties + - name: reg_props_out + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The names of the output regular properties + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MaterialConverter + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Materials/ParsedMaterial + description: | + + parameters: + - name: args + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + Arguments of F() - use vector coupling + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: compute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false, MOOSE will not call compute methods on this material. The user must call computeProperties() after retrieving the MaterialBase via MaterialBasePropertyInterface::getMaterialBase(). Non-computed MaterialBases are not sorted for dependencies. + - name: constant_expressions + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of values for the constants in constant_names (can be an FParser expression) + - name: constant_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of constants used in the parsed function (use this for kB etc.) + - name: constant_on + required: No + default: !!str NONE + cpp_type: MooseEnum + group_name: + options: NONE ELEMENT SUBDOMAIN + description: | + When ELEMENT, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps.When SUBDOMAIN, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps. Evaluations on element qps will be skipped + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: disable_fpoptimizer + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Disable the function parser algebraic optimizer + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: enable_ad_cache + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable cacheing of function derivatives for faster startup time + - name: enable_auto_optimize + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable automatic immediate optimization of derivatives + - name: enable_jit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable just-in-time compilation of function expressions for faster evaluation + - name: evalerror_behavior + required: No + default: !!str nan + cpp_type: MooseEnum + group_name: 'Advanced' + options: nan nan_warning error exception + description: | + What to do if evaluation error occurs. Options are to pass a nan, pass a nan with a warning, throw a error, or throw an exception + - name: f_name + required: No + default: !!str F + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Base name of the free energy function (used to name the material properties) + - name: fail_on_evalerror + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Fail fatally if a function evaluation returns an error code (otherwise just pass on NaN) + - name: function + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + FParser function expression for the phase free energy + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: material_property_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of material properties used in the parsed function + - name: output_properties + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Outputs' + description: | + List of material properties, from this material, to output (outputs must also be defined to an output type) + - name: outputs + required: No + default: !!str none + cpp_type: std::vector > + group_name: 'Outputs' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: tol_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of variable names to be protected from being 0 or 1 within a tolerance (needed for log(c) and log(1-c) terms) + - name: tol_values + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Vector of tolerance values for the variables in tol_names + - name: type + required: No + default: !!str ParsedMaterial + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Materials/PiecewiseLinearInterpolationMaterial + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: compute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false, MOOSE will not call compute methods on this material. The user must call computeProperties() after retrieving the MaterialBase via MaterialBasePropertyInterface::getMaterialBase(). Non-computed MaterialBases are not sorted for dependencies. + - name: constant_on + required: No + default: !!str NONE + cpp_type: MooseEnum + group_name: + options: NONE ELEMENT SUBDOMAIN + description: | + When ELEMENT, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps.When SUBDOMAIN, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps. Evaluations on element qps will be skipped + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extrapolation + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Use linear extrapolation to evaluate points that lie outside given data set domain. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: output_properties + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Outputs' + description: | + List of material properties, from this material, to output (outputs must also be defined to an output type) + - name: outputs + required: No + default: !!str none + cpp_type: std::vector > + group_name: 'Outputs' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: property + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name of the property this material will compute + - name: scale_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Scale factor to be applied to the ordinate values + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str PiecewiseLinearInterpolationMaterial + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable whose value is used as the abscissa in the interpolation + - name: x + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The abscissa values + - name: xy_data + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + All function data, supplied in abscissa, ordinate pairs + - name: y + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The ordinate values + subblocks: + - name: /Materials/RankFourTensorMaterialConverter + description: | + + parameters: + - name: ad_props_in + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The names of the AD material properties to convert to regular properties + - name: ad_props_out + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The names of the output AD properties + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: compute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false, MOOSE will not call compute methods on this material. The user must call computeProperties() after retrieving the MaterialBase via MaterialBasePropertyInterface::getMaterialBase(). Non-computed MaterialBases are not sorted for dependencies. + - name: constant_on + required: No + default: !!str NONE + cpp_type: MooseEnum + group_name: + options: NONE ELEMENT SUBDOMAIN + description: | + When ELEMENT, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps.When SUBDOMAIN, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps. Evaluations on element qps will be skipped + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: intra_convert + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether to intra convert, e.g. regular->regular, ad->ad + - name: output_properties + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Outputs' + description: | + List of material properties, from this material, to output (outputs must also be defined to an output type) + - name: outputs + required: No + default: !!str none + cpp_type: std::vector > + group_name: 'Outputs' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: reg_props_in + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The names of the regular material properties to convert to AD properties + - name: reg_props_out + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The names of the output regular properties + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str RankFourTensorMaterialConverter + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Materials/RankTwoTensorMaterialConverter + description: | + + parameters: + - name: ad_props_in + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The names of the AD material properties to convert to regular properties + - name: ad_props_out + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The names of the output AD properties + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: compute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false, MOOSE will not call compute methods on this material. The user must call computeProperties() after retrieving the MaterialBase via MaterialBasePropertyInterface::getMaterialBase(). Non-computed MaterialBases are not sorted for dependencies. + - name: constant_on + required: No + default: !!str NONE + cpp_type: MooseEnum + group_name: + options: NONE ELEMENT SUBDOMAIN + description: | + When ELEMENT, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps.When SUBDOMAIN, MOOSE will only call computeQpProperties() for the 0th quadrature point, and then copy that value to the other qps. Evaluations on element qps will be skipped + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: intra_convert + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether to intra convert, e.g. regular->regular, ad->ad + - name: output_properties + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Outputs' + description: | + List of material properties, from this material, to output (outputs must also be defined to an output type) + - name: outputs + required: No + default: !!str none + cpp_type: std::vector > + group_name: 'Outputs' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: reg_props_in + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The names of the regular material properties to convert to AD properties + - name: reg_props_out + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The names of the output regular properties + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str RankTwoTensorMaterialConverter + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: +- name: /Mesh + description: | + + parameters: + - name: displacements + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The variables corresponding to the x y z displacements of the mesh. If this is provided then the displacements will be taken into account during the computation. Creation of the displaced mesh can be suppressed even if this is set by setting 'use_displaced_mesh = false'. + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: use_displaced_mesh + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Create the displaced mesh if the 'displacements' parameter is set. If this is 'false', a displaced mesh will not be created, regardless of whether 'displacements' is set. + - name: include_local_in_ghosting + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Boolean used to toggle on the inclusion of local elements along with the ghost elements for a complete partition map + - name: output_ghosting + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Boolean to turn on ghosting auxiliary fields + - name: block_id + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Add Names' + description: | + IDs of the block id/name pairs + - name: block_name + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Add Names' + description: | + Names of the block id/name pairs (must correspond with "block_id" + - name: boundary_id + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Add Names' + description: | + IDs of the boundary id/name pairs + - name: boundary_name + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Add Names' + description: | + Names of the boundary id/name pairs (must correspond with "boundary_id" + - name: construct_side_list_from_node_list + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + If true, construct side lists from the nodesets in the mesh (i.e. if every node on a give side is in a nodeset then add that side to a sideset + - name: ghosted_boundaries + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Boundaries to be ghosted if using Nemesis + - name: ghosted_boundaries_inflation + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + If you are using ghosted boundaries you will want to set this value to a vector of amounts to inflate the bounding boxes by. ie if you are running a 3D problem you might set it to '0.2 0.1 0.4' + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: second_order + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Converts a first order mesh to a second order mesh. Note: This is NOT needed if you are reading an actual first order mesh. + - name: skip_partitioning + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + If true the mesh won't be partitioned. This may cause large load imbalanced but is currently required if you have a simulation containing uniform refinement, adaptivity and stateful material properties + - name: type + required: Yes + default: !!str FileMesh + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + - name: uniform_refine + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + Specify the level of uniform refinement applied to the initial mesh + subblocks: + - name: /Mesh/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /Mesh/ + description: | + + parameters: + subblocks: + - name: /Mesh//AnnularMesh + description: | + + parameters: + - name: allow_renumbering + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If allow_renumbering=false, node and element numbers are kept fixed until deletion + - name: centroid_partitioner_direction + required: No + default: !!str + cpp_type: MooseEnum + group_name: 'Partitioning' + options: x y z radial + description: | + Specifies the sort direction if using the centroid partitioner. Available options: x, y, z, radial + - name: construct_node_list_from_side_list + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Whether or not to generate nodesets from the sidesets (usually a good idea). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: No + default: !!str 1 + cpp_type: MooseEnum + group_name: 'Advanced' + options: 1 2 3 + description: | + This is only required for certain mesh formats where the dimension of the mesh cannot be autodetected. In particular you must supply this for GMSH meshes. Note: This is completely ignored for ExodusII meshes! + - name: dmax + required: No + default: !!str 360 + cpp_type: double + group_name: + description: | + Maximum angle, measured in degrees anticlockwise from x axis. If dmin=0 and dmax=360 an annular mesh is created. Otherwise, only a sector of an annulus is created + - name: dmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Minimum degree, measured in degrees anticlockwise from x axis + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: ghosting_patch_size + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of nearest neighbors considered for ghosting purposes when 'iteration' patch update strategy is used. Default is 5 * patch_size. + - name: growth_r + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The ratio of radial sizes of successive rings of elements + - name: max_leaf_size + required: No + default: !!str 10 + cpp_type: unsigned int + group_name: + description: | + The maximum number of points in each leaf of the KDTree used in the nearest neighbor search. As the leaf size becomes larger,KDTree construction becomes faster but the nearest neighbor searchbecomes slower. + - name: nemesis + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + If nemesis=true and file=foo.e, actually reads foo.e.N.0, foo.e.N.1, ... foo.e.N.N-1, where N = # CPUs, with NemesisIO. + - name: nr + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the radial direction + - name: nt + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + Number of elements in the angular direction + - name: parallel_type + required: No + default: !!str DEFAULT + cpp_type: MooseEnum + group_name: + options: DEFAULT REPLICATED DISTRIBUTED + description: | + DEFAULT: Use libMesh::ReplicatedMesh unless --distributed-mesh is specified on the command line REPLICATED: Always use libMesh::ReplicatedMesh DISTRIBUTED: Always use libMesh::DistributedMesh + - name: partitioner + required: No + default: !!str default + cpp_type: MooseEnum + group_name: 'Partitioning' + options: default metis parmetis linear centroid hilbert_sfc morton_sfc + description: | + Specifies a mesh partitioner to use when splitting the mesh for a parallel computation. + - name: patch_size + required: No + default: !!str 40 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of nodes to consider in the NearestNode neighborhood. + - name: patch_update_strategy + required: No + default: !!str never + cpp_type: MooseEnum + group_name: 'Advanced' + options: never always auto iteration + description: | + How often to update the geometric search 'patch'. The default is to never update it (which is the most efficient but could be a problem with lots of relative motion). 'always' will update the patch for all slave nodes at the beginning of every timestep which might be time consuming. 'auto' will attempt to determine at the start of which timesteps the patch for all slave nodes needs to be updated automatically.'iteration' updates the patch at every nonlinear iteration for a subset of slave nodes for which penetration is not detected. If there can be substantial relative motion between the master and slave surfaces during the nonlinear iterations within a timestep, it is advisable to use 'iteration' option to ensure accurate contact detection. + - name: quad_subdomain_id + required: No + default: !!str 0 + cpp_type: unsigned short + group_name: + description: | + The subdomain ID given to the QUAD4 elements + - name: rmax + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Outer radius + - name: rmin + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Inner radius. If rmin=0 then a disc mesh (with no central hole) will be created. + - name: tmax + required: No + default: !!str 6.28319 + cpp_type: double + group_name: + description: | + Maximum angle, measured in radians anticlockwise from x axis. If tmin=0 and tmax=2Pi an annular mesh is created. Otherwise, only a sector of an annulus is created + - name: tmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Minimum angle, measured in radians anticlockwise from x axis + - name: tri_subdomain_id + required: No + default: !!str 1 + cpp_type: unsigned short + group_name: + description: | + The subdomain ID given to the TRI3 elements (these exist only if rmin=0, and they exist at the center of the disc + - name: type + required: No + default: !!str AnnularMesh + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh//ConcentricCircleMesh + description: | + + parameters: + - name: allow_renumbering + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If allow_renumbering=false, node and element numbers are kept fixed until deletion + - name: centroid_partitioner_direction + required: No + default: !!str + cpp_type: MooseEnum + group_name: 'Partitioning' + options: x y z radial + description: | + Specifies the sort direction if using the centroid partitioner. Available options: x, y, z, radial + - name: construct_node_list_from_side_list + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Whether or not to generate nodesets from the sidesets (usually a good idea). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: No + default: !!str 1 + cpp_type: MooseEnum + group_name: 'Advanced' + options: 1 2 3 + description: | + This is only required for certain mesh formats where the dimension of the mesh cannot be autodetected. In particular you must supply this for GMSH meshes. Note: This is completely ignored for ExodusII meshes! + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: ghosting_patch_size + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of nearest neighbors considered for ghosting purposes when 'iteration' patch update strategy is used. Default is 5 * patch_size. + - name: has_outer_square + required: Yes + default: !!str + cpp_type: bool + group_name: + description: | + It determines if meshes for a outer square are added to concentric circle meshes. + - name: inner_mesh_fraction + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Length of inner square / radius of the innermost circle + - name: max_leaf_size + required: No + default: !!str 10 + cpp_type: unsigned int + group_name: + description: | + The maximum number of points in each leaf of the KDTree used in the nearest neighbor search. As the leaf size becomes larger,KDTree construction becomes faster but the nearest neighbor searchbecomes slower. + - name: nemesis + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + If nemesis=true and file=foo.e, actually reads foo.e.N.0, foo.e.N.1, ... foo.e.N.N-1, where N = # CPUs, with NemesisIO. + - name: num_sectors + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + num_sectors % 2 = 0, num_sectors > 0Number of azimuthal sectors in each quadrant'num_sectors' must be an even number. + - name: parallel_type + required: No + default: !!str DEFAULT + cpp_type: MooseEnum + group_name: + options: DEFAULT REPLICATED DISTRIBUTED + description: | + DEFAULT: Use libMesh::ReplicatedMesh unless --distributed-mesh is specified on the command line REPLICATED: Always use libMesh::ReplicatedMesh DISTRIBUTED: Always use libMesh::DistributedMesh + - name: partitioner + required: No + default: !!str default + cpp_type: MooseEnum + group_name: 'Partitioning' + options: default metis parmetis linear centroid hilbert_sfc morton_sfc + description: | + Specifies a mesh partitioner to use when splitting the mesh for a parallel computation. + - name: patch_size + required: No + default: !!str 40 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of nodes to consider in the NearestNode neighborhood. + - name: patch_update_strategy + required: No + default: !!str never + cpp_type: MooseEnum + group_name: 'Advanced' + options: never always auto iteration + description: | + How often to update the geometric search 'patch'. The default is to never update it (which is the most efficient but could be a problem with lots of relative motion). 'always' will update the patch for all slave nodes at the beginning of every timestep which might be time consuming. 'auto' will attempt to determine at the start of which timesteps the patch for all slave nodes needs to be updated automatically.'iteration' updates the patch at every nonlinear iteration for a subset of slave nodes for which penetration is not detected. If there can be substantial relative motion between the master and slave surfaces during the nonlinear iterations within a timestep, it is advisable to use 'iteration' option to ensure accurate contact detection. + - name: pitch + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The moderator can be added to complete meshes for one unit cell of fuel assembly.Elements are quad meshes. + - name: portion + required: No + default: !!str full + cpp_type: MooseEnum + group_name: + options: full top_right top_left bottom_left bottom_right right_half left_half top_half bottom_half + description: | + Control of which part of mesh is created + - name: preserve_volumes + required: Yes + default: !!str + cpp_type: bool + group_name: + description: | + Volume of concentric circles can be preserved using this function. + - name: radii + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + Radii of major concentric circles + - name: rings + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + Number of rings in each circle or in the moderator + - name: type + required: No + default: !!str ConcentricCircleMesh + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh//FileMesh + description: | + + parameters: + - name: allow_renumbering + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If allow_renumbering=false, node and element numbers are kept fixed until deletion + - name: centroid_partitioner_direction + required: No + default: !!str + cpp_type: MooseEnum + group_name: 'Partitioning' + options: x y z radial + description: | + Specifies the sort direction if using the centroid partitioner. Available options: x, y, z, radial + - name: construct_node_list_from_side_list + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Whether or not to generate nodesets from the sidesets (usually a good idea). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: No + default: !!str 1 + cpp_type: MooseEnum + group_name: 'Advanced' + options: 1 2 3 + description: | + This is only required for certain mesh formats where the dimension of the mesh cannot be autodetected. In particular you must supply this for GMSH meshes. Note: This is completely ignored for ExodusII meshes! + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: file + required: Yes + default: !!str + cpp_type: MeshFileName + group_name: + description: | + The name of the mesh file to read + - name: ghosting_patch_size + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of nearest neighbors considered for ghosting purposes when 'iteration' patch update strategy is used. Default is 5 * patch_size. + - name: max_leaf_size + required: No + default: !!str 10 + cpp_type: unsigned int + group_name: + description: | + The maximum number of points in each leaf of the KDTree used in the nearest neighbor search. As the leaf size becomes larger,KDTree construction becomes faster but the nearest neighbor searchbecomes slower. + - name: nemesis + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + If nemesis=true and file=foo.e, actually reads foo.e.N.0, foo.e.N.1, ... foo.e.N.N-1, where N = # CPUs, with NemesisIO. + - name: parallel_type + required: No + default: !!str DEFAULT + cpp_type: MooseEnum + group_name: + options: DEFAULT REPLICATED DISTRIBUTED + description: | + DEFAULT: Use libMesh::ReplicatedMesh unless --distributed-mesh is specified on the command line REPLICATED: Always use libMesh::ReplicatedMesh DISTRIBUTED: Always use libMesh::DistributedMesh + - name: partitioner + required: No + default: !!str default + cpp_type: MooseEnum + group_name: 'Partitioning' + options: default metis parmetis linear centroid hilbert_sfc morton_sfc + description: | + Specifies a mesh partitioner to use when splitting the mesh for a parallel computation. + - name: patch_size + required: No + default: !!str 40 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of nodes to consider in the NearestNode neighborhood. + - name: patch_update_strategy + required: No + default: !!str never + cpp_type: MooseEnum + group_name: 'Advanced' + options: never always auto iteration + description: | + How often to update the geometric search 'patch'. The default is to never update it (which is the most efficient but could be a problem with lots of relative motion). 'always' will update the patch for all slave nodes at the beginning of every timestep which might be time consuming. 'auto' will attempt to determine at the start of which timesteps the patch for all slave nodes needs to be updated automatically.'iteration' updates the patch at every nonlinear iteration for a subset of slave nodes for which penetration is not detected. If there can be substantial relative motion between the master and slave surfaces during the nonlinear iterations within a timestep, it is advisable to use 'iteration' option to ensure accurate contact detection. + - name: type + required: No + default: !!str FileMesh + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh//GeneratedMesh + description: | + + parameters: + - name: allow_renumbering + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If allow_renumbering=false, node and element numbers are kept fixed until deletion + - name: bias_x + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the x-direction. + - name: bias_y + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the y-direction. + - name: bias_z + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the z-direction. + - name: centroid_partitioner_direction + required: No + default: !!str + cpp_type: MooseEnum + group_name: 'Partitioning' + options: x y z radial + description: | + Specifies the sort direction if using the centroid partitioner. Available options: x, y, z, radial + - name: construct_node_list_from_side_list + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Whether or not to generate nodesets from the sidesets (usually a good idea). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: 'Main' + options: 1 2 3 + description: | + The dimension of the mesh to be generated + - name: elem_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: EDGE EDGE2 EDGE3 EDGE4 QUAD QUAD4 QUAD8 QUAD9 TRI3 TRI6 HEX HEX8 HEX20 HEX27 TET4 TET10 PRISM6 PRISM15 PRISM18 PYRAMID5 PYRAMID13 PYRAMID14 + description: | + The type of element from libMesh to generate (default: linear element for requested dimension) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: gauss_lobatto_grid + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Grade mesh into boundaries according to Gauss-Lobatto quadrature spacing. + - name: ghosting_patch_size + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of nearest neighbors considered for ghosting purposes when 'iteration' patch update strategy is used. Default is 5 * patch_size. + - name: max_leaf_size + required: No + default: !!str 10 + cpp_type: unsigned int + group_name: + description: | + The maximum number of points in each leaf of the KDTree used in the nearest neighbor search. As the leaf size becomes larger,KDTree construction becomes faster but the nearest neighbor searchbecomes slower. + - name: nemesis + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + If nemesis=true and file=foo.e, actually reads foo.e.N.0, foo.e.N.1, ... foo.e.N.N-1, where N = # CPUs, with NemesisIO. + - name: nx + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the X direction + - name: ny + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the Y direction + - name: nz + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the Z direction + - name: parallel_type + required: No + default: !!str DEFAULT + cpp_type: MooseEnum + group_name: + options: DEFAULT REPLICATED DISTRIBUTED + description: | + DEFAULT: Use libMesh::ReplicatedMesh unless --distributed-mesh is specified on the command line REPLICATED: Always use libMesh::ReplicatedMesh DISTRIBUTED: Always use libMesh::DistributedMesh + - name: partitioner + required: No + default: !!str default + cpp_type: MooseEnum + group_name: 'Partitioning' + options: default metis parmetis linear centroid hilbert_sfc morton_sfc + description: | + Specifies a mesh partitioner to use when splitting the mesh for a parallel computation. + - name: patch_size + required: No + default: !!str 40 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of nodes to consider in the NearestNode neighborhood. + - name: patch_update_strategy + required: No + default: !!str never + cpp_type: MooseEnum + group_name: 'Advanced' + options: never always auto iteration + description: | + How often to update the geometric search 'patch'. The default is to never update it (which is the most efficient but could be a problem with lots of relative motion). 'always' will update the patch for all slave nodes at the beginning of every timestep which might be time consuming. 'auto' will attempt to determine at the start of which timesteps the patch for all slave nodes needs to be updated automatically.'iteration' updates the patch at every nonlinear iteration for a subset of slave nodes for which penetration is not detected. If there can be substantial relative motion between the master and slave surfaces during the nonlinear iterations within a timestep, it is advisable to use 'iteration' option to ensure accurate contact detection. + - name: type + required: No + default: !!str GeneratedMesh + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: xmax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper X Coordinate of the generated mesh + - name: xmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower X Coordinate of the generated mesh + - name: ymax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper Y Coordinate of the generated mesh + - name: ymin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower Y Coordinate of the generated mesh + - name: zmax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper Z Coordinate of the generated mesh + - name: zmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower Z Coordinate of the generated mesh + subblocks: + - name: /Mesh//ImageMesh + description: | + + parameters: + - name: allow_renumbering + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If allow_renumbering=false, node and element numbers are kept fixed until deletion + - name: bias_x + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the x-direction. + - name: bias_y + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the y-direction. + - name: bias_z + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the z-direction. + - name: cells_per_pixel + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The number of mesh cells per pixel, must be <=1 + - name: centroid_partitioner_direction + required: No + default: !!str + cpp_type: MooseEnum + group_name: 'Partitioning' + options: x y z radial + description: | + Specifies the sort direction if using the centroid partitioner. Available options: x, y, z, radial + - name: construct_node_list_from_side_list + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Whether or not to generate nodesets from the sidesets (usually a good idea). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: 'Main' + options: 1 2 3 + description: | + The dimension of the mesh to be generated + - name: elem_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: EDGE EDGE2 EDGE3 EDGE4 QUAD QUAD4 QUAD8 QUAD9 TRI3 TRI6 HEX HEX8 HEX20 HEX27 TET4 TET10 PRISM6 PRISM15 PRISM18 PYRAMID5 PYRAMID13 PYRAMID14 + description: | + The type of element from libMesh to generate (default: linear element for requested dimension) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: file + required: No + default: !!str + cpp_type: FileName + group_name: + description: | + Name of single image file to extract mesh parameters from. If provided, a 2D mesh is created. + - name: file_base + required: No + default: !!str + cpp_type: FileNameNoExtension + group_name: + description: | + Image file base to open, use this option when a stack of images must be read (ignored if 'file' is given) + - name: file_range + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Range of images to analyze, used with 'file_base' (ignored if 'file' is given) + - name: file_suffix + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Suffix of the file to open, e.g. 'png' + - name: gauss_lobatto_grid + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Grade mesh into boundaries according to Gauss-Lobatto quadrature spacing. + - name: ghosting_patch_size + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of nearest neighbors considered for ghosting purposes when 'iteration' patch update strategy is used. Default is 5 * patch_size. + - name: max_leaf_size + required: No + default: !!str 10 + cpp_type: unsigned int + group_name: + description: | + The maximum number of points in each leaf of the KDTree used in the nearest neighbor search. As the leaf size becomes larger,KDTree construction becomes faster but the nearest neighbor searchbecomes slower. + - name: nemesis + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + If nemesis=true and file=foo.e, actually reads foo.e.N.0, foo.e.N.1, ... foo.e.N.N-1, where N = # CPUs, with NemesisIO. + - name: nx + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the X direction + - name: ny + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the Y direction + - name: nz + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the Z direction + - name: parallel_type + required: No + default: !!str DEFAULT + cpp_type: MooseEnum + group_name: + options: DEFAULT REPLICATED DISTRIBUTED + description: | + DEFAULT: Use libMesh::ReplicatedMesh unless --distributed-mesh is specified on the command line REPLICATED: Always use libMesh::ReplicatedMesh DISTRIBUTED: Always use libMesh::DistributedMesh + - name: partitioner + required: No + default: !!str default + cpp_type: MooseEnum + group_name: 'Partitioning' + options: default metis parmetis linear centroid hilbert_sfc morton_sfc + description: | + Specifies a mesh partitioner to use when splitting the mesh for a parallel computation. + - name: patch_size + required: No + default: !!str 40 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of nodes to consider in the NearestNode neighborhood. + - name: patch_update_strategy + required: No + default: !!str never + cpp_type: MooseEnum + group_name: 'Advanced' + options: never always auto iteration + description: | + How often to update the geometric search 'patch'. The default is to never update it (which is the most efficient but could be a problem with lots of relative motion). 'always' will update the patch for all slave nodes at the beginning of every timestep which might be time consuming. 'auto' will attempt to determine at the start of which timesteps the patch for all slave nodes needs to be updated automatically.'iteration' updates the patch at every nonlinear iteration for a subset of slave nodes for which penetration is not detected. If there can be substantial relative motion between the master and slave surfaces during the nonlinear iterations within a timestep, it is advisable to use 'iteration' option to ensure accurate contact detection. + - name: scale_to_one + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether or not to scale the image so its max dimension is 1 + - name: type + required: No + default: !!str ImageMesh + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: xmax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper X Coordinate of the generated mesh + - name: xmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower X Coordinate of the generated mesh + - name: ymax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper Y Coordinate of the generated mesh + - name: ymin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower Y Coordinate of the generated mesh + - name: zmax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper Z Coordinate of the generated mesh + - name: zmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower Z Coordinate of the generated mesh + subblocks: + - name: /Mesh//MeshGeneratorMesh + description: | + + parameters: + - name: allow_renumbering + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If allow_renumbering=false, node and element numbers are kept fixed until deletion + - name: centroid_partitioner_direction + required: No + default: !!str + cpp_type: MooseEnum + group_name: 'Partitioning' + options: x y z radial + description: | + Specifies the sort direction if using the centroid partitioner. Available options: x, y, z, radial + - name: construct_node_list_from_side_list + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Whether or not to generate nodesets from the sidesets (usually a good idea). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: No + default: !!str 1 + cpp_type: MooseEnum + group_name: 'Advanced' + options: 1 2 3 + description: | + This is only required for certain mesh formats where the dimension of the mesh cannot be autodetected. In particular you must supply this for GMSH meshes. Note: This is completely ignored for ExodusII meshes! + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: final_generator + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name of the mesh generator output to use for the final Mesh + - name: ghosting_patch_size + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of nearest neighbors considered for ghosting purposes when 'iteration' patch update strategy is used. Default is 5 * patch_size. + - name: max_leaf_size + required: No + default: !!str 10 + cpp_type: unsigned int + group_name: + description: | + The maximum number of points in each leaf of the KDTree used in the nearest neighbor search. As the leaf size becomes larger,KDTree construction becomes faster but the nearest neighbor searchbecomes slower. + - name: nemesis + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + If nemesis=true and file=foo.e, actually reads foo.e.N.0, foo.e.N.1, ... foo.e.N.N-1, where N = # CPUs, with NemesisIO. + - name: parallel_type + required: No + default: !!str DEFAULT + cpp_type: MooseEnum + group_name: + options: DEFAULT REPLICATED DISTRIBUTED + description: | + DEFAULT: Use libMesh::ReplicatedMesh unless --distributed-mesh is specified on the command line REPLICATED: Always use libMesh::ReplicatedMesh DISTRIBUTED: Always use libMesh::DistributedMesh + - name: partitioner + required: No + default: !!str default + cpp_type: MooseEnum + group_name: 'Partitioning' + options: default metis parmetis linear centroid hilbert_sfc morton_sfc + description: | + Specifies a mesh partitioner to use when splitting the mesh for a parallel computation. + - name: patch_size + required: No + default: !!str 40 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of nodes to consider in the NearestNode neighborhood. + - name: patch_update_strategy + required: No + default: !!str never + cpp_type: MooseEnum + group_name: 'Advanced' + options: never always auto iteration + description: | + How often to update the geometric search 'patch'. The default is to never update it (which is the most efficient but could be a problem with lots of relative motion). 'always' will update the patch for all slave nodes at the beginning of every timestep which might be time consuming. 'auto' will attempt to determine at the start of which timesteps the patch for all slave nodes needs to be updated automatically.'iteration' updates the patch at every nonlinear iteration for a subset of slave nodes for which penetration is not detected. If there can be substantial relative motion between the master and slave surfaces during the nonlinear iterations within a timestep, it is advisable to use 'iteration' option to ensure accurate contact detection. + - name: type + required: No + default: !!str MeshGeneratorMesh + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh//PatternedMesh + description: | + + parameters: + - name: allow_renumbering + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If allow_renumbering=false, node and element numbers are kept fixed until deletion + - name: bottom_boundary + required: No + default: !!str bottom_boundary + cpp_type: BoundaryName + group_name: + description: | + name of the bottom (y) boundary + - name: centroid_partitioner_direction + required: No + default: !!str + cpp_type: MooseEnum + group_name: 'Partitioning' + options: x y z radial + description: | + Specifies the sort direction if using the centroid partitioner. Available options: x, y, z, radial + - name: construct_node_list_from_side_list + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Whether or not to generate nodesets from the sidesets (usually a good idea). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: No + default: !!str 1 + cpp_type: MooseEnum + group_name: 'Advanced' + options: 1 2 3 + description: | + This is only required for certain mesh formats where the dimension of the mesh cannot be autodetected. In particular you must supply this for GMSH meshes. Note: This is completely ignored for ExodusII meshes! + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: files + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the mesh files to read. They are automatically assigned ids starting with zero. + - name: ghosting_patch_size + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of nearest neighbors considered for ghosting purposes when 'iteration' patch update strategy is used. Default is 5 * patch_size. + - name: left_boundary + required: No + default: !!str left_boundary + cpp_type: BoundaryName + group_name: + description: | + name of the left (x) boundary + - name: max_leaf_size + required: No + default: !!str 10 + cpp_type: unsigned int + group_name: + description: | + The maximum number of points in each leaf of the KDTree used in the nearest neighbor search. As the leaf size becomes larger,KDTree construction becomes faster but the nearest neighbor searchbecomes slower. + - name: nemesis + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + If nemesis=true and file=foo.e, actually reads foo.e.N.0, foo.e.N.1, ... foo.e.N.N-1, where N = # CPUs, with NemesisIO. + - name: parallel_type + required: No + default: !!str DEFAULT + cpp_type: MooseEnum + group_name: + options: DEFAULT REPLICATED DISTRIBUTED + description: | + DEFAULT: Use libMesh::ReplicatedMesh unless --distributed-mesh is specified on the command line REPLICATED: Always use libMesh::ReplicatedMesh DISTRIBUTED: Always use libMesh::DistributedMesh + - name: partitioner + required: No + default: !!str default + cpp_type: MooseEnum + group_name: 'Partitioning' + options: default metis parmetis linear centroid hilbert_sfc morton_sfc + description: | + Specifies a mesh partitioner to use when splitting the mesh for a parallel computation. + - name: patch_size + required: No + default: !!str 40 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of nodes to consider in the NearestNode neighborhood. + - name: patch_update_strategy + required: No + default: !!str never + cpp_type: MooseEnum + group_name: 'Advanced' + options: never always auto iteration + description: | + How often to update the geometric search 'patch'. The default is to never update it (which is the most efficient but could be a problem with lots of relative motion). 'always' will update the patch for all slave nodes at the beginning of every timestep which might be time consuming. 'auto' will attempt to determine at the start of which timesteps the patch for all slave nodes needs to be updated automatically.'iteration' updates the patch at every nonlinear iteration for a subset of slave nodes for which penetration is not detected. If there can be substantial relative motion between the master and slave surfaces during the nonlinear iterations within a timestep, it is advisable to use 'iteration' option to ensure accurate contact detection. + - name: pattern + required: Yes + default: !!str + cpp_type: std::vector >, std::allocator > > > + group_name: + description: | + A double-indexed array starting with the upper-left corner + - name: right_boundary + required: No + default: !!str right_boundary + cpp_type: BoundaryName + group_name: + description: | + name of the right (x) boundary + - name: top_boundary + required: No + default: !!str top_boundary + cpp_type: BoundaryName + group_name: + description: | + name of the top (y) boundary + - name: type + required: No + default: !!str PatternedMesh + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: x_width + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The tile width in the x direction + - name: y_width + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The tile width in the y direction + - name: z_width + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The tile width in the z direction + subblocks: + - name: /Mesh//RinglebMesh + description: | + + parameters: + - name: allow_renumbering + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If allow_renumbering=false, node and element numbers are kept fixed until deletion + - name: centroid_partitioner_direction + required: No + default: !!str + cpp_type: MooseEnum + group_name: 'Partitioning' + options: x y z radial + description: | + Specifies the sort direction if using the centroid partitioner. Available options: x, y, z, radial + - name: construct_node_list_from_side_list + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Whether or not to generate nodesets from the sidesets (usually a good idea). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: No + default: !!str 1 + cpp_type: MooseEnum + group_name: 'Advanced' + options: 1 2 3 + description: | + This is only required for certain mesh formats where the dimension of the mesh cannot be autodetected. In particular you must supply this for GMSH meshes. Note: This is completely ignored for ExodusII meshes! + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: gamma + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Gamma parameter + - name: ghosting_patch_size + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of nearest neighbors considered for ghosting purposes when 'iteration' patch update strategy is used. Default is 5 * patch_size. + - name: inflow_bid + required: No + default: !!str 1 + cpp_type: short + group_name: + description: | + The boundary id to use for the inflow + - name: inner_wall_bid + required: No + default: !!str 2 + cpp_type: short + group_name: + description: | + The boundary id to use for the inner wall + - name: kmax + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Value of k on the inner wall. + - name: kmin + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Value of k on the outer wall. + - name: max_leaf_size + required: No + default: !!str 10 + cpp_type: unsigned int + group_name: + description: | + The maximum number of points in each leaf of the KDTree used in the nearest neighbor search. As the leaf size becomes larger,KDTree construction becomes faster but the nearest neighbor searchbecomes slower. + - name: n_extra_q_pts + required: Yes + default: !!str + cpp_type: int + group_name: + description: | + How many 'extra' points should be inserted in the final element *in addition to* the equispaced q points. + - name: nemesis + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + If nemesis=true and file=foo.e, actually reads foo.e.N.0, foo.e.N.1, ... foo.e.N.N-1, where N = # CPUs, with NemesisIO. + - name: num_k_pts + required: Yes + default: !!str + cpp_type: int + group_name: + description: | + How many points in the range k=(kmin, kmax). + - name: num_q_pts + required: Yes + default: !!str + cpp_type: int + group_name: + description: | + How many points to discretize the range q = (0.5, k) into. + - name: outer_wall_bid + required: No + default: !!str 4 + cpp_type: short + group_name: + description: | + The boundary id to use for the outer wall + - name: outflow_bid + required: No + default: !!str 3 + cpp_type: short + group_name: + description: | + The boundary id to use for the outflow + - name: parallel_type + required: No + default: !!str DEFAULT + cpp_type: MooseEnum + group_name: + options: DEFAULT REPLICATED DISTRIBUTED + description: | + DEFAULT: Use libMesh::ReplicatedMesh unless --distributed-mesh is specified on the command line REPLICATED: Always use libMesh::ReplicatedMesh DISTRIBUTED: Always use libMesh::DistributedMesh + - name: partitioner + required: No + default: !!str default + cpp_type: MooseEnum + group_name: 'Partitioning' + options: default metis parmetis linear centroid hilbert_sfc morton_sfc + description: | + Specifies a mesh partitioner to use when splitting the mesh for a parallel computation. + - name: patch_size + required: No + default: !!str 40 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of nodes to consider in the NearestNode neighborhood. + - name: patch_update_strategy + required: No + default: !!str never + cpp_type: MooseEnum + group_name: 'Advanced' + options: never always auto iteration + description: | + How often to update the geometric search 'patch'. The default is to never update it (which is the most efficient but could be a problem with lots of relative motion). 'always' will update the patch for all slave nodes at the beginning of every timestep which might be time consuming. 'auto' will attempt to determine at the start of which timesteps the patch for all slave nodes needs to be updated automatically.'iteration' updates the patch at every nonlinear iteration for a subset of slave nodes for which penetration is not detected. If there can be substantial relative motion between the master and slave surfaces during the nonlinear iterations within a timestep, it is advisable to use 'iteration' option to ensure accurate contact detection. + - name: triangles + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true, all the quadrilateral elements will be split into triangles + - name: type + required: No + default: !!str RinglebMesh + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh//SpiralAnnularMesh + description: | + + parameters: + - name: allow_renumbering + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If allow_renumbering=false, node and element numbers are kept fixed until deletion + - name: centroid_partitioner_direction + required: No + default: !!str + cpp_type: MooseEnum + group_name: 'Partitioning' + options: x y z radial + description: | + Specifies the sort direction if using the centroid partitioner. Available options: x, y, z, radial + - name: construct_node_list_from_side_list + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Whether or not to generate nodesets from the sidesets (usually a good idea). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cylinder_bid + required: No + default: !!str 1 + cpp_type: short + group_name: + description: | + The boundary id to use for the cylinder (inner circle) + - name: dim + required: No + default: !!str 1 + cpp_type: MooseEnum + group_name: 'Advanced' + options: 1 2 3 + description: | + This is only required for certain mesh formats where the dimension of the mesh cannot be autodetected. In particular you must supply this for GMSH meshes. Note: This is completely ignored for ExodusII meshes! + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: exterior_bid + required: No + default: !!str 2 + cpp_type: short + group_name: + description: | + The boundary id to use for the exterior (outer circle) + - name: ghosting_patch_size + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of nearest neighbors considered for ghosting purposes when 'iteration' patch update strategy is used. Default is 5 * patch_size. + - name: initial_delta_r + required: No + default: !!str + cpp_type: double + group_name: + description: | + Width of the initial layer of elements around the cylinder.This number should be approximately 2 * pi * inner_radius / nodes_per_ring to ensure that the initial layer of elements is almost equilateral + - name: inner_radius + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The size of the inner circle. + - name: max_leaf_size + required: No + default: !!str 10 + cpp_type: unsigned int + group_name: + description: | + The maximum number of points in each leaf of the KDTree used in the nearest neighbor search. As the leaf size becomes larger,KDTree construction becomes faster but the nearest neighbor searchbecomes slower. + - name: nemesis + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + If nemesis=true and file=foo.e, actually reads foo.e.N.0, foo.e.N.1, ... foo.e.N.N-1, where N = # CPUs, with NemesisIO. + - name: nodes_per_ring + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + Number of nodes on each ring. + - name: num_rings + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of rings. + - name: outer_radius + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The size of the outer circle. Logically, it has to be greater than inner_radius + - name: parallel_type + required: No + default: !!str DEFAULT + cpp_type: MooseEnum + group_name: + options: DEFAULT REPLICATED DISTRIBUTED + description: | + DEFAULT: Use libMesh::ReplicatedMesh unless --distributed-mesh is specified on the command line REPLICATED: Always use libMesh::ReplicatedMesh DISTRIBUTED: Always use libMesh::DistributedMesh + - name: partitioner + required: No + default: !!str default + cpp_type: MooseEnum + group_name: 'Partitioning' + options: default metis parmetis linear centroid hilbert_sfc morton_sfc + description: | + Specifies a mesh partitioner to use when splitting the mesh for a parallel computation. + - name: patch_size + required: No + default: !!str 40 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of nodes to consider in the NearestNode neighborhood. + - name: patch_update_strategy + required: No + default: !!str never + cpp_type: MooseEnum + group_name: 'Advanced' + options: never always auto iteration + description: | + How often to update the geometric search 'patch'. The default is to never update it (which is the most efficient but could be a problem with lots of relative motion). 'always' will update the patch for all slave nodes at the beginning of every timestep which might be time consuming. 'auto' will attempt to determine at the start of which timesteps the patch for all slave nodes needs to be updated automatically.'iteration' updates the patch at every nonlinear iteration for a subset of slave nodes for which penetration is not detected. If there can be substantial relative motion between the master and slave surfaces during the nonlinear iterations within a timestep, it is advisable to use 'iteration' option to ensure accurate contact detection. + - name: type + required: No + default: !!str SpiralAnnularMesh + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_tri6 + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Generate mesh of TRI6 elements instead of TRI3 elements. + subblocks: + - name: /Mesh//StitchedMesh + description: | + + parameters: + - name: allow_renumbering + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If allow_renumbering=false, node and element numbers are kept fixed until deletion + - name: centroid_partitioner_direction + required: No + default: !!str + cpp_type: MooseEnum + group_name: 'Partitioning' + options: x y z radial + description: | + Specifies the sort direction if using the centroid partitioner. Available options: x, y, z, radial + - name: clear_stitched_boundary_ids + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether or not to erase the boundary IDs after they've been used for stitching. + - name: construct_node_list_from_side_list + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Whether or not to generate nodesets from the sidesets (usually a good idea). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: No + default: !!str 1 + cpp_type: MooseEnum + group_name: 'Advanced' + options: 1 2 3 + description: | + This is only required for certain mesh formats where the dimension of the mesh cannot be autodetected. In particular you must supply this for GMSH meshes. Note: This is completely ignored for ExodusII meshes! + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: files + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the mesh files to read. These mesh files will be 'stitched' into the current mesh in this order. + - name: ghosting_patch_size + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of nearest neighbors considered for ghosting purposes when 'iteration' patch update strategy is used. Default is 5 * patch_size. + - name: max_leaf_size + required: No + default: !!str 10 + cpp_type: unsigned int + group_name: + description: | + The maximum number of points in each leaf of the KDTree used in the nearest neighbor search. As the leaf size becomes larger,KDTree construction becomes faster but the nearest neighbor searchbecomes slower. + - name: nemesis + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + If nemesis=true and file=foo.e, actually reads foo.e.N.0, foo.e.N.1, ... foo.e.N.N-1, where N = # CPUs, with NemesisIO. + - name: parallel_type + required: No + default: !!str DEFAULT + cpp_type: MooseEnum + group_name: + options: DEFAULT REPLICATED DISTRIBUTED + description: | + DEFAULT: Use libMesh::ReplicatedMesh unless --distributed-mesh is specified on the command line REPLICATED: Always use libMesh::ReplicatedMesh DISTRIBUTED: Always use libMesh::DistributedMesh + - name: partitioner + required: No + default: !!str default + cpp_type: MooseEnum + group_name: 'Partitioning' + options: default metis parmetis linear centroid hilbert_sfc morton_sfc + description: | + Specifies a mesh partitioner to use when splitting the mesh for a parallel computation. + - name: patch_size + required: No + default: !!str 40 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of nodes to consider in the NearestNode neighborhood. + - name: patch_update_strategy + required: No + default: !!str never + cpp_type: MooseEnum + group_name: 'Advanced' + options: never always auto iteration + description: | + How often to update the geometric search 'patch'. The default is to never update it (which is the most efficient but could be a problem with lots of relative motion). 'always' will update the patch for all slave nodes at the beginning of every timestep which might be time consuming. 'auto' will attempt to determine at the start of which timesteps the patch for all slave nodes needs to be updated automatically.'iteration' updates the patch at every nonlinear iteration for a subset of slave nodes for which penetration is not detected. If there can be substantial relative motion between the master and slave surfaces during the nonlinear iterations within a timestep, it is advisable to use 'iteration' option to ensure accurate contact detection. + - name: stitch_boundaries + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + Pairs of boundary names (one after the other) to stitch together for each step. + - name: type + required: No + default: !!str StitchedMesh + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh//TiledMesh + description: | + + parameters: + - name: allow_renumbering + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If allow_renumbering=false, node and element numbers are kept fixed until deletion + - name: back_boundary + required: No + default: !!str back_boundary + cpp_type: BoundaryName + group_name: + description: | + name of the back (z) boundary + - name: bottom_boundary + required: No + default: !!str bottom_boundary + cpp_type: BoundaryName + group_name: + description: | + name of the bottom (y) boundary + - name: centroid_partitioner_direction + required: No + default: !!str + cpp_type: MooseEnum + group_name: 'Partitioning' + options: x y z radial + description: | + Specifies the sort direction if using the centroid partitioner. Available options: x, y, z, radial + - name: construct_node_list_from_side_list + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Whether or not to generate nodesets from the sidesets (usually a good idea). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: No + default: !!str 1 + cpp_type: MooseEnum + group_name: 'Advanced' + options: 1 2 3 + description: | + This is only required for certain mesh formats where the dimension of the mesh cannot be autodetected. In particular you must supply this for GMSH meshes. Note: This is completely ignored for ExodusII meshes! + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: file + required: Yes + default: !!str + cpp_type: MeshFileName + group_name: + description: | + The name of the mesh file to read + - name: front_boundary + required: No + default: !!str front_boundary + cpp_type: BoundaryName + group_name: + description: | + name of the front (z) boundary + - name: ghosting_patch_size + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of nearest neighbors considered for ghosting purposes when 'iteration' patch update strategy is used. Default is 5 * patch_size. + - name: left_boundary + required: No + default: !!str left_boundary + cpp_type: BoundaryName + group_name: + description: | + name of the left (x) boundary + - name: max_leaf_size + required: No + default: !!str 10 + cpp_type: unsigned int + group_name: + description: | + The maximum number of points in each leaf of the KDTree used in the nearest neighbor search. As the leaf size becomes larger,KDTree construction becomes faster but the nearest neighbor searchbecomes slower. + - name: nemesis + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + If nemesis=true and file=foo.e, actually reads foo.e.N.0, foo.e.N.1, ... foo.e.N.N-1, where N = # CPUs, with NemesisIO. + - name: parallel_type + required: No + default: !!str DEFAULT + cpp_type: MooseEnum + group_name: + options: DEFAULT REPLICATED DISTRIBUTED + description: | + DEFAULT: Use libMesh::ReplicatedMesh unless --distributed-mesh is specified on the command line REPLICATED: Always use libMesh::ReplicatedMesh DISTRIBUTED: Always use libMesh::DistributedMesh + - name: partitioner + required: No + default: !!str default + cpp_type: MooseEnum + group_name: 'Partitioning' + options: default metis parmetis linear centroid hilbert_sfc morton_sfc + description: | + Specifies a mesh partitioner to use when splitting the mesh for a parallel computation. + - name: patch_size + required: No + default: !!str 40 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of nodes to consider in the NearestNode neighborhood. + - name: patch_update_strategy + required: No + default: !!str never + cpp_type: MooseEnum + group_name: 'Advanced' + options: never always auto iteration + description: | + How often to update the geometric search 'patch'. The default is to never update it (which is the most efficient but could be a problem with lots of relative motion). 'always' will update the patch for all slave nodes at the beginning of every timestep which might be time consuming. 'auto' will attempt to determine at the start of which timesteps the patch for all slave nodes needs to be updated automatically.'iteration' updates the patch at every nonlinear iteration for a subset of slave nodes for which penetration is not detected. If there can be substantial relative motion between the master and slave surfaces during the nonlinear iterations within a timestep, it is advisable to use 'iteration' option to ensure accurate contact detection. + - name: right_boundary + required: No + default: !!str right_boundary + cpp_type: BoundaryName + group_name: + description: | + name of the right (x) boundary + - name: top_boundary + required: No + default: !!str top_boundary + cpp_type: BoundaryName + group_name: + description: | + name of the top (y) boundary + - name: type + required: No + default: !!str TiledMesh + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: x_tiles + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of tiles to stitch together (left to right) in the x-direction + - name: x_width + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The tile width in the x direction + - name: y_tiles + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of tiles to stitch together (top to bottom) in the y-direction + - name: y_width + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The tile width in the y direction + - name: z_tiles + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of tiles to stitch together (front to back) in the z-direction + - name: z_width + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The tile width in the z direction + subblocks: + - name: /Mesh/AllSideSetsByNormalsGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: fixed_normal + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This Boolean determines whether we fix our normal or allow it to vary to "paint" around curves + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: replace + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true, replace the old sidesets. If false, the current sidesets (if any) will be preserved. + - name: type + required: No + default: !!str AllSideSetsByNormalsGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variance + required: No + default: !!str 0.1 + cpp_type: double + group_name: + description: | + The variance [0.0 - 1.0] allowed when comparing normals + subblocks: + - name: /Mesh/AnnularMeshGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dmax + required: No + default: !!str 360 + cpp_type: double + group_name: + description: | + Maximum angle, measured in degrees anticlockwise from x axis. If dmin=0 and dmax=360 an annular mesh is created. Otherwise, only a sector of an annulus is created + - name: dmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Minimum degree, measured in degrees anticlockwise from x axis + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: growth_r + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The ratio of radial sizes of successive rings of elements + - name: nr + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the radial direction + - name: nt + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + Number of elements in the angular direction + - name: quad_subdomain_id + required: No + default: !!str 0 + cpp_type: unsigned short + group_name: + description: | + The subdomain ID given to the QUAD4 elements + - name: rmax + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Outer radius + - name: rmin + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Inner radius. If rmin=0 then a disc mesh (with no central hole) will be created. + - name: tmax + required: No + default: !!str 6.28319 + cpp_type: double + group_name: + description: | + Maximum angle, measured in radians anticlockwise from x axis. If tmin=0 and tmax=2Pi an annular mesh is created. Otherwise, only a sector of an annulus is created + - name: tmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Minimum angle, measured in radians anticlockwise from x axis + - name: tri_subdomain_id + required: No + default: !!str 1 + cpp_type: unsigned short + group_name: + description: | + The subdomain ID given to the TRI3 elements (these exist only if rmin=0, and they exist at the center of the disc + - name: type + required: No + default: !!str AnnularMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/BlockDeletionGenerator + description: | + + parameters: + - name: block_id + required: Yes + default: !!str + cpp_type: unsigned short + group_name: + description: | + The block to be deleted + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: new_boundary + required: No + default: !!str + cpp_type: BoundaryName + group_name: + description: | + optional boundary name to assign to the cut surface + - name: type + required: No + default: !!str BlockDeletionGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/BoundingBoxNodeSetGenerator + description: | + + parameters: + - name: bottom_left + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The bottom left point (in x,y,z with spaces in-between) of the box to select the nodes. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: location + required: No + default: !!str INSIDE + cpp_type: MooseEnum + group_name: + options: INSIDE OUTSIDE + description: | + Control of where the nodeset is to be set + - name: new_boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the nodeset to create + - name: top_right + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The bottom left point (in x,y,z with spaces in-between) of the box to select the nodes. + - name: type + required: No + default: !!str BoundingBoxNodeSetGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/BreakBoundaryOnSubdomainGenerator + description: | + + parameters: + - name: boundaries + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Boundaries to be broken. Default means to break all boundaries + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: type + required: No + default: !!str BreakBoundaryOnSubdomainGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/BreakMeshByBlockGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: interface_name + required: No + default: !!str interface + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + the name of the new interface. Cannot be used whit `split_interface=true` + - name: split_interface + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true, it create a different interface for each block pair. + - name: type + required: No + default: !!str BreakMeshByBlockGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/CartesianMeshGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: 'Main' + options: 1 2 3 + description: | + The dimension of the mesh to be generated + - name: dx + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + Intervals in the X direction + - name: dy + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Intervals in the Y direction (required when dim>1 otherwise ignored) + - name: dz + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Intervals in the Z direction (required when dim>2 otherwise ignored) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: ix + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Number of grids in all intervals in the X direction (default to all one) + - name: iy + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Number of grids in all intervals in the Y direction (default to all one) + - name: iz + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Number of grids in all intervals in the Z direction (default to all one) + - name: subdomain_id + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Block IDs (default to all zero) + - name: type + required: No + default: !!str CartesianMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/CombinerGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: inputs + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The input MeshGenerators. This can either be N generators or 1 generator. If only 1 is given then 'positions' must also be given. + - name: positions + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The (optional) position of each given mesh. If N 'inputs' were given then this must either be left blank or N positions must be given. If 1 input was given then this MUST be provided. + - name: type + required: No + default: !!str CombinerGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/ConcentricCircleMeshGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: has_outer_square + required: Yes + default: !!str + cpp_type: bool + group_name: + description: | + It determines if meshes for a outer square are added to concentric circle meshes. + - name: num_sectors + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + num_sectors % 2 = 0, num_sectors > 0Number of azimuthal sectors in each quadrant'num_sectors' must be an even number. + - name: pitch + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The enclosing square can be added to the completed concentric circle mesh.Elements are quad meshes. + - name: portion + required: No + default: !!str full + cpp_type: MooseEnum + group_name: + options: full top_right top_left bottom_left bottom_right right_half left_half top_half bottom_half + description: | + Control of which part of mesh is created + - name: preserve_volumes + required: Yes + default: !!str + cpp_type: bool + group_name: + description: | + Volume of concentric circles can be preserved using this function. + - name: radii + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + Radii of major concentric circles + - name: rings + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + Number of rings in each circle or in the enclosing square + - name: smoothing_max_it + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of Laplacian smoothing iterations + - name: type + required: No + default: !!str ConcentricCircleMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/DistributedRectilinearMeshGenerator + description: | + + parameters: + - name: apply_element_weight + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Indicate if we are going to apply element weights to partitioners + - name: apply_side_weight + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Indicate if we are going to apply side weights to partitioners + - name: bias_x + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the x-direction. + - name: bias_y + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the y-direction. + - name: bias_z + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the z-direction. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: 'Main' + options: 1 2 3 + description: | + The dimension of the mesh to be generated + - name: elem_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: EDGE EDGE2 EDGE3 EDGE4 QUAD QUAD4 QUAD8 QUAD9 TRI3 TRI6 HEX HEX8 HEX20 HEX27 TET4 TET10 PRISM6 PRISM15 PRISM18 PYRAMID5 PYRAMID13 PYRAMID14 + description: | + The type of element from libMesh to generate (default: linear element for requested dimension) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: num_cores_for_partition + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + Number of cores for partitioning the graph + - name: num_cores_per_compute_node + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of cores per compute node for hierarchical partitioning + - name: nx + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the X direction + - name: ny + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the Y direction + - name: nz + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the Z direction + - name: part_package + required: No + default: !!str parmetis + cpp_type: MooseEnum + group_name: + options: parmetis ptscotch chaco party hierarch + description: | + The external package is used for partitioning the mesh via PETSc + - name: type + required: No + default: !!str DistributedRectilinearMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: xmax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper X Coordinate of the generated mesh + - name: xmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower X Coordinate of the generated mesh + - name: ymax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper Y Coordinate of the generated mesh + - name: ymin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower Y Coordinate of the generated mesh + - name: zmax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper Z Coordinate of the generated mesh + - name: zmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower Z Coordinate of the generated mesh + subblocks: + - name: /Mesh/ElementGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: elem_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: EDGE2 EDGE3 EDGE4 QUAD4 QUAD8 QUAD9 TRI3 TRI6 HEX8 HEX20 HEX27 TET4 TET10 PRISM6 PRISM15 PRISM18 PYRAMID5 PYRAMID13 PYRAMID14 + description: | + The type of element from libMesh to generate + - name: element_connectivity + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + List of nodes to use for each element + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: No + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + Optional input mesh to add the elements to + - name: nodal_positions + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The x,y,z positions of the nodes + - name: type + required: No + default: !!str ElementGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/ElementSubdomainIDGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: element_ids + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + New element IDs of all elements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: subdomain_ids + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + New subdomain IDs of all elements + - name: type + required: No + default: !!str ElementSubdomainIDGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/ExtraNodesetGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: coord + required: No + default: !!str + cpp_type: std::vector >, std::allocator > > > + group_name: + description: | + The nodes with coordinates you want to be in the nodeset. Separate multple coords with ';' (Either this parameter or "nodes" must be supplied). + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: new_boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the boundary to create + - name: nodes + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The nodes you want to be in the nodeset (Either this parameter or "coord" must be supplied). + - name: tolerance + required: No + default: !!str 1e-06 + cpp_type: double + group_name: + description: | + The tolerance in which two nodes are considered identical + - name: type + required: No + default: !!str ExtraNodesetGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/FancyExtruderGenerator + description: | + + parameters: + - name: bottom_boundary + required: No + default: !!str + cpp_type: short + group_name: + description: | + The boundary ID to set on the bottom boundary. If omitted one will be generated. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: direction + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + A vector that points in the direction to extrude (note, this will be normalized internally - so don't worry about it here) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: heights + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The height of each elevation + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh to extrude + - name: num_layers + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The number of layers for each elevation - must be num_elevations in length! + - name: subdomain_swaps + required: No + default: !!str + cpp_type: std::vector >, std::allocator > > > + group_name: + description: | + For each row, every two entries are interpreted as a pair of 'from' and 'to' to remap the subdomains for that elevation + - name: top_boundary + required: No + default: !!str + cpp_type: short + group_name: + description: | + The boundary ID to set on the top boundary. If ommitted one will be generated. + - name: type + required: No + default: !!str FancyExtruderGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/FileMeshGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: exodus_extra_element_integers + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The variable names in the mesh file for loading extra element integers + - name: file + required: Yes + default: !!str + cpp_type: MeshFileName + group_name: + description: | + The filename to read. + - name: type + required: No + default: !!str FileMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/GeneratedMeshGenerator + description: | + + parameters: + - name: bias_x + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the x-direction. + - name: bias_y + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the y-direction. + - name: bias_z + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the z-direction. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: 'Main' + options: 1 2 3 + description: | + The dimension of the mesh to be generated + - name: elem_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: EDGE EDGE2 EDGE3 EDGE4 QUAD QUAD4 QUAD8 QUAD9 TRI3 TRI6 HEX HEX8 HEX20 HEX27 TET4 TET10 PRISM6 PRISM15 PRISM18 PYRAMID5 PYRAMID13 PYRAMID14 + description: | + The type of element from libMesh to generate (default: linear element for requested dimension) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_element_integers + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Names of extra element integers + - name: gauss_lobatto_grid + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Grade mesh into boundaries according to Gauss-Lobatto quadrature spacing. + - name: nx + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the X direction + - name: ny + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the Y direction + - name: nz + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the Z direction + - name: type + required: No + default: !!str GeneratedMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: xmax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper X Coordinate of the generated mesh + - name: xmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower X Coordinate of the generated mesh + - name: ymax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper Y Coordinate of the generated mesh + - name: ymin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower Y Coordinate of the generated mesh + - name: zmax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper Z Coordinate of the generated mesh + - name: zmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower Z Coordinate of the generated mesh + subblocks: + - name: /Mesh/ImageMeshGenerator + description: | + + parameters: + - name: bias_x + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the x-direction. + - name: bias_y + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the y-direction. + - name: bias_z + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the z-direction. + - name: cells_per_pixel + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The number of mesh cells per pixel, must be <=1 + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: 'Main' + options: 1 2 3 + description: | + The dimension of the mesh to be generated + - name: elem_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: EDGE EDGE2 EDGE3 EDGE4 QUAD QUAD4 QUAD8 QUAD9 TRI3 TRI6 HEX HEX8 HEX20 HEX27 TET4 TET10 PRISM6 PRISM15 PRISM18 PYRAMID5 PYRAMID13 PYRAMID14 + description: | + The type of element from libMesh to generate (default: linear element for requested dimension) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_element_integers + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Names of extra element integers + - name: file + required: No + default: !!str + cpp_type: FileName + group_name: + description: | + Name of single image file to extract mesh parameters from. If provided, a 2D mesh is created. + - name: file_base + required: No + default: !!str + cpp_type: FileNameNoExtension + group_name: + description: | + Image file base to open, use this option when a stack of images must be read (ignored if 'file' is given) + - name: file_range + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Range of images to analyze, used with 'file_base' (ignored if 'file' is given) + - name: file_suffix + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Suffix of the file to open, e.g. 'png' + - name: gauss_lobatto_grid + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Grade mesh into boundaries according to Gauss-Lobatto quadrature spacing. + - name: nx + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the X direction + - name: ny + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the Y direction + - name: nz + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the Z direction + - name: scale_to_one + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether or not to scale the image so its max dimension is 1 + - name: type + required: No + default: !!str ImageMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: xmax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper X Coordinate of the generated mesh + - name: xmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower X Coordinate of the generated mesh + - name: ymax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper Y Coordinate of the generated mesh + - name: ymin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower Y Coordinate of the generated mesh + - name: zmax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper Z Coordinate of the generated mesh + - name: zmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower Z Coordinate of the generated mesh + subblocks: + - name: /Mesh/ImageSubdomainGenerator + description: | + + parameters: + - name: component + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The image RGB-component to return, leaving this blank will result in a greyscale value for the image to be created. The component number is zero based, i.e. 0 returns the first (RED) component of the image. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dimensions + required: No + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + x,y,z dimensions of the image (defaults to mesh dimensions) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: file + required: No + default: !!str + cpp_type: FileName + group_name: + description: | + Name of single image file to extract mesh parameters from. If provided, a 2D mesh is created. + - name: file_base + required: No + default: !!str + cpp_type: FileNameNoExtension + group_name: + description: | + Image file base to open, use this option when a stack of images must be read (ignored if 'file' is given) + - name: file_range + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Range of images to analyze, used with 'file_base' (ignored if 'file' is given) + - name: file_suffix + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Suffix of the file to open, e.g. 'png' + - name: flip_x + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Flip' + description: | + Flip the image along the x-axis + - name: flip_y + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Flip' + description: | + Flip the image along the y-axis + - name: flip_z + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Flip' + description: | + Flip the image along the z-axis + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: lower_value + required: No + default: !!str 0 + cpp_type: double + group_name: 'Threshold' + description: | + The value to set for data less than the threshold value + - name: origin + required: No + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + Origin of the image (defaults to mesh origin) + - name: scale + required: No + default: !!str 1 + cpp_type: double + group_name: 'Rescale' + description: | + Multiplier to apply to all pixel values; occurs after shifting + - name: shift + required: No + default: !!str 0 + cpp_type: double + group_name: 'Rescale' + description: | + Value to add to all pixels; occurs prior to scaling + - name: threshold + required: No + default: !!str + cpp_type: double + group_name: 'Threshold' + description: | + The threshold value + - name: type + required: No + default: !!str ImageSubdomainGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: upper_value + required: No + default: !!str 1 + cpp_type: double + group_name: 'Threshold' + description: | + The value to set for data greater than the threshold value + subblocks: + - name: /Mesh/LowerDBlockFromSidesetGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: new_block_id + required: No + default: !!str + cpp_type: unsigned short + group_name: + description: | + The lower dimensional block id to create + - name: new_block_name + required: No + default: !!str + cpp_type: SubdomainName + group_name: + description: | + The lower dimensional block name to create (optional) + - name: sidesets + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The sidesets from which to create the new block + - name: type + required: No + default: !!str LowerDBlockFromSidesetGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/MeshCollectionGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: inputs + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The input MeshGenerators. + - name: type + required: No + default: !!str MeshCollectionGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/MeshExtruderGenerator + description: | + + parameters: + - name: bottom_sideset + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The boundary that will be applied to the bottom of the extruded mesh + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: existing_subdomains + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The subdomains that will be remapped for specific layers + - name: extrusion_vector + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The direction and length of the extrusion + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + the mesh we want to extrude + - name: layers + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The layers where the "existing_subdomain" will be remapped to new ids + - name: new_ids + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of new ids, This list should be either length "existing_subdomains" or "existing_subdomains" * layers + - name: num_layers + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + The number of layers in the extruded mesh + - name: top_sideset + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The boundary that will be to the top of the extruded mesh + - name: type + required: No + default: !!str MeshExtruderGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/MeshSideSetGenerator + description: | + + parameters: + - name: block_id + required: Yes + default: !!str + cpp_type: unsigned short + group_name: + description: | + Subdomain id to set for the new elements along the boundary + - name: block_name + required: No + default: !!str + cpp_type: SubdomainName + group_name: + description: | + Subdomain name to set for the new elements along the boundary (optional) + - name: boundaries + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the boundary to mesh + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: type + required: No + default: !!str MeshSideSetGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/OrientedSubdomainBoundingBoxGenerator + description: | + + parameters: + - name: block_id + required: Yes + default: !!str + cpp_type: unsigned short + group_name: + description: | + Subdomain id to set for inside/outside the bounding box + - name: center + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + The center (many people spell this 'center') of the box. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: height + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The height of the box + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: length + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The length of the box + - name: length_direction + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The direction along which the length is oriented (must be perpendicular to width_direction). + - name: location + required: No + default: !!str INSIDE + cpp_type: MooseEnum + group_name: + options: INSIDE OUTSIDE + description: | + Control of where the subdomain id is to be set + - name: type + required: No + default: !!str OrientedSubdomainBoundingBoxGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: width + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The width of the box + - name: width_direction + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The direction along which the width is oriented. + subblocks: + - name: /Mesh/ParsedGenerateSideset + description: | + + parameters: + - name: combinatorial_geometry + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Function expression encoding a combinatorial geometry + - name: constant_expressions + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of values for the constants in constant_names (can be an FParser expression) + - name: constant_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of constants used in the parsed function (use this for kB etc.) + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: disable_fpoptimizer + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Disable the function parser algebraic optimizer + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: enable_ad_cache + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable cacheing of function derivatives for faster startup time + - name: enable_auto_optimize + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable automatic immediate optimization of derivatives + - name: enable_jit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable just-in-time compilation of function expressions for faster evaluation + - name: evalerror_behavior + required: No + default: !!str nan + cpp_type: MooseEnum + group_name: 'Advanced' + options: nan nan_warning error exception + description: | + What to do if evaluation error occurs. Options are to pass a nan, pass a nan with a warning, throw a error, or throw an exception + - name: fail_on_evalerror + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Fail fatally if a function evaluation returns an error code (otherwise just pass on NaN) + - name: fixed_normal + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This Boolean determines whether we fix our normal or allow it to vary to "paint" around curves + - name: included_subdomain_ids + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + A set of subdomain ids whose sides will be included in the new sidesets + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: new_sideset_name + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The name of the new sideset + - name: normal + required: No + default: !!str 0 0 0 + cpp_type: libMesh::Point + group_name: + description: | + If provided specifies the normal vector on sides that are added to the new + - name: replace + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true, replace the old sidesets. If false, the current sidesets (if any) will be preserved. + - name: type + required: No + default: !!str ParsedGenerateSideset + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variance + required: No + default: !!str 0.1 + cpp_type: double + group_name: + description: | + The variance [0.0 - 1.0] allowed when comparing normals + subblocks: + - name: /Mesh/ParsedSubdomainMeshGenerator + description: | + + parameters: + - name: block_id + required: Yes + default: !!str + cpp_type: unsigned short + group_name: + description: | + Subdomain id to set for inside of the combinatorial + - name: block_name + required: No + default: !!str + cpp_type: SubdomainName + group_name: + description: | + Subdomain name to set for inside of the combinatorial + - name: combinatorial_geometry + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Function expression encoding a combinatorial geometry + - name: constant_expressions + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of values for the constants in constant_names (can be an FParser expression) + - name: constant_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of constants used in the parsed function (use this for kB etc.) + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: disable_fpoptimizer + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Disable the function parser algebraic optimizer + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: enable_ad_cache + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable cacheing of function derivatives for faster startup time + - name: enable_auto_optimize + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable automatic immediate optimization of derivatives + - name: enable_jit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable just-in-time compilation of function expressions for faster evaluation + - name: evalerror_behavior + required: No + default: !!str nan + cpp_type: MooseEnum + group_name: 'Advanced' + options: nan nan_warning error exception + description: | + What to do if evaluation error occurs. Options are to pass a nan, pass a nan with a warning, throw a error, or throw an exception + - name: excluded_subdomain_ids + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + A set of subdomain ids that will not changed even if they are inside/outside the combinatorial geometry + - name: fail_on_evalerror + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Fail fatally if a function evaluation returns an error code (otherwise just pass on NaN) + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: type + required: No + default: !!str ParsedSubdomainMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/Partitioner + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /Mesh/Partitioner/ + description: | + + parameters: + subblocks: + - name: /Mesh/Partitioner//BlockWeightedPartitioner + description: | + + parameters: + - name: apply_element_weight + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicate if we are going to apply element weights to partitioners + - name: apply_side_weight + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Indicate if we are going to apply side weights to partitioners + - name: block + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: num_cores_per_compute_node + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of cores per compute node for hierarchical partitioning + - name: part_package + required: No + default: !!str parmetis + cpp_type: MooseEnum + group_name: + options: parmetis ptscotch chaco party hierarch + description: | + The external package is used for partitioning the mesh via PETSc + - name: type + required: No + default: !!str BlockWeightedPartitioner + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: weight + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of weights (integer) that specify how heavy each block is + subblocks: + - name: /Mesh/Partitioner//GridPartitioner + description: | + + parameters: + - name: allow_renumbering + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If allow_renumbering=false, node and element numbers are kept fixed until deletion + - name: bias_x + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the x-direction. + - name: bias_y + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the y-direction. + - name: bias_z + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the z-direction. + - name: centroid_partitioner_direction + required: No + default: !!str + cpp_type: MooseEnum + group_name: 'Partitioning' + options: x y z radial + description: | + Specifies the sort direction if using the centroid partitioner. Available options: x, y, z, radial + - name: construct_node_list_from_side_list + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Whether or not to generate nodesets from the sidesets (usually a good idea). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: gauss_lobatto_grid + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Grade mesh into boundaries according to Gauss-Lobatto quadrature spacing. + - name: ghosting_patch_size + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of nearest neighbors considered for ghosting purposes when 'iteration' patch update strategy is used. Default is 5 * patch_size. + - name: max_leaf_size + required: No + default: !!str 10 + cpp_type: unsigned int + group_name: + description: | + The maximum number of points in each leaf of the KDTree used in the nearest neighbor search. As the leaf size becomes larger,KDTree construction becomes faster but the nearest neighbor searchbecomes slower. + - name: nemesis + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + If nemesis=true and file=foo.e, actually reads foo.e.N.0, foo.e.N.1, ... foo.e.N.N-1, where N = # CPUs, with NemesisIO. + - name: nx + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the X direction + - name: ny + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the Y direction + - name: nz + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the Z direction + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DEFAULT REPLICATED DISTRIBUTED + description: | + DEFAULT: Use libMesh::ReplicatedMesh unless --distributed-mesh is specified on the command line REPLICATED: Always use libMesh::ReplicatedMesh DISTRIBUTED: Always use libMesh::DistributedMesh + - name: partitioner + required: No + default: !!str linear + cpp_type: MooseEnum + group_name: 'Partitioning' + options: default metis parmetis linear centroid hilbert_sfc morton_sfc + description: | + Specifies a mesh partitioner to use when splitting the mesh for a parallel computation. + - name: patch_size + required: No + default: !!str 40 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of nodes to consider in the NearestNode neighborhood. + - name: patch_update_strategy + required: No + default: !!str never + cpp_type: MooseEnum + group_name: 'Advanced' + options: never always auto iteration + description: | + How often to update the geometric search 'patch'. The default is to never update it (which is the most efficient but could be a problem with lots of relative motion). 'always' will update the patch for all slave nodes at the beginning of every timestep which might be time consuming. 'auto' will attempt to determine at the start of which timesteps the patch for all slave nodes needs to be updated automatically.'iteration' updates the patch at every nonlinear iteration for a subset of slave nodes for which penetration is not detected. If there can be substantial relative motion between the master and slave surfaces during the nonlinear iterations within a timestep, it is advisable to use 'iteration' option to ensure accurate contact detection. + - name: type + required: No + default: !!str GridPartitioner + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/Partitioner//LibmeshPartitioner + description: | + + parameters: + - name: blocks + required: No + default: !!str + cpp_type: std::vector >, std::allocator > > > + group_name: + description: | + Block is seperated by ;, and partition mesh block by block. + - name: centroid_partitioner_direction + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z radial + description: | + Specifies the sort direction if using the centroid partitioner. Available options: x, y, z, radial + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: partitioner + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + 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. + - name: type + required: No + default: !!str LibmeshPartitioner + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/Partitioner//PetscExternalPartitioner + description: | + + parameters: + - name: apply_element_weight + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Indicate if we are going to apply element weights to partitioners + - name: apply_side_weight + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Indicate if we are going to apply side weights to partitioners + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: num_cores_per_compute_node + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of cores per compute node for hierarchical partitioning + - name: part_package + required: No + default: !!str parmetis + cpp_type: MooseEnum + group_name: + options: parmetis ptscotch chaco party hierarch + description: | + The external package is used for partitioning the mesh via PETSc + - name: type + required: No + default: !!str PetscExternalPartitioner + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/Partitioner//RandomPartitioner + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + Seed for the random generator + - name: type + required: No + default: !!str RandomPartitioner + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/PatchMeshGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: No + default: !!str 2 + cpp_type: MooseEnum + group_name: + options: 2 3 + description: | + The dimension of the mesh to be generated. Patch meshes are only valid in 2 or 3 dimensions. + - name: elem_type + required: No + default: !!str QUAD4 + cpp_type: MooseEnum + group_name: + options: QUAD4 QUAD8 HEX8 HEX20 + description: | + The type of element from libMesh to generate (default: linear element for requested dimension) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str PatchMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: x_length + required: No + default: !!str 0.24 + cpp_type: double + group_name: + description: | + Length of the domain in the x direction. + - name: x_offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Offset of the Cartesian origin in the x direction. + - name: y_length + required: No + default: !!str 0.12 + cpp_type: double + group_name: + description: | + Length of the domain in the y direction. + - name: y_offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Offset of the Cartesian origin in the y direction. + - name: z_length + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Length of the domain in the z direction. + - name: z_offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Offset of the Cartesian origin in the z direction. + subblocks: + - name: /Mesh/PatternedMeshGenerator + description: | + + parameters: + - name: bottom_boundary + required: No + default: !!str bottom + cpp_type: BoundaryName + group_name: + description: | + name of the bottom (y) boundary + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: inputs + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The input MeshGenerators. + - name: left_boundary + required: No + default: !!str left + cpp_type: BoundaryName + group_name: + description: | + name of the left (x) boundary + - name: pattern + required: Yes + default: !!str + cpp_type: std::vector >, std::allocator > > > + group_name: + description: | + A double-indexed array starting with the upper-left corner + - name: right_boundary + required: No + default: !!str right + cpp_type: BoundaryName + group_name: + description: | + name of the right (x) boundary + - name: top_boundary + required: No + default: !!str top + cpp_type: BoundaryName + group_name: + description: | + name of the top (y) boundary + - name: type + required: No + default: !!str PatternedMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: x_width + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The tile width in the x direction + - name: y_width + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The tile width in the y direction + - name: z_width + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The tile width in the z direction + subblocks: + - name: /Mesh/PlaneDeletionGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: new_boundary + required: No + default: !!str + cpp_type: BoundaryName + group_name: + description: | + optional boundary name to assign to the cut surface + - name: normal + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The normal that defines the plane + - name: point + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + The point that defines the plane + - name: type + required: No + default: !!str PlaneDeletionGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/RenameBlockGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: new_block_id + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Elements with the old block number (or name) will be given this block number. If the old blocks are named, their names will be passed onto the newly numbered blocks. + - name: new_block_name + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Elements with the old block number (or name) will be given this block name. No change of block ID is performed, unless multiple old blocks are given the same name, in which case they are all given the first old block number. + - name: old_block_id + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Elements with this block number will be given the new_block_number or new_block_name. You must supply either old_block_id or old_block_name. You may supply a vector of old_block_id, in which case the new_block information must also be a vector. + - name: old_block_name + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Elements with this block name will be given the new_block_number or new_block_name. You must supply either old_block_id or old_block_name. You may supply a vector of old_block_name, in which case the new_block information must also be a vector. + - name: type + required: No + default: !!str RenameBlockGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/RenameBoundaryGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: new_boundary_id + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Elements with the old boundary number (or name) will be given this boundary number. If the old boundaries are named, their names will be passed onto the newly numbered boundarys. + - name: new_boundary_name + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Elements with the old boundary number (or name) will be given this boundary name. No change of boundary ID is performed, unless multiple old boundaries are given the same name, in which case they are all given the first old boundary number. + - name: old_boundary_id + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Elements with this boundary number will be given the new_boundary_number or new_boundary_name. You must supply either old_boundary_id or old_boundary_name. You may supply a vector of old_boundary_id, in which case the new_boundary information must also be a vector. + - name: old_boundary_name + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Elements with this boundary name will be given the new_boundary_number or new_boundary_name. You must supply either old_boundary_id or old_boundary_name. You may supply a vector of old_boundary_name, in which case the new_boundary information must also be a vector. + - name: type + required: No + default: !!str RenameBoundaryGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/RinglebMeshGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: gamma + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Gamma parameter + - name: inflow_bid + required: No + default: !!str 1 + cpp_type: short + group_name: + description: | + The boundary id to use for the inflow + - name: inner_wall_bid + required: No + default: !!str 2 + cpp_type: short + group_name: + description: | + The boundary id to use for the inner wall + - name: kmax + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Value of k on the inner wall. + - name: kmin + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Value of k on the outer wall. + - name: n_extra_q_pts + required: Yes + default: !!str + cpp_type: int + group_name: + description: | + How many 'extra' points should be inserted in the final element *in addition to* the equispaced q points. + - name: num_k_pts + required: Yes + default: !!str + cpp_type: int + group_name: + description: | + How many points in the range k=(kmin, kmax). + - name: num_q_pts + required: Yes + default: !!str + cpp_type: int + group_name: + description: | + How many points to discretize the range q = (0.5, k) into. + - name: outer_wall_bid + required: No + default: !!str 4 + cpp_type: short + group_name: + description: | + The boundary id to use for the outer wall + - name: outflow_bid + required: No + default: !!str 3 + cpp_type: short + group_name: + description: | + The boundary id to use for the outflow + - name: triangles + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true, all the quadrilateral elements will be split into triangles + - name: type + required: No + default: !!str RinglebMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/SideSetsAroundSubdomainGenerator + description: | + + parameters: + - name: block + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The blocks around which to create sidesets + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: fixed_normal + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This Boolean determines whether we fix our normal or allow it to vary to "paint" around curves + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: new_boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs to create on the supplied subdomain + - name: normal + required: No + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + If supplied, only faces with normal equal to this, up to normal_tol, will be added to the sidesets specified + - name: normal_tol + required: No + default: !!str 0.1 + cpp_type: double + group_name: + description: | + If normal is supplied then faces are only added if face_normal.normal_hat >= 1 - normal_tol, where normal_hat = normal/|normal| + - name: replace + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true, replace the old sidesets. If false, the current sidesets (if any) will be preserved. + - name: type + required: No + default: !!str SideSetsAroundSubdomainGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variance + required: No + default: !!str 0.1 + cpp_type: double + group_name: + description: | + The variance [0.0 - 1.0] allowed when comparing normals + subblocks: + - name: /Mesh/SideSetsBetweenSubdomainsGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: master_block + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The master set of blocks for which to draw a sideset between + - name: new_boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the boundary to create + - name: paired_block + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The paired set of blocks for which to draw a sideset between + - name: type + required: No + default: !!str SideSetsBetweenSubdomainsGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/SideSetsFromBoundingBoxGenerator + description: | + + parameters: + - name: block_id + required: Yes + default: !!str + cpp_type: unsigned short + group_name: + description: | + Subdomain id to set for inside/outside the bounding box + - name: bottom_left + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The bottom left point (in x,y,z with spaces in-between). + - name: boundary_id_new + required: Yes + default: !!str + cpp_type: short + group_name: + description: | + Boundary id on specified block within the bounding box to assign + - name: boundary_id_old + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + Boundary id on specified block within the bounding box to select + - name: boundary_id_overlap + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true if boundaries need to overlap on sideset to be detected. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: location + required: No + default: !!str INSIDE + cpp_type: MooseEnum + group_name: + options: INSIDE OUTSIDE + description: | + Control of where the subdomain id is to be set + - name: top_right + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The bottom left point (in x,y,z with spaces in-between). + - name: type + required: No + default: !!str SideSetsFromBoundingBoxGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/SideSetsFromNormalsGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: fixed_normal + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This Boolean determines whether we fix our normal or allow it to vary to "paint" around curves + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: new_boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the boundary to create + - name: normals + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + A list of normals for which to start painting sidesets + - name: replace + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true, replace the old sidesets. If false, the current sidesets (if any) will be preserved. + - name: type + required: No + default: !!str SideSetsFromNormalsGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variance + required: No + default: !!str 0.1 + cpp_type: double + group_name: + description: | + The variance [0.0 - 1.0] allowed when comparing normals + subblocks: + - name: /Mesh/SideSetsFromPointsGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: fixed_normal + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This Boolean determines whether we fix our normal or allow it to vary to "paint" around curves + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: new_boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the boundary to create + - name: points + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + A list of points from which to start painting sidesets + - name: replace + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true, replace the old sidesets. If false, the current sidesets (if any) will be preserved. + - name: type + required: No + default: !!str SideSetsFromPointsGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variance + required: No + default: !!str 0.1 + cpp_type: double + group_name: + description: | + The variance [0.0 - 1.0] allowed when comparing normals + subblocks: + - name: /Mesh/SmoothMeshGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to smooth. + - name: iterations + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + The number of smoothing iterations to do. + - name: type + required: No + default: !!str SmoothMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/SpiralAnnularMeshGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cylinder_bid + required: No + default: !!str 1 + cpp_type: short + group_name: + description: | + The boundary id to use for the cylinder (inner circle) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: exterior_bid + required: No + default: !!str 2 + cpp_type: short + group_name: + description: | + The boundary id to use for the exterior (outer circle) + - name: initial_delta_r + required: No + default: !!str + cpp_type: double + group_name: + description: | + Width of the initial layer of elements around the cylinder.This number should be approximately 2 * pi * inner_radius / nodes_per_ring to ensure that the initial layer of elements is almost equilateral + - name: inner_radius + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The size of the inner circle. + - name: nodes_per_ring + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + Number of nodes on each ring. + - name: num_rings + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of rings. + - name: outer_radius + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The size of the outer circle. Logically, it has to be greater than inner_radius + - name: type + required: No + default: !!str SpiralAnnularMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_tri6 + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Generate mesh of TRI6 elements instead of TRI3 elements. + subblocks: + - name: /Mesh/StackGenerator + description: | + + parameters: + - name: back_boundary + required: No + default: !!str back + cpp_type: BoundaryName + group_name: + description: | + name of the back (z) boundary + - name: bottom_boundary + required: No + default: !!str bottom + cpp_type: BoundaryName + group_name: + description: | + name of the bottom (y) boundary + - name: bottom_height + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The height of the bottom of the final mesh + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: 2 3 + description: | + The dimension of the mesh to be generated + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: front_boundary + required: No + default: !!str front + cpp_type: BoundaryName + group_name: + description: | + name of the front (z) boundary + - name: inputs + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The meshes we want to stitch together + - name: top_boundary + required: No + default: !!str top + cpp_type: BoundaryName + group_name: + description: | + name of the top (y) boundary + - name: type + required: No + default: !!str StackGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/StitchedMeshGenerator + description: | + + parameters: + - name: algorithm + required: No + default: !!str BINARY + cpp_type: MooseEnum + group_name: + options: BINARY EXHAUSTIVE + description: | + Control the use of binary search for the nodes of the stitched surfaces. + - name: clear_stitched_boundary_ids + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether or not to clear the stitched boundary IDs + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: inputs + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The input MeshGenerators. + - name: stitch_boundaries_pairs + required: Yes + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > >, std::allocator, std::allocator >, std::allocator, std::allocator > > > > > + group_name: + description: | + Pairs of boundaries to be stitched together between the 1st mesh in inputs and each consecutive mesh + - name: type + required: No + default: !!str StitchedMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/SubdomainBoundingBoxGenerator + description: | + + parameters: + - name: block_id + required: Yes + default: !!str + cpp_type: unsigned short + group_name: + description: | + Subdomain id to set for inside/outside the bounding box + - name: block_name + required: No + default: !!str + cpp_type: SubdomainName + group_name: + description: | + Subdomain name to set for inside/outside the bounding box (optional) + - name: bottom_left + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The bottom left point (in x,y,z with spaces in-between). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: integer_name + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Element integer to be assigned (default to subdomain ID) + - name: location + required: No + default: !!str INSIDE + cpp_type: MooseEnum + group_name: + options: INSIDE OUTSIDE + description: | + Control of where the subdomain id is to be set + - name: restricted_subdomains + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Only reset subdomain ID for given subdomains within the bounding box + - name: top_right + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The bottom left point (in x,y,z with spaces in-between). + - name: type + required: No + default: !!str SubdomainBoundingBoxGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/SubdomainIDGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: subdomain_id + required: Yes + default: !!str + cpp_type: unsigned short + group_name: + description: | + New subdomain IDs of all elements + - name: type + required: No + default: !!str SubdomainIDGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Mesh/TiledMeshGenerator + description: | + + parameters: + - name: back_boundary + required: No + default: !!str back + cpp_type: BoundaryName + group_name: + description: | + name of the back (z) boundary + - name: bottom_boundary + required: No + default: !!str bottom + cpp_type: BoundaryName + group_name: + description: | + name of the bottom (y) boundary + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: front_boundary + required: No + default: !!str front + cpp_type: BoundaryName + group_name: + description: | + name of the front (z) boundary + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to repeat + - name: left_boundary + required: No + default: !!str left + cpp_type: BoundaryName + group_name: + description: | + name of the left (x) boundary + - name: right_boundary + required: No + default: !!str right + cpp_type: BoundaryName + group_name: + description: | + name of the right (x) boundary + - name: top_boundary + required: No + default: !!str top + cpp_type: BoundaryName + group_name: + description: | + name of the top (y) boundary + - name: type + required: No + default: !!str TiledMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: x_tiles + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of tiles to stitch together (left to right) in the x-direction + - name: y_tiles + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of tiles to stitch together (top to bottom) in the y-direction + - name: z_tiles + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of tiles to stitch together (front to back) in the z-direction + subblocks: + - name: /Mesh/TransformGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: transform + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: TRANSLATE ROTATE SCALE + description: | + The type of transformation to perform (TRANSLATE, ROTATE, SCALE) + - name: type + required: No + default: !!str TransformGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: vector_value + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The value to use for the transformation. When using TRANSLATE or SCALE, the xyz coordinates are applied in each direction respectively. When using ROTATE, the values are interpreted as the Euler angles phi, theta and psi given in degrees. + subblocks: +- name: /MeshGenerators + description: | + + parameters: + subblocks: + - name: /MeshGenerators/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /MeshGenerators/AllSideSetsByNormalsGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: fixed_normal + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This Boolean determines whether we fix our normal or allow it to vary to "paint" around curves + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: replace + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true, replace the old sidesets. If false, the current sidesets (if any) will be preserved. + - name: type + required: No + default: !!str AllSideSetsByNormalsGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variance + required: No + default: !!str 0.1 + cpp_type: double + group_name: + description: | + The variance [0.0 - 1.0] allowed when comparing normals + subblocks: + - name: /MeshGenerators/AnnularMeshGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dmax + required: No + default: !!str 360 + cpp_type: double + group_name: + description: | + Maximum angle, measured in degrees anticlockwise from x axis. If dmin=0 and dmax=360 an annular mesh is created. Otherwise, only a sector of an annulus is created + - name: dmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Minimum degree, measured in degrees anticlockwise from x axis + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: growth_r + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The ratio of radial sizes of successive rings of elements + - name: nr + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the radial direction + - name: nt + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + Number of elements in the angular direction + - name: quad_subdomain_id + required: No + default: !!str 0 + cpp_type: unsigned short + group_name: + description: | + The subdomain ID given to the QUAD4 elements + - name: rmax + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Outer radius + - name: rmin + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Inner radius. If rmin=0 then a disc mesh (with no central hole) will be created. + - name: tmax + required: No + default: !!str 6.28319 + cpp_type: double + group_name: + description: | + Maximum angle, measured in radians anticlockwise from x axis. If tmin=0 and tmax=2Pi an annular mesh is created. Otherwise, only a sector of an annulus is created + - name: tmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Minimum angle, measured in radians anticlockwise from x axis + - name: tri_subdomain_id + required: No + default: !!str 1 + cpp_type: unsigned short + group_name: + description: | + The subdomain ID given to the TRI3 elements (these exist only if rmin=0, and they exist at the center of the disc + - name: type + required: No + default: !!str AnnularMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/BlockDeletionGenerator + description: | + + parameters: + - name: block_id + required: Yes + default: !!str + cpp_type: unsigned short + group_name: + description: | + The block to be deleted + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: new_boundary + required: No + default: !!str + cpp_type: BoundaryName + group_name: + description: | + optional boundary name to assign to the cut surface + - name: type + required: No + default: !!str BlockDeletionGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/BoundingBoxNodeSetGenerator + description: | + + parameters: + - name: bottom_left + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The bottom left point (in x,y,z with spaces in-between) of the box to select the nodes. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: location + required: No + default: !!str INSIDE + cpp_type: MooseEnum + group_name: + options: INSIDE OUTSIDE + description: | + Control of where the nodeset is to be set + - name: new_boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the nodeset to create + - name: top_right + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The bottom left point (in x,y,z with spaces in-between) of the box to select the nodes. + - name: type + required: No + default: !!str BoundingBoxNodeSetGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/BreakBoundaryOnSubdomainGenerator + description: | + + parameters: + - name: boundaries + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Boundaries to be broken. Default means to break all boundaries + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: type + required: No + default: !!str BreakBoundaryOnSubdomainGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/BreakMeshByBlockGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: interface_name + required: No + default: !!str interface + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + the name of the new interface. Cannot be used whit `split_interface=true` + - name: split_interface + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true, it create a different interface for each block pair. + - name: type + required: No + default: !!str BreakMeshByBlockGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/CartesianMeshGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: 'Main' + options: 1 2 3 + description: | + The dimension of the mesh to be generated + - name: dx + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + Intervals in the X direction + - name: dy + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Intervals in the Y direction (required when dim>1 otherwise ignored) + - name: dz + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Intervals in the Z direction (required when dim>2 otherwise ignored) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: ix + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Number of grids in all intervals in the X direction (default to all one) + - name: iy + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Number of grids in all intervals in the Y direction (default to all one) + - name: iz + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Number of grids in all intervals in the Z direction (default to all one) + - name: subdomain_id + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Block IDs (default to all zero) + - name: type + required: No + default: !!str CartesianMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/CombinerGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: inputs + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The input MeshGenerators. This can either be N generators or 1 generator. If only 1 is given then 'positions' must also be given. + - name: positions + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The (optional) position of each given mesh. If N 'inputs' were given then this must either be left blank or N positions must be given. If 1 input was given then this MUST be provided. + - name: type + required: No + default: !!str CombinerGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/ConcentricCircleMeshGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: has_outer_square + required: Yes + default: !!str + cpp_type: bool + group_name: + description: | + It determines if meshes for a outer square are added to concentric circle meshes. + - name: num_sectors + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + num_sectors % 2 = 0, num_sectors > 0Number of azimuthal sectors in each quadrant'num_sectors' must be an even number. + - name: pitch + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The enclosing square can be added to the completed concentric circle mesh.Elements are quad meshes. + - name: portion + required: No + default: !!str full + cpp_type: MooseEnum + group_name: + options: full top_right top_left bottom_left bottom_right right_half left_half top_half bottom_half + description: | + Control of which part of mesh is created + - name: preserve_volumes + required: Yes + default: !!str + cpp_type: bool + group_name: + description: | + Volume of concentric circles can be preserved using this function. + - name: radii + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + Radii of major concentric circles + - name: rings + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + Number of rings in each circle or in the enclosing square + - name: smoothing_max_it + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of Laplacian smoothing iterations + - name: type + required: No + default: !!str ConcentricCircleMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/DistributedRectilinearMeshGenerator + description: | + + parameters: + - name: apply_element_weight + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Indicate if we are going to apply element weights to partitioners + - name: apply_side_weight + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Indicate if we are going to apply side weights to partitioners + - name: bias_x + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the x-direction. + - name: bias_y + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the y-direction. + - name: bias_z + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the z-direction. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: 'Main' + options: 1 2 3 + description: | + The dimension of the mesh to be generated + - name: elem_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: EDGE EDGE2 EDGE3 EDGE4 QUAD QUAD4 QUAD8 QUAD9 TRI3 TRI6 HEX HEX8 HEX20 HEX27 TET4 TET10 PRISM6 PRISM15 PRISM18 PYRAMID5 PYRAMID13 PYRAMID14 + description: | + The type of element from libMesh to generate (default: linear element for requested dimension) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: num_cores_for_partition + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + Number of cores for partitioning the graph + - name: num_cores_per_compute_node + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of cores per compute node for hierarchical partitioning + - name: nx + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the X direction + - name: ny + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the Y direction + - name: nz + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the Z direction + - name: part_package + required: No + default: !!str parmetis + cpp_type: MooseEnum + group_name: + options: parmetis ptscotch chaco party hierarch + description: | + The external package is used for partitioning the mesh via PETSc + - name: type + required: No + default: !!str DistributedRectilinearMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: xmax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper X Coordinate of the generated mesh + - name: xmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower X Coordinate of the generated mesh + - name: ymax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper Y Coordinate of the generated mesh + - name: ymin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower Y Coordinate of the generated mesh + - name: zmax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper Z Coordinate of the generated mesh + - name: zmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower Z Coordinate of the generated mesh + subblocks: + - name: /MeshGenerators/ElementGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: elem_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: EDGE2 EDGE3 EDGE4 QUAD4 QUAD8 QUAD9 TRI3 TRI6 HEX8 HEX20 HEX27 TET4 TET10 PRISM6 PRISM15 PRISM18 PYRAMID5 PYRAMID13 PYRAMID14 + description: | + The type of element from libMesh to generate + - name: element_connectivity + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + List of nodes to use for each element + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: No + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + Optional input mesh to add the elements to + - name: nodal_positions + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The x,y,z positions of the nodes + - name: type + required: No + default: !!str ElementGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/ElementSubdomainIDGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: element_ids + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + New element IDs of all elements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: subdomain_ids + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + New subdomain IDs of all elements + - name: type + required: No + default: !!str ElementSubdomainIDGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/ExtraNodesetGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: coord + required: No + default: !!str + cpp_type: std::vector >, std::allocator > > > + group_name: + description: | + The nodes with coordinates you want to be in the nodeset. Separate multple coords with ';' (Either this parameter or "nodes" must be supplied). + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: new_boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the boundary to create + - name: nodes + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The nodes you want to be in the nodeset (Either this parameter or "coord" must be supplied). + - name: tolerance + required: No + default: !!str 1e-06 + cpp_type: double + group_name: + description: | + The tolerance in which two nodes are considered identical + - name: type + required: No + default: !!str ExtraNodesetGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/FancyExtruderGenerator + description: | + + parameters: + - name: bottom_boundary + required: No + default: !!str + cpp_type: short + group_name: + description: | + The boundary ID to set on the bottom boundary. If omitted one will be generated. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: direction + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + A vector that points in the direction to extrude (note, this will be normalized internally - so don't worry about it here) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: heights + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The height of each elevation + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh to extrude + - name: num_layers + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The number of layers for each elevation - must be num_elevations in length! + - name: subdomain_swaps + required: No + default: !!str + cpp_type: std::vector >, std::allocator > > > + group_name: + description: | + For each row, every two entries are interpreted as a pair of 'from' and 'to' to remap the subdomains for that elevation + - name: top_boundary + required: No + default: !!str + cpp_type: short + group_name: + description: | + The boundary ID to set on the top boundary. If ommitted one will be generated. + - name: type + required: No + default: !!str FancyExtruderGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/FileMeshGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: exodus_extra_element_integers + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The variable names in the mesh file for loading extra element integers + - name: file + required: Yes + default: !!str + cpp_type: MeshFileName + group_name: + description: | + The filename to read. + - name: type + required: No + default: !!str FileMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/GeneratedMeshGenerator + description: | + + parameters: + - name: bias_x + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the x-direction. + - name: bias_y + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the y-direction. + - name: bias_z + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the z-direction. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: 'Main' + options: 1 2 3 + description: | + The dimension of the mesh to be generated + - name: elem_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: EDGE EDGE2 EDGE3 EDGE4 QUAD QUAD4 QUAD8 QUAD9 TRI3 TRI6 HEX HEX8 HEX20 HEX27 TET4 TET10 PRISM6 PRISM15 PRISM18 PYRAMID5 PYRAMID13 PYRAMID14 + description: | + The type of element from libMesh to generate (default: linear element for requested dimension) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_element_integers + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Names of extra element integers + - name: gauss_lobatto_grid + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Grade mesh into boundaries according to Gauss-Lobatto quadrature spacing. + - name: nx + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the X direction + - name: ny + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the Y direction + - name: nz + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the Z direction + - name: type + required: No + default: !!str GeneratedMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: xmax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper X Coordinate of the generated mesh + - name: xmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower X Coordinate of the generated mesh + - name: ymax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper Y Coordinate of the generated mesh + - name: ymin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower Y Coordinate of the generated mesh + - name: zmax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper Z Coordinate of the generated mesh + - name: zmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower Z Coordinate of the generated mesh + subblocks: + - name: /MeshGenerators/ImageMeshGenerator + description: | + + parameters: + - name: bias_x + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the x-direction. + - name: bias_y + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the y-direction. + - name: bias_z + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The amount by which to grow (or shrink) the cells in the z-direction. + - name: cells_per_pixel + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The number of mesh cells per pixel, must be <=1 + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: 'Main' + options: 1 2 3 + description: | + The dimension of the mesh to be generated + - name: elem_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: EDGE EDGE2 EDGE3 EDGE4 QUAD QUAD4 QUAD8 QUAD9 TRI3 TRI6 HEX HEX8 HEX20 HEX27 TET4 TET10 PRISM6 PRISM15 PRISM18 PYRAMID5 PYRAMID13 PYRAMID14 + description: | + The type of element from libMesh to generate (default: linear element for requested dimension) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_element_integers + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Names of extra element integers + - name: file + required: No + default: !!str + cpp_type: FileName + group_name: + description: | + Name of single image file to extract mesh parameters from. If provided, a 2D mesh is created. + - name: file_base + required: No + default: !!str + cpp_type: FileNameNoExtension + group_name: + description: | + Image file base to open, use this option when a stack of images must be read (ignored if 'file' is given) + - name: file_range + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Range of images to analyze, used with 'file_base' (ignored if 'file' is given) + - name: file_suffix + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Suffix of the file to open, e.g. 'png' + - name: gauss_lobatto_grid + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Grade mesh into boundaries according to Gauss-Lobatto quadrature spacing. + - name: nx + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the X direction + - name: ny + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the Y direction + - name: nz + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of elements in the Z direction + - name: scale_to_one + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether or not to scale the image so its max dimension is 1 + - name: type + required: No + default: !!str ImageMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: xmax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper X Coordinate of the generated mesh + - name: xmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower X Coordinate of the generated mesh + - name: ymax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper Y Coordinate of the generated mesh + - name: ymin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower Y Coordinate of the generated mesh + - name: zmax + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper Z Coordinate of the generated mesh + - name: zmin + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower Z Coordinate of the generated mesh + subblocks: + - name: /MeshGenerators/ImageSubdomainGenerator + description: | + + parameters: + - name: component + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The image RGB-component to return, leaving this blank will result in a greyscale value for the image to be created. The component number is zero based, i.e. 0 returns the first (RED) component of the image. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dimensions + required: No + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + x,y,z dimensions of the image (defaults to mesh dimensions) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: file + required: No + default: !!str + cpp_type: FileName + group_name: + description: | + Name of single image file to extract mesh parameters from. If provided, a 2D mesh is created. + - name: file_base + required: No + default: !!str + cpp_type: FileNameNoExtension + group_name: + description: | + Image file base to open, use this option when a stack of images must be read (ignored if 'file' is given) + - name: file_range + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Range of images to analyze, used with 'file_base' (ignored if 'file' is given) + - name: file_suffix + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Suffix of the file to open, e.g. 'png' + - name: flip_x + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Flip' + description: | + Flip the image along the x-axis + - name: flip_y + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Flip' + description: | + Flip the image along the y-axis + - name: flip_z + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Flip' + description: | + Flip the image along the z-axis + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: lower_value + required: No + default: !!str 0 + cpp_type: double + group_name: 'Threshold' + description: | + The value to set for data less than the threshold value + - name: origin + required: No + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + Origin of the image (defaults to mesh origin) + - name: scale + required: No + default: !!str 1 + cpp_type: double + group_name: 'Rescale' + description: | + Multiplier to apply to all pixel values; occurs after shifting + - name: shift + required: No + default: !!str 0 + cpp_type: double + group_name: 'Rescale' + description: | + Value to add to all pixels; occurs prior to scaling + - name: threshold + required: No + default: !!str + cpp_type: double + group_name: 'Threshold' + description: | + The threshold value + - name: type + required: No + default: !!str ImageSubdomainGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: upper_value + required: No + default: !!str 1 + cpp_type: double + group_name: 'Threshold' + description: | + The value to set for data greater than the threshold value + subblocks: + - name: /MeshGenerators/LowerDBlockFromSidesetGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: new_block_id + required: No + default: !!str + cpp_type: unsigned short + group_name: + description: | + The lower dimensional block id to create + - name: new_block_name + required: No + default: !!str + cpp_type: SubdomainName + group_name: + description: | + The lower dimensional block name to create (optional) + - name: sidesets + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The sidesets from which to create the new block + - name: type + required: No + default: !!str LowerDBlockFromSidesetGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/MeshCollectionGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: inputs + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The input MeshGenerators. + - name: type + required: No + default: !!str MeshCollectionGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/MeshExtruderGenerator + description: | + + parameters: + - name: bottom_sideset + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The boundary that will be applied to the bottom of the extruded mesh + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: existing_subdomains + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The subdomains that will be remapped for specific layers + - name: extrusion_vector + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The direction and length of the extrusion + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + the mesh we want to extrude + - name: layers + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The layers where the "existing_subdomain" will be remapped to new ids + - name: new_ids + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of new ids, This list should be either length "existing_subdomains" or "existing_subdomains" * layers + - name: num_layers + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + The number of layers in the extruded mesh + - name: top_sideset + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The boundary that will be to the top of the extruded mesh + - name: type + required: No + default: !!str MeshExtruderGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/MeshSideSetGenerator + description: | + + parameters: + - name: block_id + required: Yes + default: !!str + cpp_type: unsigned short + group_name: + description: | + Subdomain id to set for the new elements along the boundary + - name: block_name + required: No + default: !!str + cpp_type: SubdomainName + group_name: + description: | + Subdomain name to set for the new elements along the boundary (optional) + - name: boundaries + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the boundary to mesh + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: type + required: No + default: !!str MeshSideSetGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/OrientedSubdomainBoundingBoxGenerator + description: | + + parameters: + - name: block_id + required: Yes + default: !!str + cpp_type: unsigned short + group_name: + description: | + Subdomain id to set for inside/outside the bounding box + - name: center + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + The center (many people spell this 'center') of the box. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: height + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The height of the box + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: length + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The length of the box + - name: length_direction + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The direction along which the length is oriented (must be perpendicular to width_direction). + - name: location + required: No + default: !!str INSIDE + cpp_type: MooseEnum + group_name: + options: INSIDE OUTSIDE + description: | + Control of where the subdomain id is to be set + - name: type + required: No + default: !!str OrientedSubdomainBoundingBoxGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: width + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The width of the box + - name: width_direction + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The direction along which the width is oriented. + subblocks: + - name: /MeshGenerators/ParsedGenerateSideset + description: | + + parameters: + - name: combinatorial_geometry + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Function expression encoding a combinatorial geometry + - name: constant_expressions + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of values for the constants in constant_names (can be an FParser expression) + - name: constant_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of constants used in the parsed function (use this for kB etc.) + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: disable_fpoptimizer + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Disable the function parser algebraic optimizer + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: enable_ad_cache + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable cacheing of function derivatives for faster startup time + - name: enable_auto_optimize + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable automatic immediate optimization of derivatives + - name: enable_jit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable just-in-time compilation of function expressions for faster evaluation + - name: evalerror_behavior + required: No + default: !!str nan + cpp_type: MooseEnum + group_name: 'Advanced' + options: nan nan_warning error exception + description: | + What to do if evaluation error occurs. Options are to pass a nan, pass a nan with a warning, throw a error, or throw an exception + - name: fail_on_evalerror + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Fail fatally if a function evaluation returns an error code (otherwise just pass on NaN) + - name: fixed_normal + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This Boolean determines whether we fix our normal or allow it to vary to "paint" around curves + - name: included_subdomain_ids + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + A set of subdomain ids whose sides will be included in the new sidesets + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: new_sideset_name + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The name of the new sideset + - name: normal + required: No + default: !!str 0 0 0 + cpp_type: libMesh::Point + group_name: + description: | + If provided specifies the normal vector on sides that are added to the new + - name: replace + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true, replace the old sidesets. If false, the current sidesets (if any) will be preserved. + - name: type + required: No + default: !!str ParsedGenerateSideset + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variance + required: No + default: !!str 0.1 + cpp_type: double + group_name: + description: | + The variance [0.0 - 1.0] allowed when comparing normals + subblocks: + - name: /MeshGenerators/ParsedSubdomainMeshGenerator + description: | + + parameters: + - name: block_id + required: Yes + default: !!str + cpp_type: unsigned short + group_name: + description: | + Subdomain id to set for inside of the combinatorial + - name: block_name + required: No + default: !!str + cpp_type: SubdomainName + group_name: + description: | + Subdomain name to set for inside of the combinatorial + - name: combinatorial_geometry + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Function expression encoding a combinatorial geometry + - name: constant_expressions + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of values for the constants in constant_names (can be an FParser expression) + - name: constant_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of constants used in the parsed function (use this for kB etc.) + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: disable_fpoptimizer + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Disable the function parser algebraic optimizer + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: enable_ad_cache + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable cacheing of function derivatives for faster startup time + - name: enable_auto_optimize + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable automatic immediate optimization of derivatives + - name: enable_jit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable just-in-time compilation of function expressions for faster evaluation + - name: evalerror_behavior + required: No + default: !!str nan + cpp_type: MooseEnum + group_name: 'Advanced' + options: nan nan_warning error exception + description: | + What to do if evaluation error occurs. Options are to pass a nan, pass a nan with a warning, throw a error, or throw an exception + - name: excluded_subdomain_ids + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + A set of subdomain ids that will not changed even if they are inside/outside the combinatorial geometry + - name: fail_on_evalerror + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Fail fatally if a function evaluation returns an error code (otherwise just pass on NaN) + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: type + required: No + default: !!str ParsedSubdomainMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/PatchMeshGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: No + default: !!str 2 + cpp_type: MooseEnum + group_name: + options: 2 3 + description: | + The dimension of the mesh to be generated. Patch meshes are only valid in 2 or 3 dimensions. + - name: elem_type + required: No + default: !!str QUAD4 + cpp_type: MooseEnum + group_name: + options: QUAD4 QUAD8 HEX8 HEX20 + description: | + The type of element from libMesh to generate (default: linear element for requested dimension) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str PatchMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: x_length + required: No + default: !!str 0.24 + cpp_type: double + group_name: + description: | + Length of the domain in the x direction. + - name: x_offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Offset of the Cartesian origin in the x direction. + - name: y_length + required: No + default: !!str 0.12 + cpp_type: double + group_name: + description: | + Length of the domain in the y direction. + - name: y_offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Offset of the Cartesian origin in the y direction. + - name: z_length + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Length of the domain in the z direction. + - name: z_offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Offset of the Cartesian origin in the z direction. + subblocks: + - name: /MeshGenerators/PatternedMeshGenerator + description: | + + parameters: + - name: bottom_boundary + required: No + default: !!str bottom + cpp_type: BoundaryName + group_name: + description: | + name of the bottom (y) boundary + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: inputs + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The input MeshGenerators. + - name: left_boundary + required: No + default: !!str left + cpp_type: BoundaryName + group_name: + description: | + name of the left (x) boundary + - name: pattern + required: Yes + default: !!str + cpp_type: std::vector >, std::allocator > > > + group_name: + description: | + A double-indexed array starting with the upper-left corner + - name: right_boundary + required: No + default: !!str right + cpp_type: BoundaryName + group_name: + description: | + name of the right (x) boundary + - name: top_boundary + required: No + default: !!str top + cpp_type: BoundaryName + group_name: + description: | + name of the top (y) boundary + - name: type + required: No + default: !!str PatternedMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: x_width + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The tile width in the x direction + - name: y_width + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The tile width in the y direction + - name: z_width + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The tile width in the z direction + subblocks: + - name: /MeshGenerators/PlaneDeletionGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: new_boundary + required: No + default: !!str + cpp_type: BoundaryName + group_name: + description: | + optional boundary name to assign to the cut surface + - name: normal + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The normal that defines the plane + - name: point + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + The point that defines the plane + - name: type + required: No + default: !!str PlaneDeletionGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/RenameBlockGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: new_block_id + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Elements with the old block number (or name) will be given this block number. If the old blocks are named, their names will be passed onto the newly numbered blocks. + - name: new_block_name + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Elements with the old block number (or name) will be given this block name. No change of block ID is performed, unless multiple old blocks are given the same name, in which case they are all given the first old block number. + - name: old_block_id + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Elements with this block number will be given the new_block_number or new_block_name. You must supply either old_block_id or old_block_name. You may supply a vector of old_block_id, in which case the new_block information must also be a vector. + - name: old_block_name + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Elements with this block name will be given the new_block_number or new_block_name. You must supply either old_block_id or old_block_name. You may supply a vector of old_block_name, in which case the new_block information must also be a vector. + - name: type + required: No + default: !!str RenameBlockGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/RenameBoundaryGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: new_boundary_id + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Elements with the old boundary number (or name) will be given this boundary number. If the old boundaries are named, their names will be passed onto the newly numbered boundarys. + - name: new_boundary_name + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Elements with the old boundary number (or name) will be given this boundary name. No change of boundary ID is performed, unless multiple old boundaries are given the same name, in which case they are all given the first old boundary number. + - name: old_boundary_id + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Elements with this boundary number will be given the new_boundary_number or new_boundary_name. You must supply either old_boundary_id or old_boundary_name. You may supply a vector of old_boundary_id, in which case the new_boundary information must also be a vector. + - name: old_boundary_name + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Elements with this boundary name will be given the new_boundary_number or new_boundary_name. You must supply either old_boundary_id or old_boundary_name. You may supply a vector of old_boundary_name, in which case the new_boundary information must also be a vector. + - name: type + required: No + default: !!str RenameBoundaryGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/RinglebMeshGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: gamma + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Gamma parameter + - name: inflow_bid + required: No + default: !!str 1 + cpp_type: short + group_name: + description: | + The boundary id to use for the inflow + - name: inner_wall_bid + required: No + default: !!str 2 + cpp_type: short + group_name: + description: | + The boundary id to use for the inner wall + - name: kmax + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Value of k on the inner wall. + - name: kmin + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Value of k on the outer wall. + - name: n_extra_q_pts + required: Yes + default: !!str + cpp_type: int + group_name: + description: | + How many 'extra' points should be inserted in the final element *in addition to* the equispaced q points. + - name: num_k_pts + required: Yes + default: !!str + cpp_type: int + group_name: + description: | + How many points in the range k=(kmin, kmax). + - name: num_q_pts + required: Yes + default: !!str + cpp_type: int + group_name: + description: | + How many points to discretize the range q = (0.5, k) into. + - name: outer_wall_bid + required: No + default: !!str 4 + cpp_type: short + group_name: + description: | + The boundary id to use for the outer wall + - name: outflow_bid + required: No + default: !!str 3 + cpp_type: short + group_name: + description: | + The boundary id to use for the outflow + - name: triangles + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true, all the quadrilateral elements will be split into triangles + - name: type + required: No + default: !!str RinglebMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/SideSetsAroundSubdomainGenerator + description: | + + parameters: + - name: block + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The blocks around which to create sidesets + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: fixed_normal + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This Boolean determines whether we fix our normal or allow it to vary to "paint" around curves + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: new_boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs to create on the supplied subdomain + - name: normal + required: No + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + If supplied, only faces with normal equal to this, up to normal_tol, will be added to the sidesets specified + - name: normal_tol + required: No + default: !!str 0.1 + cpp_type: double + group_name: + description: | + If normal is supplied then faces are only added if face_normal.normal_hat >= 1 - normal_tol, where normal_hat = normal/|normal| + - name: replace + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true, replace the old sidesets. If false, the current sidesets (if any) will be preserved. + - name: type + required: No + default: !!str SideSetsAroundSubdomainGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variance + required: No + default: !!str 0.1 + cpp_type: double + group_name: + description: | + The variance [0.0 - 1.0] allowed when comparing normals + subblocks: + - name: /MeshGenerators/SideSetsBetweenSubdomainsGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: master_block + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The master set of blocks for which to draw a sideset between + - name: new_boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the boundary to create + - name: paired_block + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The paired set of blocks for which to draw a sideset between + - name: type + required: No + default: !!str SideSetsBetweenSubdomainsGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/SideSetsFromBoundingBoxGenerator + description: | + + parameters: + - name: block_id + required: Yes + default: !!str + cpp_type: unsigned short + group_name: + description: | + Subdomain id to set for inside/outside the bounding box + - name: bottom_left + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The bottom left point (in x,y,z with spaces in-between). + - name: boundary_id_new + required: Yes + default: !!str + cpp_type: short + group_name: + description: | + Boundary id on specified block within the bounding box to assign + - name: boundary_id_old + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + Boundary id on specified block within the bounding box to select + - name: boundary_id_overlap + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true if boundaries need to overlap on sideset to be detected. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: location + required: No + default: !!str INSIDE + cpp_type: MooseEnum + group_name: + options: INSIDE OUTSIDE + description: | + Control of where the subdomain id is to be set + - name: top_right + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The bottom left point (in x,y,z with spaces in-between). + - name: type + required: No + default: !!str SideSetsFromBoundingBoxGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/SideSetsFromNormalsGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: fixed_normal + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This Boolean determines whether we fix our normal or allow it to vary to "paint" around curves + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: new_boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the boundary to create + - name: normals + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + A list of normals for which to start painting sidesets + - name: replace + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true, replace the old sidesets. If false, the current sidesets (if any) will be preserved. + - name: type + required: No + default: !!str SideSetsFromNormalsGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variance + required: No + default: !!str 0.1 + cpp_type: double + group_name: + description: | + The variance [0.0 - 1.0] allowed when comparing normals + subblocks: + - name: /MeshGenerators/SideSetsFromPointsGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: fixed_normal + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This Boolean determines whether we fix our normal or allow it to vary to "paint" around curves + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: new_boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the boundary to create + - name: points + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + A list of points from which to start painting sidesets + - name: replace + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true, replace the old sidesets. If false, the current sidesets (if any) will be preserved. + - name: type + required: No + default: !!str SideSetsFromPointsGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variance + required: No + default: !!str 0.1 + cpp_type: double + group_name: + description: | + The variance [0.0 - 1.0] allowed when comparing normals + subblocks: + - name: /MeshGenerators/SmoothMeshGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to smooth. + - name: iterations + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + The number of smoothing iterations to do. + - name: type + required: No + default: !!str SmoothMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/SpiralAnnularMeshGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cylinder_bid + required: No + default: !!str 1 + cpp_type: short + group_name: + description: | + The boundary id to use for the cylinder (inner circle) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: exterior_bid + required: No + default: !!str 2 + cpp_type: short + group_name: + description: | + The boundary id to use for the exterior (outer circle) + - name: initial_delta_r + required: No + default: !!str + cpp_type: double + group_name: + description: | + Width of the initial layer of elements around the cylinder.This number should be approximately 2 * pi * inner_radius / nodes_per_ring to ensure that the initial layer of elements is almost equilateral + - name: inner_radius + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The size of the inner circle. + - name: nodes_per_ring + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + Number of nodes on each ring. + - name: num_rings + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of rings. + - name: outer_radius + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The size of the outer circle. Logically, it has to be greater than inner_radius + - name: type + required: No + default: !!str SpiralAnnularMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_tri6 + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Generate mesh of TRI6 elements instead of TRI3 elements. + subblocks: + - name: /MeshGenerators/StackGenerator + description: | + + parameters: + - name: back_boundary + required: No + default: !!str back + cpp_type: BoundaryName + group_name: + description: | + name of the back (z) boundary + - name: bottom_boundary + required: No + default: !!str bottom + cpp_type: BoundaryName + group_name: + description: | + name of the bottom (y) boundary + - name: bottom_height + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The height of the bottom of the final mesh + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: dim + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: 2 3 + description: | + The dimension of the mesh to be generated + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: front_boundary + required: No + default: !!str front + cpp_type: BoundaryName + group_name: + description: | + name of the front (z) boundary + - name: inputs + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The meshes we want to stitch together + - name: top_boundary + required: No + default: !!str top + cpp_type: BoundaryName + group_name: + description: | + name of the top (y) boundary + - name: type + required: No + default: !!str StackGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/StitchedMeshGenerator + description: | + + parameters: + - name: algorithm + required: No + default: !!str BINARY + cpp_type: MooseEnum + group_name: + options: BINARY EXHAUSTIVE + description: | + Control the use of binary search for the nodes of the stitched surfaces. + - name: clear_stitched_boundary_ids + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether or not to clear the stitched boundary IDs + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: inputs + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The input MeshGenerators. + - name: stitch_boundaries_pairs + required: Yes + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > >, std::allocator, std::allocator >, std::allocator, std::allocator > > > > > + group_name: + description: | + Pairs of boundaries to be stitched together between the 1st mesh in inputs and each consecutive mesh + - name: type + required: No + default: !!str StitchedMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/SubdomainBoundingBoxGenerator + description: | + + parameters: + - name: block_id + required: Yes + default: !!str + cpp_type: unsigned short + group_name: + description: | + Subdomain id to set for inside/outside the bounding box + - name: block_name + required: No + default: !!str + cpp_type: SubdomainName + group_name: + description: | + Subdomain name to set for inside/outside the bounding box (optional) + - name: bottom_left + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The bottom left point (in x,y,z with spaces in-between). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: integer_name + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Element integer to be assigned (default to subdomain ID) + - name: location + required: No + default: !!str INSIDE + cpp_type: MooseEnum + group_name: + options: INSIDE OUTSIDE + description: | + Control of where the subdomain id is to be set + - name: restricted_subdomains + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Only reset subdomain ID for given subdomains within the bounding box + - name: top_right + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The bottom left point (in x,y,z with spaces in-between). + - name: type + required: No + default: !!str SubdomainBoundingBoxGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/SubdomainIDGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: subdomain_id + required: Yes + default: !!str + cpp_type: unsigned short + group_name: + description: | + New subdomain IDs of all elements + - name: type + required: No + default: !!str SubdomainIDGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshGenerators/TiledMeshGenerator + description: | + + parameters: + - name: back_boundary + required: No + default: !!str back + cpp_type: BoundaryName + group_name: + description: | + name of the back (z) boundary + - name: bottom_boundary + required: No + default: !!str bottom + cpp_type: BoundaryName + group_name: + description: | + name of the bottom (y) boundary + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: front_boundary + required: No + default: !!str front + cpp_type: BoundaryName + group_name: + description: | + name of the front (z) boundary + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to repeat + - name: left_boundary + required: No + default: !!str left + cpp_type: BoundaryName + group_name: + description: | + name of the left (x) boundary + - name: right_boundary + required: No + default: !!str right + cpp_type: BoundaryName + group_name: + description: | + name of the right (x) boundary + - name: top_boundary + required: No + default: !!str top + cpp_type: BoundaryName + group_name: + description: | + name of the top (y) boundary + - name: type + required: No + default: !!str TiledMeshGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: x_tiles + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of tiles to stitch together (left to right) in the x-direction + - name: y_tiles + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of tiles to stitch together (top to bottom) in the y-direction + - name: z_tiles + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of tiles to stitch together (front to back) in the z-direction + subblocks: + - name: /MeshGenerators/TransformGenerator + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: input + required: Yes + default: !!str + cpp_type: MeshGeneratorName + group_name: + description: | + The mesh we want to modify + - name: transform + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: TRANSLATE ROTATE SCALE + description: | + The type of transformation to perform (TRANSLATE, ROTATE, SCALE) + - name: type + required: No + default: !!str TransformGenerator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: vector_value + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The value to use for the transformation. When using TRANSLATE or SCALE, the xyz coordinates are applied in each direction respectively. When using ROTATE, the values are interpreted as the Euler angles phi, theta and psi given in degrees. + subblocks: +- name: /MeshModifiers + description: | + + parameters: + subblocks: + - name: /MeshModifiers/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /MeshModifiers/AddAllSideSetsByNormals + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: fixed_normal + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This Boolean determines whether we fix our normal or allow it to vary to "paint" around curves + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: type + required: No + default: !!str AddAllSideSetsByNormals + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variance + required: No + default: !!str 0.1 + cpp_type: double + group_name: + description: | + The variance [0.0 - 1.0] allowed when comparing normals + subblocks: + - name: /MeshModifiers/AddExtraNodeset + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: coord + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The nodes with coordinates you want to be in the nodeset (Either this parameter or "nodes" must be supplied). + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: new_boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the boundary to create + - name: nodes + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The nodes you want to be in the nodeset (Either this parameter or "coord" must be supplied). + - name: tolerance + required: No + default: !!str 1e-06 + cpp_type: double + group_name: + description: | + The tolerance in which two nodes are considered identical + - name: type + required: No + default: !!str AddExtraNodeset + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshModifiers/AddSideSetsFromBoundingBox + description: | + + parameters: + - name: bottom_left + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The bottom left point (in x,y,z with spaces in-between). + - name: boundary_id_new + required: Yes + default: !!str + cpp_type: short + group_name: + description: | + Boundary id on specified block within the bounding box to assign + - name: boundary_id_old + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + Boundary id on specified block within the bounding box to select + - name: boundary_id_overlap + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true if boundaries need to overlap on sideset to be detected. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: location + required: No + default: !!str INSIDE + cpp_type: MooseEnum + group_name: + options: INSIDE OUTSIDE + description: | + Control of where the subdomain id is to be set + - name: top_right + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The bottom left point (in x,y,z with spaces in-between). + - name: type + required: No + default: !!str AddSideSetsFromBoundingBox + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshModifiers/AssignElementSubdomainID + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: element_ids + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + New subdomain IDs of all elements + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: subdomain_ids + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + New subdomain IDs of all elements + - name: type + required: No + default: !!str AssignElementSubdomainID + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshModifiers/AssignSubdomainID + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: subdomain_id + required: Yes + default: !!str + cpp_type: unsigned short + group_name: + description: | + New subdomain IDs of all elements + - name: type + required: No + default: !!str AssignSubdomainID + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshModifiers/BlockDeleter + description: | + + parameters: + - name: block_id + required: Yes + default: !!str + cpp_type: unsigned short + group_name: + description: | + The block to be deleted + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: new_boundary + required: No + default: !!str + cpp_type: BoundaryName + group_name: + description: | + optional boundary name to assign to the cut surface + - name: type + required: No + default: !!str BlockDeleter + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshModifiers/BoundingBoxNodeSet + description: | + + parameters: + - name: bottom_left + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The bottom left point (in x,y,z with spaces in-between) of the box to select the nodes. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: location + required: No + default: !!str INSIDE + cpp_type: MooseEnum + group_name: + options: INSIDE OUTSIDE + description: | + Control of where the nodeset is to be set + - name: new_boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the nodeset to create + - name: top_right + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The bottom left point (in x,y,z with spaces in-between) of the box to select the nodes. + - name: type + required: No + default: !!str BoundingBoxNodeSet + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshModifiers/BreakBoundaryOnSubdomain + description: | + + parameters: + - name: boundaries + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Boundaries to be broken. Default means to break all boundaries + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: type + required: No + default: !!str BreakBoundaryOnSubdomain + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshModifiers/BreakMeshByBlock + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: interface_name + required: No + default: !!str interface + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + the name of the new interface. Cannot be used whit `split_interface=true` + - name: split_interface + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true, it create a different interface for each block pair. + - name: type + required: No + default: !!str BreakMeshByBlock + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshModifiers/ImageSubdomain + description: | + + parameters: + - name: component + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The image RGB-component to return, leaving this blank will result in a greyscale value for the image to be created. The component number is zero based, i.e. 0 returns the first (RED) component of the image. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: dimensions + required: No + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + x,y,z dimensions of the image (defaults to mesh dimensions) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: file + required: No + default: !!str + cpp_type: FileName + group_name: + description: | + Name of single image file to extract mesh parameters from. If provided, a 2D mesh is created. + - name: file_base + required: No + default: !!str + cpp_type: FileNameNoExtension + group_name: + description: | + Image file base to open, use this option when a stack of images must be read (ignored if 'file' is given) + - name: file_range + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Range of images to analyze, used with 'file_base' (ignored if 'file' is given) + - name: file_suffix + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Suffix of the file to open, e.g. 'png' + - name: flip_x + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Flip' + description: | + Flip the image along the x-axis + - name: flip_y + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Flip' + description: | + Flip the image along the y-axis + - name: flip_z + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Flip' + description: | + Flip the image along the z-axis + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: lower_value + required: No + default: !!str 0 + cpp_type: double + group_name: 'Threshold' + description: | + The value to set for data less than the threshold value + - name: origin + required: No + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + Origin of the image (defaults to mesh origin) + - name: scale + required: No + default: !!str 1 + cpp_type: double + group_name: 'Rescale' + description: | + Multiplier to apply to all pixel values; occurs after shifting + - name: shift + required: No + default: !!str 0 + cpp_type: double + group_name: 'Rescale' + description: | + Value to add to all pixels; occurs prior to scaling + - name: threshold + required: No + default: !!str + cpp_type: double + group_name: 'Threshold' + description: | + The threshold value + - name: type + required: No + default: !!str ImageSubdomain + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: upper_value + required: No + default: !!str 1 + cpp_type: double + group_name: 'Threshold' + description: | + The value to set for data greater than the threshold value + subblocks: + - name: /MeshModifiers/LowerDBlockFromSideset + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: new_block_id + required: Yes + default: !!str + cpp_type: unsigned short + group_name: + description: | + The lower dimensional block id to create + - name: new_block_name + required: No + default: !!str + cpp_type: SubdomainName + group_name: + description: | + The lower dimensional block name to create (optional) + - name: sidesets + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The sidesets from which to create the new block + - name: type + required: No + default: !!str LowerDBlockFromSideset + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshModifiers/MeshExtruder + description: | + + parameters: + - name: bottom_sideset + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The boundary that will be applied to the bottom of the extruded mesh + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: existing_subdomains + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The subdomains that will be remapped for specific layers + - name: extrusion_vector + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The direction and length of the extrusion + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: layers + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The layers where the "existing_subdomain" will be remapped to new ids + - name: new_ids + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of new ids, This list should be either length "existing_subdomains" or "existing_subdomains" * layers + - name: num_layers + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + The number of layers in the extruded mesh + - name: top_sideset + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The boundary that will be to the top of the extruded mesh + - name: type + required: No + default: !!str MeshExtruder + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshModifiers/MeshSideSet + description: | + + parameters: + - name: block_id + required: Yes + default: !!str + cpp_type: unsigned short + group_name: + description: | + Subdomain id to set for the new elements along the boundary + - name: block_name + required: No + default: !!str + cpp_type: SubdomainName + group_name: + description: | + Subdomain name to set for the new elements along the boundary (optional) + - name: boundaries + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the boundary to mesh + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: type + required: No + default: !!str MeshSideSet + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshModifiers/OrientedSubdomainBoundingBox + description: | + + parameters: + - name: block_id + required: Yes + default: !!str + cpp_type: unsigned short + group_name: + description: | + Subdomain id to set for inside/outside the bounding box + - name: center + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + The center (many people spell this 'center') of the box. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: height + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The height of the box + - name: length + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The length of the box + - name: length_direction + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The direction along which the length is oriented (must be perpendicular to width_direction). + - name: location + required: No + default: !!str INSIDE + cpp_type: MooseEnum + group_name: + options: INSIDE OUTSIDE + description: | + Control of where the subdomain id is to be set + - name: type + required: No + default: !!str OrientedSubdomainBoundingBox + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: width + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The width of the box + - name: width_direction + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The direction along which the width is oriented. + subblocks: + - name: /MeshModifiers/ParsedAddSideset + description: | + + parameters: + - name: combinatorial_geometry + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Function expression encoding a combinatorial geometry + - name: constant_expressions + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of values for the constants in constant_names (can be an FParser expression) + - name: constant_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of constants used in the parsed function (use this for kB etc.) + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: disable_fpoptimizer + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Disable the function parser algebraic optimizer + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: enable_ad_cache + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable cacheing of function derivatives for faster startup time + - name: enable_auto_optimize + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable automatic immediate optimization of derivatives + - name: enable_jit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable just-in-time compilation of function expressions for faster evaluation + - name: evalerror_behavior + required: No + default: !!str nan + cpp_type: MooseEnum + group_name: 'Advanced' + options: nan nan_warning error exception + description: | + What to do if evaluation error occurs. Options are to pass a nan, pass a nan with a warning, throw a error, or throw an exception + - name: fail_on_evalerror + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Fail fatally if a function evaluation returns an error code (otherwise just pass on NaN) + - name: fixed_normal + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This Boolean determines whether we fix our normal or allow it to vary to "paint" around curves + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: included_subdomain_ids + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + A set of subdomain ids whose sides will be included in the new sidesets + - name: new_sideset_name + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The name of the new sideset + - name: normal + required: No + default: !!str 0 0 0 + cpp_type: libMesh::Point + group_name: + description: | + If provided specifies the normal vector on sides that are added to the new + - name: type + required: No + default: !!str ParsedAddSideset + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variance + required: No + default: !!str 0.1 + cpp_type: double + group_name: + description: | + The variance [0.0 - 1.0] allowed when comparing normals + subblocks: + - name: /MeshModifiers/ParsedSubdomainMeshModifier + description: | + + parameters: + - name: block_id + required: Yes + default: !!str + cpp_type: unsigned short + group_name: + description: | + Subdomain id to set for inside of the combinatorial + - name: block_name + required: No + default: !!str + cpp_type: SubdomainName + group_name: + description: | + Subdomain name to set for inside of the combinatorial + - name: combinatorial_geometry + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Function expression encoding a combinatorial geometry + - name: constant_expressions + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of values for the constants in constant_names (can be an FParser expression) + - name: constant_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of constants used in the parsed function (use this for kB etc.) + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: disable_fpoptimizer + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Disable the function parser algebraic optimizer + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: enable_ad_cache + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable cacheing of function derivatives for faster startup time + - name: enable_auto_optimize + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable automatic immediate optimization of derivatives + - name: enable_jit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable just-in-time compilation of function expressions for faster evaluation + - name: evalerror_behavior + required: No + default: !!str nan + cpp_type: MooseEnum + group_name: 'Advanced' + options: nan nan_warning error exception + description: | + What to do if evaluation error occurs. Options are to pass a nan, pass a nan with a warning, throw a error, or throw an exception + - name: excluded_subdomain_ids + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + A set of subdomain ids that will not changed even if they are inside/outside the combinatorial geometry + - name: fail_on_evalerror + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Fail fatally if a function evaluation returns an error code (otherwise just pass on NaN) + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: type + required: No + default: !!str ParsedSubdomainMeshModifier + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshModifiers/RenameBlock + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: new_block_id + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Elements with the old block number (or name) will be given this block number. If the old blocks are named, their names will be passed onto the newly numbered blocks. + - name: new_block_name + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Elements with the old block number (or name) will be given this block name. No change of block ID is performed, unless multiple old blocks are given the same name, in which case they are all given the first old block number. + - name: old_block_id + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Elements with this block number will be given the new_block_number or new_block_name. You must supply either old_block_id or old_block_name. You may supply a vector of old_block_id, in which case the new_block information must also be a vector. + - name: old_block_name + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Elements with this block name will be given the new_block_number or new_block_name. You must supply either old_block_id or old_block_name. You may supply a vector of old_block_name, in which case the new_block information must also be a vector. + - name: type + required: No + default: !!str RenameBlock + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshModifiers/SideSetsAroundSubdomain + description: | + + parameters: + - name: block + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The blocks around which to create sidesets + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: fixed_normal + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This Boolean determines whether we fix our normal or allow it to vary to "paint" around curves + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: new_boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs to create on the supplied subdomain + - name: normal + required: No + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + If supplied, only faces with normal equal to this, up to normal_tol, will be added to the sidesets specified + - name: normal_tol + required: No + default: !!str 0.1 + cpp_type: double + group_name: + description: | + If normal is supplied then faces are only added if face_normal.normal_hat >= 1 - normal_tol, where normal_hat = normal/|normal| + - name: type + required: No + default: !!str SideSetsAroundSubdomain + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variance + required: No + default: !!str 0.1 + cpp_type: double + group_name: + description: | + The variance [0.0 - 1.0] allowed when comparing normals + subblocks: + - name: /MeshModifiers/SideSetsBetweenSubdomains + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: master_block + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The master set of blocks for which to draw a sideset between + - name: new_boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the boundary to create + - name: paired_block + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The paired set of blocks for which to draw a sideset between + - name: type + required: No + default: !!str SideSetsBetweenSubdomains + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshModifiers/SideSetsFromNormals + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: fixed_normal + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This Boolean determines whether we fix our normal or allow it to vary to "paint" around curves + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: new_boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the boundary to create + - name: normals + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + A list of normals for which to start painting sidesets + - name: type + required: No + default: !!str SideSetsFromNormals + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variance + required: No + default: !!str 0.1 + cpp_type: double + group_name: + description: | + The variance [0.0 - 1.0] allowed when comparing normals + subblocks: + - name: /MeshModifiers/SideSetsFromPoints + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: fixed_normal + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This Boolean determines whether we fix our normal or allow it to vary to "paint" around curves + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: new_boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the boundary to create + - name: points + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + A list of points from which to start painting sidesets + - name: type + required: No + default: !!str SideSetsFromPoints + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variance + required: No + default: !!str 0.1 + cpp_type: double + group_name: + description: | + The variance [0.0 - 1.0] allowed when comparing normals + subblocks: + - name: /MeshModifiers/SmoothMesh + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: iterations + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + The number of smoothing iterations to do. + - name: type + required: No + default: !!str SmoothMesh + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshModifiers/SubdomainBoundingBox + description: | + + parameters: + - name: block_id + required: Yes + default: !!str + cpp_type: unsigned short + group_name: + description: | + Subdomain id to set for inside/outside the bounding box + - name: block_name + required: No + default: !!str + cpp_type: SubdomainName + group_name: + description: | + Subdomain name to set for inside/outside the bounding box (optional) + - name: bottom_left + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The bottom left point (in x,y,z with spaces in-between). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: location + required: No + default: !!str INSIDE + cpp_type: MooseEnum + group_name: + options: INSIDE OUTSIDE + description: | + Control of where the subdomain id is to be set + - name: top_right + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The bottom left point (in x,y,z with spaces in-between). + - name: type + required: No + default: !!str SubdomainBoundingBox + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /MeshModifiers/Transform + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: depends_on + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The MeshModifiers that this modifier relies upon (i.e. must execute before this one) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: force_prepare + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Normally all MeshModifiers run before the mesh is prepared for use. This flag can be set on an individual modifier to force preparation between modifiers where they might be needed. + - name: transform + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: TRANSLATE ROTATE SCALE + description: | + The type of transformation to perform (TRANSLATE, ROTATE, SCALE) + - name: type + required: No + default: !!str Transform + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: vector_value + required: Yes + default: !!str + cpp_type: libMesh::VectorValue + group_name: + description: | + The value to use for the transformation. When using TRANSLATE or SCALE, the xyz coordinates are applied in each direction respectively. When using ROTATE, the values are interpreted as the Euler angles phi, theta and psi given in degrees. + subblocks: +- name: /MultiApps + description: | + + parameters: + subblocks: + - name: /MultiApps/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /MultiApps/CentroidMultiApp + description: | + + parameters: + - name: app_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: PlatypusApp PlatypusTestApp + description: | + The type of application to build (applications not registered can be loaded with dynamic libraries. Master application type will be used if not provided. + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: bounding_box_inflation + required: No + default: !!str 0.01 + cpp_type: double + group_name: + description: | + Relative amount to 'inflate' the bounding box of this MultiApp. + - name: bounding_box_padding + required: No + default: !!str 0 0 0 + cpp_type: libMesh::Point + group_name: + description: | + Additional padding added to the dimensions of the bounding box. The values are added to the x, y and z dimension respectively. + - name: catch_up + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true this will allow failed solves to attempt to 'catch up' using smaller timesteps. + - name: cli_args + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Additional command line arguments to pass to the sub apps. If one set is provided the arguments are applied to all, otherwise there must be a set for each sub app. + - name: clone_master_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to clone master mesh and use it for this MultiApp. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: detect_steady_state + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true then while sub_cycling a steady state check will be done. In this mode output will only be done once the MultiApp reaches the target time or steady state is reached + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_BEGIN + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: global_time_offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The time offset relative to the master application for the purpose of starting a subapp at different time from the master application. The global time will be ahead by the offset specified here. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: input_files + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The input file for each App. If this parameter only contains one input file it will be used for all of the Apps. When using 'positions_from_file' it is also admissable to provide one input_file per file. + - name: interpolate_transfers + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Only valid when sub_cycling. This allows transferred values to be interpolated over the time frame the MultiApp is executing over when sub_cycling + - name: keep_solution_during_restore + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This is useful when doing Picard. It takes the final solution from the previous Picard iterationand re-uses it as the initial guess for the next picard iteration + - name: library_name + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The file name of the library (*.la file) that will be dynamically loaded. + - name: library_path + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Path to search for dynamic libraries (please avoid committing absolute paths in addition to MOOSE_LIBRARY_PATH) + - name: max_catch_up_steps + required: No + default: !!str 2 + cpp_type: double + group_name: + description: | + Maximum number of steps to allow an app to take when trying to catch back up after a failed solve. + - name: max_failures + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + Maximum number of solve failures tolerated while sub_cycling. + - name: max_procs_per_app + required: No + default: !!str 4294967295 + cpp_type: unsigned int + group_name: + description: | + Maximum number of processors to give to each App in this MultiApp. Useful for restricting small solves to just a few procs so they don't get spread out + - name: move_apps + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Apps, designated by their 'numbers' starting with 0 corresponding to the order of the App positions, to be moved at move_time to move_positions + - name: move_positions + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The positions corresponding to each move_app. + - name: move_time + required: No + default: !!str 1.79769e+308 + cpp_type: double + group_name: + description: | + The time at which Apps designated by move_apps are moved to move_positions. + - name: output_in_position + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true this will cause the output from the MultiApp to be 'moved' by its position vector + - name: output_sub_cycles + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true then every sub-cycle will be output. + - name: print_sub_cycles + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Toggle the display of sub-cycles on the screen. + - name: relaxation_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Fraction of newly computed value to keep.Set between 0 and 2. + - name: relaxed_variables + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + List of variables to relax during Picard Iteration + - name: reset_apps + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The Apps that will be reset when 'reset_time' is hit. These are the App 'numbers' starting with 0 corresponding to the order of the App positions. Resetting an App means that it is destroyed and recreated, possibly modeling the insertion of 'new' material for that app. + - name: reset_time + required: No + default: !!str 1.79769e+308 + cpp_type: double + group_name: + description: | + The time at which to reset Apps given by the 'reset_apps' parameter. Resetting an App means that it is destroyed and recreated, possibly modeling the insertion of 'new' material for that app. + - name: steady_state_tol + required: No + default: !!str 1e-08 + cpp_type: double + group_name: + description: | + The relative difference between the new solution and the old solution that will be considered to be at steady state + - name: sub_cycling + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true to allow this MultiApp to take smaller timesteps than the rest of the simulation. More than one timestep will be performed for each 'master' timestep + - name: tolerate_failure + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true this MultiApp won't participate in dt decisions and will always be fast-forwarded to the current time. + - name: type + required: No + default: !!str CentroidMultiApp + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /MultiApps/FullSolveMultiApp + description: | + + parameters: + - name: app_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: PlatypusApp PlatypusTestApp + description: | + The type of application to build (applications not registered can be loaded with dynamic libraries. Master application type will be used if not provided. + - name: bounding_box_inflation + required: No + default: !!str 0.01 + cpp_type: double + group_name: + description: | + Relative amount to 'inflate' the bounding box of this MultiApp. + - name: bounding_box_padding + required: No + default: !!str 0 0 0 + cpp_type: libMesh::Point + group_name: + description: | + Additional padding added to the dimensions of the bounding box. The values are added to the x, y and z dimension respectively. + - name: cli_args + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Additional command line arguments to pass to the sub apps. If one set is provided the arguments are applied to all, otherwise there must be a set for each sub app. + - name: clone_master_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to clone master mesh and use it for this MultiApp. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_BEGIN + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: global_time_offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The time offset relative to the master application for the purpose of starting a subapp at different time from the master application. The global time will be ahead by the offset specified here. + - name: input_files + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The input file for each App. If this parameter only contains one input file it will be used for all of the Apps. When using 'positions_from_file' it is also admissable to provide one input_file per file. + - name: keep_full_output_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to keep the full output history when this multiapp has multiple entries + - name: keep_solution_during_restore + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This is useful when doing Picard. It takes the final solution from the previous Picard iterationand re-uses it as the initial guess for the next picard iteration + - name: library_name + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The file name of the library (*.la file) that will be dynamically loaded. + - name: library_path + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Path to search for dynamic libraries (please avoid committing absolute paths in addition to MOOSE_LIBRARY_PATH) + - name: max_procs_per_app + required: No + default: !!str 4294967295 + cpp_type: unsigned int + group_name: + description: | + Maximum number of processors to give to each App in this MultiApp. Useful for restricting small solves to just a few procs so they don't get spread out + - name: move_apps + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Apps, designated by their 'numbers' starting with 0 corresponding to the order of the App positions, to be moved at move_time to move_positions + - name: move_positions + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The positions corresponding to each move_app. + - name: move_time + required: No + default: !!str 1.79769e+308 + cpp_type: double + group_name: + description: | + The time at which Apps designated by move_apps are moved to move_positions. + - name: no_backup_and_restore + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to turn off backup/restore for this multiapp. This is useful when doing steady-state Picard iterations where we want to use the solution of previous Picard iteration as the initial guess of the current Picard iteration + - name: output_in_position + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true this will cause the output from the MultiApp to be 'moved' by its position vector + - name: positions + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The positions of the App locations. Each set of 3 values will represent a Point. This and 'positions_file' cannot be both supplied. If this and 'positions_file' are not supplied, a single position (0,0,0) will be used + - name: positions_file + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + A filename that should be looked in for positions. Each set of 3 values in that file will represent a Point. This and 'positions' cannot be both supplied + - name: relaxation_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Fraction of newly computed value to keep.Set between 0 and 2. + - name: relaxed_variables + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + List of variables to relax during Picard Iteration + - name: reset_apps + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The Apps that will be reset when 'reset_time' is hit. These are the App 'numbers' starting with 0 corresponding to the order of the App positions. Resetting an App means that it is destroyed and recreated, possibly modeling the insertion of 'new' material for that app. + - name: reset_time + required: No + default: !!str 1.79769e+308 + cpp_type: double + group_name: + description: | + The time at which to reset Apps given by the 'reset_apps' parameter. Resetting an App means that it is destroyed and recreated, possibly modeling the insertion of 'new' material for that app. + - name: type + required: No + default: !!str FullSolveMultiApp + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /MultiApps/TransientMultiApp + description: | + + parameters: + - name: app_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: PlatypusApp PlatypusTestApp + description: | + The type of application to build (applications not registered can be loaded with dynamic libraries. Master application type will be used if not provided. + - name: bounding_box_inflation + required: No + default: !!str 0.01 + cpp_type: double + group_name: + description: | + Relative amount to 'inflate' the bounding box of this MultiApp. + - name: bounding_box_padding + required: No + default: !!str 0 0 0 + cpp_type: libMesh::Point + group_name: + description: | + Additional padding added to the dimensions of the bounding box. The values are added to the x, y and z dimension respectively. + - name: catch_up + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true this will allow failed solves to attempt to 'catch up' using smaller timesteps. + - name: cli_args + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Additional command line arguments to pass to the sub apps. If one set is provided the arguments are applied to all, otherwise there must be a set for each sub app. + - name: clone_master_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to clone master mesh and use it for this MultiApp. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: detect_steady_state + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true then while sub_cycling a steady state check will be done. In this mode output will only be done once the MultiApp reaches the target time or steady state is reached + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_BEGIN + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: global_time_offset + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The time offset relative to the master application for the purpose of starting a subapp at different time from the master application. The global time will be ahead by the offset specified here. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: input_files + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The input file for each App. If this parameter only contains one input file it will be used for all of the Apps. When using 'positions_from_file' it is also admissable to provide one input_file per file. + - name: interpolate_transfers + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Only valid when sub_cycling. This allows transferred values to be interpolated over the time frame the MultiApp is executing over when sub_cycling + - name: keep_solution_during_restore + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This is useful when doing Picard. It takes the final solution from the previous Picard iterationand re-uses it as the initial guess for the next picard iteration + - name: library_name + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The file name of the library (*.la file) that will be dynamically loaded. + - name: library_path + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Path to search for dynamic libraries (please avoid committing absolute paths in addition to MOOSE_LIBRARY_PATH) + - name: max_catch_up_steps + required: No + default: !!str 2 + cpp_type: double + group_name: + description: | + Maximum number of steps to allow an app to take when trying to catch back up after a failed solve. + - name: max_failures + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + Maximum number of solve failures tolerated while sub_cycling. + - name: max_procs_per_app + required: No + default: !!str 4294967295 + cpp_type: unsigned int + group_name: + description: | + Maximum number of processors to give to each App in this MultiApp. Useful for restricting small solves to just a few procs so they don't get spread out + - name: move_apps + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Apps, designated by their 'numbers' starting with 0 corresponding to the order of the App positions, to be moved at move_time to move_positions + - name: move_positions + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The positions corresponding to each move_app. + - name: move_time + required: No + default: !!str 1.79769e+308 + cpp_type: double + group_name: + description: | + The time at which Apps designated by move_apps are moved to move_positions. + - name: output_in_position + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true this will cause the output from the MultiApp to be 'moved' by its position vector + - name: output_sub_cycles + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true then every sub-cycle will be output. + - name: positions + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The positions of the App locations. Each set of 3 values will represent a Point. This and 'positions_file' cannot be both supplied. If this and 'positions_file' are not supplied, a single position (0,0,0) will be used + - name: positions_file + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + A filename that should be looked in for positions. Each set of 3 values in that file will represent a Point. This and 'positions' cannot be both supplied + - name: print_sub_cycles + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Toggle the display of sub-cycles on the screen. + - name: relaxation_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Fraction of newly computed value to keep.Set between 0 and 2. + - name: relaxed_variables + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + List of variables to relax during Picard Iteration + - name: reset_apps + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The Apps that will be reset when 'reset_time' is hit. These are the App 'numbers' starting with 0 corresponding to the order of the App positions. Resetting an App means that it is destroyed and recreated, possibly modeling the insertion of 'new' material for that app. + - name: reset_time + required: No + default: !!str 1.79769e+308 + cpp_type: double + group_name: + description: | + The time at which to reset Apps given by the 'reset_apps' parameter. Resetting an App means that it is destroyed and recreated, possibly modeling the insertion of 'new' material for that app. + - name: steady_state_tol + required: No + default: !!str 1e-08 + cpp_type: double + group_name: + description: | + The relative difference between the new solution and the old solution that will be considered to be at steady state + - name: sub_cycling + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true to allow this MultiApp to take smaller timesteps than the rest of the simulation. More than one timestep will be performed for each 'master' timestep + - name: tolerate_failure + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true this MultiApp won't participate in dt decisions and will always be fast-forwarded to the current time. + - name: type + required: No + default: !!str TransientMultiApp + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: +- name: /NodalKernels + description: | + + parameters: + subblocks: + - name: /NodalKernels/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /NodalKernels/ConstantRate + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: rate + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The constant rate in 'du/dt = rate' + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ConstantRate + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /NodalKernels/CoupledForceNodalKernel + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: coef + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Coefficent ($\sigma$) multiplier for the coupled force term. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str CoupledForceNodalKernel + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The coupled variable which provides the force + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /NodalKernels/LowerBoundNodalKernel + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: exclude_boundaries + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Boundaries on which not to execute the NodalKernel. This can be useful for avoiding singuarility in the matrix in case a constraint is active in the same place that a DirichletBC is set + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: lower_bound + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The lower bound on the coupled variable + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str LowerBoundNodalKernel + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The coupled variable we require to be greater than the lower bound + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /NodalKernels/PenaltyDirichletNodalKernel + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: penalty + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Penalty scalar + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str PenaltyDirichletNodalKernel + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Boundary value of the variable + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /NodalKernels/ReactionNodalKernel + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: coeff + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + A coefficient for multiplying the reaction term + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ReactionNodalKernel + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /NodalKernels/TimeDerivativeNodalKernel + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str TimeDerivativeNodalKernel + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /NodalKernels/UpperBoundNodalKernel + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: exclude_boundaries + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Boundaries on which not to execute the NodalKernel. This can be useful for avoiding singuarility in the matrix in case a constraint is active in the same place that a DirichletBC is set + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str UpperBoundNodalKernel + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: upper_bound + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The upper bound on the coupled variable + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The coupled variable we require to be greater than the upper bound + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /NodalKernels/UserForcingFunctionNodalKernel + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diag_save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The forcing function + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: save_in + required: No + default: !!str + cpp_type: std::vector > + group_name: + 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.) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str UserForcingFunctionNodalKernel + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this boundary condition applies to + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: +- name: /NodalNormals + description: | + + parameters: + - name: boundary + required: No + default: !!str ANY_BOUNDARY_ID + cpp_type: std::vector > + group_name: + description: | + The boundary ID or name where the normals will be computed + - name: corner_boundary + required: No + default: !!str + cpp_type: BoundaryName + group_name: + description: | + boundary ID or name with nodes at 'corners' + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: FIRST SECOND + description: | + Specifies the order of variables that hold the nodal normals. Needs to match the order of the mesh + subblocks: +- name: /Outputs + description: | + + parameters: + - name: append_date + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the date and time are appended to the output filename. + - name: append_date_format + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The format of the date/time to append (see http://www.cplusplus.com/reference/ctime/strftime). + - name: checkpoint + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Create checkpoint files using the default options. + - name: color + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Set to false to turn off all coloring in all outputs + - name: console + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Output the results using the default settings for Console output + - name: controls + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable the screen output of Control systems. + - name: csv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Output the scalar variable and postprocessors to a *.csv file using the default CSV output. + - name: dofmap + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Create the dof map .json output file + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: exodus + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Output the results using the default settings for Exodus output. + - name: file_base + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Common file base name to be utilized with all output objects + - name: gmv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Output the results using the default settings for GMV output + - name: gnuplot + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Output the scalar and postprocessor results using the default settings for GNUPlot output + - name: hide + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + A list of the variables and postprocessors that should NOT be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + The interval at which timesteps are output to the solution file. + - name: nemesis + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Output the results using the default settings for Nemesis output + - name: output_if_base_contains + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If this is supplied then output will only be done in the case that the output base contains one of these strings. This is helpful in outputting only a subset of outputs when using MultiApps. + - name: perf_graph + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable printing of the performance graph to the screen (Console) + - name: print_linear_residuals + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable printing of linear residuals to the screen (Console) + - name: print_mesh_changed_info + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true, each time the mesh is changed the mesh information is printed + - name: print_perf_log + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Use perf_graph instead! + - name: show + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + A list of the variables and postprocessors that should be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: solution_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Print a solution history file (.slh) using the default settings + - name: sync_times + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Times at which the output and solution is forced to occur + - name: tecplot + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Output the results using the default settings for Tecplot output + - name: vtk + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Output the results using the default settings for VTKOutput output + - name: xda + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Output the results using the default settings for XDA/XDR output (ascii) + - name: xdr + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Output the results using the default settings for XDA/XDR output (binary) + - name: xml + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Output the vector postprocessors to a *.xml file using the default XML output. + subblocks: + - name: /Outputs/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /Outputs/CSV + description: | + + parameters: + - name: additional_execute_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: align + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Align the outputted csv data by padding the numbers with trailing whitespace + - name: append_date + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the date and time are appended to the output filename. + - name: append_date_format + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The format of the date/time to append, if not given UTC format is used (see http://www.cplusplus.com/reference/ctime/strftime). + - name: append_restart + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Append existing file on restart + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: create_final_symlink + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable/disable the creation of a _FINAL symlink for vector postprocessor data with 'execute_on' includes 'FINAL'. + - name: create_latest_symlink + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable/disable the creation of a _LATEST symlink for vector postprocessor data. + - name: delimiter + required: No + default: !!str "," + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Assign the delimiter (default is ',' + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object stop operating + - name: end_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object stop operating + - name: execute_elemental_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of elemental variables + - name: execute_input + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of input file information + - name: execute_nodal_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of nodal variables + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: execute_postprocessors_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: 'Variables' + description: | + Control of when postprocessors are output + - name: execute_scalar_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of aux scalar variables + - name: execute_scalars_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: 'Variables' + description: | + Control the output of scalar variables + - name: execute_system_information + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of the simulation information + - name: execute_vector_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of vector postprocessors + - name: execute_vector_postprocessors_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: 'Variables' + description: | + Enable/disable the output of VectorPostprocessors + - name: file_base + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The desired solution output name without an extension. If not provided, MOOSE sets it with Outputs/file_base when available. Otherwise, MOOSE uses input file name and this object name for a master input or uses master file_base, the subapp name and this object name for a subapp input to set it. + - name: hide + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should NOT be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Timing' + description: | + The interval at which time steps are output to the solution file + - name: linear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting linear residuals + - name: linear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each linear residual evaluation + - name: linear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each linear residual evaluation + - name: linear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each linear residual evaluation + - name: new_row_tolerance + required: No + default: !!str 1e-12 + cpp_type: double + group_name: + description: | + The independent variable tolerance for determining when a new row should be added to the table (Note: This value must be set independently for Postprocessor output to type=Console and type=CSV file separately. + - name: nonlinear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting non-linear residuals + - name: nonlinear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each nonlinear residual evaluation + - name: nonlinear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each nonlinear residual evaluation + - name: nonlinear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_if_base_contains + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + If this is supplied then output will only be done in the case that the output base contains one of these strings. This is helpful in outputting only a subset of outputs when using MultiApps. + - name: output_linear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each linear residual evaluation + - name: output_nonlinear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of postprocessors + - name: precision + required: No + default: !!str 14 + cpp_type: unsigned int + group_name: + description: | + Set the output precision + - name: show + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: sort_columns + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Toggle the sorting of columns alphabetically. + - name: start_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object begins to operate + - name: start_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object begins to operate + - name: sync_only + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Timing' + description: | + Only export results at sync times + - name: sync_times + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Timing' + description: | + Times at which the output and solution is forced to occur + - name: time_column + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether or not the 'time' column should be written for Postprocessor CSV files + - name: time_data + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true and VecptorPostprocessor data exists, write a csv file containing the timestep and time information. + - name: time_tolerance + required: No + default: !!str 1e-14 + cpp_type: double + group_name: 'Timing' + description: | + Time tolerance utilized checking start and end times + - name: type + required: No + default: !!str CSV + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable/disable the use of the displaced mesh for outputting + subblocks: + - name: /Outputs/Checkpoint + description: | + + parameters: + - name: additional_execute_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: append_date + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the date and time are appended to the output filename. + - name: append_date_format + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The format of the date/time to append, if not given UTC format is used (see http://www.cplusplus.com/reference/ctime/strftime). + - name: binary + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Toggle the output of binary files + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object stop operating + - name: end_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object stop operating + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: file_base + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The desired solution output name without an extension. If not provided, MOOSE sets it with Outputs/file_base when available. Otherwise, MOOSE uses input file name and this object name for a master input or uses master file_base, the subapp name and this object name for a subapp input to set it. + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Timing' + description: | + The interval at which time steps are output to the solution file + - name: linear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting linear residuals + - name: linear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each linear residual evaluation + - name: linear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each linear residual evaluation + - name: linear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each linear residual evaluation + - name: nonlinear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting non-linear residuals + - name: nonlinear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each nonlinear residual evaluation + - name: nonlinear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each nonlinear residual evaluation + - name: nonlinear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: num_files + required: No + default: !!str 2 + cpp_type: unsigned int + group_name: + description: | + Number of the restart files to save + - name: output_if_base_contains + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + If this is supplied then output will only be done in the case that the output base contains one of these strings. This is helpful in outputting only a subset of outputs when using MultiApps. + - name: output_linear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each linear residual evaluation + - name: output_nonlinear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: padding + required: No + default: !!str 4 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of for extension suffix (e.g., out.e-s002) + - name: start_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object begins to operate + - name: start_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object begins to operate + - name: suffix + required: No + default: !!str cp + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + This will be appended to the file_base to create the directory name for checkpoint files. + - name: sync_only + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Timing' + description: | + Only export results at sync times + - name: sync_times + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Timing' + description: | + Times at which the output and solution is forced to occur + - name: time_tolerance + required: No + default: !!str 1e-14 + cpp_type: double + group_name: 'Timing' + description: | + Time tolerance utilized checking start and end times + - name: type + required: No + default: !!str Checkpoint + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable/disable the use of the displaced mesh for outputting + subblocks: + - name: /Outputs/Console + description: | + + parameters: + - name: additional_execute_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: all_variable_norms + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Norms' + description: | + If true, all variable norms will be printed after each solve + - name: append_date + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the date and time are appended to the output filename. + - name: append_date_format + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The format of the date/time to append, if not given UTC format is used (see http://www.cplusplus.com/reference/ctime/strftime). + - name: append_restart + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Append existing file on restart + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object stop operating + - name: end_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object stop operating + - name: execute_elemental_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of elemental variables + - name: execute_input + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of input file information + - name: execute_input_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: 'Variables' + description: | + Enable/disable the output of the input file + - name: execute_nodal_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of nodal variables + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_BEGIN LINEAR NONLINEAR FAILED + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: execute_postprocessors_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: 'Variables' + description: | + Control of when postprocessors are output + - name: execute_scalar_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of aux scalar variables + - name: execute_scalars_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: 'Variables' + description: | + Control the output of scalar variables + - name: execute_system_information + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of the simulation information + - name: execute_system_information_on + required: No + default: !!str INITIAL + cpp_type: ExecFlagEnum + group_name: 'Variables' + description: | + Control when the output of the simulation information occurs + - name: execute_vector_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of vector postprocessors + - name: execute_vector_postprocessors_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: 'Variables' + description: | + Enable/disable the output of VectorPostprocessors + - name: file_base + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The desired solution output name without an extension. If not provided, MOOSE sets it with Outputs/file_base when available. Otherwise, MOOSE uses input file name and this object name for a master input or uses master file_base, the subapp name and this object name for a subapp input to set it. + - name: fit_mode + required: No + default: !!str ENVIRONMENT + cpp_type: MooseEnum + group_name: + options: ENVIRONMENT AUTO 80 120 160 + description: | + Specifies the wrapping mode for post-processor tables that are printed to the screen (ENVIRONMENT: Read "MOOSE_PPS_WIDTH" for desired width, AUTO: Attempt to determine width automatically (serial only), : Desired width + - name: hide + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should NOT be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Timing' + description: | + The interval at which time steps are output to the solution file + - name: libmesh_log + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Performance Log' + description: | + Print the libMesh performance log, requires libMesh to be configured with --enable-perflog + - name: linear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting linear residuals + - name: linear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each linear residual evaluation + - name: linear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each linear residual evaluation + - name: linear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each linear residual evaluation + - name: max_rows + required: No + default: !!str 15 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The maximum number of postprocessor/scalar values displayed on screen during a timestep (set to 0 for unlimited) + - name: new_row_tolerance + required: No + default: !!str 1e-12 + cpp_type: double + group_name: + description: | + The independent variable tolerance for determining when a new row should be added to the table (Note: This value must be set independently for Postprocessor output to type=Console and type=CSV file separately. + - name: nonlinear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting non-linear residuals + - name: nonlinear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each nonlinear residual evaluation + - name: nonlinear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each nonlinear residual evaluation + - name: nonlinear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: outlier_multiplier + required: No + default: !!str 0.8 2 + cpp_type: std::vector > + group_name: 'Norms' + description: | + Multiplier utilized to determine if a residual norm is an outlier. If the variable residual is less than multiplier[0] times the total residual it is colored red. If the variable residual is less than multiplier[1] times the average residual it is colored yellow. + - name: outlier_variable_norms + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Norms' + description: | + If true, outlier variable norms will be printed after each solve + - name: output_file + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Output to the file + - name: output_if_base_contains + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + If this is supplied then output will only be done in the case that the output base contains one of these strings. This is helpful in outputting only a subset of outputs when using MultiApps. + - name: output_linear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each linear residual evaluation + - name: output_nonlinear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of postprocessors + - name: output_screen + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Output to the screen + - name: padding + required: No + default: !!str 4 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of for extension suffix (e.g., out.e-s002) + - name: perf_header + required: No + default: !!str + cpp_type: bool + group_name: 'Perf Log' + description: | + Print the libMesh performance log header (requires that 'perf_log = true') + - name: perf_log + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Perf Log' + description: | + If true, all performance logs will be printed. The individual log settings will override this option. + - name: perf_log_interval + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + If set, the performance log will be printed every n time steps + - name: print_mesh_changed_info + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true, each time the mesh is changed the mesh information is printed + - name: scientific_time + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Control the printing of time and dt in scientific notation + - name: show + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: show_multiapp_name + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Indent multiapp output using the multiapp name + - name: solve_log + required: No + default: !!str + cpp_type: bool + group_name: 'Perf Log' + description: | + Toggles the printing of the 'Moose Test Performance' log + - name: start_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object begins to operate + - name: start_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object begins to operate + - name: sync_only + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Timing' + description: | + Only export results at sync times + - name: sync_times + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Timing' + description: | + Times at which the output and solution is forced to occur + - name: system_info + required: No + default: !!str framework mesh aux nonlinear execution + cpp_type: MultiMooseEnum + group_name: 'Advanced' + options: framework mesh aux nonlinear relationship execution output + description: | + List of information types to display ('framework', 'mesh', 'aux', 'nonlinear', 'relationship', 'execution', 'output') + - name: time_column + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether or not the 'time' column should be written for Postprocessor CSV files + - name: time_data + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true and VecptorPostprocessor data exists, write a csv file containing the timestep and time information. + - name: time_precision + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of significant digits that are printed on time related outputs + - name: time_tolerance + required: No + default: !!str 1e-14 + cpp_type: double + group_name: 'Timing' + description: | + Time tolerance utilized checking start and end times + - name: type + required: No + default: !!str Console + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable/disable the use of the displaced mesh for outputting + - name: verbose + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Print detailed diagnostics on timestep calculation + subblocks: + - name: /Outputs/ControlOutput + description: | + + parameters: + - name: additional_execute_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: clear_after_output + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Clear the active control display after each output. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object stop operating + - name: end_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object stop operating + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_BEGIN + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Timing' + description: | + The interval at which time steps are output to the solution file + - name: show_active_objects + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + List active MooseObjects. + - name: start_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object begins to operate + - name: start_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object begins to operate + - name: sync_only + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Timing' + description: | + Only export results at sync times + - name: sync_times + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Timing' + description: | + Times at which the output and solution is forced to occur + - name: time_tolerance + required: No + default: !!str 1e-14 + cpp_type: double + group_name: 'Timing' + description: | + Time tolerance utilized checking start and end times + - name: type + required: No + default: !!str ControlOutput + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable/disable the use of the displaced mesh for outputting + subblocks: + - name: /Outputs/DOFMap + description: | + + parameters: + - name: additional_execute_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: append_date + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the date and time are appended to the output filename. + - name: append_date_format + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The format of the date/time to append, if not given UTC format is used (see http://www.cplusplus.com/reference/ctime/strftime). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object stop operating + - name: end_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object stop operating + - name: execute_on + required: No + default: !!str INITIAL + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: file_base + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The desired solution output name without an extension. If not provided, MOOSE sets it with Outputs/file_base when available. Otherwise, MOOSE uses input file name and this object name for a master input or uses master file_base, the subapp name and this object name for a subapp input to set it. + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Timing' + description: | + The interval at which time steps are output to the solution file + - name: linear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting linear residuals + - name: linear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each linear residual evaluation + - name: linear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each linear residual evaluation + - name: linear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each linear residual evaluation + - name: nonlinear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting non-linear residuals + - name: nonlinear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each nonlinear residual evaluation + - name: nonlinear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each nonlinear residual evaluation + - name: nonlinear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_file + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Output to the file + - name: output_if_base_contains + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + If this is supplied then output will only be done in the case that the output base contains one of these strings. This is helpful in outputting only a subset of outputs when using MultiApps. + - name: output_linear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each linear residual evaluation + - name: output_nonlinear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_screen + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Output to the screen + - name: padding + required: No + default: !!str 4 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of for extension suffix (e.g., out.e-s002) + - name: start_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object begins to operate + - name: start_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object begins to operate + - name: sync_only + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Timing' + description: | + Only export results at sync times + - name: sync_times + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Timing' + description: | + Times at which the output and solution is forced to occur + - name: system_name + required: No + default: !!str nl0 + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + System to output + - name: time_tolerance + required: No + default: !!str 1e-14 + cpp_type: double + group_name: 'Timing' + description: | + Time tolerance utilized checking start and end times + - name: type + required: No + default: !!str DOFMap + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable/disable the use of the displaced mesh for outputting + subblocks: + - name: /Outputs/Exodus + description: | + + parameters: + - name: additional_execute_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: append_date + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the date and time are appended to the output filename. + - name: append_date_format + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The format of the date/time to append, if not given UTC format is used (see http://www.cplusplus.com/reference/ctime/strftime). + - name: append_oversample + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Append '_oversample' to the output file base + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: discontinuous + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enables discontinuous output format for Exodus files. + - name: elemental_as_nodal + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Variables' + description: | + Output elemental nonlinear variables as nodal + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object stop operating + - name: end_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object stop operating + - name: execute_elemental_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: 'Variables' + description: | + Control the output of elemental variables + - name: execute_elemental_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of elemental variables + - name: execute_input + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of input file information + - name: execute_input_on + required: No + default: !!str INITIAL + cpp_type: ExecFlagEnum + group_name: 'Variables' + description: | + Enable/disable the output of the input file + - name: execute_nodal_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: 'Variables' + description: | + Control the output of nodal variables + - name: execute_nodal_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of nodal variables + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: execute_postprocessors_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: 'Variables' + description: | + Control of when postprocessors are output + - name: execute_scalar_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of aux scalar variables + - name: execute_scalars_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: 'Variables' + description: | + Control the output of scalar variables + - name: execute_system_information + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of the simulation information + - name: execute_vector_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of vector postprocessors + - name: file + required: No + default: !!str + cpp_type: MeshFileName + group_name: 'Oversampling' + description: | + The name of the mesh file to read, for oversampling + - name: file_base + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The desired solution output name without an extension. If not provided, MOOSE sets it with Outputs/file_base when available. Otherwise, MOOSE uses input file name and this object name for a master input or uses master file_base, the subapp name and this object name for a subapp input to set it. + - name: hide + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should NOT be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Timing' + description: | + The interval at which time steps are output to the solution file + - name: linear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting linear residuals + - name: linear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each linear residual evaluation + - name: linear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each linear residual evaluation + - name: linear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each linear residual evaluation + - name: nonlinear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting non-linear residuals + - name: nonlinear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each nonlinear residual evaluation + - name: nonlinear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each nonlinear residual evaluation + - name: nonlinear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_dimension + required: No + default: !!str default + cpp_type: MooseEnum + group_name: 'Advanced' + options: default 1 2 3 problem_dimension + description: | + The dimension of the output file + - name: output_if_base_contains + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + If this is supplied then output will only be done in the case that the output base contains one of these strings. This is helpful in outputting only a subset of outputs when using MultiApps. + - name: output_linear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each linear residual evaluation + - name: output_material_properties + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Materials' + description: | + Flag indicating if material properties should be output + - name: output_nonlinear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of postprocessors + - name: oversample + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true to enable oversampling + - name: overwrite + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the latest timestep will overwrite the existing file, so only a single timestep exists. + - name: padding + required: No + default: !!str 3 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of for extension suffix (e.g., out.e-s002) + - name: position + required: No + default: !!str + cpp_type: libMesh::Point + group_name: 'Oversampling' + description: | + Set a positional offset, this vector will get added to the nodal coordinates to move the domain. + - name: refinements + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Oversampling' + description: | + Number of uniform refinements for oversampling (refinement levels beyond any uniform refinements) + - name: scalar_as_nodal + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Variables' + description: | + Output scalar variables as nodal + - name: sequence + required: No + default: !!str + cpp_type: bool + group_name: + description: | + Enable/disable sequential file output (enabled by default when 'use_displace = true', otherwise defaults to false + - name: show + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: show_material_properties + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Materials' + description: | + List of materialproperties that should be written to the output + - name: start_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object begins to operate + - name: start_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object begins to operate + - name: sync_only + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Timing' + description: | + Only export results at sync times + - name: sync_times + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Timing' + description: | + Times at which the output and solution is forced to occur + - name: time_tolerance + required: No + default: !!str 1e-14 + cpp_type: double + group_name: 'Timing' + description: | + Time tolerance utilized checking start and end times + - name: type + required: No + default: !!str Exodus + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable/disable the use of the displaced mesh for outputting + - name: use_problem_dimension + required: No + default: !!str + cpp_type: bool + group_name: + description: | + Use the problem dimension to the mesh output. Set to false when outputting lower dimensional meshes embedded in a higher dimensional space. + subblocks: + - name: /Outputs/GMV + description: | + + parameters: + - name: additional_execute_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: append_date + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the date and time are appended to the output filename. + - name: append_date_format + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The format of the date/time to append, if not given UTC format is used (see http://www.cplusplus.com/reference/ctime/strftime). + - name: append_oversample + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Append '_oversample' to the output file base + - name: binary + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Output the file in binary format + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object stop operating + - name: end_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object stop operating + - name: execute_elemental_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of elemental variables + - name: execute_input + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of input file information + - name: execute_nodal_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of nodal variables + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: execute_scalar_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of aux scalar variables + - name: execute_system_information + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of the simulation information + - name: execute_vector_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of vector postprocessors + - name: file + required: No + default: !!str + cpp_type: MeshFileName + group_name: 'Oversampling' + description: | + The name of the mesh file to read, for oversampling + - name: file_base + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The desired solution output name without an extension. If not provided, MOOSE sets it with Outputs/file_base when available. Otherwise, MOOSE uses input file name and this object name for a master input or uses master file_base, the subapp name and this object name for a subapp input to set it. + - name: hide + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should NOT be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Timing' + description: | + The interval at which time steps are output to the solution file + - name: linear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting linear residuals + - name: linear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each linear residual evaluation + - name: linear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each linear residual evaluation + - name: linear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each linear residual evaluation + - name: nonlinear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting non-linear residuals + - name: nonlinear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each nonlinear residual evaluation + - name: nonlinear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each nonlinear residual evaluation + - name: nonlinear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_if_base_contains + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + If this is supplied then output will only be done in the case that the output base contains one of these strings. This is helpful in outputting only a subset of outputs when using MultiApps. + - name: output_linear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each linear residual evaluation + - name: output_nonlinear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of postprocessors + - name: oversample + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true to enable oversampling + - name: padding + required: No + default: !!str 4 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of for extension suffix (e.g., out.e-s002) + - name: position + required: No + default: !!str + cpp_type: libMesh::Point + group_name: 'Oversampling' + description: | + Set a positional offset, this vector will get added to the nodal coordinates to move the domain. + - name: refinements + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Oversampling' + description: | + Number of uniform refinements for oversampling (refinement levels beyond any uniform refinements) + - name: show + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: start_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object begins to operate + - name: start_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object begins to operate + - name: sync_only + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Timing' + description: | + Only export results at sync times + - name: sync_times + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Timing' + description: | + Times at which the output and solution is forced to occur + - name: time_tolerance + required: No + default: !!str 1e-14 + cpp_type: double + group_name: 'Timing' + description: | + Time tolerance utilized checking start and end times + - name: type + required: No + default: !!str GMV + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable/disable the use of the displaced mesh for outputting + subblocks: + - name: /Outputs/Gnuplot + description: | + + parameters: + - name: additional_execute_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: append_date + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the date and time are appended to the output filename. + - name: append_date_format + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The format of the date/time to append, if not given UTC format is used (see http://www.cplusplus.com/reference/ctime/strftime). + - name: append_restart + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Append existing file on restart + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object stop operating + - name: end_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object stop operating + - name: execute_elemental_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of elemental variables + - name: execute_input + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of input file information + - name: execute_nodal_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of nodal variables + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: execute_postprocessors_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: 'Variables' + description: | + Control of when postprocessors are output + - name: execute_scalar_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of aux scalar variables + - name: execute_scalars_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: 'Variables' + description: | + Control the output of scalar variables + - name: execute_system_information + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of the simulation information + - name: execute_vector_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of vector postprocessors + - name: execute_vector_postprocessors_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: 'Variables' + description: | + Enable/disable the output of VectorPostprocessors + - name: extension + required: No + default: !!str png + cpp_type: MooseEnum + group_name: + options: png ps gif + description: | + GNU plot file extension + - name: file_base + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The desired solution output name without an extension. If not provided, MOOSE sets it with Outputs/file_base when available. Otherwise, MOOSE uses input file name and this object name for a master input or uses master file_base, the subapp name and this object name for a subapp input to set it. + - name: hide + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should NOT be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Timing' + description: | + The interval at which time steps are output to the solution file + - name: linear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting linear residuals + - name: linear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each linear residual evaluation + - name: linear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each linear residual evaluation + - name: linear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each linear residual evaluation + - name: new_row_tolerance + required: No + default: !!str 1e-12 + cpp_type: double + group_name: + description: | + The independent variable tolerance for determining when a new row should be added to the table (Note: This value must be set independently for Postprocessor output to type=Console and type=CSV file separately. + - name: nonlinear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting non-linear residuals + - name: nonlinear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each nonlinear residual evaluation + - name: nonlinear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each nonlinear residual evaluation + - name: nonlinear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_if_base_contains + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + If this is supplied then output will only be done in the case that the output base contains one of these strings. This is helpful in outputting only a subset of outputs when using MultiApps. + - name: output_linear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each linear residual evaluation + - name: output_nonlinear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of postprocessors + - name: padding + required: No + default: !!str 4 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of for extension suffix (e.g., out.e-s002) + - name: show + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: start_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object begins to operate + - name: start_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object begins to operate + - name: sync_only + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Timing' + description: | + Only export results at sync times + - name: sync_times + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Timing' + description: | + Times at which the output and solution is forced to occur + - name: time_column + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether or not the 'time' column should be written for Postprocessor CSV files + - name: time_data + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true and VecptorPostprocessor data exists, write a csv file containing the timestep and time information. + - name: time_tolerance + required: No + default: !!str 1e-14 + cpp_type: double + group_name: 'Timing' + description: | + Time tolerance utilized checking start and end times + - name: type + required: No + default: !!str Gnuplot + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable/disable the use of the displaced mesh for outputting + subblocks: + - name: /Outputs/MaterialPropertyDebugOutput + description: | + + parameters: + - name: additional_execute_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object stop operating + - name: end_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object stop operating + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Timing' + description: | + The interval at which time steps are output to the solution file + - name: start_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object begins to operate + - name: start_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object begins to operate + - name: sync_only + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Timing' + description: | + Only export results at sync times + - name: sync_times + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Timing' + description: | + Times at which the output and solution is forced to occur + - name: time_tolerance + required: No + default: !!str 1e-14 + cpp_type: double + group_name: 'Timing' + description: | + Time tolerance utilized checking start and end times + - name: type + required: No + default: !!str MaterialPropertyDebugOutput + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable/disable the use of the displaced mesh for outputting + subblocks: + - name: /Outputs/Nemesis + description: | + + parameters: + - name: additional_execute_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: append_date + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the date and time are appended to the output filename. + - name: append_date_format + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The format of the date/time to append, if not given UTC format is used (see http://www.cplusplus.com/reference/ctime/strftime). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object stop operating + - name: end_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object stop operating + - name: execute_elemental_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of elemental variables + - name: execute_input + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of input file information + - name: execute_input_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: 'Variables' + description: | + Enable/disable the output of the input file + - name: execute_nodal_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of nodal variables + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: execute_postprocessors_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: 'Variables' + description: | + Control of when postprocessors are output + - name: execute_scalar_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of aux scalar variables + - name: execute_scalars_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: 'Variables' + description: | + Control the output of scalar variables + - name: execute_system_information + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of the simulation information + - name: execute_vector_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of vector postprocessors + - name: file_base + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The desired solution output name without an extension. If not provided, MOOSE sets it with Outputs/file_base when available. Otherwise, MOOSE uses input file name and this object name for a master input or uses master file_base, the subapp name and this object name for a subapp input to set it. + - name: hide + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should NOT be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Timing' + description: | + The interval at which time steps are output to the solution file + - name: linear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting linear residuals + - name: linear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each linear residual evaluation + - name: linear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each linear residual evaluation + - name: linear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each linear residual evaluation + - name: nonlinear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting non-linear residuals + - name: nonlinear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each nonlinear residual evaluation + - name: nonlinear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each nonlinear residual evaluation + - name: nonlinear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_if_base_contains + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + If this is supplied then output will only be done in the case that the output base contains one of these strings. This is helpful in outputting only a subset of outputs when using MultiApps. + - name: output_linear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each linear residual evaluation + - name: output_nonlinear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of postprocessors + - name: padding + required: No + default: !!str 4 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of for extension suffix (e.g., out.e-s002) + - name: show + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: start_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object begins to operate + - name: start_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object begins to operate + - name: sync_only + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Timing' + description: | + Only export results at sync times + - name: sync_times + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Timing' + description: | + Times at which the output and solution is forced to occur + - name: time_tolerance + required: No + default: !!str 1e-14 + cpp_type: double + group_name: 'Timing' + description: | + Time tolerance utilized checking start and end times + - name: type + required: No + default: !!str Nemesis + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable/disable the use of the displaced mesh for outputting + subblocks: + - name: /Outputs/PerfGraphOutput + description: | + + parameters: + - name: additional_execute_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object stop operating + - name: end_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object stop operating + - name: execute_on + required: No + default: !!str FINAL + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: heaviest_branch + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to print out the trace through the code that took the longest amount of time + - name: heaviest_sections + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The number of sections to print out showing the parts of the code that take the most time. When '0' it won't print at all. + - name: hide + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + A list of the variables and postprocessors that should NOT be output to thefile (may include Variables, ScalarVariables, and Postprocessor names). + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Timing' + description: | + The interval at which time steps are output to the solution file + - name: level + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + The level of detail to output. Higher levels will yield more detail. + - name: start_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object begins to operate + - name: start_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object begins to operate + - name: sync_only + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Timing' + description: | + Only export results at sync times + - name: sync_times + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Timing' + description: | + Times at which the output and solution is forced to occur + - name: time_tolerance + required: No + default: !!str 1e-14 + cpp_type: double + group_name: 'Timing' + description: | + Time tolerance utilized checking start and end times + - name: type + required: No + default: !!str PerfGraphOutput + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable/disable the use of the displaced mesh for outputting + subblocks: + - name: /Outputs/SolutionHistory + description: | + + parameters: + - name: additional_execute_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: append_date + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the date and time are appended to the output filename. + - name: append_date_format + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The format of the date/time to append, if not given UTC format is used (see http://www.cplusplus.com/reference/ctime/strftime). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object stop operating + - name: end_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object stop operating + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: file_base + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The desired solution output name without an extension. If not provided, MOOSE sets it with Outputs/file_base when available. Otherwise, MOOSE uses input file name and this object name for a master input or uses master file_base, the subapp name and this object name for a subapp input to set it. + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Timing' + description: | + The interval at which time steps are output to the solution file + - name: linear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting linear residuals + - name: linear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each linear residual evaluation + - name: linear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each linear residual evaluation + - name: linear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each linear residual evaluation + - name: nonlinear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting non-linear residuals + - name: nonlinear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each nonlinear residual evaluation + - name: nonlinear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each nonlinear residual evaluation + - name: nonlinear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_if_base_contains + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + If this is supplied then output will only be done in the case that the output base contains one of these strings. This is helpful in outputting only a subset of outputs when using MultiApps. + - name: output_linear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each linear residual evaluation + - name: output_nonlinear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: padding + required: No + default: !!str 4 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of for extension suffix (e.g., out.e-s002) + - name: start_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object begins to operate + - name: start_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object begins to operate + - name: sync_only + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Timing' + description: | + Only export results at sync times + - name: sync_times + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Timing' + description: | + Times at which the output and solution is forced to occur + - name: time_tolerance + required: No + default: !!str 1e-14 + cpp_type: double + group_name: 'Timing' + description: | + Time tolerance utilized checking start and end times + - name: type + required: No + default: !!str SolutionHistory + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable/disable the use of the displaced mesh for outputting + subblocks: + - name: /Outputs/Tecplot + description: | + + parameters: + - name: additional_execute_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: append_date + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the date and time are appended to the output filename. + - name: append_date_format + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The format of the date/time to append, if not given UTC format is used (see http://www.cplusplus.com/reference/ctime/strftime). + - name: append_oversample + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Append '_oversample' to the output file base + - name: ascii_append + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + If true, append to an existing ASCII file rather than creating a new file each time + - name: binary + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Set Tecplot files to output in binary format + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object stop operating + - name: end_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object stop operating + - name: execute_elemental_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of elemental variables + - name: execute_input + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of input file information + - name: execute_nodal_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of nodal variables + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: execute_scalar_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of aux scalar variables + - name: execute_system_information + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of the simulation information + - name: execute_vector_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of vector postprocessors + - name: file + required: No + default: !!str + cpp_type: MeshFileName + group_name: 'Oversampling' + description: | + The name of the mesh file to read, for oversampling + - name: file_base + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The desired solution output name without an extension. If not provided, MOOSE sets it with Outputs/file_base when available. Otherwise, MOOSE uses input file name and this object name for a master input or uses master file_base, the subapp name and this object name for a subapp input to set it. + - name: hide + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should NOT be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Timing' + description: | + The interval at which time steps are output to the solution file + - name: linear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting linear residuals + - name: linear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each linear residual evaluation + - name: linear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each linear residual evaluation + - name: linear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each linear residual evaluation + - name: nonlinear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting non-linear residuals + - name: nonlinear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each nonlinear residual evaluation + - name: nonlinear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each nonlinear residual evaluation + - name: nonlinear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_if_base_contains + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + If this is supplied then output will only be done in the case that the output base contains one of these strings. This is helpful in outputting only a subset of outputs when using MultiApps. + - name: output_linear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each linear residual evaluation + - name: output_nonlinear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of postprocessors + - name: oversample + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true to enable oversampling + - name: padding + required: No + default: !!str 4 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of for extension suffix (e.g., out.e-s002) + - name: position + required: No + default: !!str + cpp_type: libMesh::Point + group_name: 'Oversampling' + description: | + Set a positional offset, this vector will get added to the nodal coordinates to move the domain. + - name: refinements + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Oversampling' + description: | + Number of uniform refinements for oversampling (refinement levels beyond any uniform refinements) + - name: show + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: start_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object begins to operate + - name: start_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object begins to operate + - name: sync_only + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Timing' + description: | + Only export results at sync times + - name: sync_times + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Timing' + description: | + Times at which the output and solution is forced to occur + - name: time_tolerance + required: No + default: !!str 1e-14 + cpp_type: double + group_name: 'Timing' + description: | + Time tolerance utilized checking start and end times + - name: type + required: No + default: !!str Tecplot + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable/disable the use of the displaced mesh for outputting + subblocks: + - name: /Outputs/TopResidualDebugOutput + description: | + + parameters: + - name: additional_execute_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object stop operating + - name: end_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object stop operating + - name: execute_on + required: No + default: !!str LINEAR NONLINEAR TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Timing' + description: | + The interval at which time steps are output to the solution file + - name: linear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting linear residuals + - name: linear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each linear residual evaluation + - name: linear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each linear residual evaluation + - name: linear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each linear residual evaluation + - name: nonlinear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting non-linear residuals + - name: nonlinear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each nonlinear residual evaluation + - name: nonlinear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each nonlinear residual evaluation + - name: nonlinear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: num_residuals + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The number of top residuals to print out (0 = no output) + - name: output_linear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each linear residual evaluation + - name: output_nonlinear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: start_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object begins to operate + - name: start_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object begins to operate + - name: sync_only + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Timing' + description: | + Only export results at sync times + - name: sync_times + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Timing' + description: | + Times at which the output and solution is forced to occur + - name: time_tolerance + required: No + default: !!str 1e-14 + cpp_type: double + group_name: 'Timing' + description: | + Time tolerance utilized checking start and end times + - name: type + required: No + default: !!str TopResidualDebugOutput + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable/disable the use of the displaced mesh for outputting + subblocks: + - name: /Outputs/VTK + description: | + + parameters: + - name: additional_execute_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: append_date + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the date and time are appended to the output filename. + - name: append_date_format + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The format of the date/time to append, if not given UTC format is used (see http://www.cplusplus.com/reference/ctime/strftime). + - name: append_oversample + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Append '_oversample' to the output file base + - name: binary + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Set VTK files to output in binary format + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object stop operating + - name: end_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object stop operating + - name: execute_elemental_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of elemental variables + - name: execute_input + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of input file information + - name: execute_nodal_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of nodal variables + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: execute_scalar_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of aux scalar variables + - name: execute_system_information + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of the simulation information + - name: execute_vector_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of vector postprocessors + - name: file + required: No + default: !!str + cpp_type: MeshFileName + group_name: 'Oversampling' + description: | + The name of the mesh file to read, for oversampling + - name: file_base + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The desired solution output name without an extension. If not provided, MOOSE sets it with Outputs/file_base when available. Otherwise, MOOSE uses input file name and this object name for a master input or uses master file_base, the subapp name and this object name for a subapp input to set it. + - name: hide + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should NOT be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Timing' + description: | + The interval at which time steps are output to the solution file + - name: linear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting linear residuals + - name: linear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each linear residual evaluation + - name: linear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each linear residual evaluation + - name: linear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each linear residual evaluation + - name: nonlinear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting non-linear residuals + - name: nonlinear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each nonlinear residual evaluation + - name: nonlinear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each nonlinear residual evaluation + - name: nonlinear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_if_base_contains + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + If this is supplied then output will only be done in the case that the output base contains one of these strings. This is helpful in outputting only a subset of outputs when using MultiApps. + - name: output_linear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each linear residual evaluation + - name: output_nonlinear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of postprocessors + - name: oversample + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true to enable oversampling + - name: padding + required: No + default: !!str 3 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of for extension suffix (e.g., out.e-s002) + - name: position + required: No + default: !!str + cpp_type: libMesh::Point + group_name: 'Oversampling' + description: | + Set a positional offset, this vector will get added to the nodal coordinates to move the domain. + - name: refinements + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Oversampling' + description: | + Number of uniform refinements for oversampling (refinement levels beyond any uniform refinements) + - name: show + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: start_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object begins to operate + - name: start_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object begins to operate + - name: sync_only + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Timing' + description: | + Only export results at sync times + - name: sync_times + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Timing' + description: | + Times at which the output and solution is forced to occur + - name: time_tolerance + required: No + default: !!str 1e-14 + cpp_type: double + group_name: 'Timing' + description: | + Time tolerance utilized checking start and end times + - name: type + required: No + default: !!str VTK + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable/disable the use of the displaced mesh for outputting + subblocks: + - name: /Outputs/VariableResidualNormsDebugOutput + description: | + + parameters: + - name: additional_execute_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object stop operating + - name: end_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object stop operating + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Timing' + description: | + The interval at which time steps are output to the solution file + - name: linear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting linear residuals + - name: linear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each linear residual evaluation + - name: linear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each linear residual evaluation + - name: linear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each linear residual evaluation + - name: nonlinear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting non-linear residuals + - name: nonlinear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each nonlinear residual evaluation + - name: nonlinear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each nonlinear residual evaluation + - name: nonlinear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_linear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each linear residual evaluation + - name: output_nonlinear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: start_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object begins to operate + - name: start_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object begins to operate + - name: sync_only + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Timing' + description: | + Only export results at sync times + - name: sync_times + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Timing' + description: | + Times at which the output and solution is forced to occur + - name: time_tolerance + required: No + default: !!str 1e-14 + cpp_type: double + group_name: 'Timing' + description: | + Time tolerance utilized checking start and end times + - name: type + required: No + default: !!str VariableResidualNormsDebugOutput + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable/disable the use of the displaced mesh for outputting + subblocks: + - name: /Outputs/XDA + description: | + + parameters: + - name: additional_execute_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: append_date + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the date and time are appended to the output filename. + - name: append_date_format + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The format of the date/time to append, if not given UTC format is used (see http://www.cplusplus.com/reference/ctime/strftime). + - name: append_oversample + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Append '_oversample' to the output file base + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object stop operating + - name: end_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object stop operating + - name: execute_elemental_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of elemental variables + - name: execute_input + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of input file information + - name: execute_nodal_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of nodal variables + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: execute_scalar_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of aux scalar variables + - name: execute_system_information + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of the simulation information + - name: execute_vector_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of vector postprocessors + - name: file + required: No + default: !!str + cpp_type: MeshFileName + group_name: 'Oversampling' + description: | + The name of the mesh file to read, for oversampling + - name: file_base + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The desired solution output name without an extension. If not provided, MOOSE sets it with Outputs/file_base when available. Otherwise, MOOSE uses input file name and this object name for a master input or uses master file_base, the subapp name and this object name for a subapp input to set it. + - name: hide + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should NOT be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Timing' + description: | + The interval at which time steps are output to the solution file + - name: linear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting linear residuals + - name: linear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each linear residual evaluation + - name: linear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each linear residual evaluation + - name: linear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each linear residual evaluation + - name: nonlinear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting non-linear residuals + - name: nonlinear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each nonlinear residual evaluation + - name: nonlinear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each nonlinear residual evaluation + - name: nonlinear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_if_base_contains + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + If this is supplied then output will only be done in the case that the output base contains one of these strings. This is helpful in outputting only a subset of outputs when using MultiApps. + - name: output_linear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each linear residual evaluation + - name: output_nonlinear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of postprocessors + - name: oversample + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true to enable oversampling + - name: padding + required: No + default: !!str 4 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of for extension suffix (e.g., out.e-s002) + - name: position + required: No + default: !!str + cpp_type: libMesh::Point + group_name: 'Oversampling' + description: | + Set a positional offset, this vector will get added to the nodal coordinates to move the domain. + - name: refinements + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Oversampling' + description: | + Number of uniform refinements for oversampling (refinement levels beyond any uniform refinements) + - name: show + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: start_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object begins to operate + - name: start_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object begins to operate + - name: sync_only + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Timing' + description: | + Only export results at sync times + - name: sync_times + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Timing' + description: | + Times at which the output and solution is forced to occur + - name: time_tolerance + required: No + default: !!str 1e-14 + cpp_type: double + group_name: 'Timing' + description: | + Time tolerance utilized checking start and end times + - name: type + required: No + default: !!str XDA + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable/disable the use of the displaced mesh for outputting + subblocks: + - name: /Outputs/XDR + description: | + + parameters: + - name: additional_execute_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: append_date + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the date and time are appended to the output filename. + - name: append_date_format + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The format of the date/time to append, if not given UTC format is used (see http://www.cplusplus.com/reference/ctime/strftime). + - name: append_oversample + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Append '_oversample' to the output file base + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object stop operating + - name: end_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object stop operating + - name: execute_elemental_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of elemental variables + - name: execute_input + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of input file information + - name: execute_nodal_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of nodal variables + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: execute_scalar_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of aux scalar variables + - name: execute_system_information + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of the simulation information + - name: execute_vector_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of vector postprocessors + - name: file + required: No + default: !!str + cpp_type: MeshFileName + group_name: 'Oversampling' + description: | + The name of the mesh file to read, for oversampling + - name: file_base + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The desired solution output name without an extension. If not provided, MOOSE sets it with Outputs/file_base when available. Otherwise, MOOSE uses input file name and this object name for a master input or uses master file_base, the subapp name and this object name for a subapp input to set it. + - name: hide + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should NOT be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Timing' + description: | + The interval at which time steps are output to the solution file + - name: linear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting linear residuals + - name: linear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each linear residual evaluation + - name: linear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each linear residual evaluation + - name: linear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each linear residual evaluation + - name: nonlinear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting non-linear residuals + - name: nonlinear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each nonlinear residual evaluation + - name: nonlinear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each nonlinear residual evaluation + - name: nonlinear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_if_base_contains + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + If this is supplied then output will only be done in the case that the output base contains one of these strings. This is helpful in outputting only a subset of outputs when using MultiApps. + - name: output_linear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each linear residual evaluation + - name: output_nonlinear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of postprocessors + - name: oversample + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true to enable oversampling + - name: padding + required: No + default: !!str 4 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of for extension suffix (e.g., out.e-s002) + - name: position + required: No + default: !!str + cpp_type: libMesh::Point + group_name: 'Oversampling' + description: | + Set a positional offset, this vector will get added to the nodal coordinates to move the domain. + - name: refinements + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Oversampling' + description: | + Number of uniform refinements for oversampling (refinement levels beyond any uniform refinements) + - name: show + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: start_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object begins to operate + - name: start_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object begins to operate + - name: sync_only + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Timing' + description: | + Only export results at sync times + - name: sync_times + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Timing' + description: | + Times at which the output and solution is forced to occur + - name: time_tolerance + required: No + default: !!str 1e-14 + cpp_type: double + group_name: 'Timing' + description: | + Time tolerance utilized checking start and end times + - name: type + required: No + default: !!str XDR + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable/disable the use of the displaced mesh for outputting + subblocks: + - name: /Outputs/XMLOutput + description: | + + parameters: + - name: additional_execute_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: append_date + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the date and time are appended to the output filename. + - name: append_date_format + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The format of the date/time to append, if not given UTC format is used (see http://www.cplusplus.com/reference/ctime/strftime). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object stop operating + - name: end_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object stop operating + - name: execute_elemental_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of elemental variables + - name: execute_input + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of input file information + - name: execute_nodal_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of nodal variables + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, FAILED, CUSTOM. + - name: execute_scalar_variables + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of aux scalar variables + - name: execute_system_information + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of the simulation information + - name: execute_vector_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of vector postprocessors + - name: execute_vector_postprocessors_on + required: No + default: !!str + cpp_type: ExecFlagEnum + group_name: 'Variables' + description: | + Enable/disable the output of VectorPostprocessors + - name: file_base + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The desired solution output name without an extension. If not provided, MOOSE sets it with Outputs/file_base when available. Otherwise, MOOSE uses input file name and this object name for a master input or uses master file_base, the subapp name and this object name for a subapp input to set it. + - name: hide + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should NOT be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: interval + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: 'Timing' + description: | + The interval at which time steps are output to the solution file + - name: linear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting linear residuals + - name: linear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each linear residual evaluation + - name: linear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each linear residual evaluation + - name: linear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each linear residual evaluation + - name: nonlinear_residual_dt_divisor + required: No + default: !!str 1000 + cpp_type: double + group_name: 'PETSc' + description: | + Number of divisions applied to time step when outputting non-linear residuals + - name: nonlinear_residual_end_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies an end time to begin output on each nonlinear residual evaluation + - name: nonlinear_residual_start_time + required: No + default: !!str + cpp_type: double + group_name: 'PETSc' + description: | + Specifies a start time to begin output on each nonlinear residual evaluation + - name: nonlinear_residuals + required: No + default: !!str 0 + cpp_type: bool + group_name: 'PETSc' + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_if_base_contains + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + If this is supplied then output will only be done in the case that the output base contains one of these strings. This is helpful in outputting only a subset of outputs when using MultiApps. + - name: output_linear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each linear residual evaluation + - name: output_nonlinear + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Specifies whether output occurs on each nonlinear residual evaluation + - name: output_postprocessors + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Enable/disable the output of postprocessors + - name: padding + required: No + default: !!str 4 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The number of for extension suffix (e.g., out.e-s002) + - name: show + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Variables' + description: | + A list of the variables and postprocessors that should be output to the Exodus file (may include Variables, ScalarVariables, and Postprocessor names). + - name: start_step + required: No + default: !!str + cpp_type: int + group_name: + description: | + Time step at which this output object begins to operate + - name: start_time + required: No + default: !!str + cpp_type: double + group_name: 'Timing' + description: | + Time at which this output object begins to operate + - name: sync_only + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Timing' + description: | + Only export results at sync times + - name: sync_times + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Timing' + description: | + Times at which the output and solution is forced to occur + - name: time_tolerance + required: No + default: !!str 1e-14 + cpp_type: double + group_name: 'Timing' + description: | + Time tolerance utilized checking start and end times + - name: type + required: No + default: !!str XMLOutput + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Enable/disable the use of the displaced mesh for outputting + subblocks: +- name: /Postprocessors + description: | + + parameters: + subblocks: + - name: /Postprocessors/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /Postprocessors/ADElementAverageMaterialProperty + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: mat_prop + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the material property + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADElementAverageMaterialProperty + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/ADElementExtremeMaterialProperty + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: mat_prop + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + Material property for which to find extreme + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADElementExtremeMaterialProperty + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value_type + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: max min + description: | + Type of extreme value to return: 'max' returns the maximum value and 'min' returns the minimum value. + subblocks: + - name: /Postprocessors/ADElementIntegralMaterialProperty + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: mat_prop + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the material property + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADElementIntegralMaterialProperty + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/ADSideFluxAverage + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diffusivity + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the diffusivity material property that will be used in the flux computation. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str ADSideFluxAverage + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this boundary condition applies to + subblocks: + - name: /Postprocessors/ADSideFluxIntegral + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diffusivity + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the diffusivity material property that will be used in the flux computation. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str ADSideFluxIntegral + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this boundary condition applies to + subblocks: + - name: /Postprocessors/AreaPostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str AreaPostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/AverageElementSize + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str AverageElementSize + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/AverageNodalVariableValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str AverageNodalVariableValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: unique_node_execute + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When false (default), block restricted objects will have the execute method called multiple times on a single node if the node lies on a interface between two subdomains. + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this postprocessor operates on + subblocks: + - name: /Postprocessors/AxisymmetricCenterlineAverageValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str AxisymmetricCenterlineAverageValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this boundary condition applies to + subblocks: + - name: /Postprocessors/ChangeOverTimePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: change_with_respect_to_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Compute change with respect to initial value instead of previous value + - name: compute_relative_change + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Compute magnitude of relative change instead of change + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: postprocessor + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The name of the postprocessor + - name: take_absolute_value + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Option to take absolute value of change + - name: type + required: No + default: !!str ChangeOverTimePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/ChangeOverTimestepPostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: change_with_respect_to_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Compute change with respect to initial value instead of previous value + - name: compute_relative_change + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Compute magnitude of relative change instead of change + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: postprocessor + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The name of the postprocessor + - name: take_absolute_value + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Option to take absolute value of change + - name: type + required: No + default: !!str ChangeOverTimestepPostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/CumulativeValuePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: postprocessor + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The name of the postprocessor + - name: type + required: No + default: !!str CumulativeValuePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/DifferencePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str DifferencePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value1 + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + First value + - name: value2 + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + Second value + subblocks: + - name: /Postprocessors/ElementAverageMaterialProperty + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: mat_prop + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the material property + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementAverageMaterialProperty + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/ElementAverageSecondTimeDerivative + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementAverageSecondTimeDerivative + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /Postprocessors/ElementAverageTimeDerivative + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementAverageTimeDerivative + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /Postprocessors/ElementAverageValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementAverageValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /Postprocessors/ElementExtremeMaterialProperty + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: mat_prop + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + Material property for which to find extreme + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementExtremeMaterialProperty + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value_type + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: max min + description: | + Type of extreme value to return: 'max' returns the maximum value and 'min' returns the minimum value. + subblocks: + - name: /Postprocessors/ElementExtremeValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementExtremeValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value_type + required: No + default: !!str max + cpp_type: MooseEnum + group_name: + options: max min + description: | + Type of extreme value to return. 'max' returns the maximum value. 'min' returns the minimum value. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this postprocessor operates on + subblocks: + - name: /Postprocessors/ElementH1Error + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The analytic solution to compare against + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: p + required: No + default: !!str 2 + cpp_type: double + group_name: + description: | + The exponent used in the norm. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementH1Error + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /Postprocessors/ElementH1SemiError + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The analytic solution to compare against + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementH1SemiError + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /Postprocessors/ElementIntegralArrayVariablePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: component + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + Component of the array variable to be integrated + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementIntegralArrayVariablePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the array variable that this object operates on + subblocks: + - name: /Postprocessors/ElementIntegralMaterialProperty + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: mat_prop + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the material property + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementIntegralMaterialProperty + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/ElementIntegralVariablePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementIntegralVariablePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /Postprocessors/ElementL2Difference + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: other_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable to compare to + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementL2Difference + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /Postprocessors/ElementL2Error + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The analytic solution to compare against + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementL2Error + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /Postprocessors/ElementL2Norm + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementL2Norm + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /Postprocessors/ElementVectorL2Error + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: function_x + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The analytic solution to compare against + - name: function_y + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The analytic solution to compare against + - name: function_z + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The analytic solution to compare against + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementVectorL2Error + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: var_x + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The FE solution in x direction + - name: var_y + required: No + default: !!str 0 + cpp_type: std::vector + group_name: + description: | + The FE solution in y direction + - name: var_z + required: No + default: !!str 0 + cpp_type: std::vector + group_name: + description: | + The FE solution in z direction + subblocks: + - name: /Postprocessors/ElementW1pError + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The analytic solution to compare against + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: p + required: No + default: !!str 2 + cpp_type: double + group_name: + description: | + The exponent used in the norm. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementW1pError + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /Postprocessors/ElementalVariableValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: elementid + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The ID of the element where we monitor + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str ElementalVariableValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable to be monitored + subblocks: + - name: /Postprocessors/EmptyPostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str EmptyPostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/ExecutionerAttributeReporter + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str ExecutionerAttributeReporter + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/FindValueOnLine + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: default_value + required: No + default: !!str -1 + cpp_type: double + group_name: + description: | + Value to return if target value is not found on line and error_if_not_found is false. + - name: depth + required: No + default: !!str 36 + cpp_type: unsigned int + group_name: + description: | + Maximum number of bisections to perform. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_point + required: No + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + End point of the sampling line. + - name: error_if_not_found + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If true, stop with error if target value is not found on the line. If false, return default_value. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: start_point + required: No + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + Start point of the sampling line. + - name: target + required: No + default: !!str + cpp_type: double + group_name: + description: | + Target value to locate. + - name: tol + required: No + default: !!str 1e-10 + cpp_type: double + group_name: + description: | + Stop search if a value is found that is equal to the target with this tolerance applied. + - name: type + required: No + default: !!str FindValueOnLine + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + Variable to inspect + subblocks: + - name: /Postprocessors/FunctionElementIntegral + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + Name of function to integrate + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str FunctionElementIntegral + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/FunctionSideIntegral + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: function + required: No + default: !!str 1 + cpp_type: FunctionName + group_name: + description: | + This postprocessor will return the integral of this function over the boundary + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str FunctionSideIntegral + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/FunctionValuePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The function which supplies the postprocessor value. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: point + required: No + default: !!str 0 0 0 + cpp_type: libMesh::Point + group_name: + description: | + A point in space to be given to the function Default: (0, 0, 0) + - name: scale_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + A scale factor to be applied to the function + - name: type + required: No + default: !!str FunctionValuePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/GreaterThanLessThanPostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: comparator + required: No + default: !!str greater + cpp_type: MooseEnum + group_name: + options: greater less + description: | + The comparison to perform between the variable and the provided value + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: subdomain + required: No + default: !!str + cpp_type: SubdomainName + group_name: + description: | + The subdomain that the variable lives on + - name: type + required: No + default: !!str GreaterThanLessThanPostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The value to compare against + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The name of the variable to conduct a comparison for + subblocks: + - name: /Postprocessors/InterfaceAverageVariableValuePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: interface_value_type + required: No + default: !!str average + cpp_type: MooseEnum + group_name: + options: average jump_master_minus_slave jump_slave_minus_master jump_abs master slave + description: | + Type of value we want to compute + - name: neighbor_variable + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable on the slave side of the interface. By default the same variable name is used for the slave side + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str InterfaceAverageVariableValuePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable on the master side of the interface + subblocks: + - name: /Postprocessors/InterfaceIntegralVariableValuePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: interface_value_type + required: No + default: !!str average + cpp_type: MooseEnum + group_name: + options: average jump_master_minus_slave jump_slave_minus_master jump_abs master slave + description: | + Type of value we want to compute + - name: neighbor_variable + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable on the slave side of the interface. By default the same variable name is used for the slave side + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str InterfaceIntegralVariableValuePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable on the master side of the interface + subblocks: + - name: /Postprocessors/LinearCombinationPostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: b + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Additional value to add to sum + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: pp_coefs + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + List of linear combination coefficients for each post-processor + - name: pp_names + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + List of post-processors + - name: type + required: No + default: !!str LinearCombinationPostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/MemoryUsage + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: mem_type + required: No + default: !!str physical_memory + cpp_type: MooseEnum + group_name: + options: physical_memory virtual_memory page_faults + description: | + Memory metric to report. + - name: mem_units + required: No + default: !!str mebibytes + cpp_type: MooseEnum + group_name: + options: bytes kibibytes mebibytes gibibytes kilobytes megabytes gigabytes + description: | + The unit prefix used to report memory usage, default: Mebibytes + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: report_peak_value + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If the postprocessor is executed more than once during a time step, report the aggregated peak value. + - name: type + required: No + default: !!str MemoryUsage + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value_type + required: No + default: !!str total + cpp_type: MooseEnum + group_name: + options: total average max_process min_process + description: | + Aggregation method to apply to the requested memory metric. + subblocks: + - name: /Postprocessors/NodalExtremeValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NodalExtremeValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: unique_node_execute + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When false (default), block restricted objects will have the execute method called multiple times on a single node if the node lies on a interface between two subdomains. + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value_type + required: No + default: !!str max + cpp_type: MooseEnum + group_name: + options: max min + description: | + Type of extreme value to return. 'max' returns the maximum value. 'min' returns the minimum value. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this postprocessor operates on + subblocks: + - name: /Postprocessors/NodalL2Error + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The analytic solution to compare against + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NodalL2Error + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: unique_node_execute + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When false (default), block restricted objects will have the execute method called multiple times on a single node if the node lies on a interface between two subdomains. + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this postprocessor operates on + subblocks: + - name: /Postprocessors/NodalL2Norm + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NodalL2Norm + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: unique_node_execute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false (default), block restricted objects will have the execute method called multiple times on a single node if the node lies on a interface between two subdomains. + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this postprocessor operates on + subblocks: + - name: /Postprocessors/NodalMaxValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NodalMaxValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: unique_node_execute + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When false (default), block restricted objects will have the execute method called multiple times on a single node if the node lies on a interface between two subdomains. + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this postprocessor operates on + subblocks: + - name: /Postprocessors/NodalProxyMaxValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NodalProxyMaxValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: unique_node_execute + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When false (default), block restricted objects will have the execute method called multiple times on a single node if the node lies on a interface between two subdomains. + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this postprocessor operates on + subblocks: + - name: /Postprocessors/NodalSum + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NodalSum + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: unique_node_execute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false (default), block restricted objects will have the execute method called multiple times on a single node if the node lies on a interface between two subdomains. + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this postprocessor operates on + subblocks: + - name: /Postprocessors/NodalVariableValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: nodeid + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The ID of the node where we monitor + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scale_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + A scale factor to be applied to the variable + - name: type + required: No + default: !!str NodalVariableValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable to be monitored + subblocks: + - name: /Postprocessors/NumDOFs + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: system + required: No + default: !!str ALL + cpp_type: MooseEnum + group_name: + options: NL AUX ALL + description: | + The system(s) for which you want to retrieve the number of DOFs (NL, AUX, ALL). Default == ALL + - name: type + required: No + default: !!str NumDOFs + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/NumElems + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: elem_filter + required: No + default: !!str active + cpp_type: MooseEnum + group_name: + options: active total + description: | + The type of elements to include in the count (active, total). Default == active + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str NumElems + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/NumLinearIterations + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str NumLinearIterations + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/NumNodes + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str NumNodes + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/NumNonlinearIterations + description: | + + parameters: + - name: accumulate_over_step + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When set to true, accumulates to count the total over all Picard iterations for each step + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str NumNonlinearIterations + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/NumPicardIterations + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str NumPicardIterations + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/NumRelationshipManagers + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: rm_type + required: No + default: !!str ALL + cpp_type: MooseEnum + group_name: + options: GEOMETRIC ALGEBRAIC COUPLING ALL + description: | + The type of relationship managers to include in the relationship manager count + - name: type + required: No + default: !!str NumRelationshipManagers + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/NumResidualEvaluations + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str NumResidualEvaluations + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/NumVars + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: system + required: No + default: !!str ALL + cpp_type: MooseEnum + group_name: + options: NL AUX ALL + description: | + The system(s) for which you want to retrieve the number of variables (NL, AUX, ALL). Default == ALL + - name: type + required: No + default: !!str NumVars + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/PercentChangePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: postprocessor + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The name of the postprocessor used for exit criterion + - name: type + required: No + default: !!str PercentChangePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/PerfGraphData + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: data_type + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: SELF CHILDREN TOTAL SELF_AVG CHILDREN_AVG TOTAL_AVG SELF_PERCENT CHILDREN_PERCENT TOTAL_PERCENT CALLS + description: | + The type of data to retrieve for the section_name + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: section_name + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name of the section to get data for + - name: type + required: No + default: !!str PerfGraphData + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/PerformanceData + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: category + required: No + default: !!str Execution + cpp_type: MooseEnum + group_name: + options: Application Execution Output Setup Utility + description: | + The category for the event + - name: column + required: No + default: !!str total_time_with_sub + cpp_type: MooseEnum + group_name: + options: n_calls total_time average_time total_time_with_sub average_time_with_sub percent_of_active_time percent_of_active_time_with_sub + description: | + The column you want the value of (Default: total_time_with_sub). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: event + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: ACTIVE ALIVE solve() compute_residual() compute_jacobian() + description: | + The name or "label" of the event. Must match event name exactly including parenthesis if applicable. ("ALIVE" and "ACTIVE" are also valid events, category and column are ignored for these cases). + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str PerformanceData + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/PointValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: point + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + The physical point where the solution will be evaluated. + - name: type + required: No + default: !!str PointValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The name of the variable that this postprocessor operates on. + subblocks: + - name: /Postprocessors/PostprocessorComparison + description: | + + parameters: + - name: absolute_tolerance + required: No + default: !!str 1e-12 + cpp_type: double + group_name: + description: | + Absolute tolerance used in comparisons + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: comparison_type + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: equals greater_than_equals less_than_equals greater_than less_than + description: | + The type of comparison to perform. Options are: equals greater_than_equals less_than_equals greater_than less_than + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str PostprocessorComparison + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value_a + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The first post-processor or value in the comparison + - name: value_b + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The second post-processor or value in the comparison + subblocks: + - name: /Postprocessors/Receiver + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: default + required: No + default: !!str + cpp_type: double + group_name: + description: | + The default value + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: initialize_old + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Initialize the old postprocessor value with the default value + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str Receiver + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/RelativeDifferencePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str RelativeDifferencePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value1 + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + First post-processor + - name: value2 + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + Second post-processor, base for relative difference + subblocks: + - name: /Postprocessors/RelativeSolutionDifferenceNorm + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str RelativeSolutionDifferenceNorm + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/Residual + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: residual_type + required: No + default: !!str FINAL + cpp_type: MooseEnum + group_name: + options: FINAL INITIAL_BEFORE_PRESET INITIAL_AFTER_PRESET + description: | + Type of residual to be reported. Choices are: FINAL INITIAL_BEFORE_PRESET INITIAL_AFTER_PRESET + - name: type + required: No + default: !!str Residual + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/ScalarL2Error + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The analytic solution to compare against + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str ScalarL2Error + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The name of the scalar variable + subblocks: + - name: /Postprocessors/ScalarVariable + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: component + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + Component to output for this variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str ScalarVariable + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + Name of the variable + subblocks: + - name: /Postprocessors/ScalePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The scaling factor + - name: type + required: No + default: !!str ScalePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The postprocessor to be scaled + subblocks: + - name: /Postprocessors/SideAverageValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str SideAverageValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this boundary condition applies to + subblocks: + - name: /Postprocessors/SideFluxAverage + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diffusivity + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the diffusivity material property that will be used in the flux computation. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str SideFluxAverage + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this boundary condition applies to + subblocks: + - name: /Postprocessors/SideFluxIntegral + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diffusivity + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the diffusivity material property that will be used in the flux computation. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str SideFluxIntegral + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this boundary condition applies to + subblocks: + - name: /Postprocessors/SideIntegralVariablePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str SideIntegralVariablePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this boundary condition applies to + subblocks: + - name: /Postprocessors/TimeExtremeValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: postprocessor + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The name of the postprocessor used for reporting time extreme values + - name: type + required: No + default: !!str TimeExtremeValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value_type + required: No + default: !!str max + cpp_type: MooseEnum + group_name: + options: max min abs_max abs_min + description: | + Type of extreme value to return.'max' returns the maximum value.'min' returns the minimum value.'abs_max' returns the maximum absolute value.'abs_min' returns the minimum absolute value. + subblocks: + - name: /Postprocessors/TimestepSize + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str TimestepSize + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Postprocessors/TotalVariableValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str TotalVariableValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: No + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The name of the postprocessor + subblocks: + - name: /Postprocessors/VariableInnerProduct + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: second_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the second variable in the inner product (variable, second_variable) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VariableInnerProduct + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /Postprocessors/VariableResidual + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str VariableResidual + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The name of the variable to compute the residual for + subblocks: + - name: /Postprocessors/VectorPostprocessorComparison + description: | + + parameters: + - name: absolute_tolerance + required: No + default: !!str 1e-12 + cpp_type: double + group_name: + description: | + Absolute tolerance used in comparisons + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: comparison_type + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: equals greater_than_equals less_than_equals greater_than less_than + description: | + The type of comparison to perform. Options are: equals greater_than_equals less_than_equals greater_than less_than + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str VectorPostprocessorComparison + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: vector_name_a + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name of the vector in the first vector post-processor to compare + - name: vector_name_b + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name of the vector in the second vector post-processor to compare + - name: vectorpostprocessor_a + required: Yes + default: !!str + cpp_type: VectorPostprocessorName + group_name: + description: | + The first vector post-processor in the comparison + - name: vectorpostprocessor_b + required: Yes + default: !!str + cpp_type: VectorPostprocessorName + group_name: + description: | + The second vector post-processor in the comparison + subblocks: + - name: /Postprocessors/VectorPostprocessorComponent + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: index + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + Index of the vectorpostprocessor for which to report a value + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str VectorPostprocessorComponent + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: vector_name + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Name of the vector for which to report a value + - name: vectorpostprocessor + required: Yes + default: !!str + cpp_type: VectorPostprocessorName + group_name: + description: | + The vectorpostprocessor from which a value is extracted + subblocks: + - name: /Postprocessors/VolumePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VolumePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: +- name: /Preconditioning + description: | + + parameters: + subblocks: + - name: /Preconditioning/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /Preconditioning/*/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: petsc_options + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: -dm_moose_print_embedding -dm_view -ksp_converged_reason -ksp_gmres_modifiedgramschmidt -ksp_monitor -ksp_monitor_snes_lg-snes_ksp_ew -ksp_snes_ew -snes_converged_reason -snes_ksp -snes_ksp_ew -snes_linesearch_monitor -snes_mf -snes_mf_operator -snes_monitor -snes_test_display -snes_view + description: | + Singleton PETSc options + - name: petsc_options_iname + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: -ksp_atol -ksp_gmres_restart -ksp_max_it -ksp_pc_side -ksp_rtol -ksp_type -mat_fd_coloring_err -mat_fd_type -mat_mffd_type -pc_asm_overlap -pc_factor_levels -pc_factor_mat_ordering_type -pc_hypre_boomeramg_grid_sweeps_all -pc_hypre_boomeramg_max_iter -pc_hypre_boomeramg_strong_threshold -pc_hypre_type -pc_type -snes_atol -snes_linesearch_type -snes_ls -snes_max_it -snes_rtol -snes_divergence_tolerance -snes_type -sub_ksp_type -sub_pc_type + description: | + Names of PETSc name/value pairs + - name: petsc_options_value + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Values of PETSc name/value pairs (must correspond with "petsc_options_iname" + - name: type + required: Yes + default: !!str Split + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Classname of the split object + - name: vars + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + variables for this field + subblocks: + - name: /Preconditioning/*/Split + description: | + + parameters: + - name: blocks + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Mesh blocks Split operates on (omitting this implies "all blocks" + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: petsc_options + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: -dm_moose_print_embedding -dm_view -ksp_converged_reason -ksp_gmres_modifiedgramschmidt -ksp_monitor -ksp_monitor_snes_lg-snes_ksp_ew -ksp_snes_ew -snes_converged_reason -snes_ksp -snes_ksp_ew -snes_linesearch_monitor -snes_mf -snes_mf_operator -snes_monitor -snes_test_display -snes_view + description: | + PETSc flags for the FieldSplit solver + - name: petsc_options_iname + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + PETSc option names for the FieldSplit solver + - name: petsc_options_value + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + PETSc option values for the FieldSplit solver + - name: schur_ainv + required: No + default: !!str diag + cpp_type: MooseEnum + group_name: + options: diag lump + description: | + Type of approximation to inv(A) used when forming S = D - C inv(A) B + - name: schur_pre + required: No + default: !!str S + cpp_type: MooseEnum + group_name: + options: S Sp A11 + description: | + Type of Schur complement preconditioner matrix + - name: schur_type + required: No + default: !!str full + cpp_type: MooseEnum + group_name: + options: full upper lower + description: | + Type of Schur complement + - name: sides + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Sidesets Split operates on (omitting this implies "no sidesets" + - name: splitting + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The names of the splits (subsystems) in the decomposition of this split + - name: splitting_type + required: No + default: !!str additive + cpp_type: MooseEnum + group_name: + options: additive multiplicative symmetric_multiplicative schur + description: | + Split decomposition type + - name: type + required: No + default: !!str Split + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: unsides + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Sidesets Split excludes (omitting this implies "do not exclude any sidesets" + - name: vars + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Variables Split operates on (omitting this implies "all variables" + subblocks: + - name: /Preconditioning/FDP + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: finite_difference_type + required: No + default: !!str coloring + cpp_type: MooseEnum + group_name: + options: standard coloring + description: | + standard: standard finite differencecoloring: finite difference based on coloring + - name: full + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true if you want the full set of couplings. Simply for convenience so you don't have to set every off_diag_row and off_diag_column combination. + - name: implicit_geometric_coupling + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true if you want to add entries into the matrix for degrees of freedom that might be coupled by inspection of the geometric search objects. + - name: ksp_norm + required: No + default: !!str unpreconditioned + cpp_type: MooseEnum + group_name: + options: none preconditioned unpreconditioned natural default + description: | + Sets the norm that is used for convergence testing + - name: mffd_type + required: No + default: !!str wp + cpp_type: MooseEnum + group_name: + options: wp ds + description: | + Specifies the finite differencing type for Jacobian-free solve types. Note that the default is wp (for Walker and Pernice). + - name: off_diag_column + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The off diagonal column you want to add into the matrix, it will be associated with an off diagonal row from the same position in off_diag_row. + - name: off_diag_row + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The off diagonal row you want to add into the matrix, it will be associated with an off diagonal column from the same position in off_diag_colum. + - name: pc_side + required: No + default: !!str default + cpp_type: MooseEnum + group_name: + options: left right symmetric default + description: | + Preconditioning side + - name: petsc_options + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: -dm_moose_print_embedding -dm_view -ksp_converged_reason -ksp_gmres_modifiedgramschmidt -ksp_monitor -ksp_monitor_snes_lg-snes_ksp_ew -ksp_snes_ew -snes_converged_reason -snes_ksp -snes_ksp_ew -snes_linesearch_monitor -snes_mf -snes_mf_operator -snes_monitor -snes_test_display -snes_view + description: | + Singleton PETSc options + - name: petsc_options_iname + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: -ksp_atol -ksp_gmres_restart -ksp_max_it -ksp_pc_side -ksp_rtol -ksp_type -mat_fd_coloring_err -mat_fd_type -mat_mffd_type -pc_asm_overlap -pc_factor_levels -pc_factor_mat_ordering_type -pc_hypre_boomeramg_grid_sweeps_all -pc_hypre_boomeramg_max_iter -pc_hypre_boomeramg_strong_threshold -pc_hypre_type -pc_type -snes_atol -snes_linesearch_type -snes_ls -snes_max_it -snes_rtol -snes_divergence_tolerance -snes_type -sub_ksp_type -sub_pc_type + description: | + Names of PETSc name/value pairs + - name: petsc_options_value + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Values of PETSc name/value pairs (must correspond with "petsc_options_iname" + - name: solve_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: PJFNK JFNK NEWTON FD LINEAR + description: | + PJFNK: Preconditioned Jacobian-Free Newton Krylov JFNK: Jacobian-Free Newton Krylov NEWTON: Full Newton Solve FD: Use finite differences to compute Jacobian LINEAR: Solving a linear problem + - name: type + required: No + default: !!str FDP + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Preconditioning/FSP + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: full + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Set to true if you want the full set of couplings. Simply for convenience so you don't have to set every off_diag_row and off_diag_column combination. + - name: ksp_norm + required: No + default: !!str unpreconditioned + cpp_type: MooseEnum + group_name: + options: none preconditioned unpreconditioned natural default + description: | + Sets the norm that is used for convergence testing + - name: mffd_type + required: No + default: !!str wp + cpp_type: MooseEnum + group_name: + options: wp ds + description: | + Specifies the finite differencing type for Jacobian-free solve types. Note that the default is wp (for Walker and Pernice). + - name: off_diag_column + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The off diagonal column you want to add into the matrix, it will be associated with an off diagonal row from the same position in off_diag_row. + - name: off_diag_row + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The off diagonal row you want to add into the matrix, it will be associated with an off diagonal column from the same position in off_diag_colum. + - name: pc_side + required: No + default: !!str default + cpp_type: MooseEnum + group_name: + options: left right symmetric default + description: | + Preconditioning side + - name: petsc_options + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: -dm_moose_print_embedding -dm_view -ksp_converged_reason -ksp_gmres_modifiedgramschmidt -ksp_monitor -ksp_monitor_snes_lg-snes_ksp_ew -ksp_snes_ew -snes_converged_reason -snes_ksp -snes_ksp_ew -snes_linesearch_monitor -snes_mf -snes_mf_operator -snes_monitor -snes_test_display -snes_view + description: | + Singleton PETSc options + - name: petsc_options_iname + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: -ksp_atol -ksp_gmres_restart -ksp_max_it -ksp_pc_side -ksp_rtol -ksp_type -mat_fd_coloring_err -mat_fd_type -mat_mffd_type -pc_asm_overlap -pc_factor_levels -pc_factor_mat_ordering_type -pc_hypre_boomeramg_grid_sweeps_all -pc_hypre_boomeramg_max_iter -pc_hypre_boomeramg_strong_threshold -pc_hypre_type -pc_type -snes_atol -snes_linesearch_type -snes_ls -snes_max_it -snes_rtol -snes_divergence_tolerance -snes_type -sub_ksp_type -sub_pc_type + description: | + Names of PETSc name/value pairs + - name: petsc_options_value + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Values of PETSc name/value pairs (must correspond with "petsc_options_iname" + - name: solve_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: PJFNK JFNK NEWTON FD LINEAR + description: | + PJFNK: Preconditioned Jacobian-Free Newton Krylov JFNK: Jacobian-Free Newton Krylov NEWTON: Full Newton Solve FD: Use finite differences to compute Jacobian LINEAR: Solving a linear problem + - name: topsplit + required: Yes + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + entrance to splits, the top split will specify how splits will go. + - name: type + required: No + default: !!str FSP + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Preconditioning/PBP + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: ksp_norm + required: No + default: !!str unpreconditioned + cpp_type: MooseEnum + group_name: + options: none preconditioned unpreconditioned natural default + description: | + Sets the norm that is used for convergence testing + - name: mffd_type + required: No + default: !!str wp + cpp_type: MooseEnum + group_name: + options: wp ds + description: | + Specifies the finite differencing type for Jacobian-free solve types. Note that the default is wp (for Walker and Pernice). + - name: off_diag_column + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The off diagonal column you want to add into the matrix, it will be associated with an off diagonal row from the same position in off_diag_row. + - name: off_diag_row + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The off diagonal row you want to add into the matrix, it will be associated with an off diagonal column from the same position in off_diag_colum. + - name: pc_side + required: No + default: !!str default + cpp_type: MooseEnum + group_name: + options: left right symmetric default + description: | + Preconditioning side + - name: petsc_options + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: -dm_moose_print_embedding -dm_view -ksp_converged_reason -ksp_gmres_modifiedgramschmidt -ksp_monitor -ksp_monitor_snes_lg-snes_ksp_ew -ksp_snes_ew -snes_converged_reason -snes_ksp -snes_ksp_ew -snes_linesearch_monitor -snes_mf -snes_mf_operator -snes_monitor -snes_test_display -snes_view + description: | + Singleton PETSc options + - name: petsc_options_iname + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: -ksp_atol -ksp_gmres_restart -ksp_max_it -ksp_pc_side -ksp_rtol -ksp_type -mat_fd_coloring_err -mat_fd_type -mat_mffd_type -pc_asm_overlap -pc_factor_levels -pc_factor_mat_ordering_type -pc_hypre_boomeramg_grid_sweeps_all -pc_hypre_boomeramg_max_iter -pc_hypre_boomeramg_strong_threshold -pc_hypre_type -pc_type -snes_atol -snes_linesearch_type -snes_ls -snes_max_it -snes_rtol -snes_divergence_tolerance -snes_type -sub_ksp_type -sub_pc_type + description: | + Names of PETSc name/value pairs + - name: petsc_options_value + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Values of PETSc name/value pairs (must correspond with "petsc_options_iname" + - name: preconditioner + required: Yes + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + TODO: docstring + - name: solve_order + required: Yes + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The order the block rows will be solved in. Put the name of variables here to stand for solving that variable's block row. A variable may appear more than once (to create cylces if you like). + - name: solve_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: PJFNK JFNK NEWTON FD LINEAR + description: | + PJFNK: Preconditioned Jacobian-Free Newton Krylov JFNK: Jacobian-Free Newton Krylov NEWTON: Full Newton Solve FD: Use finite differences to compute Jacobian LINEAR: Solving a linear problem + - name: type + required: No + default: !!str PBP + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Preconditioning/SMP + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: coupled_groups + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + List multiple space separated groups of comma separated variables. Off-diagonal jacobians will be generated for all pairs within a group. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: full + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true if you want the full set of couplings. Simply for convenience so you don't have to set every off_diag_row and off_diag_column combination. + - name: ksp_norm + required: No + default: !!str unpreconditioned + cpp_type: MooseEnum + group_name: + options: none preconditioned unpreconditioned natural default + description: | + Sets the norm that is used for convergence testing + - name: mffd_type + required: No + default: !!str wp + cpp_type: MooseEnum + group_name: + options: wp ds + description: | + Specifies the finite differencing type for Jacobian-free solve types. Note that the default is wp (for Walker and Pernice). + - name: off_diag_column + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The off diagonal column you want to add into the matrix, it will be associated with an off diagonal row from the same position in off_diag_row. + - name: off_diag_row + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The off diagonal row you want to add into the matrix, it will be associated with an off diagonal column from the same position in off_diag_colum. + - name: pc_side + required: No + default: !!str default + cpp_type: MooseEnum + group_name: + options: left right symmetric default + description: | + Preconditioning side + - name: petsc_options + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: -dm_moose_print_embedding -dm_view -ksp_converged_reason -ksp_gmres_modifiedgramschmidt -ksp_monitor -ksp_monitor_snes_lg-snes_ksp_ew -ksp_snes_ew -snes_converged_reason -snes_ksp -snes_ksp_ew -snes_linesearch_monitor -snes_mf -snes_mf_operator -snes_monitor -snes_test_display -snes_view + description: | + Singleton PETSc options + - name: petsc_options_iname + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: -ksp_atol -ksp_gmres_restart -ksp_max_it -ksp_pc_side -ksp_rtol -ksp_type -mat_fd_coloring_err -mat_fd_type -mat_mffd_type -pc_asm_overlap -pc_factor_levels -pc_factor_mat_ordering_type -pc_hypre_boomeramg_grid_sweeps_all -pc_hypre_boomeramg_max_iter -pc_hypre_boomeramg_strong_threshold -pc_hypre_type -pc_type -snes_atol -snes_linesearch_type -snes_ls -snes_max_it -snes_rtol -snes_divergence_tolerance -snes_type -sub_ksp_type -sub_pc_type + description: | + Names of PETSc name/value pairs + - name: petsc_options_value + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Values of PETSc name/value pairs (must correspond with "petsc_options_iname" + - name: solve_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: PJFNK JFNK NEWTON FD LINEAR + description: | + PJFNK: Preconditioned Jacobian-Free Newton Krylov JFNK: Jacobian-Free Newton Krylov NEWTON: Full Newton Solve FD: Use finite differences to compute Jacobian LINEAR: Solving a linear problem + - name: type + required: No + default: !!str SMP + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: +- name: /Problem + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: name + required: No + default: !!str MOOSE Problem + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name the problem + - name: type + required: Yes + default: !!str FEProblem + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Problem type + - name: library_name + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The file name of the library (*.la file) that will be dynamically loaded. + - name: library_path + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Path to search for dynamic libraries (please avoid committing absolute paths in addition to MOOSE_LIBRARY_PATH) + - name: object_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The names of the objects to register (Default: register all). + - name: register_objects_from + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The names of other applications from which objects will be registered from (dynamic registration). + subblocks: + - name: /Problem/ + description: | + + parameters: + subblocks: + - name: /Problem//DisplacedProblem + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: default_ghosting + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Whether or not to use libMesh's default amount of algebraic and geometric ghosting + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str DisplacedProblem + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + subblocks: + - name: /Problem//DumpObjectsProblem + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Block IDs for the coordinate systems + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: coord_type + required: No + default: !!str XYZ + cpp_type: MultiMooseEnum + group_name: + options: XYZ RZ RSPHERICAL + description: | + Type of the coordinate system per block param + - name: default_ghosting + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Whether or not to use libMesh's default amount of algebraic and geometric ghosting + - name: dump_path + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Syntax path of the action of which to dump the generated syntax + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: error_on_jacobian_nonzero_reallocation + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This causes PETSc to error if it had to reallocate memory in the Jacobian matrix due to not having enough nonzeros + - name: extra_tag_matrices + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Extra matrices to add to the system that can be filled by objects which compute residuals and Jacobians (Kernels, BCs, etc.) by setting tags on them. + - name: extra_tag_vectors + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Extra vectors to add to the system that can be filled by objects which compute residuals and Jacobians (Kernels, BCs, etc.) by setting tags on them. + - name: force_restart + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + EXPERIMENTAL: If true, a sub_app may use a restart file instead of using of using the master backup file + - name: ignore_zeros_in_jacobian + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Do not explicitly store zero values in the Jacobian matrix if true + - name: kernel_coverage_check + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Set to false to disable kernel->subdomain coverage check + - name: material_coverage_check + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Set to false to disable material->subdomain coverage check + - name: material_dependency_check + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Set to false to disable material dependency check + - name: near_null_space_dimension + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The dimension of the near nullspace + - name: null_space_dimension + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The dimension of the nullspace + - name: parallel_barrier_messaging + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Displays messaging from parallel barrier notifications when executing or transferring to/from Multiapps (default: false) + - name: restart_file_base + required: No + default: !!str + cpp_type: FileNameNoExtension + group_name: + description: | + File base name used for restart (e.g. / or /LATEST to grab the latest file available) + - name: rz_coord_axis + required: No + default: !!str Y + cpp_type: MooseEnum + group_name: + options: X Y + description: | + The rotation axis (X | Y) for axisymetric coordinates + - name: skip_additional_restart_data + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to skip additional data in equation system for restart. It is useful for starting a transient calculation with a steady-state solution + - name: skip_nl_system_check + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to skip the NonlinearSystem check for work to do (e.g. Make sure that there are variables to solve for). + - name: solve + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether or not to actually solve the Nonlinear system. This is handy in the case that all you want to do is execute AuxKernels, Transfers, etc. without actually solving anything + - name: transpose_null_space_dimension + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The dimension of the transpose nullspace + - name: type + required: No + default: !!str DumpObjectsProblem + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_nonlinear + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Determines whether to use a Nonlinear vs a Eigenvalue system (Automatically determined based on executioner) + subblocks: + - name: /Problem//EigenProblem + description: | + + parameters: + - name: active_eigen_index + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + Which eigen vector is used to compute residual and also associateed to nonlinear variable + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Block IDs for the coordinate systems + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: coord_type + required: No + default: !!str XYZ + cpp_type: MultiMooseEnum + group_name: + options: XYZ RZ RSPHERICAL + description: | + Type of the coordinate system per block param + - name: default_ghosting + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Whether or not to use libMesh's default amount of algebraic and geometric ghosting + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: error_on_jacobian_nonzero_reallocation + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This causes PETSc to error if it had to reallocate memory in the Jacobian matrix due to not having enough nonzeros + - name: extra_tag_matrices + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Extra matrices to add to the system that can be filled by objects which compute residuals and Jacobians (Kernels, BCs, etc.) by setting tags on them. + - name: extra_tag_vectors + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Extra vectors to add to the system that can be filled by objects which compute residuals and Jacobians (Kernels, BCs, etc.) by setting tags on them. + - name: force_restart + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + EXPERIMENTAL: If true, a sub_app may use a restart file instead of using of using the master backup file + - name: ignore_zeros_in_jacobian + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Do not explicitly store zero values in the Jacobian matrix if true + - name: kernel_coverage_check + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Set to false to disable kernel->subdomain coverage check + - name: material_coverage_check + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Set to false to disable material->subdomain coverage check + - name: material_dependency_check + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Set to false to disable material dependency check + - name: near_null_space_dimension + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The dimension of the near nullspace + - name: negative_sign_eigen_kernel + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether or not to use a negative sign for eigenvalue kernels. Using a negative sign makes eigenvalue kernels consistent with a nonlinear solver + - name: null_space_dimension + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The dimension of the nullspace + - name: parallel_barrier_messaging + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Displays messaging from parallel barrier notifications when executing or transferring to/from Multiapps (default: false) + - name: restart_file_base + required: No + default: !!str + cpp_type: FileNameNoExtension + group_name: + description: | + File base name used for restart (e.g. / or /LATEST to grab the latest file available) + - name: rz_coord_axis + required: No + default: !!str Y + cpp_type: MooseEnum + group_name: + options: X Y + description: | + The rotation axis (X | Y) for axisymetric coordinates + - name: skip_additional_restart_data + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to skip additional data in equation system for restart. It is useful for starting a transient calculation with a steady-state solution + - name: skip_nl_system_check + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to skip the NonlinearSystem check for work to do (e.g. Make sure that there are variables to solve for). + - name: solve + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether or not to actually solve the Nonlinear system. This is handy in the case that all you want to do is execute AuxKernels, Transfers, etc. without actually solving anything + - name: transpose_null_space_dimension + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The dimension of the transpose nullspace + - name: type + required: No + default: !!str EigenProblem + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_nonlinear + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Determines whether to use a Nonlinear vs a Eigenvalue system (Automatically determined based on executioner) + subblocks: + - name: /Problem//FEProblem + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Block IDs for the coordinate systems + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: coord_type + required: No + default: !!str XYZ + cpp_type: MultiMooseEnum + group_name: + options: XYZ RZ RSPHERICAL + description: | + Type of the coordinate system per block param + - name: default_ghosting + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Whether or not to use libMesh's default amount of algebraic and geometric ghosting + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: error_on_jacobian_nonzero_reallocation + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This causes PETSc to error if it had to reallocate memory in the Jacobian matrix due to not having enough nonzeros + - name: extra_tag_matrices + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Extra matrices to add to the system that can be filled by objects which compute residuals and Jacobians (Kernels, BCs, etc.) by setting tags on them. + - name: extra_tag_vectors + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Extra vectors to add to the system that can be filled by objects which compute residuals and Jacobians (Kernels, BCs, etc.) by setting tags on them. + - name: force_restart + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + EXPERIMENTAL: If true, a sub_app may use a restart file instead of using of using the master backup file + - name: ignore_zeros_in_jacobian + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Do not explicitly store zero values in the Jacobian matrix if true + - name: kernel_coverage_check + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Set to false to disable kernel->subdomain coverage check + - name: material_coverage_check + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Set to false to disable material->subdomain coverage check + - name: material_dependency_check + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Set to false to disable material dependency check + - name: near_null_space_dimension + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The dimension of the near nullspace + - name: null_space_dimension + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The dimension of the nullspace + - name: parallel_barrier_messaging + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Displays messaging from parallel barrier notifications when executing or transferring to/from Multiapps (default: false) + - name: restart_file_base + required: No + default: !!str + cpp_type: FileNameNoExtension + group_name: + description: | + File base name used for restart (e.g. / or /LATEST to grab the latest file available) + - name: rz_coord_axis + required: No + default: !!str Y + cpp_type: MooseEnum + group_name: + options: X Y + description: | + The rotation axis (X | Y) for axisymetric coordinates + - name: skip_additional_restart_data + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to skip additional data in equation system for restart. It is useful for starting a transient calculation with a steady-state solution + - name: skip_nl_system_check + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to skip the NonlinearSystem check for work to do (e.g. Make sure that there are variables to solve for). + - name: solve + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether or not to actually solve the Nonlinear system. This is handy in the case that all you want to do is execute AuxKernels, Transfers, etc. without actually solving anything + - name: transpose_null_space_dimension + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The dimension of the transpose nullspace + - name: type + required: No + default: !!str FEProblem + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_nonlinear + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Determines whether to use a Nonlinear vs a Eigenvalue system (Automatically determined based on executioner) + subblocks: + - name: /Problem//ReferenceResidualProblem + description: | + + parameters: + - name: acceptable_iterations + required: No + default: !!str 0 + cpp_type: int + group_name: + description: | + Iterations after which convergence to acceptable limits is accepted + - name: acceptable_multiplier + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Multiplier applied to relative tolerance for acceptable limit + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Block IDs for the coordinate systems + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: coord_type + required: No + default: !!str XYZ + cpp_type: MultiMooseEnum + group_name: + options: XYZ RZ RSPHERICAL + description: | + Type of the coordinate system per block param + - name: default_ghosting + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Whether or not to use libMesh's default amount of algebraic and geometric ghosting + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: error_on_jacobian_nonzero_reallocation + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + This causes PETSc to error if it had to reallocate memory in the Jacobian matrix due to not having enough nonzeros + - name: extra_tag_matrices + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Extra matrices to add to the system that can be filled by objects which compute residuals and Jacobians (Kernels, BCs, etc.) by setting tags on them. + - name: extra_tag_vectors + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Extra vectors to add to the system that can be filled by objects which compute residuals and Jacobians (Kernels, BCs, etc.) by setting tags on them. + - name: force_restart + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + EXPERIMENTAL: If true, a sub_app may use a restart file instead of using of using the master backup file + - name: group_variables + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > >, std::allocator, std::allocator >, std::allocator, std::allocator > > > > > + group_name: + description: | + Name of variables that are grouped together to check convergence. (Multiple groups can be provided, separated by semicolon) + - name: ignore_zeros_in_jacobian + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Do not explicitly store zero values in the Jacobian matrix if true + - name: kernel_coverage_check + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Set to false to disable kernel->subdomain coverage check + - name: material_coverage_check + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Set to false to disable material->subdomain coverage check + - name: material_dependency_check + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Set to false to disable material dependency check + - name: near_null_space_dimension + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The dimension of the near nullspace + - name: null_space_dimension + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The dimension of the nullspace + - name: parallel_barrier_messaging + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Displays messaging from parallel barrier notifications when executing or transferring to/from Multiapps (default: false) + - name: reference_residual_variables + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Set of variables that provide reference residuals for relative convergence check + - name: reference_vector + required: No + default: !!str + cpp_type: TagName + group_name: + description: | + The tag name of the reference residual vector. + - name: restart_file_base + required: No + default: !!str + cpp_type: FileNameNoExtension + group_name: + description: | + File base name used for restart (e.g. / or /LATEST to grab the latest file available) + - name: rz_coord_axis + required: No + default: !!str Y + cpp_type: MooseEnum + group_name: + options: X Y + description: | + The rotation axis (X | Y) for axisymetric coordinates + - name: skip_additional_restart_data + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to skip additional data in equation system for restart. It is useful for starting a transient calculation with a steady-state solution + - name: skip_nl_system_check + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to skip the NonlinearSystem check for work to do (e.g. Make sure that there are variables to solve for). + - name: solution_variables + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Set of solution variables to be checked for relative convergence + - name: solve + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Whether or not to actually solve the Nonlinear system. This is handy in the case that all you want to do is execute AuxKernels, Transfers, etc. without actually solving anything + - name: transpose_null_space_dimension + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + The dimension of the transpose nullspace + - name: type + required: No + default: !!str ReferenceResidualProblem + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_nonlinear + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Determines whether to use a Nonlinear vs a Eigenvalue system (Automatically determined based on executioner) + subblocks: +- name: /Samplers + description: | + + parameters: + subblocks: + - name: /Samplers/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: +- name: /ScalarKernels + description: | + + parameters: + subblocks: + - name: /ScalarKernels/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /ScalarKernels/CoupledODETimeDerivative + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: type + required: No + default: !!str CoupledODETimeDerivative + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + Coupled variable. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this kernel operates on + - name: vector_tags + required: No + default: !!str time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /ScalarKernels/NodalEqualValueConstraint + description: | + + parameters: + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this nodal kernel applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: nodes + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Supply nodes using node ids + - name: type + required: No + default: !!str NodalEqualValueConstraint + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: var + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + Variable(s) to put the constraint on + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /ScalarKernels/ODETimeDerivative + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system time + description: | + The tag for the matrices this Kernel should fill + - name: type + required: No + default: !!str ODETimeDerivative + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this kernel operates on + - name: vector_tags + required: No + default: !!str time + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: + - name: /ScalarKernels/ParsedODEKernel + description: | + + parameters: + - name: args + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + additional coupled variables + - name: constant_expressions + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of values for the constants in constant_names (can be an FParser expression) + - name: constant_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Vector of constants used in the parsed function (use this for kB etc.) + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: disable_fpoptimizer + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Disable the function parser algebraic optimizer + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: enable_ad_cache + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable cacheing of function derivatives for faster startup time + - name: enable_auto_optimize + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable automatic immediate optimization of derivatives + - name: enable_jit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Enable just-in-time compilation of function expressions for faster evaluation + - name: evalerror_behavior + required: No + default: !!str nan + cpp_type: MooseEnum + group_name: 'Advanced' + options: nan nan_warning error exception + description: | + What to do if evaluation error occurs. Options are to pass a nan, pass a nan with a warning, throw a error, or throw an exception + - name: extra_matrix_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the matrices this Kernel should fill + - name: extra_vector_tags + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Tagging' + description: | + The extra tags for the vectors this Kernel should fill + - name: fail_on_evalerror + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Fail fatally if a function evaluation returns an error code (otherwise just pass on NaN) + - name: function + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + function expression + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: matrix_tags + required: No + default: !!str system + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime system + description: | + The tag for the matrices this Kernel should fill + - name: postprocessors + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Vector of postprocessor names used in the function expression + - name: type + required: No + default: !!str ParsedODEKernel + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: NonlinearVariableName + group_name: + description: | + The name of the variable that this kernel operates on + - name: vector_tags + required: No + default: !!str nontime + cpp_type: MultiMooseEnum + group_name: 'Tagging' + options: nontime time + description: | + The tag for the vectors this Kernel should fill + subblocks: +- name: /Transfers + description: | + + parameters: + subblocks: + - name: /Transfers/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /Transfers/MultiAppCopyTransfer + description: | + + parameters: + - name: check_multiapp_execute_on + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false the check between the multiapp and transfer execute on flags is not preformed. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: direction + required: Yes + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: to_multiapp from_multiapp + description: | + Whether this Transfer will be 'to' or 'from' a MultiApp, or bidirectional, by providing both FROM_MULTIAPP and TO_MULTIAPP. + - name: displaced_source_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the source mesh. + - name: displaced_target_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the target mesh. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str SAME_AS_MULTIAPP + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, SAME_AS_MULTIAPP. + - name: multi_app + required: Yes + default: !!str + cpp_type: MultiAppName + group_name: + description: | + The name of the MultiApp to use. + - name: source_variable + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The variable to transfer from. + - name: type + required: No + default: !!str MultiAppCopyTransfer + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The auxiliary variable to store the transferred values in. + subblocks: + - name: /Transfers/MultiAppInterpolationTransfer + description: | + + parameters: + - name: check_multiapp_execute_on + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false the check between the multiapp and transfer execute on flags is not preformed. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: direction + required: Yes + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: to_multiapp from_multiapp + description: | + Whether this Transfer will be 'to' or 'from' a MultiApp, or bidirectional, by providing both FROM_MULTIAPP and TO_MULTIAPP. + - name: displaced_source_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the source mesh. + - name: displaced_target_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the target mesh. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str SAME_AS_MULTIAPP + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, SAME_AS_MULTIAPP. + - name: from_postprocessors_to_be_preserved + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the Postprocessor in the from-app to evaluate an adjusting factor. + - name: interp_type + required: No + default: !!str inverse_distance + cpp_type: MooseEnum + group_name: + options: inverse_distance radial_basis + description: | + The algorithm to use for interpolation. + - name: multi_app + required: Yes + default: !!str + cpp_type: MultiAppName + group_name: + description: | + The name of the MultiApp to use. + - name: num_points + required: No + default: !!str 3 + cpp_type: unsigned int + group_name: + description: | + The number of nearest points to use for interpolation. + - name: power + required: No + default: !!str 2 + cpp_type: double + group_name: + description: | + The polynomial power to use for calculation of the decay in the interpolation. + - name: radius + required: No + default: !!str -1 + cpp_type: double + group_name: + description: | + Radius to use for radial_basis interpolation. If negative then the radius is taken as the max distance between points. + - name: source_variable + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The variable to transfer from. + - name: to_postprocessors_to_be_preserved + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the Postprocessor in the to-app to evaluate an adjusting factor. + - name: type + required: No + default: !!str MultiAppInterpolationTransfer + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The auxiliary variable to store the transferred values in. + subblocks: + - name: /Transfers/MultiAppMeshFunctionTransfer + description: | + + parameters: + - name: check_multiapp_execute_on + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false the check between the multiapp and transfer execute on flags is not preformed. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: direction + required: Yes + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: to_multiapp from_multiapp + description: | + Whether this Transfer will be 'to' or 'from' a MultiApp, or bidirectional, by providing both FROM_MULTIAPP and TO_MULTIAPP. + - name: displaced_source_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the source mesh. + - name: displaced_target_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the target mesh. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: error_on_miss + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to error in the case that a target point is not found in the source domain. + - name: execute_on + required: No + default: !!str SAME_AS_MULTIAPP + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, SAME_AS_MULTIAPP. + - name: from_postprocessors_to_be_preserved + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the Postprocessor in the from-app to evaluate an adjusting factor. + - name: multi_app + required: Yes + default: !!str + cpp_type: MultiAppName + group_name: + description: | + The name of the MultiApp to use. + - name: source_variable + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The variable to transfer from. + - name: to_postprocessors_to_be_preserved + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the Postprocessor in the to-app to evaluate an adjusting factor. + - name: type + required: No + default: !!str MultiAppMeshFunctionTransfer + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The auxiliary variable to store the transferred values in. + subblocks: + - name: /Transfers/MultiAppNearestNodeTransfer + description: | + + parameters: + - name: check_multiapp_execute_on + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false the check between the multiapp and transfer execute on flags is not preformed. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: direction + required: Yes + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: to_multiapp from_multiapp + description: | + Whether this Transfer will be 'to' or 'from' a MultiApp, or bidirectional, by providing both FROM_MULTIAPP and TO_MULTIAPP. + - name: displaced_source_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the source mesh. + - name: displaced_target_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the target mesh. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str SAME_AS_MULTIAPP + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, SAME_AS_MULTIAPP. + - name: fixed_meshes + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true when the meshes are not changing (ie, no movement or adaptivity). This will cache nearest node neighbors to greatly speed up the transfer. + - name: from_postprocessors_to_be_preserved + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the Postprocessor in the from-app to evaluate an adjusting factor. + - name: multi_app + required: Yes + default: !!str + cpp_type: MultiAppName + group_name: + description: | + The name of the MultiApp to use. + - name: source_boundary + required: No + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The boundary we are transferring from (if not specified, whole domain is used). + - name: source_variable + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The variable to transfer from. + - name: target_boundary + required: No + default: !!str + cpp_type: BoundaryName + group_name: + description: | + The boundary we are transferring to (if not specified, whole domain is used). + - name: to_postprocessors_to_be_preserved + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the Postprocessor in the to-app to evaluate an adjusting factor. + - name: type + required: No + default: !!str MultiAppNearestNodeTransfer + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The auxiliary variable to store the transferred values in. + subblocks: + - name: /Transfers/MultiAppPostprocessorInterpolationTransfer + description: | + + parameters: + - name: check_multiapp_execute_on + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false the check between the multiapp and transfer execute on flags is not preformed. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: direction + required: Yes + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: to_multiapp from_multiapp + description: | + Whether this Transfer will be 'to' or 'from' a MultiApp, or bidirectional, by providing both FROM_MULTIAPP and TO_MULTIAPP. + - name: displaced_source_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the source mesh. + - name: displaced_target_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the target mesh. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str SAME_AS_MULTIAPP + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, SAME_AS_MULTIAPP. + - name: interp_type + required: No + default: !!str inverse_distance + cpp_type: MooseEnum + group_name: + options: inverse_distance radial_basis + description: | + The algorithm to use for interpolation. + - name: multi_app + required: Yes + default: !!str + cpp_type: MultiAppName + group_name: + description: | + The name of the MultiApp to use. + - name: num_points + required: No + default: !!str 3 + cpp_type: unsigned int + group_name: + description: | + The number of nearest points to use for interpolation. + - name: postprocessor + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The Postprocessor to interpolate. + - name: power + required: No + default: !!str 2 + cpp_type: double + group_name: + description: | + The polynomial power to use for calculation of the decay in the interpolation. + - name: radius + required: No + default: !!str -1 + cpp_type: double + group_name: + description: | + Radius to use for radial_basis interpolation. If negative then the radius is taken as the max distance between points. + - name: type + required: No + default: !!str MultiAppPostprocessorInterpolationTransfer + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The auxiliary variable to store the transferred values in. + subblocks: + - name: /Transfers/MultiAppPostprocessorToAuxScalarTransfer + description: | + + parameters: + - name: check_multiapp_execute_on + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false the check between the multiapp and transfer execute on flags is not preformed. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: direction + required: Yes + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: to_multiapp from_multiapp + description: | + Whether this Transfer will be 'to' or 'from' a MultiApp, or bidirectional, by providing both FROM_MULTIAPP and TO_MULTIAPP. + - name: displaced_source_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the source mesh. + - name: displaced_target_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the target mesh. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str SAME_AS_MULTIAPP + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, SAME_AS_MULTIAPP. + - name: from_postprocessor + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The name of the Postprocessor in the Master to transfer the value from. + - name: multi_app + required: Yes + default: !!str + cpp_type: MultiAppName + group_name: + description: | + The name of the MultiApp to use. + - name: to_aux_scalar + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The name of the scalar Aux variable in the MultiApp to transfer the value to. + - name: type + required: No + default: !!str MultiAppPostprocessorToAuxScalarTransfer + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Transfers/MultiAppPostprocessorTransfer + description: | + + parameters: + - name: check_multiapp_execute_on + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false the check between the multiapp and transfer execute on flags is not preformed. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: direction + required: Yes + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: to_multiapp from_multiapp + description: | + Whether this Transfer will be 'to' or 'from' a MultiApp, or bidirectional, by providing both FROM_MULTIAPP and TO_MULTIAPP. + - name: displaced_source_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the source mesh. + - name: displaced_target_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the target mesh. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str SAME_AS_MULTIAPP + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, SAME_AS_MULTIAPP. + - name: from_postprocessor + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The name of the Postprocessor in the Master to transfer the value from. + - name: multi_app + required: Yes + default: !!str + cpp_type: MultiAppName + group_name: + description: | + The name of the MultiApp to use. + - name: reduction_type + required: No + default: !!str + cpp_type: MooseEnum + group_name: + options: average sum maximum minimum + description: | + The type of reduction to perform to reduce postprocessor values from multiple SubApps to a single value + - name: to_postprocessor + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The name of the Postprocessor in the MultiApp to transfer the value to. This should most likely be a Reporter Postprocessor. + - name: type + required: No + default: !!str MultiAppPostprocessorTransfer + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Transfers/MultiAppProjectionTransfer + description: | + + parameters: + - name: check_multiapp_execute_on + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false the check between the multiapp and transfer execute on flags is not preformed. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: direction + required: Yes + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: to_multiapp from_multiapp + description: | + Whether this Transfer will be 'to' or 'from' a MultiApp, or bidirectional, by providing both FROM_MULTIAPP and TO_MULTIAPP. + - name: displaced_source_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the source mesh. + - name: displaced_target_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the target mesh. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str SAME_AS_MULTIAPP + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, SAME_AS_MULTIAPP. + - name: fixed_meshes + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true when the meshes are not changing (ie, no movement or adaptivity). This will cache some information to speed up the transfer. + - name: from_postprocessors_to_be_preserved + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the Postprocessor in the from-app to evaluate an adjusting factor. + - name: multi_app + required: Yes + default: !!str + cpp_type: MultiAppName + group_name: + description: | + The name of the MultiApp to use. + - name: proj_type + required: No + default: !!str l2 + cpp_type: MooseEnum + group_name: + options: l2 + description: | + The type of the projection. + - name: source_variable + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The variable to transfer from. + - name: to_postprocessors_to_be_preserved + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the Postprocessor in the to-app to evaluate an adjusting factor. + - name: type + required: No + default: !!str MultiAppProjectionTransfer + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The auxiliary variable to store the transferred values in. + subblocks: + - name: /Transfers/MultiAppScalarToAuxScalarTransfer + description: | + + parameters: + - name: check_multiapp_execute_on + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false the check between the multiapp and transfer execute on flags is not preformed. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: direction + required: Yes + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: to_multiapp from_multiapp + description: | + Whether this Transfer will be 'to' or 'from' a MultiApp, or bidirectional, by providing both FROM_MULTIAPP and TO_MULTIAPP. + - name: displaced_source_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the source mesh. + - name: displaced_target_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the target mesh. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str SAME_AS_MULTIAPP + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, SAME_AS_MULTIAPP. + - name: multi_app + required: Yes + default: !!str + cpp_type: MultiAppName + group_name: + description: | + The name of the MultiApp to use. + - name: source_variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The name of the scalar variable in the MultiApp to transfer the value from. + - name: to_aux_scalar + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The name of the scalar Aux variable in the MultiApp to transfer the value to. + - name: type + required: No + default: !!str MultiAppScalarToAuxScalarTransfer + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Transfers/MultiAppUserObjectTransfer + description: | + + parameters: + - name: all_master_nodes_contained_in_sub_app + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set to true if every master node is mapped to a distinct point on one of the subApps during a transfer from sub App to Master App. If master node cannot be found within bounding boxes of any of the subApps, an error is generated. + - name: check_multiapp_execute_on + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false the check between the multiapp and transfer execute on flags is not preformed. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: direction + required: Yes + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: to_multiapp from_multiapp + description: | + Whether this Transfer will be 'to' or 'from' a MultiApp, or bidirectional, by providing both FROM_MULTIAPP and TO_MULTIAPP. + - name: displaced_source_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the source mesh. + - name: displaced_target_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the target mesh. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str SAME_AS_MULTIAPP + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, SAME_AS_MULTIAPP. + - name: from_postprocessors_to_be_preserved + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the Postprocessor in the from-app to evaluate an adjusting factor. + - name: multi_app + required: Yes + default: !!str + cpp_type: MultiAppName + group_name: + description: | + The name of the MultiApp to use. + - name: skip_bounding_box_check + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Skip the check if the to_elem is within the bounding box of the from_app. + - name: to_postprocessors_to_be_preserved + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The name of the Postprocessor in the to-app to evaluate an adjusting factor. + - name: type + required: No + default: !!str MultiAppUserObjectTransfer + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: user_object + required: Yes + default: !!str + cpp_type: UserObjectName + group_name: + description: | + The UserObject you want to transfer values from. Note: This might be a UserObject from your MultiApp's input file! + - name: variable + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The auxiliary variable to store the transferred values in. + subblocks: + - name: /Transfers/MultiAppVariableValueSamplePostprocessorTransfer + description: | + + parameters: + - name: check_multiapp_execute_on + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false the check between the multiapp and transfer execute on flags is not preformed. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: direction + required: Yes + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: to_multiapp from_multiapp + description: | + Whether this Transfer will be 'to' or 'from' a MultiApp, or bidirectional, by providing both FROM_MULTIAPP and TO_MULTIAPP. + - name: displaced_source_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the source mesh. + - name: displaced_target_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the target mesh. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str SAME_AS_MULTIAPP + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, SAME_AS_MULTIAPP. + - name: multi_app + required: Yes + default: !!str + cpp_type: MultiAppName + group_name: + description: | + The name of the MultiApp to use. + - name: postprocessor + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The name of the postprocessor in the MultiApp to transfer the value to. This should most likely be a Reciever Postprocessor. + - name: source_variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable to transfer from. + - name: type + required: No + default: !!str MultiAppVariableValueSamplePostprocessorTransfer + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /Transfers/MultiAppVariableValueSampleTransfer + description: | + + parameters: + - name: check_multiapp_execute_on + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false the check between the multiapp and transfer execute on flags is not preformed. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: direction + required: Yes + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: to_multiapp from_multiapp + description: | + Whether this Transfer will be 'to' or 'from' a MultiApp, or bidirectional, by providing both FROM_MULTIAPP and TO_MULTIAPP. + - name: displaced_source_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the source mesh. + - name: displaced_target_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the target mesh. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str SAME_AS_MULTIAPP + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, SAME_AS_MULTIAPP. + - name: multi_app + required: Yes + default: !!str + cpp_type: MultiAppName + group_name: + description: | + The name of the MultiApp to use. + - name: source_variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable to transfer from. + - name: type + required: No + default: !!str MultiAppVariableValueSampleTransfer + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: AuxVariableName + group_name: + description: | + The auxiliary variable to store the transferred values in. + subblocks: + - name: /Transfers/MultiAppVectorPostprocessorTransfer + description: | + + parameters: + - name: check_multiapp_execute_on + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false the check between the multiapp and transfer execute on flags is not preformed. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: direction + required: Yes + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: to_multiapp from_multiapp + description: | + Whether this Transfer will be 'to' or 'from' a MultiApp, or bidirectional, by providing both FROM_MULTIAPP and TO_MULTIAPP. + - name: displaced_source_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the source mesh. + - name: displaced_target_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to use the displaced mesh for the target mesh. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str SAME_AS_MULTIAPP + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, SAME_AS_MULTIAPP. + - name: multi_app + required: Yes + default: !!str + cpp_type: MultiAppName + group_name: + description: | + The name of the MultiApp to use. + - name: postprocessor + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The name of the Postprocessors on the sub-app to transfer from/to. + - name: type + required: No + default: !!str MultiAppVectorPostprocessorTransfer + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: vector_name + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Named vector quantity to transfer from/to in VectorPostprocessor. + - name: vector_postprocessor + required: Yes + default: !!str + cpp_type: VectorPostprocessorName + group_name: + description: | + The name of the VectorPostprocessor in the MultiApp to transfer values from/to. + subblocks: +- name: /UserObjects + description: | + + parameters: + subblocks: + - name: /UserObjects/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /UserObjects/ADElementAverageMaterialProperty + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: mat_prop + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the material property + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADElementAverageMaterialProperty + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/ADElementExtremeMaterialProperty + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: mat_prop + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + Material property for which to find extreme + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADElementExtremeMaterialProperty + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value_type + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: max min + description: | + Type of extreme value to return: 'max' returns the maximum value and 'min' returns the minimum value. + subblocks: + - name: /UserObjects/ADElementIntegralMaterialProperty + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: mat_prop + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the material property + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ADElementIntegralMaterialProperty + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/ADSideFluxAverage + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diffusivity + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the diffusivity material property that will be used in the flux computation. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str ADSideFluxAverage + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this boundary condition applies to + subblocks: + - name: /UserObjects/ADSideFluxIntegral + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diffusivity + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the diffusivity material property that will be used in the flux computation. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str ADSideFluxIntegral + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this boundary condition applies to + subblocks: + - name: /UserObjects/AreaPostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str AreaPostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/AverageElementSize + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str AverageElementSize + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/AverageNodalVariableValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str AverageNodalVariableValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: unique_node_execute + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When false (default), block restricted objects will have the execute method called multiple times on a single node if the node lies on a interface between two subdomains. + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this postprocessor operates on + subblocks: + - name: /UserObjects/AxisymmetricCenterlineAverageValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str AxisymmetricCenterlineAverageValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this boundary condition applies to + subblocks: + - name: /UserObjects/ChangeOverTimePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: change_with_respect_to_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Compute change with respect to initial value instead of previous value + - name: compute_relative_change + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Compute magnitude of relative change instead of change + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: postprocessor + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The name of the postprocessor + - name: take_absolute_value + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Option to take absolute value of change + - name: type + required: No + default: !!str ChangeOverTimePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/ChangeOverTimestepPostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: change_with_respect_to_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Compute change with respect to initial value instead of previous value + - name: compute_relative_change + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Compute magnitude of relative change instead of change + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: postprocessor + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The name of the postprocessor + - name: take_absolute_value + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Option to take absolute value of change + - name: type + required: No + default: !!str ChangeOverTimestepPostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/CumulativeValuePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: postprocessor + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The name of the postprocessor + - name: type + required: No + default: !!str CumulativeValuePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/DifferencePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str DifferencePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value1 + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + First value + - name: value2 + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + Second value + subblocks: + - name: /UserObjects/ElementAverageMaterialProperty + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: mat_prop + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the material property + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementAverageMaterialProperty + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/ElementAverageSecondTimeDerivative + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementAverageSecondTimeDerivative + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /UserObjects/ElementAverageTimeDerivative + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementAverageTimeDerivative + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /UserObjects/ElementAverageValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementAverageValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /UserObjects/ElementExtremeMaterialProperty + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: mat_prop + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + Material property for which to find extreme + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementExtremeMaterialProperty + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value_type + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: max min + description: | + Type of extreme value to return: 'max' returns the maximum value and 'min' returns the minimum value. + subblocks: + - name: /UserObjects/ElementExtremeValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementExtremeValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value_type + required: No + default: !!str max + cpp_type: MooseEnum + group_name: + options: max min + description: | + Type of extreme value to return. 'max' returns the maximum value. 'min' returns the minimum value. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this postprocessor operates on + subblocks: + - name: /UserObjects/ElementH1Error + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The analytic solution to compare against + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: p + required: No + default: !!str 2 + cpp_type: double + group_name: + description: | + The exponent used in the norm. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementH1Error + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /UserObjects/ElementH1SemiError + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The analytic solution to compare against + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementH1SemiError + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /UserObjects/ElementIntegralArrayVariablePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: component + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + Component of the array variable to be integrated + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementIntegralArrayVariablePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the array variable that this object operates on + subblocks: + - name: /UserObjects/ElementIntegralMaterialProperty + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: mat_prop + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the material property + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementIntegralMaterialProperty + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/ElementIntegralVariablePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementIntegralVariablePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /UserObjects/ElementIntegralVariableUserObject + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementIntegralVariableUserObject + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /UserObjects/ElementL2Difference + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: other_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable to compare to + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementL2Difference + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /UserObjects/ElementL2Error + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The analytic solution to compare against + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementL2Error + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /UserObjects/ElementL2Norm + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementL2Norm + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /UserObjects/ElementQualityChecker + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str INITIAL + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: failure_type + required: No + default: !!str WARNING + cpp_type: MooseEnum + group_name: + options: WARNING ERROR + description: | + The way how the failure of quality metric check should respond + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: lower_bound + required: No + default: !!str + cpp_type: double + group_name: + description: | + The lower bound for provided metric type + - name: metric_type + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: ASPECT_RATIO SKEW SHEAR SHAPE MAX_ANGLE MIN_ANGLE CONDITION DISTORTION TAPER WARP STRETCH DIAGONAL ASPECT_RATIO_BETA ASPECT_RATIO_GAMMA SIZE JACOBIAN + description: | + Type of quality metric to be checked + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementQualityChecker + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: upper_bound + required: No + default: !!str + cpp_type: double + group_name: + description: | + the upper bound for provided metric type + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/ElementVectorL2Error + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: function_x + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The analytic solution to compare against + - name: function_y + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The analytic solution to compare against + - name: function_z + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + The analytic solution to compare against + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementVectorL2Error + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: var_x + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The FE solution in x direction + - name: var_y + required: No + default: !!str 0 + cpp_type: std::vector + group_name: + description: | + The FE solution in y direction + - name: var_z + required: No + default: !!str 0 + cpp_type: std::vector + group_name: + description: | + The FE solution in z direction + subblocks: + - name: /UserObjects/ElementW1pError + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The analytic solution to compare against + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: p + required: No + default: !!str 2 + cpp_type: double + group_name: + description: | + The exponent used in the norm. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementW1pError + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /UserObjects/ElementalVariableValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: elementid + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The ID of the element where we monitor + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str ElementalVariableValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable to be monitored + subblocks: + - name: /UserObjects/EmptyPostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str EmptyPostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/ExecutionerAttributeReporter + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str ExecutionerAttributeReporter + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/FindValueOnLine + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: default_value + required: No + default: !!str -1 + cpp_type: double + group_name: + description: | + Value to return if target value is not found on line and error_if_not_found is false. + - name: depth + required: No + default: !!str 36 + cpp_type: unsigned int + group_name: + description: | + Maximum number of bisections to perform. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_point + required: No + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + End point of the sampling line. + - name: error_if_not_found + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If true, stop with error if target value is not found on the line. If false, return default_value. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: start_point + required: No + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + Start point of the sampling line. + - name: target + required: No + default: !!str + cpp_type: double + group_name: + description: | + Target value to locate. + - name: tol + required: No + default: !!str 1e-10 + cpp_type: double + group_name: + description: | + Stop search if a value is found that is equal to the target with this tolerance applied. + - name: type + required: No + default: !!str FindValueOnLine + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: v + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + Variable to inspect + subblocks: + - name: /UserObjects/FunctionElementIntegral + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + Name of function to integrate + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str FunctionElementIntegral + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/FunctionSideIntegral + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: function + required: No + default: !!str 1 + cpp_type: FunctionName + group_name: + description: | + This postprocessor will return the integral of this function over the boundary + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str FunctionSideIntegral + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/FunctionValuePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The function which supplies the postprocessor value. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: point + required: No + default: !!str 0 0 0 + cpp_type: libMesh::Point + group_name: + description: | + A point in space to be given to the function Default: (0, 0, 0) + - name: scale_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + A scale factor to be applied to the function + - name: type + required: No + default: !!str FunctionValuePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/GeometrySphere + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + List of boundaries whose nodes are snapped to a given geometry + - name: center + required: No + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + Sphere center + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: radius + required: No + default: !!str + cpp_type: double + group_name: + description: | + Sphere radius + - name: type + required: No + default: !!str GeometrySphere + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/GhostingUserObject + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str INITIAL + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: pids + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The PID(s) to see the ghosting for + - name: type + required: No + default: !!str GhostingUserObject + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/GreaterThanLessThanPostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: comparator + required: No + default: !!str greater + cpp_type: MooseEnum + group_name: + options: greater less + description: | + The comparison to perform between the variable and the provided value + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: subdomain + required: No + default: !!str + cpp_type: SubdomainName + group_name: + description: | + The subdomain that the variable lives on + - name: type + required: No + default: !!str GreaterThanLessThanPostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The value to compare against + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The name of the variable to conduct a comparison for + subblocks: + - name: /UserObjects/InterfaceAverageVariableValuePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: interface_value_type + required: No + default: !!str average + cpp_type: MooseEnum + group_name: + options: average jump_master_minus_slave jump_slave_minus_master jump_abs master slave + description: | + Type of value we want to compute + - name: neighbor_variable + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable on the slave side of the interface. By default the same variable name is used for the slave side + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str InterfaceAverageVariableValuePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable on the master side of the interface + subblocks: + - name: /UserObjects/InterfaceIntegralVariableValuePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: interface_value_type + required: No + default: !!str average + cpp_type: MooseEnum + group_name: + options: average jump_master_minus_slave jump_slave_minus_master jump_abs master slave + description: | + Type of value we want to compute + - name: neighbor_variable + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable on the slave side of the interface. By default the same variable name is used for the slave side + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str InterfaceIntegralVariableValuePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable on the master side of the interface + subblocks: + - name: /UserObjects/InterfaceQpMaterialPropertyRealUO + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: interface_value_type + required: No + default: !!str average + cpp_type: MooseEnum + group_name: + options: average jump_master_minus_slave jump_slave_minus_master jump_abs master slave + description: | + Type of scalar output + - name: property + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The material property name + - name: property_neighbor + required: No + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The neighbor material property name + - name: type + required: No + default: !!str InterfaceQpMaterialPropertyRealUO + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value_type + required: No + default: !!str value + cpp_type: MooseEnum + group_name: + options: value rate increment + description: | + Type of value to compute and store + subblocks: + - name: /UserObjects/InterfaceQpValueUserObject + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str INITIAL TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: interface_value_type + required: No + default: !!str average + cpp_type: MooseEnum + group_name: + options: average jump_master_minus_slave jump_slave_minus_master jump_abs master slave + description: | + Type of scalar output + - name: type + required: No + default: !!str InterfaceQpValueUserObject + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value_type + required: No + default: !!str value + cpp_type: MooseEnum + group_name: + options: value rate increment + description: | + Type of value to compute and store + - name: var + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The variable name + - name: var_neighbor + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + The neighbor variable name + subblocks: + - name: /UserObjects/LayeredAverage + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: average_radius + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + When using 'average' sampling this is how the number of values both above and below the layer that will be averaged. + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: bounds + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The 'bounding' positions of the layers i.e.: '0, 1.2, 3.7, 4.2' will mean 3 layers between those positions. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cumulative + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the value in each layer is the sum of the values up to and including that layer + - name: direction + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z + description: | + The direction of the layers. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: layer_bounding_block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + List of block ids (SubdomainID) that are used to determine the upper and lower geometric bounds for all layers. If this is not specified, the ids specified in 'block' are used for this purpose. + - name: num_layers + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of layers. + - name: sample_type + required: No + default: !!str direct + cpp_type: MooseEnum + group_name: + options: direct interpolate average + description: | + How to sample the layers. 'direct' means get the value of the layer the point falls in directly (or average if that layer has no value). 'interpolate' does a linear interpolation between the two closest layers. 'average' averages the two closest layers. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str LayeredAverage + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /UserObjects/LayeredIntegral + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: average_radius + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + When using 'average' sampling this is how the number of values both above and below the layer that will be averaged. + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: bounds + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The 'bounding' positions of the layers i.e.: '0, 1.2, 3.7, 4.2' will mean 3 layers between those positions. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cumulative + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the value in each layer is the sum of the values up to and including that layer + - name: direction + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z + description: | + The direction of the layers. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: layer_bounding_block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + List of block ids (SubdomainID) that are used to determine the upper and lower geometric bounds for all layers. If this is not specified, the ids specified in 'block' are used for this purpose. + - name: num_layers + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of layers. + - name: sample_type + required: No + default: !!str direct + cpp_type: MooseEnum + group_name: + options: direct interpolate average + description: | + How to sample the layers. 'direct' means get the value of the layer the point falls in directly (or average if that layer has no value). 'interpolate' does a linear interpolation between the two closest layers. 'average' averages the two closest layers. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str LayeredIntegral + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /UserObjects/LayeredSideAverage + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: average_radius + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + When using 'average' sampling this is how the number of values both above and below the layer that will be averaged. + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: bounds + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The 'bounding' positions of the layers i.e.: '0, 1.2, 3.7, 4.2' will mean 3 layers between those positions. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cumulative + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the value in each layer is the sum of the values up to and including that layer + - name: direction + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z + description: | + The direction of the layers. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: layer_bounding_block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + List of block ids (SubdomainID) that are used to determine the upper and lower geometric bounds for all layers. If this is not specified, the ids specified in 'block' are used for this purpose. + - name: num_layers + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of layers. + - name: sample_type + required: No + default: !!str direct + cpp_type: MooseEnum + group_name: + options: direct interpolate average + description: | + How to sample the layers. 'direct' means get the value of the layer the point falls in directly (or average if that layer has no value). 'interpolate' does a linear interpolation between the two closest layers. 'average' averages the two closest layers. + - name: type + required: No + default: !!str LayeredSideAverage + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this boundary condition applies to + subblocks: + - name: /UserObjects/LayeredSideFluxAverage + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: average_radius + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + When using 'average' sampling this is how the number of values both above and below the layer that will be averaged. + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: bounds + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The 'bounding' positions of the layers i.e.: '0, 1.2, 3.7, 4.2' will mean 3 layers between those positions. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cumulative + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the value in each layer is the sum of the values up to and including that layer + - name: diffusivity + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name of the diffusivity material property that will be used in the flux computation. + - name: direction + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z + description: | + The direction of the layers. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: layer_bounding_block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + List of block ids (SubdomainID) that are used to determine the upper and lower geometric bounds for all layers. If this is not specified, the ids specified in 'block' are used for this purpose. + - name: num_layers + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of layers. + - name: sample_type + required: No + default: !!str direct + cpp_type: MooseEnum + group_name: + options: direct interpolate average + description: | + How to sample the layers. 'direct' means get the value of the layer the point falls in directly (or average if that layer has no value). 'interpolate' does a linear interpolation between the two closest layers. 'average' averages the two closest layers. + - name: type + required: No + default: !!str LayeredSideFluxAverage + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this boundary condition applies to + subblocks: + - name: /UserObjects/LayeredSideIntegral + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: average_radius + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + When using 'average' sampling this is how the number of values both above and below the layer that will be averaged. + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: bounds + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The 'bounding' positions of the layers i.e.: '0, 1.2, 3.7, 4.2' will mean 3 layers between those positions. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cumulative + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the value in each layer is the sum of the values up to and including that layer + - name: direction + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z + description: | + The direction of the layers. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: layer_bounding_block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + List of block ids (SubdomainID) that are used to determine the upper and lower geometric bounds for all layers. If this is not specified, the ids specified in 'block' are used for this purpose. + - name: num_layers + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of layers. + - name: sample_type + required: No + default: !!str direct + cpp_type: MooseEnum + group_name: + options: direct interpolate average + description: | + How to sample the layers. 'direct' means get the value of the layer the point falls in directly (or average if that layer has no value). 'interpolate' does a linear interpolation between the two closest layers. 'average' averages the two closest layers. + - name: type + required: No + default: !!str LayeredSideIntegral + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this boundary condition applies to + subblocks: + - name: /UserObjects/LinearCombinationPostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: b + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Additional value to add to sum + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: pp_coefs + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + List of linear combination coefficients for each post-processor + - name: pp_names + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + List of post-processors + - name: type + required: No + default: !!str LinearCombinationPostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/MemoryUsage + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: mem_type + required: No + default: !!str physical_memory + cpp_type: MooseEnum + group_name: + options: physical_memory virtual_memory page_faults + description: | + Memory metric to report. + - name: mem_units + required: No + default: !!str mebibytes + cpp_type: MooseEnum + group_name: + options: bytes kibibytes mebibytes gibibytes kilobytes megabytes gigabytes + description: | + The unit prefix used to report memory usage, default: Mebibytes + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: report_peak_value + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If the postprocessor is executed more than once during a time step, report the aggregated peak value. + - name: type + required: No + default: !!str MemoryUsage + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value_type + required: No + default: !!str total + cpp_type: MooseEnum + group_name: + options: total average max_process min_process + description: | + Aggregation method to apply to the requested memory metric. + subblocks: + - name: /UserObjects/NearestPointLayeredAverage + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: average_radius + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + When using 'average' sampling this is how the number of values both above and below the layer that will be averaged. + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: bounds + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The 'bounding' positions of the layers i.e.: '0, 1.2, 3.7, 4.2' will mean 3 layers between those positions. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cumulative + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the value in each layer is the sum of the values up to and including that layer + - name: direction + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z + description: | + The direction of the layers. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: layer_bounding_block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + List of block ids (SubdomainID) that are used to determine the upper and lower geometric bounds for all layers. If this is not specified, the ids specified in 'block' are used for this purpose. + - name: num_layers + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of layers. + - name: points + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Computations will be lumped into values at these points. + - name: points_file + required: No + default: !!str + cpp_type: FileName + group_name: + description: | + A filename that should be looked in for points. Each set of 3 values in that file will represent a Point. This and 'points' cannot be both supplied. + - name: sample_type + required: No + default: !!str direct + cpp_type: MooseEnum + group_name: + options: direct interpolate average + description: | + How to sample the layers. 'direct' means get the value of the layer the point falls in directly (or average if that layer has no value). 'interpolate' does a linear interpolation between the two closest layers. 'average' averages the two closest layers. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NearestPointLayeredAverage + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /UserObjects/NearestPointLayeredIntegral + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: average_radius + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + When using 'average' sampling this is how the number of values both above and below the layer that will be averaged. + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: bounds + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The 'bounding' positions of the layers i.e.: '0, 1.2, 3.7, 4.2' will mean 3 layers between those positions. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cumulative + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the value in each layer is the sum of the values up to and including that layer + - name: direction + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z + description: | + The direction of the layers. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: layer_bounding_block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + List of block ids (SubdomainID) that are used to determine the upper and lower geometric bounds for all layers. If this is not specified, the ids specified in 'block' are used for this purpose. + - name: num_layers + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of layers. + - name: points + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Computations will be lumped into values at these points. + - name: points_file + required: No + default: !!str + cpp_type: FileName + group_name: + description: | + A filename that should be looked in for points. Each set of 3 values in that file will represent a Point. This and 'points' cannot be both supplied. + - name: sample_type + required: No + default: !!str direct + cpp_type: MooseEnum + group_name: + options: direct interpolate average + description: | + How to sample the layers. 'direct' means get the value of the layer the point falls in directly (or average if that layer has no value). 'interpolate' does a linear interpolation between the two closest layers. 'average' averages the two closest layers. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NearestPointLayeredIntegral + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /UserObjects/NearestPointLayeredSideAverage + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: average_radius + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + When using 'average' sampling this is how the number of values both above and below the layer that will be averaged. + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: bounds + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The 'bounding' positions of the layers i.e.: '0, 1.2, 3.7, 4.2' will mean 3 layers between those positions. + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cumulative + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When true the value in each layer is the sum of the values up to and including that layer + - name: direction + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z + description: | + The direction of the layers. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: layer_bounding_block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + List of block ids (SubdomainID) that are used to determine the upper and lower geometric bounds for all layers. If this is not specified, the ids specified in 'block' are used for this purpose. + - name: num_layers + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of layers. + - name: points + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Computations will be lumped into values at these points. + - name: points_file + required: No + default: !!str + cpp_type: FileName + group_name: + description: | + A filename that should be looked in for points. Each set of 3 values in that file will represent a Point. This and 'points' cannot be both supplied. + - name: sample_type + required: No + default: !!str direct + cpp_type: MooseEnum + group_name: + options: direct interpolate average + description: | + How to sample the layers. 'direct' means get the value of the layer the point falls in directly (or average if that layer has no value). 'interpolate' does a linear interpolation between the two closest layers. 'average' averages the two closest layers. + - name: type + required: No + default: !!str NearestPointLayeredSideAverage + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this boundary condition applies to + subblocks: + - name: /UserObjects/NodalExtremeValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NodalExtremeValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: unique_node_execute + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When false (default), block restricted objects will have the execute method called multiple times on a single node if the node lies on a interface between two subdomains. + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value_type + required: No + default: !!str max + cpp_type: MooseEnum + group_name: + options: max min + description: | + Type of extreme value to return. 'max' returns the maximum value. 'min' returns the minimum value. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this postprocessor operates on + subblocks: + - name: /UserObjects/NodalL2Error + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The analytic solution to compare against + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NodalL2Error + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: unique_node_execute + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When false (default), block restricted objects will have the execute method called multiple times on a single node if the node lies on a interface between two subdomains. + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this postprocessor operates on + subblocks: + - name: /UserObjects/NodalL2Norm + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NodalL2Norm + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: unique_node_execute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false (default), block restricted objects will have the execute method called multiple times on a single node if the node lies on a interface between two subdomains. + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this postprocessor operates on + subblocks: + - name: /UserObjects/NodalMaxValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NodalMaxValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: unique_node_execute + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When false (default), block restricted objects will have the execute method called multiple times on a single node if the node lies on a interface between two subdomains. + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this postprocessor operates on + subblocks: + - name: /UserObjects/NodalNormalsCorner + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: corner_boundary + required: Yes + default: !!str + cpp_type: BoundaryName + group_name: + description: | + Node set ID which contains the nodes that are in 'corners'. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: type + required: No + default: !!str NodalNormalsCorner + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/NodalNormalsEvaluator + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str ANY_BLOCK_ID + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NodalNormalsEvaluator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: unique_node_execute + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When false (default), block restricted objects will have the execute method called multiple times on a single node if the node lies on a interface between two subdomains. + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/NodalNormalsPreprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: corner_boundary + required: No + default: !!str + cpp_type: BoundaryName + group_name: + description: | + Node set ID which contains the nodes that are in 'corners'. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: surface_boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs where nodal normals are computed + - name: type + required: No + default: !!str NodalNormalsPreprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/NodalProxyMaxValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NodalProxyMaxValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: unique_node_execute + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When false (default), block restricted objects will have the execute method called multiple times on a single node if the node lies on a interface between two subdomains. + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this postprocessor operates on + subblocks: + - name: /UserObjects/NodalSum + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NodalSum + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: unique_node_execute + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When false (default), block restricted objects will have the execute method called multiple times on a single node if the node lies on a interface between two subdomains. + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this postprocessor operates on + subblocks: + - name: /UserObjects/NodalVariableValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: nodeid + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The ID of the node where we monitor + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scale_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + A scale factor to be applied to the variable + - name: type + required: No + default: !!str NodalVariableValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable to be monitored + subblocks: + - name: /UserObjects/NumDOFs + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: system + required: No + default: !!str ALL + cpp_type: MooseEnum + group_name: + options: NL AUX ALL + description: | + The system(s) for which you want to retrieve the number of DOFs (NL, AUX, ALL). Default == ALL + - name: type + required: No + default: !!str NumDOFs + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/NumElems + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: elem_filter + required: No + default: !!str active + cpp_type: MooseEnum + group_name: + options: active total + description: | + The type of elements to include in the count (active, total). Default == active + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str NumElems + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/NumLinearIterations + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str NumLinearIterations + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/NumNodes + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str NumNodes + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/NumNonlinearIterations + description: | + + parameters: + - name: accumulate_over_step + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When set to true, accumulates to count the total over all Picard iterations for each step + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str NumNonlinearIterations + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/NumPicardIterations + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str NumPicardIterations + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/NumRelationshipManagers + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: rm_type + required: No + default: !!str ALL + cpp_type: MooseEnum + group_name: + options: GEOMETRIC ALGEBRAIC COUPLING ALL + description: | + The type of relationship managers to include in the relationship manager count + - name: type + required: No + default: !!str NumRelationshipManagers + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/NumResidualEvaluations + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str NumResidualEvaluations + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/NumVars + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: system + required: No + default: !!str ALL + cpp_type: MooseEnum + group_name: + options: NL AUX ALL + description: | + The system(s) for which you want to retrieve the number of variables (NL, AUX, ALL). Default == ALL + - name: type + required: No + default: !!str NumVars + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/PercentChangePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: postprocessor + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The name of the postprocessor used for exit criterion + - name: type + required: No + default: !!str PercentChangePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/PerfGraphData + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: data_type + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: SELF CHILDREN TOTAL SELF_AVG CHILDREN_AVG TOTAL_AVG SELF_PERCENT CHILDREN_PERCENT TOTAL_PERCENT CALLS + description: | + The type of data to retrieve for the section_name + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: section_name + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name of the section to get data for + - name: type + required: No + default: !!str PerfGraphData + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/PerformanceData + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: category + required: No + default: !!str Execution + cpp_type: MooseEnum + group_name: + options: Application Execution Output Setup Utility + description: | + The category for the event + - name: column + required: No + default: !!str total_time_with_sub + cpp_type: MooseEnum + group_name: + options: n_calls total_time average_time total_time_with_sub average_time_with_sub percent_of_active_time percent_of_active_time_with_sub + description: | + The column you want the value of (Default: total_time_with_sub). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: event + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: ACTIVE ALIVE solve() compute_residual() compute_jacobian() + description: | + The name or "label" of the event. Must match event name exactly including parenthesis if applicable. ("ALIVE" and "ACTIVE" are also valid events, category and column are ignored for these cases). + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str PerformanceData + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/PointValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: point + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + The physical point where the solution will be evaluated. + - name: type + required: No + default: !!str PointValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The name of the variable that this postprocessor operates on. + subblocks: + - name: /UserObjects/PostprocessorComparison + description: | + + parameters: + - name: absolute_tolerance + required: No + default: !!str 1e-12 + cpp_type: double + group_name: + description: | + Absolute tolerance used in comparisons + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: comparison_type + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: equals greater_than_equals less_than_equals greater_than less_than + description: | + The type of comparison to perform. Options are: equals greater_than_equals less_than_equals greater_than less_than + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str PostprocessorComparison + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value_a + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The first post-processor or value in the comparison + - name: value_b + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The second post-processor or value in the comparison + subblocks: + - name: /UserObjects/PostprocessorSpatialUserObject + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: postprocessor + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The name of the postprocessor + - name: type + required: No + default: !!str PostprocessorSpatialUserObject + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/Receiver + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: default + required: No + default: !!str + cpp_type: double + group_name: + description: | + The default value + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: initialize_old + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Initialize the old postprocessor value with the default value + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str Receiver + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/RelativeDifferencePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str RelativeDifferencePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value1 + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + First post-processor + - name: value2 + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + Second post-processor, base for relative difference + subblocks: + - name: /UserObjects/RelativeSolutionDifferenceNorm + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str RelativeSolutionDifferenceNorm + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/Residual + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: residual_type + required: No + default: !!str FINAL + cpp_type: MooseEnum + group_name: + options: FINAL INITIAL_BEFORE_PRESET INITIAL_AFTER_PRESET + description: | + Type of residual to be reported. Choices are: FINAL INITIAL_BEFORE_PRESET INITIAL_AFTER_PRESET + - name: type + required: No + default: !!str Residual + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/ScalarL2Error + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The analytic solution to compare against + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str ScalarL2Error + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The name of the scalar variable + subblocks: + - name: /UserObjects/ScalarVariable + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: component + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + Component to output for this variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str ScalarVariable + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + Name of the variable + subblocks: + - name: /UserObjects/ScalePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling_factor + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + The scaling factor + - name: type + required: No + default: !!str ScalePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The postprocessor to be scaled + subblocks: + - name: /UserObjects/SideAverageValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str SideAverageValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this boundary condition applies to + subblocks: + - name: /UserObjects/SideFluxAverage + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diffusivity + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the diffusivity material property that will be used in the flux computation. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str SideFluxAverage + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this boundary condition applies to + subblocks: + - name: /UserObjects/SideFluxIntegral + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: diffusivity + required: Yes + default: !!str + cpp_type: MaterialPropertyName + group_name: + description: | + The name of the diffusivity material property that will be used in the flux computation. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str SideFluxIntegral + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this boundary condition applies to + subblocks: + - name: /UserObjects/SideIntegralVariablePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str SideIntegralVariablePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this boundary condition applies to + subblocks: + - name: /UserObjects/SolutionUserObject + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: es + required: No + default: !!str + cpp_type: FileName + group_name: + description: | + The name of the file holding the equation system info in xda format (xda only). + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: mesh + required: Yes + default: !!str + cpp_type: MeshFileName + group_name: + description: | + The name of the mesh file (must be xda or exodusII file). + - name: rotation0_angle + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Anticlockwise rotation angle (in degrees) to use for rotation about rotation0_vector. + - name: rotation0_vector + required: No + default: !!str 0 0 1 + cpp_type: libMesh::VectorValue + group_name: + description: | + Vector about which to rotate points of the simulation. + - name: rotation1_angle + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Anticlockwise rotation angle (in degrees) to use for rotation about rotation1_vector. + - name: rotation1_vector + required: No + default: !!str 0 0 1 + cpp_type: libMesh::VectorValue + group_name: + description: | + Vector about which to rotate points of the simulation. + - name: scale + required: No + default: !!str 1 1 1 + cpp_type: std::vector > + group_name: + description: | + Scale factor for points in the simulation + - name: scale_multiplier + required: No + default: !!str 1 1 1 + cpp_type: std::vector > + group_name: + description: | + Scale multiplying factor for points in the simulation + - name: system + required: No + default: !!str nl0 + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name of the system to pull values out of (xda only). + - name: system_variables + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + The name of the nodal and elemental variables from the file you want to use for values + - name: timestep + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Index of the single timestep used or "LATEST" for the last timestep (exodusII only). If not supplied, time interpolation will occur. + - name: transformation_order + required: No + default: !!str translation scale + cpp_type: MultiMooseEnum + group_name: + options: rotation0 translation scale rotation1 scale_multiplier + description: | + The order to perform the operations in. Define R0 to be the rotation matrix encoded by rotation0_vector and rotation0_angle. Similarly for R1. Denote the scale by s, the scale_multiplier by m, and the translation by t. Then, given a point x in the simulation, if transformation_order = 'rotation0 scale_multiplier translation scale rotation1' then form p = R1*(R0*x*m - t)/s. Then the values provided by the SolutionUserObject at point x in the simulation are the variable values at point p in the mesh. + - name: translation + required: No + default: !!str 0 0 0 + cpp_type: std::vector > + group_name: + description: | + Translation factors for x,y,z coordinates of the simulation + - name: type + required: No + default: !!str SolutionUserObject + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/Terminator + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: expression + required: Yes + default: !!str + cpp_type: FunctionExpression + group_name: + description: | + FParser expression to process Postprocessor values into a boolean value. Termination of the simulation occurs when this returns true. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: type + required: No + default: !!str Terminator + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/TimeExtremeValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: postprocessor + required: Yes + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The name of the postprocessor used for reporting time extreme values + - name: type + required: No + default: !!str TimeExtremeValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value_type + required: No + default: !!str max + cpp_type: MooseEnum + group_name: + options: max min abs_max abs_min + description: | + Type of extreme value to return.'max' returns the maximum value.'min' returns the minimum value.'abs_max' returns the maximum absolute value.'abs_min' returns the minimum absolute value. + subblocks: + - name: /UserObjects/TimestepSize + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str TimestepSize + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/TotalVariableValue + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str TotalVariableValue + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: No + default: !!str + cpp_type: PostprocessorName + group_name: + description: | + The name of the postprocessor + subblocks: + - name: /UserObjects/VariableInnerProduct + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: second_variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the second variable in the inner product (variable, second_variable) + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VariableInnerProduct + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /UserObjects/VariableResidual + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str VariableResidual + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The name of the variable to compute the residual for + subblocks: + - name: /UserObjects/VectorPostprocessorComparison + description: | + + parameters: + - name: absolute_tolerance + required: No + default: !!str 1e-12 + cpp_type: double + group_name: + description: | + Absolute tolerance used in comparisons + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: comparison_type + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: equals greater_than_equals less_than_equals greater_than less_than + description: | + The type of comparison to perform. Options are: equals greater_than_equals less_than_equals greater_than less_than + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str VectorPostprocessorComparison + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: vector_name_a + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name of the vector in the first vector post-processor to compare + - name: vector_name_b + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name of the vector in the second vector post-processor to compare + - name: vectorpostprocessor_a + required: Yes + default: !!str + cpp_type: VectorPostprocessorName + group_name: + description: | + The first vector post-processor in the comparison + - name: vectorpostprocessor_b + required: Yes + default: !!str + cpp_type: VectorPostprocessorName + group_name: + description: | + The second vector post-processor in the comparison + subblocks: + - name: /UserObjects/VectorPostprocessorComponent + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: index + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + Index of the vectorpostprocessor for which to report a value + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: type + required: No + default: !!str VectorPostprocessorComponent + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: vector_name + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + Name of the vector for which to report a value + - name: vectorpostprocessor + required: Yes + default: !!str + cpp_type: VectorPostprocessorName + group_name: + description: | + The vectorpostprocessor from which a value is extracted + subblocks: + - name: /UserObjects/VerifyElementUniqueID + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VerifyElementUniqueID + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/VerifyNodalUniqueID + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VerifyNodalUniqueID + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: unique_node_execute + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When false (default), block restricted objects will have the execute method called multiple times on a single node if the node lies on a interface between two subdomains. + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /UserObjects/VolumePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VolumePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: +- name: /Variables + description: | + + parameters: + subblocks: + - name: /Variables/* + description: | + + parameters: + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH + description: | + Specifies the order of the FE shape function to use for this variable (additional orders not listed are allowed) + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: Yes + default: !!str MooseVariableBase + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + - name: initial_from_file_timestep + required: No + default: !!str LATEST + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: 'Initial From File' + description: | + Gives the timestep (or "LATEST") for which to read a solution from a file for a given variable. (Default: LATEST) + - name: initial_from_file_var + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: 'Initial From File' + description: | + Gives the name of a variable for which to read an initial condition from a mesh file + subblocks: + - name: /Variables/*/InitialCondition + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /Variables/*/InitialCondition/ + description: | + + parameters: + subblocks: + - name: /Variables/*/InitialCondition//ArrayConstantIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: type + required: No + default: !!str ArrayConstantIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: value + required: Yes + default: !!str + cpp_type: Eigen::Matrix + group_name: + description: | + The values to be set in IC + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /Variables/*/InitialCondition//ArrayFunctionIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: function + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The initial condition functions. + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: type + required: No + default: !!str ArrayFunctionIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /Variables/*/InitialCondition//BoundingBoxIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: inside + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The value of the variable inside the box + - name: int_width + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The width of the diffuse interface. Set to 0 for sharp interface. + - name: outside + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The value of the variable outside the box + - name: type + required: No + default: !!str BoundingBoxIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + - name: x1 + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The x coordinate of the lower left-hand corner of the box + - name: x2 + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The x coordinate of the upper right-hand corner of the box + - name: y1 + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The y coordinate of the lower left-hand corner of the box + - name: y2 + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The y coordinate of the upper right-hand corner of the box + - name: z1 + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The z coordinate of the lower left-hand corner of the box + - name: z2 + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The z coordinate of the upper right-hand corner of the box + subblocks: + - name: /Variables/*/InitialCondition//ConstantIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: type + required: No + default: !!str ConstantIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: value + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The value to be set in IC + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /Variables/*/InitialCondition//FunctionIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + The initial condition function. + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: type + required: No + default: !!str FunctionIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /Variables/*/InitialCondition//FunctionScalarIC + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: function + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The initial condition function. + - name: type + required: No + default: !!str FunctionScalarIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: No + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /Variables/*/InitialCondition//RandomIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: distribution + required: No + default: !!str + cpp_type: DistributionName + group_name: + description: | + Name of distribution defining distribution of randomly generated values + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: legacy_generator + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Determines whether or not the legacy generator (deprecated) should be used. + - name: max + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Upper bound of uniformly distributed randomly generated values + - name: min + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Lower bound of uniformly distributed randomly generated values + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: + description: | + Seed value for the random number generator + - name: type + required: No + default: !!str RandomIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /Variables/*/InitialCondition//ScalarComponentIC + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str ScalarComponentIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: values + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + Initial values to initialize the scalar variable. + - name: variable + required: No + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /Variables/*/InitialCondition//ScalarConstantIC + description: | + + parameters: + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: type + required: No + default: !!str ScalarConstantIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + + - name: variable + required: No + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /Variables/*/InitialCondition//VectorConstantIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: type + required: No + default: !!str VectorConstantIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + - name: x_value + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + The x value to be set in IC + - name: y_value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The y value to be set in IC + - name: z_value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + The z value to be set in IC + subblocks: + - name: /Variables/*/InitialCondition//VectorFunctionIC + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: function + required: No + default: !!str + cpp_type: FunctionName + group_name: + description: | + The initial condition vector function. This cannot be supplied with the component parameters. + - name: function_x + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + A function that describes the x-component of the initial condition + - name: function_y + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + A function that describes the y-component of the initial condition + - name: function_z + required: No + default: !!str 0 + cpp_type: FunctionName + group_name: + description: | + A function that describes the z-component of the initial condition + - name: ignore_uo_dependency + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + When set to true, a UserObject retrieved by this IC will not be executed before the this IC + - name: type + required: No + default: !!str VectorFunctionIC + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: variable + required: Yes + default: !!str + cpp_type: VariableName + group_name: + description: | + The variable this initial condition is supposed to provide values for. + subblocks: + - name: /Variables/ArrayMooseVariable + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str ArrayMooseVariable + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /Variables/MooseVariable + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str MooseVariable + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /Variables/MooseVariableBase + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str MooseVariableBase + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /Variables/MooseVariableConstMonomial + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str MONOMIAL + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str CONSTANT + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str MooseVariableConstMonomial + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /Variables/MooseVariableFVReal + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str MooseVariableFVReal + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /Variables/MooseVariableScalar + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str SCALAR + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str MooseVariableScalar + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: + - name: /Variables/VectorMooseVariable + description: | + + parameters: + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: components + required: No + default: !!str 1 + cpp_type: unsigned int + group_name: + description: | + Number of components for an array variable + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: eigen + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + True to make this variable an eigen variable + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: family + required: No + default: !!str LAGRANGE + cpp_type: MooseEnum + group_name: + options: LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC + description: | + Specifies the family of FE shape functions to use for this variable. + - name: fv + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to make this variable a finite volume variable + - name: initial_condition + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Specifies the initial condition for this variable + - name: order + required: No + default: !!str FIRST + cpp_type: MooseEnum + group_name: + options: CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH EIGHTTEENTH NINETEENTH TWENTIETH TWENTYFIRST TWENTYSECOND TWENTYTHIRD TWENTYFOURTH TWENTYFIFTH TWENTYSIXTH TWENTYSEVENTH TWENTYEIGHTH TWENTYNINTH THIRTIETH THIRTYFIRST THIRTYSECOND THIRTYTHIRD THIRTYFOURTH THIRTYFIFTH THIRTYSIXTH THIRTYSEVENTH THIRTYEIGHTH THIRTYNINTH FORTIETH FORTYFIRST FORTYSECOND FORTYTHIRD + description: | + Order of the FE shape function to use for this variable (additional orders not listed here are allowed, depending on the family). + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: scaling + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Specifies a scaling factor to apply to this variable + - name: type + required: No + default: !!str VectorMooseVariable + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_dual + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + True to use dual basis for Lagrange multipliers + subblocks: +- name: /VectorPostprocessors + description: | + + parameters: + subblocks: + - name: /VectorPostprocessors/* + description: | + + parameters: + - name: inactive + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + If specified blocks matching these identifiers will be skipped. + - name: isObjectAction + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Indicates that this is a MooseObjectAction. + - name: type + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + A string representing the Moose Object that will be built by this Action + subblocks: + - name: /VectorPostprocessors/CSVReader + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: csv_file + required: Yes + default: !!str + cpp_type: FileName + group_name: + description: | + The name of the CSV file to read. Currently, with the exception of the header row, only numeric values are supported. + - name: delimiter + required: No + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The column delimiter. Despite the name this can read files separated by delimiter other than a comma. If this options is omitted it will read comma or space separated files. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str INITIAL + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: header + required: No + default: !!str + cpp_type: bool + group_name: + description: | + When true it is assumed that the first row contains column headers, these headers are used as the VectorPostprocessor vector names. If false the file is assumed to contain only numbers and the vectors are named automatically based on the column number (e.g., 'column_0000', 'column_0001'). If not supplied the reader attempts to auto detect the headers. + - name: ignore_empty_lines + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + When true new empty lines in the file are ignored. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: type + required: No + default: !!str CSVReader + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /VectorPostprocessors/ConstantVectorPostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: type + required: No + default: !!str ConstantVectorPostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: value + required: Yes + default: !!str + cpp_type: std::vector >, std::allocator > > > + group_name: + description: | + Vector values this object will have. Leading dimension must be equal to leading dimension of vector_names parameter. + - name: vector_names + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Names of the column vectors in this object + subblocks: + - name: /VectorPostprocessors/CylindricalAverage + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: bin_number + required: No + default: !!str 50 + cpp_type: unsigned int + group_name: + description: | + Number of histogram bins + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: cylinder_axis + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + Vector along cylinder coordinate axis + - name: empty_bin_value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Value to assign to bins into which no datapoints fall + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: origin + required: No + default: !!str 0 0 0 + cpp_type: libMesh::Point + group_name: + description: | + Origin of the cylinder + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: radius + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Radius to average out to + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str CylindricalAverage + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + Variables to average radially + subblocks: + - name: /VectorPostprocessors/Eigenvalues + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: type + required: No + default: !!str Eigenvalues + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /VectorPostprocessors/ElementValueSampler + description: | + + parameters: + - name: _auto_broadcast + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: sort_by + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z id + description: | + What to sort the samples by + - name: type + required: No + default: !!str ElementValueSampler + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The names of the variables that this VectorPostprocessor operates on + subblocks: + - name: /VectorPostprocessors/ElementVariablesDifferenceMax + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: compare_a + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The first variable to evaluate the difference with, performed as "compare_a - compare_b" + - name: compare_b + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The second variable to evaluate the difference with, performed as "compare_a - compare_b" + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: furthest_from_zero + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Find the difference with the highest absolute value + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str ElementVariablesDifferenceMax + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /VectorPostprocessors/ElementsAlongLine + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + The end of the line + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: start + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + The beginning of the line + - name: type + required: No + default: !!str ElementsAlongLine + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /VectorPostprocessors/ElementsAlongPlane + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: normal + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + Normal vector to the plane + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: point + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + Point in the plane + - name: type + required: No + default: !!str ElementsAlongPlane + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /VectorPostprocessors/HistogramVectorPostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: num_bins + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of bins for the histograms + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: type + required: No + default: !!str HistogramVectorPostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: vpp + required: Yes + default: !!str + cpp_type: VectorPostprocessorName + group_name: + description: | + The VectorPostprocessor to compute histogram of + subblocks: + - name: /VectorPostprocessors/IntersectionPointsAlongLine + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + The end of the line + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: start + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + The beginning of the line + - name: type + required: No + default: !!str IntersectionPointsAlongLine + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /VectorPostprocessors/LeastSquaresFit + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: num_samples + required: No + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of samples to be output + - name: order + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The order of the polynomial fit + - name: output + required: No + default: !!str Coefficients + cpp_type: MooseEnum + group_name: + options: Coefficients Samples + description: | + The quantity to output. Options are: Coefficients Samples + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: sample_x_max + required: No + default: !!str + cpp_type: double + group_name: + description: | + The maximum x value of the of samples to be output + - name: sample_x_min + required: No + default: !!str + cpp_type: double + group_name: + description: | + The minimum x value of the of samples to be output + - name: truncate_order + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Truncate the order of the fitted polynomial if an insufficient number of data points are provided. If this is set to false, an error will be generated in that case. + - name: type + required: No + default: !!str LeastSquaresFit + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: vectorpostprocessor + required: Yes + default: !!str + cpp_type: VectorPostprocessorName + group_name: + description: | + The vectorpostprocessor on whose values we perform a least squares fit + - name: x_name + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name of the independent variable + - name: x_scale + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Value used to scale x values (scaling is done after shifting) + - name: x_shift + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Value used to shift x values (shifting is done before scaling) + - name: y_name + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name of the dependent variable + - name: y_scale + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Value used to scale y values (scaling is done after shifting) + - name: y_shift + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Value used to shift y values (shifting is done before scaling) + subblocks: + - name: /VectorPostprocessors/LeastSquaresFitHistory + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: contains_complete_history + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: order + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The order of the polynomial fit + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: truncate_order + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + Truncate the order of the fitted polynomial if an insufficient number of data points are provided. If this is set to false, an error will be generated in that case. + - name: type + required: No + default: !!str LeastSquaresFitHistory + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: vectorpostprocessor + required: Yes + default: !!str + cpp_type: VectorPostprocessorName + group_name: + description: | + The vectorpostprocessor on whose values we perform a least squares fit + - name: x_name + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name of the independent variable + - name: x_scale + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Value used to scale x values (scaling is done after shifting) + - name: x_shift + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Value used to shift x values (shifting is done before scaling) + - name: y_name + required: Yes + default: !!str + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + The name of the dependent variable + - name: y_scale + required: No + default: !!str 1 + cpp_type: double + group_name: + description: | + Value used to scale y values (scaling is done after shifting) + - name: y_shift + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Value used to shift y values (shifting is done before scaling) + subblocks: + - name: /VectorPostprocessors/LineFunctionSampler + description: | + + parameters: + - name: _auto_broadcast + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_point + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + The ending of the line + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: functions + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The Functions to sample along the line + - name: num_points + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of points to sample along the line + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: sort_by + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z id + description: | + What to sort the samples by + - name: start_point + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + The beginning of the line + - name: type + required: No + default: !!str LineFunctionSampler + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /VectorPostprocessors/LineMaterialRealSampler + description: | + + parameters: + - name: _auto_broadcast + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + The end of the line + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: property + required: Yes + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: + description: | + Name of the material property to be output along a line + - name: sort_by + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z id + description: | + What to sort the samples by + - name: start + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + The beginning of the line + - name: type + required: No + default: !!str LineMaterialRealSampler + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /VectorPostprocessors/LineValueSampler + description: | + + parameters: + - name: _auto_broadcast + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: end_point + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + The ending of the line + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: num_points + required: Yes + default: !!str + cpp_type: unsigned int + group_name: + description: | + The number of points to sample along the line + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: scaling + required: No + default: !!str 1 + cpp_type: PostprocessorName + group_name: + description: | + The postprocessor that the variables are multiplied with + - name: sort_by + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z id + description: | + What to sort the samples by + - name: start_point + required: Yes + default: !!str + cpp_type: libMesh::Point + group_name: + description: | + The beginning of the line + - name: type + required: No + default: !!str LineValueSampler + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The names of the variables that this VectorPostprocessor operates on + subblocks: + - name: /VectorPostprocessors/MaterialVectorPostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: elem_ids + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + Element IDs to print data for (others are ignored). + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: material + required: Yes + default: !!str + cpp_type: MaterialName + group_name: + description: | + Material for which all properties will be recorded. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str MaterialVectorPostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /VectorPostprocessors/NearestPointIntegralVariablePostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: points + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + Computations will be lumped into values at these points. + - name: points_file + required: No + default: !!str + cpp_type: FileName + group_name: + description: | + A filename that should be looked in for points. Each set of 3 values in that file will represent a Point. This and 'points' cannot be both supplied. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str NearestPointIntegralVariablePostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The name of the variable that this object operates on + subblocks: + - name: /VectorPostprocessors/NodalValueSampler + description: | + + parameters: + - name: _auto_broadcast + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: boundary + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: sort_by + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z id + description: | + What to sort the samples by + - name: type + required: No + default: !!str NodalValueSampler + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: unique_node_execute + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + When false (default), block restricted objects will have the execute method called multiple times on a single node if the node lies on a interface between two subdomains. + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The names of the variables that this VectorPostprocessor operates on + subblocks: + - name: /VectorPostprocessors/PiecewiseFunctionTabulate + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: function + required: Yes + default: !!str + cpp_type: FunctionName + group_name: + description: | + Name of the piecewise function object to extract the time steps from + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: type + required: No + default: !!str PiecewiseFunctionTabulate + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /VectorPostprocessors/PointValueSampler + description: | + + parameters: + - name: _auto_broadcast + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: points + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The points where you want to evaluate the variables + - name: scaling + required: No + default: !!str 1 + cpp_type: PostprocessorName + group_name: + description: | + The postprocessor that the variables are multiplied with + - name: sort_by + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z id + description: | + What to sort the samples by + - name: type + required: No + default: !!str PointValueSampler + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The names of the variables that this VectorPostprocessor operates on + subblocks: + - name: /VectorPostprocessors/SideValueSampler + description: | + + parameters: + - name: _auto_broadcast + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: sort_by + required: Yes + default: !!str + cpp_type: MooseEnum + group_name: + options: x y z id + description: | + What to sort the samples by + - name: type + required: No + default: !!str SideValueSampler + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: Yes + default: !!str + cpp_type: std::vector + group_name: + description: | + The names of the variables that this VectorPostprocessor operates on + subblocks: + - name: /VectorPostprocessors/SidesetInfoVectorPostprocessor + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: boundary + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of boundary IDs from the mesh where this boundary condition applies + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: meta_data_types + required: No + default: !!str + cpp_type: MultiMooseEnum + group_name: + options: centroid min max area + description: | + Data types that are obtained and written to file. + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: type + required: No + default: !!str SidesetInfoVectorPostprocessor + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /VectorPostprocessors/SphericalAverage + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: bin_number + required: No + default: !!str 50 + cpp_type: unsigned int + group_name: + description: | + Number of histogram bins + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: empty_bin_value + required: No + default: !!str 0 + cpp_type: double + group_name: + description: | + Value to assign to bins into which no datapoints fall + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: origin + required: No + default: !!str 0 0 0 + cpp_type: libMesh::Point + group_name: + description: | + Origin of the cylinder + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: radius + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Radius to average out to + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str SphericalAverage + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + Variables to average radially + subblocks: + - name: /VectorPostprocessors/VectorMemoryUsage + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: mem_units + required: No + default: !!str mebibytes + cpp_type: MooseEnum + group_name: + options: bytes kibibytes mebibytes gibibytes kilobytes megabytes gigabytes + description: | + The unit prefix used to report memory usage, default: Mebibytes + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: report_peak_value + required: No + default: !!str 1 + cpp_type: bool + group_name: + description: | + If the vectorpostprocessor is executed more than once during a time step, report the aggregated peak value. + - name: type + required: No + default: !!str VectorMemoryUsage + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /VectorPostprocessors/VectorOfPostprocessors + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: postprocessors + required: Yes + default: !!str + cpp_type: std::vector > + group_name: + description: | + The postprocessors whose values are to be reported + - name: type + required: No + default: !!str VectorOfPostprocessors + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: + - name: /VectorPostprocessors/VolumeHistogram + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: bin_number + required: No + default: !!str 50 + cpp_type: unsigned int + group_name: + description: | + Number of histogram bins + - name: block + required: No + default: !!str + cpp_type: std::vector > + group_name: + description: | + The list of block ids (SubdomainID) that this object will be applied + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: implicit + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Determines whether this object is calculated using an implicit or explicit form + - name: max_value + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Maximum variable value + - name: min_value + required: Yes + default: !!str + cpp_type: double + group_name: + description: | + Minimum variable value + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: seed + required: No + default: !!str 0 + cpp_type: unsigned int + group_name: 'Advanced' + description: | + The seed for the master random number generator + - name: type + required: No + default: !!str VolumeHistogram + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + - name: variable + required: No + default: !!str + cpp_type: std::vector + group_name: + description: | + Variable to bin the volume of + subblocks: + - name: /VectorPostprocessors/WorkBalance + description: | + + parameters: + - name: allow_duplicate_execution_on_initial + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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). + - name: balances + required: No + default: !!str num_elems num_nodes num_dofs num_partition_sides partition_surface_area num_partition_hardware_id_sides partition_hardware_id_surface_area + cpp_type: MultiMooseEnum + group_name: + options: num_elems num_nodes num_dofs num_partition_sides partition_surface_area num_partition_hardware_id_sides partition_hardware_id_surface_area + description: | + Which metrics do you want to use to represent word balance + - name: contains_complete_history + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Set this flag to indicate that the values in all vectors declared by this VPP represent a time history (e.g. with each invocation, new values are added and old values are never removed). This changes the output so that only a single file is output and updated with each invocation + - name: control_tags + required: No + default: !!str + cpp_type: std::vector, std::allocator >, std::allocator, std::allocator > > > + group_name: 'Advanced' + description: | + Adds user-defined labels for accessing object parameters via control logic. + - name: enable + required: No + default: !!str 1 + cpp_type: bool + group_name: 'Advanced' + description: | + Set the enabled status of the MooseObject. + - name: execute_on + required: No + default: !!str TIMESTEP_END + cpp_type: ExecFlagEnum + group_name: + description: | + The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM. + - name: force_preaux + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREAUX + - name: force_preic + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + description: | + Forces the GeneralUserObject to be executed in PREIC during initial setup + - name: outputs + required: No + default: !!str + cpp_type: std::vector > + group_name: 'Advanced' + description: | + Vector of output names were you would like to restrict the output of variables(s) associated with this object + - name: parallel_type + required: No + default: !!str REPLICATED + cpp_type: MooseEnum + group_name: + options: DISTRIBUTED REPLICATED + description: | + Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' indicates that data within the VPP is distributed and no auto communication is preformed, this setting will result in parallel output within the CSV output; 'replicated' indicates that the data within the VPP is correct on processor 0, the data will automatically be broadcast to all processors unless the '_auto_broadcast' param is set to false within the validParams function. + - name: sync_to_all_procs + required: No + default: !!str 0 + cpp_type: bool + group_name: + description: | + Whether or not to sync the vectors to all processors. By default we only sync them to processor 0 so they can be written out. Setting this to true will use more communication, but is necessary if you expect these vectors to be available on all processors + - name: system + required: No + default: !!str ALL + cpp_type: MooseEnum + group_name: + options: ALL NL AUX + description: | + The system(s) to retrieve the number of DOFs from (NL, AUX, ALL). Default == ALL + - name: type + required: No + default: !!str WorkBalance + cpp_type: std::__cxx11::basic_string, std::allocator > + group_name: + description: | + + - name: use_displaced_mesh + required: No + default: !!str 0 + cpp_type: bool + group_name: 'Advanced' + 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. + subblocks: +**END YAML DATA** diff --git a/test/include/base/PlatypusTestApp.h b/test/include/base/PlatypusTestApp.h new file mode 100644 index 00000000..ff8133e2 --- /dev/null +++ b/test/include/base/PlatypusTestApp.h @@ -0,0 +1,16 @@ +#pragma once + +#include "MooseApp.h" + +class PlatypusTestApp : public MooseApp +{ +public: + static InputParameters validParams(); + + PlatypusTestApp(InputParameters parameters); + virtual ~PlatypusTestApp(); + + static void registerApps(); + static void registerAll(Factory & f, ActionFactory & af, Syntax & s, bool use_test_objs = false); +}; + diff --git a/test/src/base/PlatypusTestApp.C b/test/src/base/PlatypusTestApp.C new file mode 100644 index 00000000..3102d674 --- /dev/null +++ b/test/src/base/PlatypusTestApp.C @@ -0,0 +1,54 @@ +#include "PlatypusTestApp.h" +#include "PlatypusApp.h" +#include "Moose.h" +#include "AppFactory.h" +#include "MooseSyntax.h" +#include "ModulesApp.h" + +InputParameters +PlatypusTestApp::validParams() +{ + InputParameters params = PlatypusApp::validParams(); + return params; +} + +PlatypusTestApp::PlatypusTestApp(InputParameters parameters) : MooseApp(parameters) +{ + PlatypusTestApp::registerAll( + _factory, _action_factory, _syntax, getParam("allow_test_objects")); +} + +PlatypusTestApp::~PlatypusTestApp() {} + +void +PlatypusTestApp::registerAll(Factory & f, ActionFactory & af, Syntax & s, bool use_test_objs) +{ + PlatypusApp::registerAll(f, af, s); + if (use_test_objs) + { + Registry::registerObjectsTo(f, {"PlatypusTestApp"}); + Registry::registerActionsTo(af, {"PlatypusTestApp"}); + } +} + +void +PlatypusTestApp::registerApps() +{ + registerApp(PlatypusApp); + registerApp(PlatypusTestApp); +} + +/*************************************************************************************************** + *********************** Dynamic Library Entry Points - DO NOT MODIFY ****************************** + **************************************************************************************************/ +// External entry point for dynamic application loading +extern "C" void +PlatypusTestApp__registerAll(Factory & f, ActionFactory & af, Syntax & s) +{ + PlatypusTestApp::registerAll(f, af, s); +} +extern "C" void +PlatypusTestApp__registerApps() +{ + PlatypusTestApp::registerApps(); +} diff --git a/test/src/base/StorkTestApp.C.module b/test/src/base/StorkTestApp.C.module new file mode 100644 index 00000000..89043483 --- /dev/null +++ b/test/src/base/StorkTestApp.C.module @@ -0,0 +1,53 @@ +#include "PlatypusTestApp.h" +#include "PlatypusApp.h" +#include "Moose.h" +#include "AppFactory.h" +#include "MooseSyntax.h" + +InputParameters +PlatypusTestApp::validParams() +{ + InputParameters params = PlatypusApp::validParams(); + return params; +} + +PlatypusTestApp::PlatypusTestApp(InputParameters parameters) : MooseApp(parameters) +{ + PlatypusTestApp::registerAll( + _factory, _action_factory, _syntax, getParam("allow_test_objects")); +} + +PlatypusTestApp::~PlatypusTestApp() {} + +void +PlatypusTestApp::registerAll(Factory & f, ActionFactory & af, Syntax & s, bool use_test_objs) +{ + PlatypusApp::registerAll(f, af, s); + if (use_test_objs) + { + Registry::registerObjectsTo(f, {"PlatypusTestApp"}); + Registry::registerActionsTo(af, {"PlatypusTestApp"}); + } +} + +void +PlatypusTestApp::registerApps() +{ + registerApp(PlatypusApp); + registerApp(PlatypusTestApp); +} + +/*************************************************************************************************** + *********************** Dynamic Library Entry Points - DO NOT MODIFY ****************************** + **************************************************************************************************/ +// External entry point for dynamic application loading +extern "C" void +PlatypusTestApp__registerAll(Factory & f, ActionFactory & af, Syntax & s) +{ + PlatypusTestApp::registerAll(f, af, s); +} +extern "C" void +PlatypusTestApp__registerApps() +{ + PlatypusTestApp::registerApps(); +} diff --git a/test/tests/unit/auxkernels/gold/lagrange_vector_variable_from_components_aux_out.csv b/test/tests/unit/auxkernels/gold/lagrange_vector_variable_from_components_aux_out.csv new file mode 100644 index 00000000..fdd6d7b6 --- /dev/null +++ b/test/tests/unit/auxkernels/gold/lagrange_vector_variable_from_components_aux_out.csv @@ -0,0 +1,3 @@ +time,element_l2_difference +0,0 +1,0 diff --git a/test/tests/unit/auxkernels/gold/lagrange_vector_variable_to_components_aux_out.csv b/test/tests/unit/auxkernels/gold/lagrange_vector_variable_to_components_aux_out.csv new file mode 100644 index 00000000..c46f53fb --- /dev/null +++ b/test/tests/unit/auxkernels/gold/lagrange_vector_variable_to_components_aux_out.csv @@ -0,0 +1,3 @@ +time,compare_x,compare_y,compare_z +0,0,0,0 +1,0,0,0 diff --git a/test/tests/unit/auxkernels/gold/monomial_vector_variable_from_components_aux_out.csv b/test/tests/unit/auxkernels/gold/monomial_vector_variable_from_components_aux_out.csv new file mode 100644 index 00000000..fdd6d7b6 --- /dev/null +++ b/test/tests/unit/auxkernels/gold/monomial_vector_variable_from_components_aux_out.csv @@ -0,0 +1,3 @@ +time,element_l2_difference +0,0 +1,0 diff --git a/test/tests/unit/auxkernels/gold/monomial_vector_variable_to_components_aux_out.csv b/test/tests/unit/auxkernels/gold/monomial_vector_variable_to_components_aux_out.csv new file mode 100644 index 00000000..7f67f21a --- /dev/null +++ b/test/tests/unit/auxkernels/gold/monomial_vector_variable_to_components_aux_out.csv @@ -0,0 +1,3 @@ +time,compare_x,compare_y,compare_z +0,0,0,0 +1,8.7075427791676e-14,8.6684069026608e-14,9.7976825775776e-14 diff --git a/test/tests/unit/auxkernels/lagrange_vector_variable_from_components_aux.i b/test/tests/unit/auxkernels/lagrange_vector_variable_from_components_aux.i new file mode 100644 index 00000000..9fbeb202 --- /dev/null +++ b/test/tests/unit/auxkernels/lagrange_vector_variable_from_components_aux.i @@ -0,0 +1,119 @@ +[Mesh] + type = GeneratedMesh + nx = 5 + ny = 5 + nz = 5 + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [test_vector] + family = LAGRANGE_VEC + order = FIRST + [] + + [target_vector] + family = LAGRANGE_VEC + order = FIRST + [] + + [target_x] + family = LAGRANGE + order = FIRST + [] + + [target_y] + family = LAGRANGE + order = FIRST + [] + + [target_z] + family = LAGRANGE + order = FIRST + [] +[] + +[AuxKernels] + [set_test_vector_from_target_components] + type = VectorVariableFromComponentsAux + variable = test_vector + component_x = target_x + component_y = target_y + component_z = target_z + execute_on = timestep_end + [] +[] + +[Functions] + [function_target_x] + type = ParsedFunction + expression = '100*x' + [] + + [function_target_y] + type = ParsedFunction + expression = '100*y' + [] + + [function_target_z] + type = ParsedFunction + expression = '100*z' + [] + + [function_target] + type = ParsedVectorFunction + expression_x = '100*x' + expression_y = '100*y' + expression_z = '100*z' + [] +[] + +[ICs] + [set_target_x] + type = FunctionIC + variable = target_x + function = function_target_x + [] + + [set_target_y] + type = FunctionIC + variable = target_y + function = function_target_y + [] + + [set_target_z] + type = FunctionIC + variable = target_z + function = function_target_z + [] + + [set_target_vector] + type = VectorFunctionIC + variable = target_vector + function = function_target + [] +[] + +[Postprocessors] + [element_l2_difference] + type = ElementVectorL2Difference + variable = target_vector + other_variable = test_vector + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true + exodus = false +[] diff --git a/test/tests/unit/auxkernels/lagrange_vector_variable_to_components_aux.i b/test/tests/unit/auxkernels/lagrange_vector_variable_to_components_aux.i new file mode 100644 index 00000000..6466378c --- /dev/null +++ b/test/tests/unit/auxkernels/lagrange_vector_variable_to_components_aux.i @@ -0,0 +1,137 @@ +[Mesh] + type = GeneratedMesh + nx = 5 + ny = 5 + nz = 5 + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [target_vector] + family = LAGRANGE_VEC + order = FIRST + [] + + [target_x] + family = LAGRANGE + order = FIRST + [] + + [target_y] + family = LAGRANGE + order = FIRST + [] + + [target_z] + family = LAGRANGE + order = FIRST + [] + + [test_x] + family = LAGRANGE + order = FIRST + [] + + [test_y] + family = LAGRANGE + order = FIRST + [] + + [test_z] + family = LAGRANGE + order = FIRST + [] +[] + +[Functions] + [function_target] + type = ParsedVectorFunction + expression_x = '100*x' + expression_y = '100*y' + expression_z = '100*z' + [] +[] + +[ICs] + # 1. Setup our target vector. + [set_target_vector] + type = VectorFunctionIC + variable = target_vector + function = function_target + [] +[] + +[AuxKernels] + # 2. Set x y z target components using MOOSE AuxKernel. + # These will be used for comparison with test_x/y/z. + [set_target_x] + type = VectorVariableComponentAux + variable = target_x + vector_variable = target_vector + component = 'x' + execute_on = timestep_end + [] + + [set_target_y] + type = VectorVariableComponentAux + variable = target_y + vector_variable = target_vector + component = 'y' + execute_on = timestep_end + [] + + [set_target_z] + type = VectorVariableComponentAux + variable = target_z + vector_variable = target_vector + component = 'z' + execute_on = timestep_end + [] + + # 3. Set x y z test components in one step using custom AuxKernel. + [set_components_from_target_vector] + type = VectorVariableToComponentsAux + variable = target_vector + component_x = test_x + component_y = test_y + component_z = test_z + execute_on = timestep_end + [] +[] + +[Postprocessors] + # 4. Compare test and target components. Should match! + [compare_x] + type = ElementL2Difference + variable = test_x + other_variable = target_x + [] + + [compare_y] + type = ElementL2Difference + variable = test_y + other_variable = target_y + [] + + [compare_z] + type = ElementL2Difference + variable = test_z + other_variable = target_z + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true + exodus = false +[] diff --git a/test/tests/unit/auxkernels/monomial_vector_variable_from_components_aux.i b/test/tests/unit/auxkernels/monomial_vector_variable_from_components_aux.i new file mode 100644 index 00000000..463b9226 --- /dev/null +++ b/test/tests/unit/auxkernels/monomial_vector_variable_from_components_aux.i @@ -0,0 +1,119 @@ +[Mesh] + type = GeneratedMesh + nx = 5 + ny = 5 + nz = 5 + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [test_vector] + family = MONOMIAL_VEC + order = CONSTANT + [] + + [target_vector] + family = MONOMIAL_VEC + order = CONSTANT + [] + + [target_x] + family = MONOMIAL + order = CONSTANT + [] + + [target_y] + family = MONOMIAL + order = CONSTANT + [] + + [target_z] + family = MONOMIAL + order = CONSTANT + [] +[] + +[AuxKernels] + [set_test_vector_from_target_components] + type = VectorVariableFromComponentsAux + variable = test_vector + component_x = target_x + component_y = target_y + component_z = target_z + execute_on = timestep_end + [] +[] + +[Functions] + [function_target_x] + type = ParsedFunction + expression = '100*x' + [] + + [function_target_y] + type = ParsedFunction + expression = '100*y' + [] + + [function_target_z] + type = ParsedFunction + expression = '100*z' + [] + + [function_target] + type = ParsedVectorFunction + expression_x = '100*x' + expression_y = '100*y' + expression_z = '100*z' + [] +[] + +[ICs] + [set_target_x] + type = FunctionIC + variable = target_x + function = function_target_x + [] + + [set_target_y] + type = FunctionIC + variable = target_y + function = function_target_y + [] + + [set_target_z] + type = FunctionIC + variable = target_z + function = function_target_z + [] + + [set_target_vector] + type = VectorFunctionIC + variable = target_vector + function = function_target + [] +[] + +[Postprocessors] + [element_l2_difference] + type = ElementVectorL2Difference + variable = target_vector + other_variable = test_vector + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true + exodus = false +[] diff --git a/test/tests/unit/auxkernels/monomial_vector_variable_to_components_aux.i b/test/tests/unit/auxkernels/monomial_vector_variable_to_components_aux.i new file mode 100644 index 00000000..84b50ff1 --- /dev/null +++ b/test/tests/unit/auxkernels/monomial_vector_variable_to_components_aux.i @@ -0,0 +1,137 @@ +[Mesh] + type = GeneratedMesh + nx = 5 + ny = 5 + nz = 5 + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [target_vector] + family = MONOMIAL_VEC + order = CONSTANT + [] + + [target_x] + family = MONOMIAL + order = CONSTANT + [] + + [target_y] + family = MONOMIAL + order = CONSTANT + [] + + [target_z] + family = MONOMIAL + order = CONSTANT + [] + + [test_x] + family = MONOMIAL + order = CONSTANT + [] + + [test_y] + family = MONOMIAL + order = CONSTANT + [] + + [test_z] + family = MONOMIAL + order = CONSTANT + [] +[] + +[Functions] + [function_target] + type = ParsedVectorFunction + expression_x = '100*x' + expression_y = '100*y' + expression_z = '100*z' + [] +[] + +[ICs] + # 1. Setup our target vector. + [set_target_vector] + type = VectorFunctionIC + variable = target_vector + function = function_target + [] +[] + +[AuxKernels] + # 2. Set x y z target components using MOOSE AuxKernel. + # These will be used for comparison with test_x/y/z. + [set_target_x] + type = VectorVariableComponentAux + variable = target_x + vector_variable = target_vector + component = 'x' + execute_on = timestep_end + [] + + [set_target_y] + type = VectorVariableComponentAux + variable = target_y + vector_variable = target_vector + component = 'y' + execute_on = timestep_end + [] + + [set_target_z] + type = VectorVariableComponentAux + variable = target_z + vector_variable = target_vector + component = 'z' + execute_on = timestep_end + [] + + # 3. Set x y z test components in one step using custom AuxKernel. + [set_components_from_target_vector] + type = VectorVariableToComponentsAux + variable = target_vector + component_x = test_x + component_y = test_y + component_z = test_z + execute_on = timestep_end + [] +[] + +[Postprocessors] + # 4. Compare test and target components. Should match! + [compare_x] + type = ElementL2Difference + variable = test_x + other_variable = target_x + [] + + [compare_y] + type = ElementL2Difference + variable = test_y + other_variable = target_y + [] + + [compare_z] + type = ElementL2Difference + variable = test_z + other_variable = target_z + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true + exodus = false +[] diff --git a/test/tests/unit/auxkernels/tests b/test/tests/unit/auxkernels/tests new file mode 100644 index 00000000..09bc57eb --- /dev/null +++ b/test/tests/unit/auxkernels/tests @@ -0,0 +1,30 @@ +[Tests] + design = 'syntax/Problem/index.md' + [./LagrangeVectorVariableFromComponentsAux] + type = 'CSVDiff' + input = 'lagrange_vector_variable_from_components_aux.i' + csvdiff = 'lagrange_vector_variable_from_components_aux_out.csv' + requirement = 'Platypus shall have the ability to build a Lagrange vector variable from three standard Lagrange variables.' + [] + + [./MonomialVectorVariableFromComponentsAux] + type = 'CSVDiff' + input = 'monomial_vector_variable_from_components_aux.i' + csvdiff = 'monomial_vector_variable_from_components_aux_out.csv' + requirement = 'Platypus shall have the ability to build a Monomial vector variable from three standard Monomial variables.' + [] + + [./LagrangeVectorVariableToComponentsAux] + type = 'CSVDiff' + input = 'lagrange_vector_variable_to_components_aux.i' + csvdiff = 'lagrange_vector_variable_to_components_aux_out.csv' + requirement = 'Platypus shall have the ability to extract the components from a Lagrange vector variable.' + [] + + [./MonomialVectorVariableToComponentsAux] + type = 'CSVDiff' + input = 'monomial_vector_variable_to_components_aux.i' + csvdiff = 'monomial_vector_variable_to_components_aux_out.csv' + requirement = 'Platypus shall have the ability to extract the components from a constant-order Monomial vector variable.' + [] +[] diff --git a/test/tests/unit/kernels/diffusion_master.i b/test/tests/unit/kernels/diffusion_master.i new file mode 100644 index 00000000..7c4c7618 --- /dev/null +++ b/test/tests/unit/kernels/diffusion_master.i @@ -0,0 +1,86 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/mug.e + dim = 3 +[] + +[Variables] + [./moose_diffused] + family = LAGRANGE + order = FIRST + [../] +[] + +[AuxVariables] + [./mfem_diffused] + family = LAGRANGE + order = FIRST + [../] +[] + +[Kernels] + [diff] + type = Diffusion + variable = moose_diffused + [] +[] + +[BCs] + [bottom] + type = DirichletBC + variable = moose_diffused + boundary = 'bottom' + value = 1 + [] + + [top] + type = DirichletBC + variable = moose_diffused + boundary = 'top' + value = 0 + [] +[] + +[Postprocessors] + [./l2_difference] + type = ElementL2Difference + variable = moose_diffused + other_variable = mfem_diffused + [../] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true + exodus = true +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'diffusion_mfem.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [pull_diffused] + type = MultiAppNearestNodeTransfer + + # Transfer from the sub-app to this app + from_multi_app = sub_app + + # The name of the variable in the sub-app + source_variable = mfem_diffused + + # The name of the auxiliary variable in this app + variable = mfem_diffused + [] +[] diff --git a/test/tests/unit/kernels/diffusion_mfem.i b/test/tests/unit/kernels/diffusion_mfem.i new file mode 100644 index 00000000..d960cde4 --- /dev/null +++ b/test/tests/unit/kernels/diffusion_mfem.i @@ -0,0 +1,87 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/mug.e + dim = 3 +[] + +[Problem] + type = MFEMProblem + use_glvis = true +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [mfem_diffused] + family = LAGRANGE + order = FIRST + [] +[] + +[Functions] + [value_bottom] + type = ParsedFunction + value = 1.0 + [] + [value_top] + type = ParsedFunction + value = 0.0 + [] +[] + +[BCs] + [bottom] + type = MFEMScalarDirichletBC + variable = mfem_diffused + boundary = '1' + coefficient = BottomValue + [] + [low_terminal] + type = MFEMScalarDirichletBC + variable = mfem_diffused + boundary = '2' + coefficient = TopValue + [] +[] + +[Coefficients] + [one] + type = MFEMConstantCoefficient + value = 1.0 + [] + [TopValue] + type = MFEMFunctionCoefficient + function = value_top + [] + [BottomValue] + type = MFEMFunctionCoefficient + function = value_bottom + [] +[] + +[Kernels] + [diff] + type = MFEMDiffusionKernel + variable = mfem_diffused + coefficient = one + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 + + l_tol = 1e-16 + l_max_its = 1000 +[] + +[Outputs] + [VisItDataCollection] + type = MFEMVisItDataCollection + file_base = OutputData/Diffusion + [] +[] diff --git a/test/tests/unit/kernels/gold/diffusion_master_out.csv b/test/tests/unit/kernels/gold/diffusion_master_out.csv new file mode 100644 index 00000000..cf1a7a8c --- /dev/null +++ b/test/tests/unit/kernels/gold/diffusion_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,1.1939933806136e-06 diff --git a/test/tests/unit/kernels/gold/mug.e b/test/tests/unit/kernels/gold/mug.e new file mode 100644 index 00000000..6770d8dd Binary files /dev/null and b/test/tests/unit/kernels/gold/mug.e differ diff --git a/test/tests/unit/kernels/tests b/test/tests/unit/kernels/tests new file mode 100644 index 00000000..6fe2eca0 --- /dev/null +++ b/test/tests/unit/kernels/tests @@ -0,0 +1,9 @@ +[Tests] + design = 'syntax/Problem/index.md' + [./MFEMDiffusion] + type = 'CSVDiff' + input = 'diffusion_master.i' + csvdiff = 'diffusion_master_out.csv' + requirement = 'Platypus shall have the ability to solve a diffusion problem set up from MOOSE and produce the same result as a native run.' + [] +[] diff --git a/test/tests/unit/outputs/gold/simple-cube-tet10.e b/test/tests/unit/outputs/gold/simple-cube-tet10.e new file mode 100644 index 00000000..baddc534 Binary files /dev/null and b/test/tests/unit/outputs/gold/simple-cube-tet10.e differ diff --git a/test/tests/unit/outputs/output_master.i b/test/tests/unit/outputs/output_master.i new file mode 100644 index 00000000..5a11c646 --- /dev/null +++ b/test/tests/unit/outputs/output_master.i @@ -0,0 +1,75 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-tet10.e + dim = 3 +[] + +[Variables] + [moose_diffused] + family = LAGRANGE + order = FIRST + [] +[] + +[AuxVariables] + [mfem_diffused] + family = LAGRANGE + order = FIRST + [] +[] + +[Kernels] + [diff] + type = Diffusion + variable = moose_diffused + [] +[] + +[BCs] + [bottom] + type = DirichletBC + variable = moose_diffused + boundary = 'bottom' + value = 1 + [] + + [top] + type = DirichletBC + variable = moose_diffused + boundary = 'top' + value = 0 + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = moose_diffused + other_variable = mfem_diffused + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 2.0 + nl_abs_tol = 1e-5 + l_tol = 1e-5 +[] + +[Outputs] + csv = true + exodus = true +[] + +[MultiApps] + [sub_app] + type = FullSolveMultiApp + positions = '0 0 0' + input_files = 'output_mfem.i' + execute_on = timestep_begin + keep_full_output_history = true + [] +[] + diff --git a/test/tests/unit/outputs/output_mfem.i b/test/tests/unit/outputs/output_mfem.i new file mode 100644 index 00000000..f8317362 --- /dev/null +++ b/test/tests/unit/outputs/output_mfem.i @@ -0,0 +1,76 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-tet10.e + dim = 3 +[] + +[Problem] + type = MFEMProblem + use_glvis = true +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [mfem_diffused] + family = LAGRANGE + order = FIRST + [] +[] + +[BCs] + [bottom] + type = MFEMScalarDirichletBC + variable = mfem_diffused + boundary = '1' + coefficient = BottomValue + [] + [low_terminal] + type = MFEMScalarDirichletBC + variable = mfem_diffused + boundary = '2' + coefficient = TopValue + [] +[] + +[Coefficients] + [one] + type = MFEMConstantCoefficient + value = 1.0 + [] + [TopValue] + type = MFEMConstantCoefficient + value = 0 + [] + [BottomValue] + type = MFEMConstantCoefficient + value = 1 + [] +[] + +[Kernels] + [diff] + type = MFEMDiffusionKernel + variable = mfem_diffused + coefficient = one + [] +[] + +[Executioner] + type = Transient + dt = 0.1 + start_time = 0.0 + end_time = 0.1 + + l_tol = 1e-5 + l_max_its = 1000 +[] + +[Outputs] + [ParaViewDataCollection] + type = MFEMParaViewDataCollection + file_base = OutputData/ParaViewCoil + [] +[] diff --git a/test/tests/unit/outputs/tests b/test/tests/unit/outputs/tests new file mode 100644 index 00000000..a08d338c --- /dev/null +++ b/test/tests/unit/outputs/tests @@ -0,0 +1,14 @@ +[Tests] + design = 'syntax/Problem/index.md' + [MFEMOutputs] + type = CheckFiles + input = output_master.i + check_files = 'OutputData/ParaViewCoil/Run0/Run0.pvd + OutputData/ParaViewCoil/Run1/Run1.pvd + OutputData/ParaViewCoil/Run0/Cycle000000/data.pvtu + OutputData/ParaViewCoil/Run0/Cycle000001/data.pvtu + OutputData/ParaViewCoil/Run1/Cycle000000/data.pvtu + OutputData/ParaViewCoil/Run1/Cycle000001/data.pvtu' + requirement = 'Platypus shall have the ability to create DataCollections saved to enumerated folders when called in a FullSolveMultiApps.' + [] +[] diff --git a/test/tests/unit/postprocessors/gold/lagrange_vector_l2_difference_out.csv b/test/tests/unit/postprocessors/gold/lagrange_vector_l2_difference_out.csv new file mode 100644 index 00000000..90ca55b3 --- /dev/null +++ b/test/tests/unit/postprocessors/gold/lagrange_vector_l2_difference_out.csv @@ -0,0 +1,3 @@ +time,primary_secondary_difference,primary_tertiary_difference +0,0,0 +1,99.498743710662,0 diff --git a/test/tests/unit/postprocessors/gold/monomial_vector_l2_difference_out.csv b/test/tests/unit/postprocessors/gold/monomial_vector_l2_difference_out.csv new file mode 100644 index 00000000..90ca55b3 --- /dev/null +++ b/test/tests/unit/postprocessors/gold/monomial_vector_l2_difference_out.csv @@ -0,0 +1,3 @@ +time,primary_secondary_difference,primary_tertiary_difference +0,0,0 +1,99.498743710662,0 diff --git a/test/tests/unit/postprocessors/lagrange_vector_l2_difference.i b/test/tests/unit/postprocessors/lagrange_vector_l2_difference.i new file mode 100644 index 00000000..af0defd5 --- /dev/null +++ b/test/tests/unit/postprocessors/lagrange_vector_l2_difference.i @@ -0,0 +1,96 @@ +[Mesh] + type = GeneratedMesh + nx = 5 + ny = 5 + nz = 5 + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [primary_lagrange_vector] + family = LAGRANGE_VEC + order = FIRST + [] + + [secondary_lagrange_vector] + family = LAGRANGE_VEC + order = FIRST + [] + + [tertiary_lagrange_vector] + family = LAGRANGE_VEC + order = FIRST + [] +[] + +[Functions] + [primary_function] + type = ParsedVectorFunction + expression_x = '100*x' + expression_y = '100*y' + expression_z = '100*z' + [] + + [secondary_function] + type = ParsedVectorFunction + expression_x = '0' + expression_y = '0' + expression_z = '0' + [] + + [tertiary_function] + type = ParsedVectorFunction + expression_x = '100*x' + expression_y = '100*y' + expression_z = '100*z' + [] +[] + +[ICs] + [primary_ic] + type = VectorFunctionIC + variable = primary_lagrange_vector + function = primary_function + [] + + [secondary_ic] + type = VectorFunctionIC + variable = secondary_lagrange_vector + function = secondary_function + [] + + [tertiary_ic] + type = VectorFunctionIC + variable = tertiary_lagrange_vector + function = tertiary_function + [] +[] + +[Postprocessors] + [primary_secondary_difference] + type = ElementVectorL2Difference + variable = primary_lagrange_vector + other_variable = secondary_lagrange_vector + [] + + [primary_tertiary_difference] + type = ElementVectorL2Difference + variable = primary_lagrange_vector + other_variable = tertiary_lagrange_vector + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] diff --git a/test/tests/unit/postprocessors/monomial_vector_l2_difference.i b/test/tests/unit/postprocessors/monomial_vector_l2_difference.i new file mode 100644 index 00000000..5d239221 --- /dev/null +++ b/test/tests/unit/postprocessors/monomial_vector_l2_difference.i @@ -0,0 +1,97 @@ +[Mesh] + type = GeneratedMesh + nx = 5 + ny = 5 + nz = 5 + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [primary_monomial_vector] + family = MONOMIAL_VEC + order = CONSTANT + [] + + [secondary_monomial_vector] + family = MONOMIAL_VEC + order = CONSTANT + [] + + [tertiary_monomial_vector] + family = MONOMIAL_VEC + order = CONSTANT + [] +[] + +[Functions] + [primary_function] + type = ParsedVectorFunction + expression_x = '100*x' + expression_y = '100*y' + expression_z = '100*z' + [] + + [secondary_function] + type = ParsedVectorFunction + expression_x = '0' + expression_y = '0' + expression_z = '0' + [] + + [tertiary_function] + type = ParsedVectorFunction + expression_x = '100*x' + expression_y = '100*y' + expression_z = '100*z' + [] +[] + +[ICs] + [primary_ic] + type = VectorFunctionIC + variable = primary_monomial_vector + function = primary_function + [] + + [secondary_ic] + type = VectorFunctionIC + variable = secondary_monomial_vector + function = secondary_function + [] + + [tertiary_ic] + type = VectorFunctionIC + variable = tertiary_monomial_vector + function = tertiary_function + [] +[] + +[Postprocessors] + [primary_secondary_difference] + type = ElementVectorL2Difference + variable = primary_monomial_vector + other_variable = secondary_monomial_vector + [] + + [primary_tertiary_difference] + type = ElementVectorL2Difference + variable = primary_monomial_vector + other_variable = tertiary_monomial_vector + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true + exodus = false +[] diff --git a/test/tests/unit/postprocessors/tests b/test/tests/unit/postprocessors/tests new file mode 100644 index 00000000..147be0c9 --- /dev/null +++ b/test/tests/unit/postprocessors/tests @@ -0,0 +1,16 @@ +[Tests] + design = 'syntax/Problem/index.md' + [./LagrangeVectorL2Difference] + type = 'CSVDiff' + input = 'lagrange_vector_l2_difference.i' + csvdiff = 'lagrange_vector_l2_difference_out.csv' + requirement = 'Platypus shall have the ability to compute the element-wise l2 difference between Lagrange vector variables.' + [] + + [./MonomialVectorL2Difference] + type = 'CSVDiff' + input = 'monomial_vector_l2_difference.i' + csvdiff = 'monomial_vector_l2_difference_out.csv' + requirement = 'Platypus shall have the ability to compute the element-wise l2 difference between Monomial vector variables.' + [] +[] diff --git a/test/tests/unit/transfers/gold/cylinder-hex-q2.e b/test/tests/unit/transfers/gold/cylinder-hex-q2.e new file mode 100644 index 00000000..d8f1a83b Binary files /dev/null and b/test/tests/unit/transfers/gold/cylinder-hex-q2.e differ diff --git a/test/tests/unit/transfers/gold/cylinder_fo.e b/test/tests/unit/transfers/gold/cylinder_fo.e new file mode 100644 index 00000000..91a8dd30 Binary files /dev/null and b/test/tests/unit/transfers/gold/cylinder_fo.e differ diff --git a/test/tests/unit/transfers/gold/elemental_var_coupled_out.e b/test/tests/unit/transfers/gold/elemental_var_coupled_out.e new file mode 100644 index 00000000..e263034e Binary files /dev/null and b/test/tests/unit/transfers/gold/elemental_var_coupled_out.e differ diff --git a/test/tests/unit/transfers/gold/fo_nodal_var_coupled_out.e b/test/tests/unit/transfers/gold/fo_nodal_var_coupled_out.e new file mode 100644 index 00000000..2b9db2fc Binary files /dev/null and b/test/tests/unit/transfers/gold/fo_nodal_var_coupled_out.e differ diff --git a/test/tests/unit/transfers/gold/nodal_var_coupled_out.e b/test/tests/unit/transfers/gold/nodal_var_coupled_out.e new file mode 100644 index 00000000..f7166edd Binary files /dev/null and b/test/tests/unit/transfers/gold/nodal_var_coupled_out.e differ diff --git a/test/tests/unit/transfers/gold/pull_hex27_transfer_master_out.csv b/test/tests/unit/transfers/gold/pull_hex27_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/pull_hex27_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/pull_hex8_transfer_master_out.csv b/test/tests/unit/transfers/gold/pull_hex8_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/pull_hex8_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/pull_multi_element_order1_transfer_master_out.csv b/test/tests/unit/transfers/gold/pull_multi_element_order1_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/pull_multi_element_order1_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/pull_multi_element_order2_transfer_master_out.csv b/test/tests/unit/transfers/gold/pull_multi_element_order2_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/pull_multi_element_order2_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/pull_pyramid5_transfer_master_out.csv b/test/tests/unit/transfers/gold/pull_pyramid5_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/pull_pyramid5_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/pull_tet10_transfer_master_out.csv b/test/tests/unit/transfers/gold/pull_tet10_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/pull_tet10_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/pull_tet4_transfer_master_out.csv b/test/tests/unit/transfers/gold/pull_tet4_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/pull_tet4_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/pull_wedge18_transfer_master_out.csv b/test/tests/unit/transfers/gold/pull_wedge18_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/pull_wedge18_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/pull_wedge6_transfer_master_out.csv b/test/tests/unit/transfers/gold/pull_wedge6_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/pull_wedge6_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/push_pull_hex27_transfer_master_out.csv b/test/tests/unit/transfers/gold/push_pull_hex27_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/push_pull_hex27_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/push_pull_hex8_transfer_master_out.csv b/test/tests/unit/transfers/gold/push_pull_hex8_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/push_pull_hex8_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/push_pull_multi_element_order1_distributed_transfer_master_out.csv b/test/tests/unit/transfers/gold/push_pull_multi_element_order1_distributed_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/push_pull_multi_element_order1_distributed_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/push_pull_multi_element_order1_monomial_transfer_master_out.csv b/test/tests/unit/transfers/gold/push_pull_multi_element_order1_monomial_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/push_pull_multi_element_order1_monomial_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/push_pull_multi_element_order1_transfer_master_out.csv b/test/tests/unit/transfers/gold/push_pull_multi_element_order1_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/push_pull_multi_element_order1_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/push_pull_multi_element_order2_distributed_transfer_master_out.csv b/test/tests/unit/transfers/gold/push_pull_multi_element_order2_distributed_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/push_pull_multi_element_order2_distributed_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/push_pull_multi_element_order2_transfer_master_out.csv b/test/tests/unit/transfers/gold/push_pull_multi_element_order2_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/push_pull_multi_element_order2_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/push_pull_pyramid5_transfer_master_out.csv b/test/tests/unit/transfers/gold/push_pull_pyramid5_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/push_pull_pyramid5_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/push_pull_tet10_transfer_master_out.csv b/test/tests/unit/transfers/gold/push_pull_tet10_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/push_pull_tet10_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/push_pull_tet4_transfer_master_out.csv b/test/tests/unit/transfers/gold/push_pull_tet4_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/push_pull_tet4_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/push_pull_wedge18_distributed_transfer_master_out.csv b/test/tests/unit/transfers/gold/push_pull_wedge18_distributed_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/push_pull_wedge18_distributed_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/push_pull_wedge18_transfer_master_out.csv b/test/tests/unit/transfers/gold/push_pull_wedge18_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/push_pull_wedge18_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/push_pull_wedge6_transfer_master_out.csv b/test/tests/unit/transfers/gold/push_pull_wedge6_transfer_master_out.csv new file mode 100644 index 00000000..9d1f27dd --- /dev/null +++ b/test/tests/unit/transfers/gold/push_pull_wedge6_transfer_master_out.csv @@ -0,0 +1,3 @@ +time,l2_difference +0,0 +1,0 diff --git a/test/tests/unit/transfers/gold/simple-cube-hex27.e b/test/tests/unit/transfers/gold/simple-cube-hex27.e new file mode 100644 index 00000000..9a0a75da Binary files /dev/null and b/test/tests/unit/transfers/gold/simple-cube-hex27.e differ diff --git a/test/tests/unit/transfers/gold/simple-cube-hex8.e b/test/tests/unit/transfers/gold/simple-cube-hex8.e new file mode 100644 index 00000000..9c8b3a32 Binary files /dev/null and b/test/tests/unit/transfers/gold/simple-cube-hex8.e differ diff --git a/test/tests/unit/transfers/gold/simple-cube-multi-element-order1.e b/test/tests/unit/transfers/gold/simple-cube-multi-element-order1.e new file mode 100644 index 00000000..36774d00 Binary files /dev/null and b/test/tests/unit/transfers/gold/simple-cube-multi-element-order1.e differ diff --git a/test/tests/unit/transfers/gold/simple-cube-multi-element-order2.e b/test/tests/unit/transfers/gold/simple-cube-multi-element-order2.e new file mode 100644 index 00000000..115d70ff Binary files /dev/null and b/test/tests/unit/transfers/gold/simple-cube-multi-element-order2.e differ diff --git a/test/tests/unit/transfers/gold/simple-cube-pyramid5.e b/test/tests/unit/transfers/gold/simple-cube-pyramid5.e new file mode 100644 index 00000000..e77962a7 Binary files /dev/null and b/test/tests/unit/transfers/gold/simple-cube-pyramid5.e differ diff --git a/test/tests/unit/transfers/gold/simple-cube-tet10.e b/test/tests/unit/transfers/gold/simple-cube-tet10.e new file mode 100644 index 00000000..baddc534 Binary files /dev/null and b/test/tests/unit/transfers/gold/simple-cube-tet10.e differ diff --git a/test/tests/unit/transfers/gold/simple-cube-tet4.e b/test/tests/unit/transfers/gold/simple-cube-tet4.e new file mode 100644 index 00000000..ff6f4fdf Binary files /dev/null and b/test/tests/unit/transfers/gold/simple-cube-tet4.e differ diff --git a/test/tests/unit/transfers/gold/simple-cube-wedge18.e b/test/tests/unit/transfers/gold/simple-cube-wedge18.e new file mode 100644 index 00000000..e1337eff Binary files /dev/null and b/test/tests/unit/transfers/gold/simple-cube-wedge18.e differ diff --git a/test/tests/unit/transfers/gold/simple-cube-wedge6.e b/test/tests/unit/transfers/gold/simple-cube-wedge6.e new file mode 100644 index 00000000..7d1ecce4 Binary files /dev/null and b/test/tests/unit/transfers/gold/simple-cube-wedge6.e differ diff --git a/test/tests/unit/transfers/pull_hex27_transfer_master.i b/test/tests/unit/transfers/pull_hex27_transfer_master.i new file mode 100644 index 00000000..c3ba5978 --- /dev/null +++ b/test/tests/unit/transfers/pull_hex27_transfer_master.i @@ -0,0 +1,73 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-hex27.e + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [received_variable] + family = LAGRANGE + order = SECOND + [] + + [expected_variable] + family = LAGRANGE + order = SECOND + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = expected_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = expected_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'pull_hex27_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = sent_variable + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/pull_hex27_transfer_sub_app.i b/test/tests/unit/transfers/pull_hex27_transfer_sub_app.i new file mode 100644 index 00000000..6685f5a4 --- /dev/null +++ b/test/tests/unit/transfers/pull_hex27_transfer_sub_app.i @@ -0,0 +1,43 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-hex27.e + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [sent_variable] + family = LAGRANGE + order = SECOND + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/pull_hex8_transfer_master.i b/test/tests/unit/transfers/pull_hex8_transfer_master.i new file mode 100644 index 00000000..464670ff --- /dev/null +++ b/test/tests/unit/transfers/pull_hex8_transfer_master.i @@ -0,0 +1,73 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-hex8.e + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [received_variable] + family = LAGRANGE + order = FIRST + [] + + [expected_variable] + family = LAGRANGE + order = FIRST + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = expected_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = expected_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'pull_hex8_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = sent_variable + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/pull_hex8_transfer_sub_app.i b/test/tests/unit/transfers/pull_hex8_transfer_sub_app.i new file mode 100644 index 00000000..ba51182c --- /dev/null +++ b/test/tests/unit/transfers/pull_hex8_transfer_sub_app.i @@ -0,0 +1,43 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-hex8.e + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [sent_variable] + family = LAGRANGE + order = FIRST + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/pull_multi_element_order1_transfer_master.i b/test/tests/unit/transfers/pull_multi_element_order1_transfer_master.i new file mode 100644 index 00000000..ee07233e --- /dev/null +++ b/test/tests/unit/transfers/pull_multi_element_order1_transfer_master.i @@ -0,0 +1,73 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-multi-element-order1.e + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [received_variable] + family = LAGRANGE + order = FIRST + [] + + [expected_variable] + family = LAGRANGE + order = FIRST + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = expected_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = expected_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'pull_multi_element_order1_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = sent_variable + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/pull_multi_element_order1_transfer_sub_app.i b/test/tests/unit/transfers/pull_multi_element_order1_transfer_sub_app.i new file mode 100644 index 00000000..13950354 --- /dev/null +++ b/test/tests/unit/transfers/pull_multi_element_order1_transfer_sub_app.i @@ -0,0 +1,43 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-multi-element-order1.e + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [sent_variable] + family = LAGRANGE + order = FIRST + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/pull_multi_element_order2_transfer_master.i b/test/tests/unit/transfers/pull_multi_element_order2_transfer_master.i new file mode 100644 index 00000000..af441a6b --- /dev/null +++ b/test/tests/unit/transfers/pull_multi_element_order2_transfer_master.i @@ -0,0 +1,73 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-multi-element-order2.e + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [received_variable] + family = LAGRANGE + order = SECOND + [] + + [expected_variable] + family = LAGRANGE + order = SECOND + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = expected_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = expected_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'pull_multi_element_order2_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = sent_variable + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/pull_multi_element_order2_transfer_sub_app.i b/test/tests/unit/transfers/pull_multi_element_order2_transfer_sub_app.i new file mode 100644 index 00000000..71679f46 --- /dev/null +++ b/test/tests/unit/transfers/pull_multi_element_order2_transfer_sub_app.i @@ -0,0 +1,43 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-multi-element-order2.e + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [sent_variable] + family = LAGRANGE + order = SECOND + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/pull_pyramid5_transfer_master.i b/test/tests/unit/transfers/pull_pyramid5_transfer_master.i new file mode 100644 index 00000000..cd248df4 --- /dev/null +++ b/test/tests/unit/transfers/pull_pyramid5_transfer_master.i @@ -0,0 +1,73 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-pyramid5.e + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [received_variable] + family = LAGRANGE + order = FIRST + [] + + [expected_variable] + family = LAGRANGE + order = FIRST + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = expected_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = expected_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'pull_pyramid5_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = sent_variable + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/pull_pyramid5_transfer_sub_app.i b/test/tests/unit/transfers/pull_pyramid5_transfer_sub_app.i new file mode 100644 index 00000000..ddff5046 --- /dev/null +++ b/test/tests/unit/transfers/pull_pyramid5_transfer_sub_app.i @@ -0,0 +1,43 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-pyramid5.e + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [sent_variable] + family = LAGRANGE + order = FIRST + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/pull_tet10_transfer_master.i b/test/tests/unit/transfers/pull_tet10_transfer_master.i new file mode 100644 index 00000000..bf3f2564 --- /dev/null +++ b/test/tests/unit/transfers/pull_tet10_transfer_master.i @@ -0,0 +1,73 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-tet10.e + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [received_variable] + family = LAGRANGE + order = SECOND + [] + + [expected_variable] + family = LAGRANGE + order = SECOND + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = expected_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = expected_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'pull_tet10_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = sent_variable + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/pull_tet10_transfer_sub_app.i b/test/tests/unit/transfers/pull_tet10_transfer_sub_app.i new file mode 100644 index 00000000..af1b85bd --- /dev/null +++ b/test/tests/unit/transfers/pull_tet10_transfer_sub_app.i @@ -0,0 +1,43 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-tet10.e + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [sent_variable] + family = LAGRANGE + order = SECOND + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/pull_tet4_transfer_master.i b/test/tests/unit/transfers/pull_tet4_transfer_master.i new file mode 100644 index 00000000..5a58bfe0 --- /dev/null +++ b/test/tests/unit/transfers/pull_tet4_transfer_master.i @@ -0,0 +1,73 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-tet4.e + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [received_variable] + family = LAGRANGE + order = FIRST + [] + + [expected_variable] + family = LAGRANGE + order = FIRST + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = expected_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = expected_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'pull_tet4_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = sent_variable + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/pull_tet4_transfer_sub_app.i b/test/tests/unit/transfers/pull_tet4_transfer_sub_app.i new file mode 100644 index 00000000..d16f61d9 --- /dev/null +++ b/test/tests/unit/transfers/pull_tet4_transfer_sub_app.i @@ -0,0 +1,43 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-tet4.e + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [sent_variable] + family = LAGRANGE + order = FIRST + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/pull_wedge18_transfer_master.i b/test/tests/unit/transfers/pull_wedge18_transfer_master.i new file mode 100644 index 00000000..e42a80b6 --- /dev/null +++ b/test/tests/unit/transfers/pull_wedge18_transfer_master.i @@ -0,0 +1,73 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-wedge18.e + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [received_variable] + family = LAGRANGE + order = SECOND + [] + + [expected_variable] + family = LAGRANGE + order = SECOND + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = expected_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = expected_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'pull_wedge18_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = sent_variable + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/pull_wedge18_transfer_sub_app.i b/test/tests/unit/transfers/pull_wedge18_transfer_sub_app.i new file mode 100644 index 00000000..44e300b5 --- /dev/null +++ b/test/tests/unit/transfers/pull_wedge18_transfer_sub_app.i @@ -0,0 +1,43 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-wedge18.e + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [sent_variable] + family = LAGRANGE + order = SECOND + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/pull_wedge6_transfer_master.i b/test/tests/unit/transfers/pull_wedge6_transfer_master.i new file mode 100644 index 00000000..ab044cab --- /dev/null +++ b/test/tests/unit/transfers/pull_wedge6_transfer_master.i @@ -0,0 +1,73 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-wedge6.e + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [received_variable] + family = LAGRANGE + order = FIRST + [] + + [expected_variable] + family = LAGRANGE + order = FIRST + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = expected_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = expected_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'pull_wedge6_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = sent_variable + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/pull_wedge6_transfer_sub_app.i b/test/tests/unit/transfers/pull_wedge6_transfer_sub_app.i new file mode 100644 index 00000000..2490a598 --- /dev/null +++ b/test/tests/unit/transfers/pull_wedge6_transfer_sub_app.i @@ -0,0 +1,43 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-wedge6.e + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [sent_variable] + family = LAGRANGE + order = FIRST + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_hex27_transfer_master.i b/test/tests/unit/transfers/push_pull_hex27_transfer_master.i new file mode 100644 index 00000000..30338ec3 --- /dev/null +++ b/test/tests/unit/transfers/push_pull_hex27_transfer_master.i @@ -0,0 +1,80 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-hex27.e + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [sent_variable] + family = LAGRANGE + order = SECOND + [] + + [received_variable] + family = LAGRANGE + order = SECOND + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = sent_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'push_pull_hex27_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [push] + type = MultiAppCopyTransfer + to_multi_app = sub_app + source_variable = sent_variable + variable = received_variable_subapp + [] + + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = received_variable_subapp + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_hex27_transfer_sub_app.i b/test/tests/unit/transfers/push_pull_hex27_transfer_sub_app.i new file mode 100644 index 00000000..bb044e95 --- /dev/null +++ b/test/tests/unit/transfers/push_pull_hex27_transfer_sub_app.i @@ -0,0 +1,35 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-hex27.e + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [received_variable_subapp] + family = LAGRANGE + order = SECOND + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_hex8_transfer_master.i b/test/tests/unit/transfers/push_pull_hex8_transfer_master.i new file mode 100644 index 00000000..2fb509c4 --- /dev/null +++ b/test/tests/unit/transfers/push_pull_hex8_transfer_master.i @@ -0,0 +1,80 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-hex8.e + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [sent_variable] + family = LAGRANGE + order = FIRST + [] + + [received_variable] + family = LAGRANGE + order = FIRST + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = sent_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'push_pull_hex8_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [push] + type = MultiAppCopyTransfer + to_multi_app = sub_app + source_variable = sent_variable + variable = received_variable_subapp + [] + + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = received_variable_subapp + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_hex8_transfer_sub_app.i b/test/tests/unit/transfers/push_pull_hex8_transfer_sub_app.i new file mode 100644 index 00000000..97a8f967 --- /dev/null +++ b/test/tests/unit/transfers/push_pull_hex8_transfer_sub_app.i @@ -0,0 +1,35 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-hex8.e + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [received_variable_subapp] + family = LAGRANGE + order = FIRST + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_multi_element_order1_distributed_transfer_master.i b/test/tests/unit/transfers/push_pull_multi_element_order1_distributed_transfer_master.i new file mode 100644 index 00000000..936606dd --- /dev/null +++ b/test/tests/unit/transfers/push_pull_multi_element_order1_distributed_transfer_master.i @@ -0,0 +1,81 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-multi-element-order1.cpr + parallel_type = distributed + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [sent_variable] + family = LAGRANGE + order = FIRST + [] + + [received_variable] + family = LAGRANGE + order = FIRST + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = sent_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'push_pull_multi_element_order1_distributed_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [push] + type = MultiAppCopyTransfer + to_multi_app = sub_app + source_variable = sent_variable + variable = received_variable_subapp + [] + + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = received_variable_subapp + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_multi_element_order1_distributed_transfer_sub_app.i b/test/tests/unit/transfers/push_pull_multi_element_order1_distributed_transfer_sub_app.i new file mode 100644 index 00000000..f1f2dea4 --- /dev/null +++ b/test/tests/unit/transfers/push_pull_multi_element_order1_distributed_transfer_sub_app.i @@ -0,0 +1,36 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-multi-element-order1.cpr + parallel_type = distributed + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [received_variable_subapp] + family = LAGRANGE + order = FIRST + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_multi_element_order1_monomial_transfer_master.i b/test/tests/unit/transfers/push_pull_multi_element_order1_monomial_transfer_master.i new file mode 100644 index 00000000..b0c35d33 --- /dev/null +++ b/test/tests/unit/transfers/push_pull_multi_element_order1_monomial_transfer_master.i @@ -0,0 +1,80 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-multi-element-order1.e + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [sent_variable] + family = MONOMIAL + order = CONSTANT + [] + + [received_variable] + family = MONOMIAL + order = CONSTANT + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = sent_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'push_pull_multi_element_order1_monomial_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [push] + type = MultiAppCopyTransfer + to_multi_app = sub_app + source_variable = sent_variable + variable = received_variable_subapp + [] + + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = received_variable_subapp + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_multi_element_order1_monomial_transfer_sub_app.i b/test/tests/unit/transfers/push_pull_multi_element_order1_monomial_transfer_sub_app.i new file mode 100644 index 00000000..64449cb9 --- /dev/null +++ b/test/tests/unit/transfers/push_pull_multi_element_order1_monomial_transfer_sub_app.i @@ -0,0 +1,35 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-multi-element-order1.e + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [received_variable_subapp] + family = MONOMIAL + order = CONSTANT + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_multi_element_order1_transfer_master.i b/test/tests/unit/transfers/push_pull_multi_element_order1_transfer_master.i new file mode 100644 index 00000000..f2076a1a --- /dev/null +++ b/test/tests/unit/transfers/push_pull_multi_element_order1_transfer_master.i @@ -0,0 +1,80 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-multi-element-order1.e + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [sent_variable] + family = LAGRANGE + order = FIRST + [] + + [received_variable] + family = LAGRANGE + order = FIRST + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = sent_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'push_pull_multi_element_order1_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [push] + type = MultiAppCopyTransfer + to_multi_app = sub_app + source_variable = sent_variable + variable = received_variable_subapp + [] + + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = received_variable_subapp + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_multi_element_order1_transfer_sub_app.i b/test/tests/unit/transfers/push_pull_multi_element_order1_transfer_sub_app.i new file mode 100644 index 00000000..240c92c2 --- /dev/null +++ b/test/tests/unit/transfers/push_pull_multi_element_order1_transfer_sub_app.i @@ -0,0 +1,35 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-multi-element-order1.e + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [received_variable_subapp] + family = LAGRANGE + order = FIRST + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_multi_element_order2_distributed_transfer_master.i b/test/tests/unit/transfers/push_pull_multi_element_order2_distributed_transfer_master.i new file mode 100644 index 00000000..bb921238 --- /dev/null +++ b/test/tests/unit/transfers/push_pull_multi_element_order2_distributed_transfer_master.i @@ -0,0 +1,81 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-multi-element-order2.cpr + parallel_type = distributed + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [sent_variable] + family = LAGRANGE + order = SECOND + [] + + [received_variable] + family = LAGRANGE + order = SECOND + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = sent_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'push_pull_multi_element_order2_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [push] + type = MultiAppCopyTransfer + to_multi_app = sub_app + source_variable = sent_variable + variable = received_variable_subapp + [] + + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = received_variable_subapp + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_multi_element_order2_distributed_transfer_sub_app.i b/test/tests/unit/transfers/push_pull_multi_element_order2_distributed_transfer_sub_app.i new file mode 100644 index 00000000..e979a015 --- /dev/null +++ b/test/tests/unit/transfers/push_pull_multi_element_order2_distributed_transfer_sub_app.i @@ -0,0 +1,36 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-multi-element-order2.cpr + parallel_type = distributed + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [received_variable_subapp] + family = LAGRANGE + order = SECOND + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_multi_element_order2_transfer_master.i b/test/tests/unit/transfers/push_pull_multi_element_order2_transfer_master.i new file mode 100644 index 00000000..ed5d6587 --- /dev/null +++ b/test/tests/unit/transfers/push_pull_multi_element_order2_transfer_master.i @@ -0,0 +1,80 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-multi-element-order2.e + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [sent_variable] + family = LAGRANGE + order = SECOND + [] + + [received_variable] + family = LAGRANGE + order = SECOND + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = sent_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'push_pull_multi_element_order2_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [push] + type = MultiAppCopyTransfer + to_multi_app = sub_app + source_variable = sent_variable + variable = received_variable_subapp + [] + + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = received_variable_subapp + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_multi_element_order2_transfer_sub_app.i b/test/tests/unit/transfers/push_pull_multi_element_order2_transfer_sub_app.i new file mode 100644 index 00000000..1a1e3dfb --- /dev/null +++ b/test/tests/unit/transfers/push_pull_multi_element_order2_transfer_sub_app.i @@ -0,0 +1,35 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-multi-element-order2.e + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [received_variable_subapp] + family = LAGRANGE + order = SECOND + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_pyramid5_transfer_master.i b/test/tests/unit/transfers/push_pull_pyramid5_transfer_master.i new file mode 100644 index 00000000..59fef242 --- /dev/null +++ b/test/tests/unit/transfers/push_pull_pyramid5_transfer_master.i @@ -0,0 +1,80 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-pyramid5.e + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [sent_variable] + family = LAGRANGE + order = FIRST + [] + + [received_variable] + family = LAGRANGE + order = FIRST + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = sent_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'push_pull_pyramid5_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [push] + type = MultiAppCopyTransfer + to_multi_app = sub_app + source_variable = sent_variable + variable = received_variable_subapp + [] + + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = received_variable_subapp + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_pyramid5_transfer_sub_app.i b/test/tests/unit/transfers/push_pull_pyramid5_transfer_sub_app.i new file mode 100644 index 00000000..e51c33b9 --- /dev/null +++ b/test/tests/unit/transfers/push_pull_pyramid5_transfer_sub_app.i @@ -0,0 +1,35 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-pyramid5.e + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [received_variable_subapp] + family = LAGRANGE + order = FIRST + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_tet10_transfer_master.i b/test/tests/unit/transfers/push_pull_tet10_transfer_master.i new file mode 100644 index 00000000..d83aedd8 --- /dev/null +++ b/test/tests/unit/transfers/push_pull_tet10_transfer_master.i @@ -0,0 +1,80 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-tet10.e + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [sent_variable] + family = LAGRANGE + order = SECOND + [] + + [received_variable] + family = LAGRANGE + order = SECOND + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = sent_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'push_pull_tet10_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [push] + type = MultiAppCopyTransfer + to_multi_app = sub_app + source_variable = sent_variable + variable = received_variable_subapp + [] + + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = received_variable_subapp + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_tet10_transfer_sub_app.i b/test/tests/unit/transfers/push_pull_tet10_transfer_sub_app.i new file mode 100644 index 00000000..06c952a6 --- /dev/null +++ b/test/tests/unit/transfers/push_pull_tet10_transfer_sub_app.i @@ -0,0 +1,35 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-tet10.e + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [received_variable_subapp] + family = LAGRANGE + order = SECOND + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_tet4_transfer_master.i b/test/tests/unit/transfers/push_pull_tet4_transfer_master.i new file mode 100644 index 00000000..c384af47 --- /dev/null +++ b/test/tests/unit/transfers/push_pull_tet4_transfer_master.i @@ -0,0 +1,80 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-tet4.e + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [sent_variable] + family = LAGRANGE + order = FIRST + [] + + [received_variable] + family = LAGRANGE + order = FIRST + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = sent_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'push_pull_tet4_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [push] + type = MultiAppCopyTransfer + to_multi_app = sub_app + source_variable = sent_variable + variable = received_variable_subapp + [] + + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = received_variable_subapp + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_tet4_transfer_sub_app.i b/test/tests/unit/transfers/push_pull_tet4_transfer_sub_app.i new file mode 100644 index 00000000..4dc1beda --- /dev/null +++ b/test/tests/unit/transfers/push_pull_tet4_transfer_sub_app.i @@ -0,0 +1,35 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-tet4.e + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [received_variable_subapp] + family = LAGRANGE + order = FIRST + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_wedge18_distributed_transfer_master.i b/test/tests/unit/transfers/push_pull_wedge18_distributed_transfer_master.i new file mode 100644 index 00000000..37bcb571 --- /dev/null +++ b/test/tests/unit/transfers/push_pull_wedge18_distributed_transfer_master.i @@ -0,0 +1,81 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-wedge18.cpr + parallel_type = distributed + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [sent_variable] + family = LAGRANGE + order = SECOND + [] + + [received_variable] + family = LAGRANGE + order = SECOND + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = sent_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'push_pull_wedge18_distributed_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [push] + type = MultiAppCopyTransfer + to_multi_app = sub_app + source_variable = sent_variable + variable = received_variable_subapp + [] + + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = received_variable_subapp + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_wedge18_distributed_transfer_sub_app.i b/test/tests/unit/transfers/push_pull_wedge18_distributed_transfer_sub_app.i new file mode 100644 index 00000000..6582bd2f --- /dev/null +++ b/test/tests/unit/transfers/push_pull_wedge18_distributed_transfer_sub_app.i @@ -0,0 +1,36 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-wedge18.cpr + parallel_type = distributed + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [received_variable_subapp] + family = LAGRANGE + order = SECOND + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_wedge18_transfer_master.i b/test/tests/unit/transfers/push_pull_wedge18_transfer_master.i new file mode 100644 index 00000000..39c0750a --- /dev/null +++ b/test/tests/unit/transfers/push_pull_wedge18_transfer_master.i @@ -0,0 +1,80 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-wedge18.e + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [sent_variable] + family = LAGRANGE + order = SECOND + [] + + [received_variable] + family = LAGRANGE + order = SECOND + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = sent_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'push_pull_wedge18_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [push] + type = MultiAppCopyTransfer + to_multi_app = sub_app + source_variable = sent_variable + variable = received_variable_subapp + [] + + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = received_variable_subapp + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_wedge18_transfer_sub_app.i b/test/tests/unit/transfers/push_pull_wedge18_transfer_sub_app.i new file mode 100644 index 00000000..05b59272 --- /dev/null +++ b/test/tests/unit/transfers/push_pull_wedge18_transfer_sub_app.i @@ -0,0 +1,35 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-wedge18.e + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [received_variable_subapp] + family = LAGRANGE + order = SECOND + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_wedge6_transfer_master.i b/test/tests/unit/transfers/push_pull_wedge6_transfer_master.i new file mode 100644 index 00000000..a76ce784 --- /dev/null +++ b/test/tests/unit/transfers/push_pull_wedge6_transfer_master.i @@ -0,0 +1,80 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-wedge6.e + dim = 3 +[] + +[Problem] + solve = false +[] + +[AuxVariables] + [sent_variable] + family = LAGRANGE + order = FIRST + [] + + [received_variable] + family = LAGRANGE + order = FIRST + [] +[] + +[ICs] + [set_variable] + type = FunctionIC + variable = sent_variable + function = set_variable + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Postprocessors] + [l2_difference] + type = ElementL2Difference + variable = sent_variable + other_variable = received_variable + [] +[] + +[MultiApps] + [sub_app] + type = TransientMultiApp + positions = '0 0 0' + input_files = 'push_pull_wedge6_transfer_sub_app.i' + execute_on = timestep_begin + [] +[] + +[Transfers] + [push] + type = MultiAppCopyTransfer + to_multi_app = sub_app + source_variable = sent_variable + variable = received_variable_subapp + [] + + [pull] + type = MultiAppCopyTransfer + from_multi_app = sub_app + source_variable = received_variable_subapp + variable = received_variable + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] + +[Outputs] + csv = true +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/push_pull_wedge6_transfer_sub_app.i b/test/tests/unit/transfers/push_pull_wedge6_transfer_sub_app.i new file mode 100644 index 00000000..d5b1a029 --- /dev/null +++ b/test/tests/unit/transfers/push_pull_wedge6_transfer_sub_app.i @@ -0,0 +1,35 @@ +[Mesh] + type = CoupledMFEMMesh + file = gold/simple-cube-wedge6.e + dim = 3 +[] + +[Problem] + solve = false + type = MFEMProblem +[] + +[Formulation] + type = CustomFormulation +[] + +[AuxVariables] + [received_variable_subapp] + family = LAGRANGE + order = FIRST + [] +[] + +[Functions] + [set_variable] + type = ParsedFunction + expression = '42 + 100*x*x' + [] +[] + +[Executioner] + type = Transient + dt = 1.0 + start_time = 0.0 + end_time = 1.0 +[] \ No newline at end of file diff --git a/test/tests/unit/transfers/tests b/test/tests/unit/transfers/tests new file mode 100644 index 00000000..56c40cb8 --- /dev/null +++ b/test/tests/unit/transfers/tests @@ -0,0 +1,226 @@ +[Tests] + design = 'syntax/Problem/index.md' + + [./PullHex8Transfer] + type = 'CSVDiff' + input = 'pull_hex8_transfer_master.i' + csvdiff = 'pull_hex8_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer from MFEM to MOOSE using first-order hex8 elements.' + [] + + [./PushPullHex8Transfer] + type = 'CSVDiff' + input = 'push_pull_hex8_transfer_master.i' + csvdiff = 'push_pull_hex8_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer between MOOSE and MFEM using first-order hex8 elements.' + [] + + [./PullHex27Transfer] + type = 'CSVDiff' + input = 'pull_hex27_transfer_master.i' + csvdiff = 'pull_hex27_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer from MFEM to MOOSE using second-order hex27 elements.' + [] + + [./PushPullHex27Transfer] + type = 'CSVDiff' + input = 'push_pull_hex27_transfer_master.i' + csvdiff = 'push_pull_hex27_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer between MOOSE and MFEM using second-order hex27 elements.' + [] + + [./PullTet4Transfer] + type = 'CSVDiff' + input = 'pull_tet4_transfer_master.i' + csvdiff = 'pull_tet4_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer from MFEM to MOOSE using first-order tet4 elements.' + [] + + [./PushPullTet4Transfer] + type = 'CSVDiff' + input = 'push_pull_tet4_transfer_master.i' + csvdiff = 'push_pull_tet4_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer between MOOSE and MFEM using first-order tet4 elements.' + [] + + [./PullTet10Transfer] + type = 'CSVDiff' + input = 'pull_tet10_transfer_master.i' + csvdiff = 'pull_tet10_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer from MFEM to MOOSE using second-order tet10 elements.' + [] + + [./PushPullTet10Transfer] + type = 'CSVDiff' + input = 'push_pull_tet10_transfer_master.i' + csvdiff = 'push_pull_tet10_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer between MOOSE and MFEM using second-order tet10 elements.' + [] + + [./PullWedge6Transfer] + type = 'CSVDiff' + input = 'pull_wedge6_transfer_master.i' + csvdiff = 'pull_wedge6_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer from MFEM to MOOSE using wedge6 (prism6) elements.' + [] + + [./PushPullWedge6Transfer] + type = 'CSVDiff' + input = 'push_pull_wedge6_transfer_master.i' + csvdiff = 'push_pull_wedge6_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer between MFEM and MOOSE using wedge6 (prism6) elements.' + [] + + [./PullWedge18Transfer] + type = 'CSVDiff' + input = 'pull_wedge18_transfer_master.i' + csvdiff = 'pull_wedge18_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer from MFEM to MOOSE using wedge18 (prism18) elements.' + [] + + [./PushPullWedge18Transfer] + type = 'CSVDiff' + input = 'push_pull_wedge18_transfer_master.i' + csvdiff = 'push_pull_wedge18_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer between MFEM and MOOSE using wedge18 (prism18) elements.' + [] + + [./PullPyramid5Transfer] + type = 'CSVDiff' + input = 'pull_pyramid5_transfer_master.i' + csvdiff = 'pull_pyramid5_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer from MFEM to MOOSE using pyramid5 elements.' + [] + + [./PushPullPyramid5Transfer] + type = 'CSVDiff' + input = 'push_pull_pyramid5_transfer_master.i' + csvdiff = 'push_pull_pyramid5_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer between MFEM and MOOSE using pyramid5 elements.' + [] + + [./PullMultiElementOrder1Transfer] + type = 'CSVDiff' + input = 'pull_multi_element_order1_transfer_master.i' + csvdiff = 'pull_multi_element_order1_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer from MFEM to MOOSE using multiple first-order element types.' + [] + + [./PushPullMultiElementOrder1Transfer] + type = 'CSVDiff' + input = 'push_pull_multi_element_order1_transfer_master.i' + csvdiff = 'push_pull_multi_element_order1_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer between MFEM and MOOSE using multiple first-order element types.' + [] + + [./PushPullMultiElementOrder1MonomialTransfer] + type = 'CSVDiff' + input = 'push_pull_multi_element_order1_monomial_transfer_master.i' + csvdiff = 'push_pull_multi_element_order1_monomial_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer constant-order Monomials between MFEM and MOOSE using multiple first-order element types.' + [] + + [./PullMultiElementOrder2Transfer] + type = 'CSVDiff' + input = 'pull_multi_element_order2_transfer_master.i' + csvdiff = 'pull_multi_element_order2_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer from MFEM to MOOSE using multiple second-order element types.' + [] + + [./PushPullMultiElementOrder2Transfer] + type = 'CSVDiff' + input = 'push_pull_multi_element_order2_transfer_master.i' + csvdiff = 'push_pull_multi_element_order2_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer between MFEM and MOOSE using multiple second-order element types.' + [] + + # Order 1, Parallel. + [./PullMultiElementOrder1ParallelReplicatedTransfer] + type = 'CSVDiff' + input = 'pull_multi_element_order1_transfer_master.i' + csvdiff = 'pull_multi_element_order1_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer from MFEM to MOOSE using multiple first-order element types (parallel).' + min_parallel = 2 + [] + + [./PushPullMultiElementOrder1ParallelReplicatedTransfer] + type = 'CSVDiff' + input = 'push_pull_multi_element_order1_transfer_master.i' + csvdiff = 'push_pull_multi_element_order1_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer between MFEM and MOOSE using multiple first-order element types (parallel).' + min_parallel = 2 + [] + + [./PushPullMultiElementOrder1ParallelDistributedTransfer] + type = 'CSVDiff' + input = 'push_pull_multi_element_order1_distributed_transfer_master.i' + csvdiff = 'push_pull_multi_element_order1_distributed_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer between MFEM and MOOSE using multiple first-order element types (distributed).' + min_parallel = 2 + max_parallel = 2 + [] + + [./PushPullMultiElementOrder1ParallelReplicatedMonomialTransfer] + type = 'CSVDiff' + input = 'push_pull_multi_element_order1_monomial_transfer_master.i' + csvdiff = 'push_pull_multi_element_order1_monomial_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer constant-order Monomials between MFEM and MOOSE using multiple first-order element types (parallel).' + min_parallel = 2 + [] + + # Order 2, Parallel. + # + # Notes: + # 1. pyramid14 is not supported. The multi-element order-2 test cases only contain hex27 and tet10 elements. Wedge18 elements are therefore tested + # separately. If pyramid14 is added in the future, update the multi-element order-2 test case to include all four second-order element types. + # 2. monomials currently supported only to first-order. Hence no second-order tests. + [./PullMultiElementOrder2ParallelReplicatedTransfer] + type = 'CSVDiff' + input = 'pull_multi_element_order2_transfer_master.i' + csvdiff = 'pull_multi_element_order2_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer from MFEM to MOOSE using multiple second-order element types (parallel).' + min_parallel = 2 + [] + + [./PushPullMultiElementOrder2ParallelReplicatedTransfer] + type = 'CSVDiff' + input = 'push_pull_multi_element_order2_transfer_master.i' + csvdiff = 'push_pull_multi_element_order2_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer between MFEM and MOOSE using multiple second-order element types (parallel).' + min_parallel = 2 + [] + + [./PushPullMultiElementOrder2ParallelDistributedTransfer] + type = 'CSVDiff' + input = 'push_pull_multi_element_order2_distributed_transfer_master.i' + csvdiff = 'push_pull_multi_element_order2_distributed_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer between MFEM and MOOSE using multiple second-order element types (distributed).' + min_parallel = 2 + max_parallel = 2 + [] + + [./PullWedge18ParallelReplicatedTransfer] + type = 'CSVDiff' + input = 'pull_wedge18_transfer_master.i' + csvdiff = 'pull_wedge18_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer from MFEM to MOOSE using wedge18 elements (parallel).' + min_parallel = 2 + [] + + [./PushPullWedge18ParallelReplicatedTransfer] + type = 'CSVDiff' + input = 'push_pull_wedge18_transfer_master.i' + csvdiff = 'push_pull_wedge18_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer between MFEM and MOOSE using wedge18 elements (parallel).' + min_parallel = 2 + [] + + [./PushPullWedge18ParallelDistributedTransfer] + type = 'CSVDiff' + input = 'push_pull_wedge18_distributed_transfer_master.i' + csvdiff = 'push_pull_wedge18_distributed_transfer_master_out.csv' + requirement = 'Platypus shall have the ability to transfer between MFEM and MOOSE using wedge18 elements (distributed).' + min_parallel = 2 + max_parallel = 2 + [] +[] diff --git a/testroot b/testroot new file mode 100644 index 00000000..44528cbc --- /dev/null +++ b/testroot @@ -0,0 +1,4 @@ +app_name = platypus +allow_warnings = false +allow_unused = false +allow_override = false diff --git a/unit/Makefile b/unit/Makefile new file mode 100644 index 00000000..819c9f7e --- /dev/null +++ b/unit/Makefile @@ -0,0 +1,70 @@ +############################################################################### +################### MOOSE Application Standard Makefile ####################### +############################################################################### +# +# Required Environment variables (one of the following) +# PACKAGES_DIR - Location of the MOOSE redistributable package +# +# Optional Environment variables +# MOOSE_DIR - Root directory of the MOOSE project +# FRAMEWORK_DIR - Location of the MOOSE framework +# +############################################################################### +# Use the MOOSE submodule if it exists and MOOSE_DIR is not set +MOOSE_SUBMODULE := $(CURDIR)/../moose +ifneq ($(wildcard $(MOOSE_SUBMODULE)/framework/Makefile),) + MOOSE_DIR ?= $(MOOSE_SUBMODULE) +else + MOOSE_DIR ?= $(shell dirname `pwd`)/../moose +endif +FRAMEWORK_DIR ?= $(MOOSE_DIR)/framework +############################################################################### + +# framework +include $(FRAMEWORK_DIR)/build.mk +include $(FRAMEWORK_DIR)/moose.mk + +################################## MODULES #################################### +# set desired physics modules equal to 'yes' to enable them +CHEMICAL_REACTIONS := no +CONTACT := no +FLUID_PROPERTIES := no +HEAT_CONDUCTION := no +MISC := no +NAVIER_STOKES := no +PHASE_FIELD := no +RDG := no +RICHARDS := no +SOLID_MECHANICS := no +STOCHASTIC_TOOLS := no +TENSOR_MECHANICS := no +XFEM := no +POROUS_FLOW := no +LEVEL_SET := no +include $(MOOSE_DIR)/modules/modules.mk +############################################################################### + +# Extra stuff for GTEST +ADDITIONAL_INCLUDES := -I$(FRAMEWORK_DIR)/contrib/gtest +ADDITIONAL_LIBS := $(FRAMEWORK_DIR)/contrib/gtest/libgtest.la + +# dep apps +CURRENT_DIR := $(shell pwd) +APPLICATION_DIR := $(CURRENT_DIR)/.. +APPLICATION_NAME := platypus +include $(FRAMEWORK_DIR)/app.mk + +APPLICATION_DIR := $(CURRENT_DIR) +APPLICATION_NAME := platypus-unit +BUILD_EXEC := yes + +DEP_APPS ?= $(shell $(FRAMEWORK_DIR)/scripts/find_dep_apps.py $(APPLICATION_NAME)) +include $(FRAMEWORK_DIR)/app.mk + +# Find all the Platypus unit test source files and include their dependencies. +platypus_unit_srcfiles := $(shell find $(CURRENT_DIR)/src -name "*.C") +platypus_unit_deps := $(patsubst %.C, %.$(obj-suffix).d, $(platypus_unit_srcfiles)) +-include $(platypus_unit_deps) + +############################################################################### +# Additional special case targets should be added here diff --git a/unit/include/place_holder b/unit/include/place_holder new file mode 100644 index 00000000..e69de29b diff --git a/unit/run_tests b/unit/run_tests new file mode 100755 index 00000000..f79debb7 --- /dev/null +++ b/unit/run_tests @@ -0,0 +1,18 @@ +#!/bin/bash + +APPLICATION_NAME=platypus +# If $METHOD is not set, use opt +if [ -z $METHOD ]; then + export METHOD=opt +fi + +if [ -e ./unit/$APPLICATION_NAME-unit-$METHOD ] +then + ./unit/$APPLICATION_NAME-unit-$METHOD +elif [ -e ./$APPLICATION_NAME-unit-$METHOD ] +then + ./$APPLICATION_NAME-unit-$METHOD +else + echo "Executable missing!" + exit 1 +fi diff --git a/unit/src/SampleTest.C b/unit/src/SampleTest.C new file mode 100644 index 00000000..b1acf597 --- /dev/null +++ b/unit/src/SampleTest.C @@ -0,0 +1,23 @@ +#include "gtest/gtest.h" + +TEST(MySampleTests, descriptiveTestName) +{ + // compare equality + EXPECT_EQ(2, 1 + 1); + EXPECT_DOUBLE_EQ(2 * 3.5, 1.0 * 8 - 1); + + // compare equality and immediately terminate this test if it fails + // ASSERT_EQ(2, 1); + + // this won't run if you uncomment the above test because above assert will fail + ASSERT_NO_THROW(1 + 1); + + // for a complete list of assertions and for more unit testing documentation see: + // https://github.com/google/googletest/blob/master/googletest/docs/Primer.md +} + +TEST(MySampleTests, anotherTest) +{ + EXPECT_LE(1, 2); + // ... +} diff --git a/unit/src/main.C b/unit/src/main.C new file mode 100644 index 00000000..85379756 --- /dev/null +++ b/unit/src/main.C @@ -0,0 +1,25 @@ +#include "PlatypusApp.h" +#include "gtest/gtest.h" + +// Moose includes +#include "Moose.h" +#include "MooseInit.h" +#include "AppFactory.h" + +#include +#include + +PerfLog Moose::perf_log("gtest"); + +GTEST_API_ int +main(int argc, char ** argv) +{ + // gtest removes (only) its args from argc and argv - so this must be before moose init + testing::InitGoogleTest(&argc, argv); + + MooseInit init(argc, argv); + registerApp(PlatypusApp); + Moose::_throw_on_error = true; + + return RUN_ALL_TESTS(); +}